Plate_Segmentation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 0. Install and Import Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "import imutils\n",
    "import cv2\n",
    "import numpy as np\n",
    "from skimage import io\n",
    "import matplotlib.pyplot as plt\n",
    "from commonfunctions import *\n",
    "\n",
    "import skimage.io as io\n",
    "import matplotlib.pyplot as plt\n",
    "from skimage.color import rgb2gray\n",
    "from skimage.measure import find_contours\n",
    "from skimage.draw import rectangle\n",
    "\n",
    "# Show the figures / plots inside the notebook\n",
    "%matplotlib inline\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess (input_image):\n",
    "    gray_image = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)\n",
    "    show_images([gray_image])\n",
    "    filtered_image = cv2.bilateralFilter(gray_image, 11, 17, 17) \n",
    "    show_images([filtered_image])\n",
    "    after_edge_detection = cv2.Canny(filtered_image, 30, 200) \n",
    "    show_images([after_edge_detection])\n",
    "    element = cv2.getStructuringElement( shape=cv2.MORPH_RECT, ksize=(1, 1))\n",
    "    cv2.morphologyEx(src=after_edge_detection, op=cv2.MORPH_CLOSE,   kernel=element, dst=after_edge_detection)\n",
    "    show_images([after_edge_detection])\n",
    "    return after_edge_detection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# grab_contours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def grab_contours(cnts):\n",
    "#     # if the length the contours tuple returned by cv2.findContours\n",
    "#     # is '2' then we are using either OpenCV v2.4, v4-beta, or\n",
    "#     # v4-official\n",
    "#     if len(cnts) == 2:\n",
    "#         cnts = cnts[0]\n",
    "\n",
    "#     # if the length of the contours tuple is '3' then we are using\n",
    "#     # either OpenCV v3, v4-pre, or v4-alpha\n",
    "#     elif len(cnts) == 3:\n",
    "#         cnts = cnts[1]\n",
    "\n",
    "#     # otherwise OpenCV has changed their cv2.findContours return\n",
    "#     # signature yet again and I have no idea WTH is going on\n",
    "#     else:\n",
    "#         raise Exception((\"Contours tuple must have length 2 or 3, \"\n",
    "#             \"otherwise OpenCV changed their cv2.findContours return \"\n",
    "#             \"signature yet again. Refer to OpenCV's documentation \"\n",
    "#             \"in that case\"))\n",
    "\n",
    "#     # return the actual contours array\n",
    "#     return cnts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Find contours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_contours(after_edge_detection):\n",
    "    contours = cv2.findContours(after_edge_detection.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n",
    "    contours = imutils.grab_contours(contours)\n",
    "    contours = sorted(contours, key=cv2.contourArea, reverse=True)\n",
    "    return contours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkIfPlate(contour, img):\n",
    "    \n",
    "    minRatio = 2.3\n",
    "    maxRatio = 5\n",
    "\n",
    "    height, width, _ = img.shape \n",
    "    area = height * width\n",
    "    \n",
    "    minArea = 0.01 * area\n",
    "    maxArea = 0.25 * area\n",
    "    \n",
    "    x,y,w,h = cv2.boundingRect(contour)  \n",
    "    contourArea = w*h\n",
    "\n",
    "    if (w/h >  minRatio and  w/h <maxRatio and contourArea > minArea and  contourArea < maxArea ):\n",
    "\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_plate(input_image):\n",
    "    after_edge_detection = preprocess(input_image)\n",
    "    contours = find_contours(after_edge_detection)\n",
    "    location = None\n",
    "    candidate_contours = []\n",
    "    images = []\n",
    "    for contour in contours:\n",
    "        perimeter = cv2.arcLength(contour, True)\n",
    "        approx = cv2.approxPolyDP(contour, 0.02*perimeter , True)\n",
    "        # approx = cv2.approxPolyDP(contour, 10, True)\n",
    "        if len(approx) == 4:\n",
    "            location = approx \n",
    "            if (checkIfPlate(contour, input_image)): \n",
    "                candidate_contours.append(contour)               \n",
    "                mask = np.zeros(cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY).shape, np.uint8)\n",
    "                new_image = cv2.drawContours(mask, [location], 0,255, -1)\n",
    "                new_image = cv2.bitwise_and(input_image, input_image, mask=mask)\n",
    "                show_images([new_image])\n",
    "                (x,y) = np.where(mask==255)\n",
    "                (x1, y1) = (np.min(x), np.min(y))\n",
    "                (x2, y2) = (np.max(x), np.max(y))\n",
    "                images.append(cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)[x1:x2+1, y1:y2+1])\n",
    "    show_images(images)\n",
    "    if (len(candidate_contours) > 1):\n",
    "        candidate_contours = sorted(candidate_contours, key=cv2.contourArea, reverse=True)\n",
    "        perimeter = cv2.arcLength(candidate_contours[0], True)\n",
    "        approx = cv2.approxPolyDP(candidate_contours[0], 0.02*perimeter , True)\n",
    "        mask = np.zeros(cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY).shape, np.uint8)\n",
    "        new_image = cv2.drawContours(mask, [approx], 0,255, -1)\n",
    "        new_image = cv2.bitwise_and(input_image, input_image, mask=mask)\n",
    "        (x,y) = np.where(mask==255)\n",
    "        (x1, y1) = (np.min(x), np.min(y))\n",
    "        (x2, y2) = (np.max(x), np.max(y))\n",
    "        new_image = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY)[x1:x2+1, y1:y2+1]\n",
    "        images = new_image\n",
    "    return images\n",
    "\n",
    "input_image = cv2.imread(\"images/Car_1.jpg\")\n",
    "plate = find_plate(input_image)\n",
    "show_images([plate])\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}