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