CharactersExtraction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np;\n",
    "from skimage import io;\n",
    "from skimage.transform import rotate;\n",
    "from scipy.signal import find_peaks;\n",
    "import cv2;\n",
    "import math;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_skew(image):\n",
    "    '''\n",
    "    This function is used to compute the angle needed to deskew image\n",
    "    \n",
    "    :param image: our plate image that we will compute skew angle on it\n",
    "    \n",
    "    :constant ksize:        kernel size used in median filtering\n",
    "    :constant threshold1:   lower threshould used in canny edge detection\n",
    "    :constant threshold2:   upper threshould used in canny edge detection\n",
    "    :constant apertureSize: kernel size for cobel operator\n",
    "    :constant L2gradient:   boolean to tell function to use more percise \n",
    "                            method in calculating gradient magnitude(mean square)\n",
    "    :constant rho: \n",
    "    :constant theta:\n",
    "    :constant threshold:\n",
    "    :constant minLineLength:Minimum line length. Line shorter than that are rejected\n",
    "    :constant maxLineGap:   Maximum allowed gap between points on the same line to link them\n",
    "    \n",
    "    \n",
    "    :return angle: Thiis is the angle needed to fix deskewed image in degree\n",
    "    '''\n",
    "    \n",
    "    #checking if the image is sutable for processing\n",
    "    if len(image.shape) == 3:\n",
    "        h, w, _ = image.shape\n",
    "    elif len(image.shape) == 2:\n",
    "        h, w = image.shape\n",
    "    else:\n",
    "        print('upsupported image type')\n",
    "        return 0;\n",
    "\n",
    "    #using median filter to remove unrequried noise and very weak edges\n",
    "    img = cv2.medianBlur(image, ksize = 3)\n",
    "\n",
    "    #applying canny edge detection to extract edges that exists in the plate\n",
    "    edges = cv2.Canny(img,  threshold1 = 30,  threshold2 = 100, apertureSize = 3, L2gradient = True)\n",
    "    \n",
    "    #\n",
    "    lines = cv2.HoughLinesP(edges, rho = 1, theta = math.pi/180, threshold = 30, minLineLength = w / 4.0, maxLineGap = h/4.0)\n",
    "    \n",
    "    angle = 0.0\n",
    "    nlines = lines.size\n",
    "    #calculating sum of the anles of the lines resulting from previous function \n",
    "    count = 0\n",
    "    for x1, y1, x2, y2 in lines[0]:\n",
    "        ang = np.arctan2(y2 - y1, x2 - x1)\n",
    "        if math.fabs(ang) <= 30: # excluding line angles with extreme rotations(outliars)\n",
    "            angle += ang\n",
    "            count += 1\n",
    "\n",
    "    if count == 0:\n",
    "        return 0;\n",
    "    \n",
    "    #returns average angle in degrees\n",
    "    return (angle / count)*180/math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotate_image(image, angle):\n",
    "    '''\n",
    "    This function is a combination of both the abovr\n",
    "    \n",
    "    :param image: our plate image could be RGB or Grayscale\n",
    "    \n",
    "    :return image: the plate image after rotation\n",
    "    ''' \n",
    "    result = rotate(image, angle, cval = 0);\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "    This function is just to rotate our image\n",
    "    \n",
    "    :param image: our plate image could be RGB or Grayscale\n",
    "    :param angle: angle provided to the function to rotate image with\n",
    "    \n",
    "    :constant cval: represents the value to be assigned to the out of\n",
    "                    bounds pixels that will appear due to rotation\n",
    "    \n",
    "    :return image: the plate image after rotation\n",
    "    ''' \n",
    "def deskew(image):\n",
    "    return rotate_image(image, compute_skew(image))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "im = cv2.imread('D:\\GitHub\\License-Plate-Recognition\\Cars33.png');\n",
    "newImage = deskew(im);\n",
    "io.imshow(newImage);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_characters(img, debug=0):\n",
    "    GaussianFilter= cv2.GaussianBlur(img, (5, 5), 0)\n",
    "    # binary = cv2.threshold(GaussianFilter, 0, 255,cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]\n",
    "    _, binary = cv2.threshold(GaussianFilter, 80, 255, cv2.THRESH_BINARY_INV)\n",
    "\n",
    "    kernel3 = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))\n",
    "    thre_mor = cv2.morphologyEx(binary, cv2.MORPH_DILATE, kernel3)\n",
    "    thre_mor = thre_mor/255\n",
    "    if debug:\n",
    "        print('extracting stage output:')\n",
    "        io.imshow(thre_mor)\n",
    "        io.show()\n",
    "\n",
    "    vertical_projection = np.sum(thre_mor, axis = 0)\n",
    "    start = []\n",
    "    end = []\n",
    "    for i in range(vertical_projection.size -1):\n",
    "        if(vertical_projection[i] == 0):\n",
    "            if(vertical_projection[i+1] != 0):\n",
    "                start.append(i)\n",
    "        if(vertical_projection[i] != 0):\n",
    "            if(vertical_projection[i+1] == 0):\n",
    "                end.append(i)\n",
    "    characters = []\n",
    "    for i in range(len(start)):\n",
    "        characters.append(img[:,start[i]:end[i]])\n",
    "    return characters\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im = cv2.imread('./DataSet/Brazil/brasil_1.png', cv2.IMREAD_GRAYSCALE)\n",
    "extract_characters(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "f2f3cf91280d617e7f70b1f315f066237280cb9e9177b8df3951076cffbd0af3"
  },
  "kernelspec": {
   "display_name": "Python 3.10.0 64-bit",
   "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.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}