1

Author: cdahms123

1.png

@@ -0,0 +1,142 @@
+# DetectChars.py
+
+import cv2
+import numpy as np
+import math
+
+# module level variables ##########################################################################
+
+kNearest = cv2.ml.KNearest_create()
+
+        # constants for checkIfPossibleChar, this checks one possible char only (does not compare to another char)
+MIN_PIXEL_WIDTH = 2
+MIN_PIXEL_HEIGHT = 8
+
+MIN_ASPECT_RATIO = 0.25
+MAX_ASPECT_RATIO = 1.0
+
+MIN_PIXEL_AREA = 80
+
+        # constants for comparing two chars
+MIN_DIAG_SIZE_MULTIPLE_AWAY = 0.3
+MAX_DIAG_SIZE_MULTIPLE_AWAY = 5.0
+
+MAX_CHANGE_IN_AREA = 0.5
+
+MAX_CHANGE_IN_WIDTH = 0.8
+MAX_CHANGE_IN_HEIGHT = 0.2
+
+MAX_ANGLE_BETWEEN_CHARS = 12.0
+
+        # other constants
+MIN_NUMBER_OF_MATCHING_CHARS = 3
+
+RESIZED_CHAR_IMAGE_WIDTH = 20
+RESIZED_CHAR_IMAGE_HEIGHT = 30
+
+MIN_CONTOUR_AREA = 100
+
+###################################################################################################
+def loadKNNDataAndTrainKNN():
+
+
+
+
+    return True
+# end function
+
+###################################################################################################
+def detectCharsInPlates(listOfPossiblePlates):
+
+
+
+
+    return listOfPossiblePlates
+# end function
+
+###################################################################################################
+def findPossibleCharsInPlate(imgGrayscale, imgThresh):
+
+    listOfPossibleChars = []
+
+
+
+    return listOfPossibleChars
+# end function
+
+###################################################################################################
+def checkIfPossibleChar(possibleChar):
+
+
+
+    return True
+# end function
+
+###################################################################################################
+def findListOfListsOfMatchingChars(listOfPossibleChars):
+
+    listOfListOfMatchingChars = []
+
+
+    return listOfListOfMatchingChars
+# end function
+
+###################################################################################################
+def findListOfMatchingChars(possibleChar, listOfChars):
+
+    listOfMatchingChars = []
+
+
+
+    return listOfMatchingChars
+# end function
+
+###################################################################################################
+def distanceBetweenChars(firstChar, secondChar):
+
+    intX = abs(firstChar.intCenterX - secondChar.intCenterX)
+    intY = abs(firstChar.intCenterY - secondChar.intCenterY)
+
+    return math.sqrt((intX ** 2) + (intY ** 2))
+# end function
+
+###################################################################################################
+def angleBetweenChars(firstChar, secondChar):
+
+    fltAdj = float(abs(firstChar.intCenterX - secondChar.intCenterX))
+    fltOpp = float(abs(firstChar.intCenterY - secondChar.intCenterY))
+
+    fltAngleInRad = math.atan(fltOpp / fltAdj)
+
+    fltAngleInDeg = fltAngleInRad * (180.0 / math.pi)
+
+    return fltAngleInDeg
+# end function
+
+###################################################################################################
+def removeInnerOverlappingChars(listOfMatchingChars):
+    listOfMatchingCharsWithInnerCharRemoved = []
+
+
+
+    return listOfMatchingCharsWithInnerCharRemoved
+# end function
+
+###################################################################################################
+def recognizeCharsInPlate(imgThresh, listOfMatchingChars):
+    strChars = ""
+
+
+
+
+
+    return strChars
+# end function
+
+
+
+
+
+
+
+

DetectChars.py

@@ -0,0 +1,47 @@
+# DetectPlates.py
+
+import cv2
+import numpy as np
+import math
+
+# module level variables ##########################################################################
+PLATE_WIDTH_PADDING_FACTOR = 1.3
+PLATE_HEIGHT_PADDING_FACTOR = 1.5
+
+###################################################################################################
+def detectPlatesInScene(imgOriginalScene):
+
+    listOfPossiblePlates = []
+
+
+
+    return listOfPossiblePlates
+# end function
+
+###################################################################################################
+def findPossibleCharsInScene(imgThresh):
+
+    listOfPossibleChars
+
+
+
+    return listOfPossibleChars
+# end function
+
+
+###################################################################################################
+def extractPlate(imgOriginal, listOfMatchingChars):
+
+    possiblePlate = PossiblePlate()
+
+
+    return possiblePlate
+# end function
+
+
+
+
+
+
+
+

DetectPlates.py

