Update alpr.py

alpr.py

@@ -9,9 +9,6 @@ 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:
@@ -25,7 +22,7 @@ class DetectLicensePlate:
         self.graph = tf.get_default_graph()
         set_session(self.sess)
 
-        self.wpod_net_path = models_path+"wpod-net.json"  # model path
+        self.wpod_net_path ="wpod-net.json"  # model path
         self.wpod_net = self.load_model(self.wpod_net_path)
 
     def load_model(self, path):
@@ -58,218 +55,6 @@ class DetectLicensePlate:
         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
-