Update number_plate.py

Author: mehabhalodiya

Num-Plate-Detector/number_plate.py

@@ -1,334 +1,82 @@
-import cv2
+# importing libraries
 import numpy as np
-from skimage.filters import threshold_local
-import tensorflow as tf
-from skimage import measure
-import imutils
-
-def sort_cont(character_contours):
-    """
-    To sort contours from left to right
-    """
-    i = 0
-    boundingBoxes = [cv2.boundingRect(c) for c in character_contours]
-    (character_contours, boundingBoxes) = zip(*sorted(zip(character_contours, boundingBoxes),
-                                                      key=lambda b: b[1][i], reverse=False))
-    return character_contours
-
-
-def segment_chars(plate_img, fixed_width):
-    """
-    extract Value channel from the HSV format of image and apply adaptive thresholding
-    to reveal the characters on the license plate
-    """
-    V = cv2.split(cv2.cvtColor(plate_img, cv2.COLOR_BGR2HSV))[2]
-
-    T = threshold_local(V, 29, offset=15, method='gaussian')
-
-    thresh = (V > T).astype('uint8') * 255
-
-    thresh = cv2.bitwise_not(thresh)
-
-    # resize the license plate region to a canoncial size
-    plate_img = imutils.resize(plate_img, width=fixed_width)
-    thresh = imutils.resize(thresh, width=fixed_width)
-    bgr_thresh = cv2.cvtColor(thresh, cv2.COLOR_GRAY2BGR)
-
-    # perform a connected components analysis and initialize the mask to store the locations
-    # of the character candidates
-    labels = measure.label(thresh, neighbors=8, background=0)
-
-    charCandidates = np.zeros(thresh.shape, dtype='uint8')
-
-    # loop over the unique components
-    characters = []
-    for label in np.unique(labels):
-        # if this is the background label, ignore it
-        if label == 0:
-            continue
-        # otherwise, construct the label mask to display only connected components for the
-        # current label, then find contours in the label mask
-        labelMask = np.zeros(thresh.shape, dtype='uint8')
-        labelMask[labels == label] = 255
-
-        cnts = cv2.findContours(labelMask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        cnts = cnts[0] if imutils.is_cv2() else cnts[1]
-
-        # ensure at least one contour was found in the mask
-        if len(cnts) > 0:
-
-            # grab the largest contour which corresponds to the component in the mask, then
-            # grab the bounding box for the contour
-            c = max(cnts, key=cv2.contourArea)
-            (boxX, boxY, boxW, boxH) = cv2.boundingRect(c)
-
-            # compute the aspect ratio, solodity, and height ration for the component
-            aspectRatio = boxW / float(boxH)
-            solidity = cv2.contourArea(c) / float(boxW * boxH)
-            heightRatio = boxH / float(plate_img.shape[0])
-
-            # determine if the aspect ratio, solidity, and height of the contour pass
-            # the rules tests
-            keepAspectRatio = aspectRatio < 1.0
-            keepSolidity = solidity > 0.15
-            keepHeight = heightRatio > 0.5 and heightRatio < 0.95
-
-            # check to see if the component passes all the tests
-            if keepAspectRatio and keepSolidity and keepHeight and boxW > 14:
-                # compute the convex hull of the contour and draw it on the character
-                # candidates mask
-                hull = cv2.convexHull(c)
-
-                cv2.drawContours(charCandidates, [hull], -1, 255, -1)
-
-    _, contours, hier = cv2.findContours(charCandidates, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if contours:
-        contours = sort_cont(contours)
-        addPixel = 4  # value to be added to each dimension of the character
-        for c in contours:
-            (x, y, w, h) = cv2.boundingRect(c)
-            if y > addPixel:
-                y = y - addPixel
-            else:
-                y = 0
-            if x > addPixel:
-                x = x - addPixel
-            else:
-                x = 0
-            temp = bgr_thresh[y:y + h + (addPixel * 2), x:x + w + (addPixel * 2)]
-
-            characters.append(temp)
-        return characters
-    else:
-        return None
-
-
-class PlateFinder:
-    def __init__(self):
-        self.min_area = 4500  # minimum area of the plate
-        self.max_area = 30000  # maximum area of the plate
-
-        self.element_structure = cv2.getStructuringElement(shape=cv2.MORPH_RECT, ksize=(22, 3))
-
-    def preprocess(self, input_img):
-        imgBlurred = cv2.GaussianBlur(input_img, (7, 7), 0)  # old window was (5,5)
-        gray = cv2.cvtColor(imgBlurred, cv2.COLOR_BGR2GRAY)  # convert to gray
-        sobelx = cv2.Sobel(gray, cv2.CV_8U, 1, 0, ksize=3)  # sobelX to get the vertical edges
-        ret2, threshold_img = cv2.threshold(sobelx, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+import cv2
+import  imutils
+import sys
+import pytesseract
+import pandas as pd
+import time
 
-        element = self.element_structure
-        morph_n_thresholded_img = threshold_img.copy()
-        cv2.morphologyEx(src=threshold_img, op=cv2.MORPH_CLOSE, kernel=element, dst=morph_n_thresholded_img)
-        return morph_n_thresholded_img
+image = cv2.imread('car.jpeg')
 
-    def extract_contours(self, after_preprocess):
-        _, contours, _ = cv2.findContours(after_preprocess, mode=cv2.RETR_EXTERNAL,
-                                                    method=cv2.CHAIN_APPROX_NONE)
-        return contours
+image = imutils.resize(image, width=500)
 
-    def clean_plate(self, plate):
-        gray = cv2.cvtColor(plate, cv2.COLOR_BGR2GRAY)
-        thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)
-        _, contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+# displaying it
+cv2.imshow("Original Image", image)
 
-        if contours:
-            areas = [cv2.contourArea(c) for c in contours]
-            max_index = np.argmax(areas)  # index of the largest contour in the area array
+# converting it into gtray scale
+# cv2.imshow("1 - Grayscale Conversion", gray)
+gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
-            max_cnt = contours[max_index]
-            max_cntArea = areas[max_index]
-            x, y, w, h = cv2.boundingRect(max_cnt)
-            rect = cv2.minAreaRect(max_cnt)
-            rotatedPlate = plate
-            if not self.ratioCheck(max_cntArea, rotatedPlate.shape[1], rotatedPlate.shape[0]):
-                return plate, False, None
-            return rotatedPlate, True, [x, y, w, h]
-        else:
-            return plate, False, None
+#cv2.imshow("2 - Bilateral Filter", gray)
+gray = cv2.bilateralFilter(gray, 11, 17, 17)
 
+# canny edge detector
+#cv2.imshow("4 - Canny Edges", edged)
+edged = cv2.Canny(gray, 170, 200)
 
+"""
+there are three arguments in cv2.findContours() function, first one is source image, 
+second is contour retrieval mode, third is contour approximation method.py
 
-    def check_plate(self, input_img, contour):
-        min_rect = cv2.minAreaRect(contour)
-        if self.validateRatio(min_rect):
-            x, y, w, h = cv2.boundingRect(contour)
-            after_validation_img = input_img[y:y + h, x:x + w]
-            after_clean_plate_img, plateFound, coordinates = self.clean_plate(after_validation_img)
-            if plateFound:
-                characters_on_plate = self.find_characters_on_plate(after_clean_plate_img)
-                if (characters_on_plate is not None and len(characters_on_plate) == 8):
-                    x1, y1, w1, h1 = coordinates
-                    coordinates = x1 + x, y1 + y
-                    after_check_plate_img = after_clean_plate_img
-                    return after_check_plate_img, characters_on_plate, coordinates
-        return None, None, None
+If you pass cv2.CHAIN_APPROX_NONE, all the boundary points are stored.
+But actually do we need all the points? For eg, you found the contour of a straight line.
+Do you need all the points on the line to represent that line?
+No, we need just two end points of that line.
+This is what cv2.CHAIN_APPROX_SIMPLE does.
+It removes all redundant points and compresses the contour, thereby saving memory.
+"""
 
+cnts, _ = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
 
+# contour area is given by the function cv2.contourArea()
+cnts=sorted(cnts, key = cv2.contourArea, reverse = True)[:30]
+NumberPlateCnt = None
 
-    def find_possible_plates(self, input_img):
-        """
-        Finding all possible contours that can be plates
+count = 0
+for c in cnts:
         """
-        plates = []
-        self.char_on_plate = []
-        self.corresponding_area = []
-
-        self.after_preprocess = self.preprocess(input_img)
-        possible_plate_contours = self.extract_contours(self.after_preprocess)
-
-        for cnts in possible_plate_contours:
-            plate, characters_on_plate, coordinates = self.check_plate(input_img, cnts)
-            if plate is not None:
-                plates.append(plate)
-                self.char_on_plate.append(characters_on_plate)
-                self.corresponding_area.append(coordinates)
-
-        if (len(plates) > 0):
-            return plates
-        else:
-            return None
-
-    def find_characters_on_plate(self, plate):
-
-        charactersFound = segment_chars(plate, 400)
-        if charactersFound:
-            return charactersFound
-
-    # PLATE FEATURES
-    def ratioCheck(self, area, width, height):
-        min = self.min_area
-        max = self.max_area
-
-        ratioMin = 3
-        ratioMax = 6
-
-        ratio = float(width) / float(height)
-        if ratio < 1:
-            ratio = 1 / ratio
-
-        if (area < min or area > max) or (ratio < ratioMin or ratio > ratioMax):
-            return False
-        return True
-
-    def preRatioCheck(self, area, width, height):
-        min = self.min_area
-        max = self.max_area
-
-        ratioMin = 2.5
-        ratioMax = 7
-
-        ratio = float(width) / float(height)
-        if ratio < 1:
-            ratio = 1 / ratio
-
-        if (area < min or area > max) or (ratio < ratioMin or ratio > ratioMax):
-            return False
-        return True
-
-    def validateRatio(self, rect):
-        (x, y), (width, height), rect_angle = rect
-
-        if (width > height):
-            angle = -rect_angle
-        else:
-            angle = 90 + rect_angle
-
-        if angle > 15:
-            return False
-        if (height == 0 or width == 0):
-            return False
-
-        area = width * height
-        if not self.preRatioCheck(area, width, height):
-            return False
-        else:
-            return True
-
-
-class NeuralNetwork:
-    def __init__(self):
-        self.model_file = "./model/binary_128_0.50_ver3.pb"
-        self.label_file = "./model/binary_128_0.50_labels_ver2.txt"
-        self.label = self.load_label(self.label_file)
-        self.graph = self.load_graph(self.model_file)
-        self.sess = tf.Session(graph=self.graph)
-
-    def load_graph(self, modelFile):
-        graph = tf.Graph()
-        graph_def = tf.GraphDef()
-        with open(modelFile, "rb") as f:
-            graph_def.ParseFromString(f.read())
-        with graph.as_default():
-            tf.import_graph_def(graph_def)
-        return graph
-
-    def load_label(self, labelFile):
-        label = []
-        proto_as_ascii_lines = tf.gfile.GFile(labelFile).readlines()
-        for l in proto_as_ascii_lines:
-            label.append(l.rstrip())
-        return label
-
-    def convert_tensor(self, image, imageSizeOuput):
+        contour perimeter is also called arclength. It can be found out using cv2.arcLength()
+        function.Second argument specify whether shape is a closed contour( if passed
+        True), or just a curve.
         """
-    takes an image and tranform it in tensor
-    """
-        image = cv2.resize(image, dsize=(imageSizeOuput, imageSizeOuput), interpolation=cv2.INTER_CUBIC)
-        np_image_data = np.asarray(image)
-        np_image_data = cv2.normalize(np_image_data.astype('float'), None, -0.5, .5, cv2.NORM_MINMAX)
-        np_final = np.expand_dims(np_image_data, axis=0)
-        return np_final
-
-    def label_image(self, tensor):
-
-        input_name = "import/input"
-        output_name = "import/final_result"
-
-        input_operation = self.graph.get_operation_by_name(input_name)
-        output_operation = self.graph.get_operation_by_name(output_name)
-
-        results = self.sess.run(output_operation.outputs[0],
-                                {input_operation.outputs[0]: tensor})
-        results = np.squeeze(results)
-        labels = self.label
-        top = results.argsort()[-1:][::-1]
-        return labels[top[0]]
+        peri = cv2.arcLength(c, True)
+        approx = cv2.approxPolyDP(c, 0.02 * peri, True)
+        if len(approx) == 4:
+            NumberPlateCnt = approx
+            break
 
-    def label_image_list(self, listImages, imageSizeOuput):
-        plate = ""
-        for img in listImages:
-            if cv2.waitKey(25) & 0xFF == ord('q'):
-                break
-            plate = plate + self.label_image(self.convert_tensor(img, imageSizeOuput))
-        return plate, len(plate)
+# Masking the part other than the number plate
+mask = np.zeros(gray.shape,np.uint8)
+new_image = cv2.drawContours(mask,[NumberPlateCnt],0,255,-1)
+new_image = cv2.bitwise_and(image,image,mask=mask)
+cv2.namedWindow("Final_image",cv2.WINDOW_NORMAL)
+cv2.imshow("Final_image",new_image)
 
+# Configuration for tesseract
+config = ('-l eng --oem 1 --psm 3')
 
-if __name__ == "__main__":
-    findPlate = PlateFinder()
+# Run tesseract OCR on image
+text = pytesseract.image_to_string(new_image, config=config)
 
-    # Initialize the Neural Network
-    model = NeuralNetwork()
+#Data is stored in CSV file
+raw_data = {'date': [time.asctime( time.localtime(time.time()) )],
+        'v_number': [text]}
 
-    cap = cv2.VideoCapture('test_videos/test.MOV')
-    while (cap.isOpened()):
-        ret, img = cap.read()
-        if ret == True:
-            cv2.imshow('original video', img)
-            if cv2.waitKey(25) & 0xFF == ord('q'):
-                break
-            # cv2.waitKey(0)
-            possible_plates = findPlate.find_possible_plates(img)
-            if possible_plates is not None:
-                for i, p in enumerate(possible_plates):
-                    chars_on_plate = findPlate.char_on_plate[i]
-                    recognized_plate, _ = model.label_image_list(chars_on_plate, imageSizeOuput=128)
-                    print(recognized_plate)
-                    cv2.imshow('plate', p)
-                    if cv2.waitKey(25) & 0xFF == ord('q'):
-                        break
+df = pd.DataFrame(raw_data, columns = ['date', 'v_number'])
+df.to_csv('data.csv')
 
+# Print recognized text
+print(text)
 
-        else:
-            break
-    cap.release()
-    cv2.destroyAllWindows()
+cv2.waitKey(0)