@@ -0,0 +1,80 @@
+# Main.py
+
+import cv2
+import numpy as np
+import os
+
+import DetectChars
+import DetectPlates
+import PossiblePlate
+
+# module level variables ##########################################################################
+SCALAR_BLACK = (0.0, 0.0, 0.0)
+SCALAR_WHITE = (255.0, 255.0, 255.0)
+SCALAR_YELLOW = (0.0, 255.0, 255.0)
+SCALAR_GREEN = (0.0, 255.0, 0.0)
+SCALAR_RED = (0.0, 0.0, 255.0)
+
+###################################################################################################
+def main():
+
+    blnKNNTrainingSuccessful = DetectChars.loadKNNDataAndTrainKNN()
+
+    if blnKNNTrainingSuccessful:
+        print "\n\nerror: error: KNN traning was not successful\n\n"
+        return
+    # end if
+
+    imgOriginalScene  = cv2.imread("1.png")               # open image
+
+    if imgOriginal is None:                             # if image was not read successfully
+        print "\nerror: image not read from file \n\n"      # print error message to std out
+        os.system("pause")                                  # pause so user can see error message
+        return                                              # and exit function (which exits program)
+
+    listOfPossiblePlates = DetectPlates.detectPlatesInScene(imgOriginalScene)
+
+    listOfPossiblePlates = DetectChars.detectCharsInPlates(listOfPossiblePlates)
+
+    cv2.imshow("imgOriginalScene", imgOriginalScene)
+
+    if listOfPossiblePlates.empty():
+        print "\nno license plates were detected\n"
+    else:
+                # if we get in here vector of possible plates has at leat one plate
+
+                # sort the vector of possible plates in DESCENDING order (most number of chars to least number of chars)
+
+
+        # left off here !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+
+
+
+        pass
+    # end if else
+
+
+
+
+    return
+# end main
+
+###################################################################################################
+def drawRedRectangleAroundPlate(imgOriginalScene, licPlate):
+    pass
+# end function
+
+###################################################################################################
+def writeLicensePlateCharsOnImage(imgOriginalScene, licPlate):
+    pass
+# end function
+
+###################################################################################################
+if __name__ == "__main__":
+    main()
+
+
+
+
+

Main.py

@@ -0,0 +1,26 @@
+# PossibleChar.py
+
+import cv2
+import numpy as np
+
+###################################################################################################
+class PossibleChar:
+
+    # constructor #################################################################################
+    def __init__(self, _contour):
+        self.contour = _contour
+
+        self.boundingRect = cv2.boundingRect(self.contour)
+
+        self.intCenterX = (self.boundingRect.x + self.boundingRect.x + self.boundingRect.width) / 2
+        self.intCenterY = (self.boundingRect.y + self.boundingRect.y + self.boundingRect.height) / 2
+
+        self.fltDiagonalSize = sqrt((boundingRect.width ** 2) + (boundingRect.height ** 2))
+
+        self.fltAspectRatio = boundingRect.width / boundingRect.height
+    # end constructor
+
+# end class
+
+
+

PossibleChar.py

@@ -0,0 +1,24 @@
+# PossiblePlate.py
+
+import cv2
+import numpy as np
+
+###################################################################################################
+class PossiblePlate:
+
+    # constructor #################################################################################
+    def __init__(self, name):
+        self.imgPlate = None
+        self.imgGrayscale = None
+        self.imgThresh = None
+
+        self.rrLocationOfPlateInScene = None
+
+        self.strChars = ""
+    # end constructor
+
+# end class
+
+
+
+

PossiblePlate.py

@@ -0,0 +1,68 @@
+# Preprocess.py
+
+import cv2
+import numpy as np
+import math
+
+# module level variables ##########################################################################
+GAUSSIAN_SMOOTH_FILTER_SIZE = (5, 5)
+ADAPTIVE_THRESH_BLOCK_SIZE = 19
+ADAPTIVE_THRESH_WEIGHT = 9
+
+###################################################################################################
+def preprocess(imgOriginal, imgGrayscale, imgThresh):
+    imgGrayscale = extractValue(imgOriginal)
+
+    imgMaxContrastGrayscale = maximizeContrast(imgGrayscale)
+
+    height, width = imgGrayscale.shape
+
+    imgBlurred = np.zeros((height, width, 1), np.uint8)
+
+    cv2.GaussianBlur(imgMaxContrastGrayscale, imgBlurred, GAUSSIAN_SMOOTH_FILTER_SIZE, 0)
+
+    cv2.adaptiveThreshold(imgBlurred, imgThresh, 255.0, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, ADAPTIVE_THRESH_BLOCK_SIZE, ADAPTIVE_THRESH_WEIGHT)
+# end function
+
+###################################################################################################
+def extractValue(imgOriginal):
+
+    height, width, numChannels = imgOriginal.shape
+
+    imgHSV = np.zeros((height, width, 3), np.uint8)
+
+    cv2.cvtColor(imgOriginal, imgHSV, cv2.COLOR_BGR2HSV)
+
+    imgHue, imgSaturation, imgValue = cv2.split(imgHSV)
+
+    return imgValue
+# end function
+
+###################################################################################################
+def maximizeContrast(imgGrayscale):
+
+    height, width = imgGrayscale.shape
+
+    imgTopHat = np.zeros((height, width, 1), np.uint8)
+    imgBlackHat = np.zeros((height, width, 1), np.uint8)
+
+    structuringElement = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+
+    cv2.morphologyEx(imgGrayscale, imgTopHat, cv2.MORPH_TOPHAT, structuringElement)
+    cv2.morphologyEx(imgGrayscale, imgBlackHat, cv2.MORPH_BLACKHAT, structuringElement)
+
+    imgGrayscalePlusTopHat = imgGrayscale + imgTopHat
+    imgGrayscalePlusTopHatMinusBlackHat = imgGrayscalePlusTopHat - imgBlackHat
+
+    return imgGrayscalePlusTopHatMinusBlackHat
+# end function
+
+
+
+
+
+
+
+
+
+