def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
imgGrayscaleScene, imgThreshScene = preprocess(imgOriginalScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
# end if
# end for
#print("\n" + str(len(listOfPossiblePlates)) + " possible plates found") # 13 with MCLRNF1 image
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
possiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
possibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(possibleCharsInScene)
for matchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, matchingChars)
if possiblePlate.imgPlate is not None:
possiblePlates.append(possiblePlate)
print "\n" + str(len(possiblePlates)) + " possible plates found"
return possiblePlates
def detectPlatesInScene(imgOriginal):
possiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginal.shape
frameThresh = np.zeros((height, width, 1), np.uint8)
frameContours = np.zeros((height, width, 3), np.uint8)
#cv2.destroyAllWindows()
frameThresh = filter.threshold(imgOriginal)
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
possibleCharsInScene = findPossibleCharsInScene(frameThresh)
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
possibleCharsInScene)
# for each group of matching chars
for matchingChars in listOfListsOfMatchingCharsInScene:
# attempt to extract plate
plate = extractPlate(imgOriginal, matchingChars)
# if plate was found
if plate.plateCrop is not None:
# add to list of possible plates
possiblePlates.append(plate)
return possiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # preprocess to get grayscale and threshold images
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
# end if
# end for
#print("\n" + str(len(listOfPossiblePlates)) + " possible plates found") # 13 with MCLRNF1 image
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
print ("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
# cv2.destroyAllWindows()
# 1. Przetworzenie zdjecia
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # preprocess to get grayscale and threshold images
# 2. Znajdywanie potencjalnego tekstu na zdjeciu - wycwiczona funkcja porownuje zdjecie ze zbiorem znakow, grupuje je
# find all contours, then only include contours that could be chars
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
# 3. Za krotkie ciagi sa odrzucane, reszta traktowana jako potencjalne tablice.
# given a list of all possible chars, find groups of matching chars
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = rotatePlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene, debug=True):
if debug:
imgDebug = copy.copy(imgOriginalScene)
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # preprocess to get grayscale and threshold images
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = findPossibleCharsInScene(
imgThreshScene
) # Here we get a list of all the contours in the image that may be characters.
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
#lista de listas :V
if debug:
contador = 0
if (len(listOfListsOfMatchingCharsInScene) > 0):
#print(type(listOfListsOfMatchingCharsInScene[0]))
for lists in listOfListsOfMatchingCharsInScene:
for chars in lists:
(x, y) = chars.intBoundingRectX, chars.intBoundingRectY
(
w, h
) = chars.intBoundingRectWidth, chars.intBoundingRectHeight
cv2.rectangle(imgDebug, (x, y), (x + w, y + h),
colors[contador % 3], 2)
#font = cv2.FONT_HERSHEY_SIMPLEX
#cv2.putText(imgDebug, str(contador), (x, y), font, 1, (0, 0, 0), 1,cv2.LINE_AA)
contador += 1
cv2.imwrite("imgDebug.jpg", imgDebug)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
# Niz sa potencijalnim tablicama, isti kao u Main.py
listOfPossiblePlates = []
# Ddređivanje visine, širine i broja kanala originalne slike
height, width, numChannels = imgOriginalScene.shape
# Prazne matrice u koje se sprema obrađena slika.
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
# Uništavanje prozora
cv2.destroyAllWindows()
# ----------------------------- PREOBRADA SLIKE - PREPROCESS ( 1 ) --------------------------------------------------
# Pozivanje druge skripte i istoimene funkcije u njoj Preprocess
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # PROMJENA Preprocess.py
# Vraćanje iz Preprocess skripte sa dvije matrice, imgGrayscale i imgTresh
# ------------------------------------------------------------------------------------------------------------------
# ----------------------------- TRAŽENJE ZNAKOVA ( 2 ) -------------------------------------------------------------
# Funkcija koristi matricu imgTreshScene ( crno-bijela slika bez šuma ) - binarna slika
listOfPossibleCharsInScene = findPossibleCharsInScene(
imgThreshScene) # LOKALNA PROMJENA
# Dobivene su konture koju su najvjerojantije znak, jer su mjerene dimenzije
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene) # PROMEJNA
# Vraća listulistaMogucih znakova
# Traženje tablice medju mogucim tablicama
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene,
listOfMatchingChars) # LOKALNA PROMJENA
# Došla possible plate iz funcije extract plate
# Ukoliko tablica postoji, dodajes se u listu tablica
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
# Ispis na konzoli : broj pronađenih tablica
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
# Vraća broj mogucih tablica
return listOfPossiblePlates
def detectPlatesInScene(input_image):
Possible_Plates = []
height, width, Channels = input_image.shape
threshold_image = np.zeros((height, width, 1), np.uint8)
grayscale_image, threshold_image = Preprocess.preprocess(input_image)
# cv2.imshow("grayscale", grayscale_image)
# cv2.imshow("threshold", threshold_image)
#finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
Possible_Chars = get_Possible_Chars_in_input_image(threshold_image)
# given a list of all possible chars, find groups of matching chars
Matching_Chars = DetectChars.findListOfListsOfMatchingChars(Possible_Chars)
for listOfMatchingChars in Matching_Chars:
possiblePlate = extractPlate(input_image, listOfMatchingChars)
if possiblePlate.imgPlate is not None:
Possible_Plates.append(possiblePlate)
return Possible_Plates
def detect_plate(imgOriginalScene):
possible_plates = [] # this will be the return value
# extracint values, like height, width, and number of hannels
height, width, numChannels = imgOriginalScene.shape
# Initialization
GrayscaleScene = np.zeros((height, width, 1), np.uint8)
ThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
#First, calling the preprocess function
GrayscaleScene, ThreshScene = Preprocess.preprocess(imgOriginalScene)
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = find_char(ThreshScene)
#After this function returns we have a list of contous that are possibile to be characters.
# This function find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
#For each group, extract the plate
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = plate_extraction(imgOriginalScene, listOfMatchingChars)
#if plate is foun, add it to the list
if possiblePlate.imgPlate is not None:
possible_plates.append(possiblePlate)
return possible_plates
def detectPlatesInScene(imgOriginalScene,type):
listOfPossiblePlates = [] # Dönüş değeri olacak
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8) #matris olusturma
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene,type) # Gri tonlamalı ve eşikli görüntüler elde etmek için ön işlem
# Sahnedeki tüm olası karakterleri bul
# Bu işlev ilk önce tüm konturları bulur, ardından sadece karakter olabilecek kontürleri içerir (henüz diğer karakterlerle karşılaştırılmadan)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
# Olası tüm karakterlerin bir listesi verildiğinde eşleşen karakter gruplarını bulun
# Sonraki adımlarda, eşleşen her karakter grubu bir plaka olarak tanınmaya çalışacaktır
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # Eşleşen karakter grubunun her biri için
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars) # Plaka çıkarma girişimi
if possiblePlate.imgPlate is not None: # Eğer plaka bulunursa
listOfPossiblePlates.append(possiblePlate) # Olası plakalar listesine ekle
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene): #单个单个char组成的list
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
cv2.destroyAllWindows()
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
#单个单个char组成的list
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
#把识别到的chars分组
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
#识别可能是车牌的char组
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
#grayscale and threshold images preprocessing
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
# Here we get a list of all the contours in the image that may be characters.
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True: # show steps #######################################################
cv2.imshow("0", imgOriginalScene)
# end if # show steps #########################################################################
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene) # preprocess to get grayscale and threshold images
if Main.showSteps == True: # show steps #######################################################
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# end if # show steps #########################################################################
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True: # show steps #######################################################
print "step 2 - len(listOfPossibleCharsInScene) = " + str(len(listOfPossibleCharsInScene)) # 131 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# end if # show steps #########################################################################
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
if Main.showSteps == True: # show steps #######################################################
print "step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(len(listOfListsOfMatchingCharsInScene)) # 13 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, (intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
# end if # show steps #########################################################################
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(possiblePlate) # add to list of possible plates
# end if
# end for
print "\n" + str(len(listOfPossiblePlates)) + " possible plates found" # 13 with MCLRNF1 image
if Main.showSteps == True: # show steps #######################################################
print "\n"
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]), tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]), tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]), tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]), tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print "possible plate " + str(i) + ", click on any image and press a key to continue . . ."
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
# end for
print "\nplate detection complete, click on any image and press a key to begin char recognition . . .\n"
cv2.waitKey(0)
# end if # show steps #########################################################################
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene): #Orjinal resmi aldı
listOfPossiblePlates = [
] # this will be the return value #Muhtemel plaka boş listesi
height, width, numChannels = imgOriginalScene.shape #O.R. Şekillendirildi
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) #Resim gray ve threshe çevrildi.
# preprocess to get grayscale and threshold images
if Main.showSteps == True:
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
#findPossibleCharsInScene fonksiyoununa Thresh resmi verildi. ---> findPossibleCharsInScene
#KARAKTER OLMASI MUHTEMEL OLAN ŞEKİLLER listOfPossibleCharsInScene' E EKLENDİ
if Main.showSteps == True:
print("step 2 - len(listOfPossibleCharsInScene) = " +
str(len(listOfPossibleCharsInScene))) # 131 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene: #
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(
len(listOfListsOfMatchingCharsInScene))) # 13 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
cv2.imshow("3", imgContours)
#GÖRÜNTÜDE Kİ PLAKA OLMASI MUHTEMEL GÖRÜNTÜLER BULUNDU
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
print("\n" + str(len(listOfPossiblePlates)) +
" plaka olması muhtemel görüntü bulundu.") # 13 with MCLRNF1 image
if Main.showSteps == True:
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("possible plate " + str(i) +
", click on any image and press a key to continue . . .")
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
print(
"\nplate detection complete, click on any image and press a key to begin char recognition . . .\n"
)
cv2.waitKey(0)
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # tiền xử lý đưa ảnh sang thang màu xám
if Main.showSteps == True: # show quá trình thực hiện
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# Tìm tất cả các ký tự có trong ảnh
# tìm các đường viền trong hình và bao quanh các đường viền đó không phân biệt đó có phải là ký tự hay không
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
print("step 2 - len(listOfPossibleCharsInScene) = " +
str(len(listOfPossibleCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " +
str(len(listOfListsOfMatchingCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
cv2.imshow("3", imgContours)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
if possiblePlate.imgPlate is not None: # nếu thìm thấy biển số
listOfPossiblePlates.append(possiblePlate)
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
if Main.showSteps == True:
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("possible plate " + str(i) +
", click on any image and press a key to continue . . .")
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
print(
"\nplate detection complete, click on any image and press a key to begin char recognition . . .\n"
)
cv2.waitKey(0)
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # este será el valor de retorno
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True: # mostrar pasos
cv2.imshow("0", imgOriginalScene)
# end if # mostrar pasos
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene
) # preproceso para obtener imágenes en escala de grises y umbral
if Main.showSteps == True: # mostrar pasos
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# end if # ,ostrar pasos
# encuentra todos los caracteres posibles en la escena,
#Esta función primero encuentra todos los contornos, luego solo incluye los contornos que podrían ser caracteres (sin comparación con otros caracteres aún)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True: # mostrar pasos
print("step 2 - len(listOfPossibleCharsInScene) = " +
str(len(listOfPossibleCharsInScene))) # 131 con imagen MCLRNF1
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# end if # mostrar pasos
# dada una lista de todos los caracteres posibles, encuentre grupos de caracteres coincidentes
# En los próximos pasos, cada grupo de caracteres coincidentes intentará ser reconocido como una placa
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True: # mostrar pasos
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(
len(listOfListsOfMatchingCharsInScene))) # 13 con MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
# end if # mostrar pasos
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # para cada grupo de caracteres coincidentes
possiblePlate = extractPlate(
imgOriginalScene,
listOfMatchingChars) # para cada grupo de caracteres coincidentes
if possiblePlate.imgPlate is not None: # si se encontró placa
listOfPossiblePlates.append(
possiblePlate) # añadir a la lista de posibles platos
# end if
# end for
print("\n" + str(len(listOfPossiblePlates)) +
" posibles placas encontradas") # 13 con MCLRNF1 image
if Main.showSteps == True: # mostrar pasos
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print(
"posible placa " + str(i) +
", haga clic en cualquier imagen y presione una tecla para continuar . . ."
)
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
# end for
print(
"\nplate detection complete, click on any image and press a key to begin char recognition . . .\n"
)
cv2.waitKey(0)
# end if # mostrar pasos
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
if Main.showSteps == True:
Image.fromarray(imgOriginalScene).show()
input('Press any key to continue...')
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
Image.fromarray(imgOriginalScene).show()
input('Press any key to continue...')
# This is for the boxing of all the contours
"""
for possibleChar in listOfPossibleCharsInScene:
cv2.rectangle(imgContours,(possibleChar.intBoundingRectX,possibleChar.intBoundingRectY),(possibleChar.intBoundingRectX+possibleChar.intBoundingRectWidth,possibleChar.intBoundingRectY+possibleChar.intBoundingRectHeight),(0.0, 255.0, 255.0),1)
cv2.imshow('PossiblePlate',imgContours)
cv2.waitKey(0)
"""
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
if Main.showSteps == True: # show steps #######################################################
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(len(listOfListsOfMatchingCharsInScene))) # 13 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
#imgContours2 = np.zeros((height, width, 3), np.uint8)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
#cv2.drawContours(imgContours, contours, -1, (255, 255, 255))
cv2.drawContours(imgContours, contours, -1, (intRandomBlue, intRandomGreen, intRandomRed))
# end for
#imgContours = Image.fromarray(imgContours,'RGB').show()
# end if # show steps #########################################################################
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(possiblePlate) # add to list of possible plates
if Main.showSteps == True:
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
if Main.showSteps == True: # show steps #######################################################
print("\n")
Image.fromarray(imgContours,'RGB').show()
input('Press any key to continue...')
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]), tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]), tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]), tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]), tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
#cv2.imshow("4a", imgContours)
print("possible plate " + str(i) + ", click on any image and press a key to continue . . .")
#Image.fromarray(listOfPossiblePlates[i].imgPlate,'RGB').show()
# end for
print("\nplate detection complete, press a key to begin char recognition . . .\n")
input()
# end if # show steps #########################################################################
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
if Main.showSteps == True:
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
print "step 2 - len(listOfPossibleCharsInScene) = " + str(len(listOfPossibleCharsInScene))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
if Main.showSteps == True:
print "step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(len(listOfListsOfMatchingCharsInScene))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
cv2.drawContours(imgContours, contours, -1, (intRandomBlue, intRandomGreen, intRandomRed))
cv2.imshow("3", imgContours)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
if Main.showSteps == True:
print "\n"
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]), tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]), tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]), tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]), tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print "possible plate " + str(i) + ", click on any image and press a key to continue . . ."
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
print "\nplate detection complete, click on any image and press a key to begin char recognition . . .\n"
cv2.waitKey(0)
return listOfPossiblePlates
def detectPlatesInScene(img):
listOfPossiblePlates = []
height, width, numChannels = img.shape
imgGray = np.zeros((height, width, 1), np.uint8)
imgThresh = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", img)
imgGray, imgThresh = Preprocess.preprocess(img) # preprocess to get grayscale and threshold images
if Main.showSteps == True:
cv2.imshow("Gray SCale Image", imgGray)
cv2.imshow("Image threshold", imgThresh)
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThresh)
if Main.showSteps == True: #
print("step 2 - len(listOfPossibleCharsInScene) = " + str(len(listOfPossibleCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
if Main.showSteps == True:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str( len(listOfListsOfMatchingCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
RandomBlue = random.randint(0, 255)
RandomGreen = random.randint(0, 255)
RandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
cv2.drawContours(imgContours, contours, -1, (RandomBlue, RandomGreen, RandomRed))
cv2.imshow("Image Contours", imgContours)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(img, listOfMatchingChars)
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
if Main.showSteps == True:
print("\n")
cv2.imshow("Image Contours", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]), tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]), tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]), tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]), tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("Image Contpurs", imgContours)
print("possible plate " + str(i) + ", click on any image and press a key to continue . . .")
cv2.imshow("List of Possible plates", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
print("\nplate detection complete, click on any image and press a key to begin char recognition . . .\n")
cv2.waitKey(0)
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
# Verifica se esta no modo debug
if Main.showSteps:
cv2.imshow("0", imgOriginalScene)
# Executa o pré-processamento para recuperar as imagens de escala de cinza e binária
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
if Main.showSteps:
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# Encontra todos os possiveis caracteres na cena
# Esta funcao primeiramente encontra todos os contornos e inclui apenas os contornos que podem ser um caracter (sem comparar por enquanto)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps:
print "step 2 - len(listOfPossibleCharsInScene) = " + str(
len(listOfPossibleCharsInScene)) # 131 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# end if
# A partir da lista de todos os possiveis caracteres, encontre grupos de caracteres semelhantes
# No proximo passo cada grupo tentará ser reconhecido como uma placa
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps:
print "step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(
len(listOfListsOfMatchingCharsInScene))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
# end if
# Itera sobre cada grupo de caracteres
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
# Tenta reconhecer a placa
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
# Verifica se foi encontrada
if possiblePlate.imgPlate is not None:
# Adiciona na lista de possiveis placas
listOfPossiblePlates.append(possiblePlate)
# end if
# end for
print "\n" + str(
len(listOfPossiblePlates)) + " possíveis placas encontradas"
if Main.showSteps:
print "\n"
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_GREEN, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_GREEN, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_GREEN, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_GREEN, 2)
cv2.imshow("4a", imgContours)
print "possível placa " + str(
i
) + ". Clique em qualquer imagem e pressione uma tecla para continuar."
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
# end for
print "\nDetecção de placa completada. Clique on qualquer imagem e pressione uma tecla para iniciar o reconhecimento de caracteres.\n"
cv2.waitKey(0)
# end if
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene)
if Main.showSteps == True:
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
print("step 2 - len(listOfPossibleCharsInScene) = " + str(
len(listOfPossibleCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
if Main.showSteps == True:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(
len(listOfListsOfMatchingCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
cv2.drawContours(imgContours, contours, -1, (intRandomBlue, intRandomGreen, intRandomRed))
cv2.imshow("3", imgContours)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
possiblePlate = extractPlate(imgOriginalScene, listOfMatchingChars)
if possiblePlate.imgPlate is not None:
listOfPossiblePlates.append(possiblePlate)
if Main.showSteps == True:
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]), tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]), tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]), tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]), tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
print("\nplate detection complete, click on any image and press a key to begin char recognition . . .\n")
cv2.waitKey(0)
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossPlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
# end if
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # za grayscale i detekciju rubova
if Main.showSteps == True:
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# end if
# funkcija prvo pronalazi sve konture, a zatim uključuje samo obrise koji bi mogli biti karakteri (bez usporedbe s ostalim značajkama)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
print("step 2 - len(listOfPossibleCharsInScene) = " +
str(len(listOfPossibleCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# end if
# od popisa svih mogućih znakova, pronalazi grupe podudaranja - svaka će skupina podudarnih znakova pokušati biti prepoznata kao oznaka
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " +
str(len(listOfListsOfMatchingCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
# end if
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # za svaku grupu vezanih karaktera pokušat izdvojiti oznaku
possPlate = extractPlate(imgOriginalScene, listOfMatchingChars)
if possPlate.imgPlate is not None: # ako je oznaka nađena dodaje se listi mogućih
listOfPossPlates.append(possPlate)
# end if
# end for
print("\n" + str(len(listOfPossPlates)) +
" moguće oznake nađene") # vrati koliko je mogucih oznaka nadeno
if Main.showSteps == True:
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossPlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossPlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("moguća oznaka " + str(i) +
", klikni na sliku i pritisni bilo koju tipku za nastavak")
cv2.imshow("4b", listOfPossPlates[i].imgPlate)
cv2.waitKey(0)
# end for
print(
"\ndetekcija dovrsena, klikni na sliku i pritisni tipku za nastavak\n"
)
cv2.waitKey(0)
# end if
return listOfPossPlates
def detectPlatesInScene(imgOriginalScene, location):
listOfRawPossiblePlates = []
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(imgOriginalScene) # preprocess to get grayscale and threshold images
if Main.showSteps == True: # show steps #######################################################
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
listOfPossibleCharsInScene.sort(key = lambda Char: Char.intCenterX)
if Main.showSteps == True: # show steps #######################################################
print("step 2 - len(listOfPossibleCharsInScene) = " + str(len(listOfPossibleCharsInScene))) # 131 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(listOfPossibleCharsInScene)
if Main.showSteps == True: # show steps #######################################################
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(len(listOfListsOfMatchingCharsInScene))) # 13 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
cv2.drawContours(imgContours, contours, -1, (intRandomBlue, intRandomGreen, intRandomRed))
cv2.imshow("3", imgContours)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(listOfMatchingChars) # attempt to extract plate
listOfRawPossiblePlates.append(possiblePlate) # add to list of possible plates
listOfPossiblePlates = groupPossiblePlates(imgOriginalScene, listOfRawPossiblePlates)
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found") # 13 with MCLRNF1 image
if Main.showSteps == True: # show steps #######################################################
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]), tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]), tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]), tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]), tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("possible plate " + str(i) + ", click on any image and press a key to continue . . .")
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
# end for
print("\nplate detection complete, click on any image and press a key to begin char recognition . . .\n")
cv2.waitKey(0)
if Main.save == True:
for i in range(0, len(listOfPossiblePlates)):
# save plate
fileName = location.split("/")[-1].split(".")
plateFolder = "outputs/" + fileName[0]
if not os.path.isdir(plateFolder):
os.makedirs(plateFolder)
extractedPlateName = fileName[0] + "/plate_" + str(i) + "." + fileName[1]
resized_plate = cv2.resize(listOfPossiblePlates[i].imgPlate, SHAPE_OF_POSSIBLE_PLATE)
cv2.imwrite("outputs/" + extractedPlateName, resized_plate)
return listOfPossiblePlates
def detectPlates(imgOriginal):
listOfPossiblePlates = []
height, width, numChannels = imgOriginal.shape
imgGray = np.zeros((height, width, 1), np.uint8)
imgThresh = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showstep_plate:
cv2.imshow("0", imgOriginal)
imgGray, imgThresh = preprocess(imgOriginal)
# imgCanny not used at this point for comparison
# imgCanny = cv2.Canny(imgThresh.copy(), CANNY_THRESHOLD1,CANNY_THRESHOLD2,CANNY_APPERTURE_SIZE)
# imgSuzuki, contours, npaHierarchy = cv2.findContours(imgThresh.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # find all contours
if Main.showstep_plate:
# cv2.imshow("suzuki85", imgSuzuki)
# cv2.imshow('Canny Edge',imgCanny)
cv2.imshow('1', imgGray)
cv2.imshow('2', imgThresh)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThresh)
###########
if Main.showstep_plate:
print("step 2 - len(listOfPossibleCharsInScene) = " +
str(len(listOfPossibleCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
if Main.showstep_plate:
cv2.imshow("2b", imgContours)
###########
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showstep_plate:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(
len(listOfListsOfMatchingCharsInScene))) # 13 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginal, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
# end if
# end for
if Main.showstep_plate:
print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
if Main.showstep_plate:
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("possible plate " + str(i) +
", click on any image and press a key to continue . . .")
# cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
# end for
# print("\nplate detection complete, click on any image and press a key to begin char recognition . . .\n")
######################
if Main.showstep_plate:
cv2.waitKey(0)
cv2.destroyAllWindows()
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # danh sách khả năng là biển số
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True:
cv2.imshow("0", imgOriginalScene)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # tiền xử lý ảnh đầu vào
if Main.showSteps == True:
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# tìm tất cả nơi có khả năng có kí tự
# Tìm tất cả các đường viền -> tìm các đường viền có khả năng làm kí tự
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
# print("step 2 - len(listOfPossibleCharsInScene = " + str(len(listOfPossibleCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene: # thêm các đường viền có thể là kí tự vào contour[]
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
Main.SCALAR_WHITE) # vẽ các đường viền trên ảnh
cv2.imshow("2b", imgContours)
# đưa ra một danh sách tất cả các ký tự có thể, tìm các nhóm ký tự phù hợp
# trong các bước tiếp theo, mỗi nhóm ký tự phù hợp sẽ cố gắng được công nhận là một tấm
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True:
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " +
str(len(listOfListsOfMatchingCharsInScene)))
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
# end for
cv2.imshow("3", imgContours)
# # end if
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # duyệt mỗi nhóm kí tự khớp
possiblePlate = extractPlate(imgOriginalScene,
listOfMatchingChars) # trích xuất tấm
if possiblePlate.imgPlate is not None: # nếu tấm không được tìm thấy
listOfPossiblePlates.append(possiblePlate) #
# end if
# end for
# print("\n" + str(len(listOfPossiblePlates)) + " possible plates found")
if Main.showSteps == True: #
print("\n")
cv2.imshow("4a", imgContours)
# đánh dấu viền đổ cho mỗi tấm được tìm thấy
for i in range(0, len(listOfPossiblePlates)):
# toa do goc cua tấm
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("Tấm được tìm thấy " + str(i) + ", click tiếp")
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
# end for
print("\nHoàn thành, click tiếp để tiếp tục nhận dạng\n")
cv2.waitKey(0)
# end if
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
cv2.destroyAllWindows()
if Main.showSteps == True: # show steps #######################################################
cv2.imshow("0", imgOriginalScene)
# end if # show steps #########################################################################
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # preprocess to get grayscale and threshold images
if Main.showSteps == True: # show steps #######################################################
cv2.imshow("1a", imgGrayscaleScene)
cv2.imshow("1b", imgThreshScene)
# end if # show steps #########################################################################
# find all possible chars in the scene,
# this function first finds all contours, then only includes contours that could be chars (without comparison to other chars yet)
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True: # show steps #######################################################
print("step 2 - len(listOfPossibleCharsInScene) = " +
str(len(listOfPossibleCharsInScene))) # 131 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
# end if # show steps #########################################################################
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True: # show steps #######################################################
print("step 3 - listOfListsOfMatchingCharsInScene.Count = " + str(
len(listOfListsOfMatchingCharsInScene))) # 13 with MCLRNF1 image
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
# end if # show steps #########################################################################
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
# end if
# end for
print("\n" + str(len(listOfPossiblePlates)) +
" possible plates found") # 13 with MCLRNF1 image
if Main.showSteps == True: # show steps #######################################################
print("\n")
cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
cv2.imshow("4a", imgContours)
print("possible plate " + str(i) +
", click on any image and press a key to continue . . .")
cv2.imshow("4b", listOfPossiblePlates[i].imgPlate)
cv2.waitKey(0)
# end for
print(
"\nplate detection complete, click on any image and press a key to begin char recognition . . .\n"
)
cv2.waitKey(0)
# end if # show steps #########################################################################
return listOfPossiblePlates
def detectPlatesInScene(imgOriginalScene):
listOfPossiblePlates = [] # this will be the return value
height, width, numChannels = imgOriginalScene.shape
imgGrayscaleScene = np.zeros((height, width, 1), np.uint8)
imgThreshScene = np.zeros((height, width, 1), np.uint8)
imgContours = np.zeros((height, width, 3), np.uint8)
imgGrayscaleScene, imgThreshScene = Preprocess.preprocess(
imgOriginalScene) # preprocess to get grayscale and threshold images
listOfPossibleCharsInScene = findPossibleCharsInScene(imgThreshScene)
if Main.showSteps == True:
imgContours = np.zeros((height, width, 3), np.uint8)
contours = []
for possibleChar in listOfPossibleCharsInScene:
contours.append(possibleChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1, Main.SCALAR_WHITE)
cv2.imshow("2b", imgContours)
cv2.waitKey(0)
# given a list of all possible chars, find groups of matching chars
# in the next steps each group of matching chars will attempt to be recognized as a plate
listOfListsOfMatchingCharsInScene = DetectChars.findListOfListsOfMatchingChars(
listOfPossibleCharsInScene)
if Main.showSteps == True: # show steps #######################################################
imgContours = np.zeros((height, width, 3), np.uint8)
for listOfMatchingChars in listOfListsOfMatchingCharsInScene:
intRandomBlue = random.randint(0, 255)
intRandomGreen = random.randint(0, 255)
intRandomRed = random.randint(0, 255)
contours = []
for matchingChar in listOfMatchingChars:
contours.append(matchingChar.contour)
# end for
cv2.drawContours(imgContours, contours, -1,
(intRandomBlue, intRandomGreen, intRandomRed))
# end for
cv2.imshow("3", imgContours)
# end if # show steps #########################################################################
for listOfMatchingChars in listOfListsOfMatchingCharsInScene: # for each group of matching chars
possiblePlate = extractPlate(
imgOriginalScene, listOfMatchingChars) # attempt to extract plate
if possiblePlate.imgPlate is not None: # if plate was found
listOfPossiblePlates.append(
possiblePlate) # add to list of possible plates
# end if
# end for
# print("\n" + str(len(listOfPossiblePlates)) + " possible plates found") # 13 with MCLRNF1 image
if Main.showSteps == True:
print("\n")
#cv2.imshow("4a", imgContours)
for i in range(0, len(listOfPossiblePlates)):
p2fRectPoints = cv2.boxPoints(
listOfPossiblePlates[i].rrLocationOfPlateInScene)
cv2.line(imgContours, tuple(p2fRectPoints[0]),
tuple(p2fRectPoints[1]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[1]),
tuple(p2fRectPoints[2]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[2]),
tuple(p2fRectPoints[3]), Main.SCALAR_RED, 2)
cv2.line(imgContours, tuple(p2fRectPoints[3]),
tuple(p2fRectPoints[0]), Main.SCALAR_RED, 2)
text = pytesseract.image_to_string(listOfPossiblePlates[i].imgPlate,
lang='eng')
# print("Number is:", text)
print("\nplate detection complete...\n")
cv2.waitKey(0)
return listOfPossiblePlates
