Upload alpr.py

alpr.py

@@ -0,0 +1,287 @@
+import os
+
+import cv2
+import numpy as np
+import tensorflow.compat.v1 as tf
+from numpy.linalg import norm
+from local_utils import detect_lp
+from os.path import splitext
+from tensorflow.python.keras.backend import set_session
+from tensorflow.keras.models import model_from_json
+from tensorflow.compat.v1 import ConfigProto
+#from tensorflow.compat.v1 import InteractiveSession
+from vars import models_path
+
+
+
+class DetectLicensePlate:
+    def __init__(self):
+        tf.compat.v1.disable_eager_execution()
+        #config = ConfigProto()
+        #config.gpu_options.allow_growth = False
+        gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.433)
+        self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
+        #self.sess = tf.Session(config=config)
+        self.graph = tf.get_default_graph()
+        set_session(self.sess)
+
+        self.wpod_net_path = models_path+"wpod-net.json"  # model path
+        self.wpod_net = self.load_model(self.wpod_net_path)
+
+    def load_model(self, path):
+        try:
+            path = splitext(path)[0]
+            with open('%s.json' % path, 'r') as json_file:
+                model_json = json_file.read()
+            model = model_from_json(model_json, custom_objects={})
+            model.load_weights('%s.h5' % path)
+            print("Loading model successfully...")
+            self.graph = tf.get_default_graph()
+            return model
+        except Exception as e:
+            print(e)
+
+    def preprocess_image(self, image_path, resize=False):
+        img = image_path
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = img / 255
+        if resize:
+            img = cv2.resize(img, (224, 224))
+        return img
+
+    def get_plate(self, image_path, Dmax=608, Dmin=608):
+        vehicle = self.preprocess_image(image_path)
+        ratio = float(max(vehicle.shape[:2])) / min(vehicle.shape[:2])
+        side = int(ratio * Dmin)
+        bound_dim = min(side, Dmax)
+        _, plates, _, cor = detect_lp(self.graph,self.sess,self.wpod_net, vehicle, bound_dim, lp_threshold=0.5)
+        return vehicle, plates, cor
+
+
+class Segmentation:
+    # to grab the contour of each digit from left to right
+    def sort_contours(self, cnts, reverse=False):
+        i = 0
+        boundingBoxes = [cv2.boundingRect(c) for c in cnts]
+        (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
+                                            key=lambda b: b[1][i], reverse=False))
+        return cnts
+
+    def find_characters(self, thresh, plate_image):
+        # 2li 3lü gruplama için
+        tmp_space = None
+        short_space = None
+        letter_num = 0
+        state_ = 0
+
+        cont, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # creat a copy version "test_roi" of plat_image to draw bounding box
+        test_roi = thresh.copy()
+
+        # Initialize a list which will be used to append charater image
+        crop_characters = []
+
+        # define standard width and height of character
+        digit_w, digit_h = 32, 32
+        try:
+            conturs = self.sort_contours(cont)
+        except:
+            return
+        for c in conturs:
+            (x, y, w, h) = cv2.boundingRect(c)
+            ratio = h / w
+            if 1 <= ratio <= 5.7:  # Only select contour with defined ratio
+                if h / plate_image.shape[0] >= 0.3:  # Select contour which has the height larger than 50% of the plate
+                    if letter_num == 1:
+                        short_space = x - tmp_space
+                    if letter_num == 3:
+                        space = x - tmp_space
+                        if space > short_space + 2:
+                            # print("4.karakter sayı")
+                            state_ = 2
+                            letter_num += 2
+                    elif letter_num == 4:
+                        space = x - tmp_space
+                        if space > short_space + 2:
+                            state_ = 3
+                            # print("5.karakter sayı")
+                        else:
+                            state_ = 4
+                            # print("5.karakter harf")
+                    tmp_space = x + w
+
+                    # Draw bounding box arroung digit number
+                    cv2.rectangle(test_roi, (x, y), (x + w, y + h), (0, 255, 0), 2)
+                    try:
+                        # Sperate number and gibe prediction
+                        curr_num = thresh[y - 1:y + h + 2, x - 1:x + w + 2]
+                        curr_num = cv2.resize(curr_num, dsize=(digit_w, digit_h))
+                        crop_characters.append(curr_num)
+                        letter_num += 1
+                    except Exception as e:
+                        print(str(e))
+        return crop_characters, state_
+
+
+class SVM(object):
+    def __init__(self, C=1.0, gamma=0.5):  # def C = 1.0, gamma = 0.5
+        self.model = cv2.ml.SVM_create()
+        self.model.setGamma(gamma)
+        self.model.setC(C)
+        self.model.setKernel(cv2.ml.SVM_RBF)
+        self.model.setType(cv2.ml.SVM_C_SVC)
+
+    def train(self, samples, responses):
+        self.model.train(samples, cv2.ml.ROW_SAMPLE, responses)
+
+    def predict(self, samples):
+        return self.model.predict(samples)[1].ravel()
+
+    def load(self, fn):
+        self.model = cv2.ml.SVM_load(fn)
+
+    def save(self, fn):
+        self.model.save(fn)
+
+
+class Ocr:
+    def __init__(self):
+
+        self.letter_dict = dict()
+        self.letter_dict["0"] = "O"
+        self.letter_dict["1"] = "I"
+        self.letter_dict["2"] = "Z"
+        self.letter_dict["3"] = "3"
+        self.letter_dict["4"] = "L"
+        self.letter_dict["5"] = "S"
+        self.letter_dict["6"] = "G"
+        self.letter_dict["7"] = "7"
+        self.letter_dict["8"] = "B"
+        self.letter_dict["9"] = "9"
+        self.letter_dict["10"] = "A"
+        self.letter_dict["11"] = "B"
+        self.letter_dict["12"] = "C"
+        self.letter_dict["13"] = "D"
+        self.letter_dict["14"] = "E"
+        self.letter_dict["15"] = "F"
+        self.letter_dict["16"] = "G"
+        self.letter_dict["17"] = "H"
+        self.letter_dict["18"] = "I"
+        self.letter_dict["19"] = "J"
+        self.letter_dict["20"] = "K"
+        self.letter_dict["21"] = "L"
+        self.letter_dict["22"] = "M"
+        self.letter_dict["23"] = "N"
+        self.letter_dict["24"] = "O"
+        self.letter_dict["25"] = "P"
+        self.letter_dict["26"] = "R"
+        self.letter_dict["27"] = "S"
+        self.letter_dict["28"] = "T"
+        self.letter_dict["29"] = "U"
+        self.letter_dict["30"] = "V"
+        self.letter_dict["31"] = "Y"
+        self.letter_dict["32"] = "Z"
+
+        self.num_dict = dict()
+        self.num_dict["0"] = "0"
+        self.num_dict["1"] = "1"
+        self.num_dict["2"] = "2"
+        self.num_dict["3"] = "3"
+        self.num_dict["4"] = "4"
+        self.num_dict["5"] = "5"
+        self.num_dict["6"] = "6"
+        self.num_dict["7"] = "7"
+        self.num_dict["8"] = "8"
+        self.num_dict["9"] = "9"
+        self.num_dict["10"] = "A"
+        self.num_dict["11"] = "8"
+        self.num_dict["12"] = "C"
+        self.num_dict["13"] = "0"
+        self.num_dict["14"] = "E"
+        self.num_dict["15"] = "F"
+        self.num_dict["16"] = "6"
+        self.num_dict["17"] = "H"
+        self.num_dict["18"] = "1"
+        self.num_dict["19"] = "3"
+        self.num_dict["20"] = "K"
+        self.num_dict["21"] = "4"
+        self.num_dict["22"] = "M"
+        self.num_dict["23"] = "N"
+        self.num_dict["24"] = "0"
+        self.num_dict["25"] = "P"
+        self.num_dict["26"] = "8"
+        self.num_dict["27"] = "5"
+        self.num_dict["28"] = "T"
+        self.num_dict["29"] = "U"
+        self.num_dict["30"] = "V"
+        self.num_dict["31"] = "Y"
+        self.num_dict["32"] = "2"
+
+    def preprocess_hog(self, digits):
+        samples = []
+        for img in digits:
+            gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
+            gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
+            mag, ang = cv2.cartToPolar(gx, gy)
+            bin_n = 16
+            bin = np.int32(bin_n * ang / (2 * np.pi))
+            bin_cells = bin[:10, :10], bin[10:, :10], bin[:10, 10:], bin[10:, 10:]
+            mag_cells = mag[:10, :10], mag[10:, :10], mag[:10, 10:], mag[10:, 10:]
+            hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
+            hist = np.hstack(hists)
+
+            # transform to Hellinger kernel
+            eps = 1e-7
+            hist /= hist.sum() + eps
+            hist = np.sqrt(hist)
+            hist /= norm(hist) + eps
+            samples.append(hist)
+        return np.float32(samples)
+
+    def deskew(self, img):
+        SZ = 32
+        m = cv2.moments(img)
+        if abs(m['mu02']) < 1e-2:
+            return img.copy()
+        skew = m['mu11'] / m['mu02']
+        M = np.float32([[1, skew, -0.5 * SZ * skew], [0, 1, 0]])
+        img = cv2.warpAffine(img, M, (SZ, SZ), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR)
+        return img
+
+    def find_label(self, character_, model_):
+        arr = [character_]
+        arr = np.array(arr)
+        mapped = list(map(self.deskew, arr))
+        mapped = self.preprocess_hog(mapped)
+        predict = model_.predict(mapped)[0].ravel()
+        return str(predict).split(".")[0].replace("[", "").replace(" ","").replace("]","")
+
+    def recognize_characters(self, characters, model_, state):
+        plate_text = ""
+        num = 0
+        for character in characters:
+            character = cv2.bitwise_not(character)
+            pred = self.find_label(character, model_)
+            if num < 2 or num > state:
+                plate_text += self.num_dict.get(pred)
+            else:
+                plate_text += self.letter_dict.get(pred)
+            num += 1
+        return plate_text
+
+
+
+
+def alpr(frame,license_plate):
+
+    plate_image = frame.copy()
+
+    try:
+        vehicle, plates, cor = license_plate.get_plate(frame)
+        return plates[0]
+
+    except Exception as e:
+        print(str(e))
+
+