def findPossibleCharsInScene(imgThresh, char_aspect_ratio_interval):
imgThreshCopy = imgThresh.copy()
_, contours, _ = cv2.findContours(imgThreshCopy, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
return [
PossibleChar.PossibleChar(contour)
for contour in contours if DetectChars.checkIfPossibleChar(
PossibleChar.PossibleChar(contour), char_aspect_ratio_interval)
]
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
#print('Now we start to find the contours in the thresholded image that may be characters:')
#if error with expected values: add imgContours to the next line
contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
possibleChar = PossibleChar.PossibleChar(
contours[i]
) # Here we calculate the x,y,w,h,flatdiagonalsize,aspedctratio,area and (x,y) of the center of the rectangle that is bounding the contour.
if DetectChars.checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not compare to other chars (yet) . . .
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
listOfPossibleChars.append(
possibleChar) # and add to list of possible chars
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
if Main.showSteps == True: # show steps ###################################################
cv2.drawContours(imgContours, contours, i, Main.SCALAR_WHITE)
# end if # show steps #####################################################################
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not compare to other chars (yet) . . .
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
listOfPossibleChars.append(
possibleChar) # and add to list of possible chars
# end if
# end for
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not compare to other chars (yet) . . .
# kontur olası bir char ise, bu diğer karakterlerle (henüz) karşılaştırılamaz.
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars (olası karakterlerin artış sayısı)
listOfPossibleChars.append(
possibleChar
) # and add to list of possible chars (ve olası karakterlerin listesine ekle)
# end if
# end for
return listOfPossibleChars
def find_char(imgThresh):
listOfPossibleChars = []
intCountOfPossibleChars = 0
#Creating a copy of the thresholded image
imgThreshCopy = imgThresh.copy()
#The following finds all the contours.
#To remember contours: https://docs.opencv.org/3.1.0/d4/d73/tutorial_py_contours_begin.html
imgContours, contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
#get height and width of the thresholded image
height, width = imgThresh.shape
#intializing
imgContours = np.zeros((height, width, 3), np.uint8)
#loop i from 0 to the number of contours(contours is a list containing the contour's information in each entry, so we get it's length)
for i in range(0, len(contours)):
#refer to the file PossibleChar.py
#it's constructor takes the contour
possibleChar = PossibleChar.PossibleChar(contours[i])
#check if the a contour is a possible character.
if DetectChars.checkIfPossibleChar(possibleChar):
#increment count
intCountOfPossibleChars = intCountOfPossibleChars + 1
#add to list of possible chars
listOfPossibleChars.append(possibleChar)
#When the loop finishes we have a list with all contours having a possibility of being a character.
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
# if Main.showSteps == True:
# cv2.drawContours(imgContours, contours, i, Main.SCALAR_YELLOW)
# cv2.imshow('Thresholded',imgContours)
# cv2.waitKey(0)
possibleChar = PossibleChar.PossibleChar(contours[i])
if CharacterDetection.checkIfPossibleChar(possibleChar):
intCountOfPossibleChars = intCountOfPossibleChars + 1
listOfPossibleChars.append(possibleChar)
# if Main.showSteps == True:
# # print("\nstep 2 - Total number of contours found in the image are = " + str(len(contours)))
# # print("step 2 - number of contours those may be characters = " + str(intCountOfPossibleChars))
# # # #print("These are the contours those may be characters :")
# # cv2.imshow("2a", imgContours)
# # cv2.waitKey(0)
return listOfPossibleChars
def findPossibleCharsInScene(img_thresh):
possible_chars = []
possible_chars_count = 0
img_thresh_copy = img_thresh.copy()
img_contours, contours, npa_hierarchy = cv2.findContours(img_thresh_copy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
height, width = img_thresh.shape
img_contours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
if Recognitor.showSteps:
cv2.drawContours(img_contours, contours, i, Recognitor.SCALAR_WHITE)
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(possibleChar):
possible_chars_count = possible_chars_count + 1 # increment count of possible chars
possible_chars.append(possibleChar) # and add to list of possible chars
if Recognitor.showSteps:
print("\nstep 2 - len(contours) = " + str(len(contours)))
print("step 2 - intCountOfPossibleChars = " + str(possible_chars_count))
cv2.imshow("2a", img_contours)
return possible_chars
def find_possible_chars_in_scene(img_thresh) -> [PossibleChar]:
list_of_possible_chars: [PossibleChar] = []
int_count_of_possible_chars: int = 0
img_thresh_copy = img_thresh.copy()
contours, npa_hierarchy = cv2.findContours(img_thresh_copy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
height, width = img_thresh.shape
img_contours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
if not SUPER_SPEED_MODE:
cv2.drawContours(img_contours, contours, i, SCALAR_WHITE, 3)
possible_char = PossibleChar.PossibleChar(contours[i])
if DetectChars.check_if_possible_char(possible_char):
int_count_of_possible_chars = int_count_of_possible_chars + 1
list_of_possible_chars.append(possible_char)
if NO_ERROR_PRINT_ENABLED:
print("\n[F:Find Possible Chars in Scene] - len(contours) = " + str(len(contours)))
print("\n[F:Find Possible Chars in Scene] - int_count_of_possible_chars = " + str(int_count_of_possible_chars))
if SHOW_IMAGE:
cv2.imshow("[F:Find Possible Chars in Scene] - Contours", img_contours)
if SAVE_IMAGE:
cv2.imwrite("./output/showImage/4-Find Possible Chars-Contours.jpg", img_contours)
return list_of_possible_chars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
# imgContours, contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # find all contours
contours,npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)[-2:]
# find all contours
# print("imgContours",imgContours)
# print("contours",contours)
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for contour in contours:
# type(contour)
# print(type(contour))
# x,y,w,h=cv2.boundingRect(contour)
# print('x,y,w,h',x,y,w,h)
#if Main.showSteps == True:
#cv2.drawContours(imgThreshCopy, contour, -1, (0, 255, 0), 3)
possibleChar = PossibleChar.PossibleChar(contour)
x,y,w,h=cv2.boundingRect(contour)
# print('x,y,w,h',x,y,w,h)
if DetectChars.checkIfPossibleChar(possibleChar):
# if contour is a possible char, note this does not compare to other chars (yet) . . .
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
listOfPossibleChars.append(possibleChar) # and add to list of possible chars
# print("listOfPossibleChars in findPossibleChars",listOfPossibleChars)
# for i in range(0, len(contours)): # for each contour
#
# if Main.showSteps == True: # show steps ###################################################
# # cv2.drawContours(imgContours, contours, i, Main.SCALAR_WHITE)
# cv2.drawContours(imgThresh, contours, i, Main.SCALAR_WHITE)
# # end if # show steps #####################################################################
#
# possibleChar = PossibleChar.PossibleChar(contours[i])
#
# if DetectChars.checkIfPossibleChar(possibleChar): # if contour is a possible char, note this does not compare to other chars (yet) . . .
# intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
# listOfPossibleChars.append(possibleChar) # and add to list of possible chars
# # end if
# # end for
if Main.showSteps == True: # show steps #######################################################
print("\nstep 2 - len(contours) = " + str(len(contours))) # 2362 with MCLRNF1 image
print("step 2 - intCountOfPossibleChars = " + str(intCountOfPossibleChars)) # 131 with MCLRNF1 image
cv2.imshow("2a", imgContours)
# end if # show steps #########################################################################
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not compare to other chars (yet) . . .
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
listOfPossibleChars.append(
possibleChar) # and add to list of possible chars
# end if
# end for
if Main.showstep_plate:
print("\nstep 2 - len(contours) = " + str(len(contours)))
print("step 2 - intCountOfPossibleChars = " +
str(intCountOfPossibleChars))
cv2.imshow("2a", imgContours)
return listOfPossibleChars
def methodEight(imgpath):
img = cv2.imread(imgpath)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.resize(gray, (0, 0), fx=1.5, fy=1.5)
ret, thresh = cv2.threshold(gray, 127, 255, 0)
height, width = chain(gray.shape)
_, contours, _ = cv2.findContours(thresh, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
#contours = sorted(contours, key=cv2.contourArea)
for contour in contours:
if cv2.contourArea(contour) > 50:
rectangleInfo = PossibleChar.PossibleChar(contour)
#h,w=rectangleInfo.intBoundingRectHeight,rectangleInfo.intBoundingRectWidth
x, y, w, h = cv2.boundingRect(contour)
mask = np.zeros((height, width), np.uint8)
cv2.drawContours(mask, [contour], -1, 255.0, -1)
dst = cv2.bitwise_and(gray, gray, mask=mask)
crop = dst[y:y + h, x:x + w]
showImage(crop)
cv2.imwrite("book/0006.bin.png", thresh)
result = pytesseract.image_to_string(Image.open("book/0006.bin.png"))
writeInFile(outpath, result)
accuracy = calculateAccuracy(imgpath, outpath, type='P')
print(accuracy)
return
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = []
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) #xác định các đường viền đã có
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
if Main.showSteps == True:
cv2.drawContours(imgContours, contours, i, Main.SCALAR_WHITE)
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(possibleChar):
intCountOfPossibleChars = intCountOfPossibleChars + 1
listOfPossibleChars.append(possibleChar)
if Main.showSteps == True:
print("\nstep 2 - len(contours) = " + str(len(contours)))
print("step 2 - intCountOfPossibleChars = " +
str(intCountOfPossibleChars))
cv2.imshow("2a", imgContours)
return listOfPossibleChars
def find_psbl_chr(img_thresh, psbl_char_params, explore_area=False):
"""
check all contours on image if can they be chrs
"""
list_of_possible_chars = []
none_char = []
# find all contours in plate
_, contours, _ = cv2.findContours(img_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
plate_area = img_thresh.shape[0] * img_thresh.shape[1]
for contour in range(len(contours)):
# make simple contour like instance of PossibleChar
pssbl_chr = PossibleChar.PossibleChar(contours[contour])
char_area = pssbl_chr.height * pssbl_chr.width
# checking for: can contour be a character
if not explore_area and check_if_pssbl_chr(pssbl_chr, psbl_char_params):
list_of_possible_chars.append(pssbl_chr)
elif explore_area and 0.04 < char_area / plate_area < 0.1 and check_if_pssbl_chr(pssbl_chr, psbl_char_params):
list_of_possible_chars.append(pssbl_chr)
else:
none_char.append(pssbl_chr)
number_of_chars = len(list_of_possible_chars)
list_of_possible_chars = list(sorted(list_of_possible_chars, key=lambda obj: obj.area))
return list_of_possible_chars, number_of_chars, none_char
def findPossibleCharsInScene(imgThresh):
list_of_possible_chars = [] # this will be the return value
int_count_of_possible_chars = 0
img_thresh_copy = imgThresh.copy()
contours, npa_hierarchy = cv2.findContours(
img_thresh_copy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
img_contours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
if app.showSteps:
cv2.drawContours(img_contours, contours, i, app.SCALAR_WHITE)
possible_char = PossibleChar.PossibleChar(contours[i])
if detect_chars.checkIfPossibleChar(
possible_char
): # if contour is a possible char, note this does not compare to other chars
int_count_of_possible_chars = int_count_of_possible_chars + 1 # increment count of possible chars
list_of_possible_chars.append(
possible_char) # and add to list of possible chars
if app.showSteps:
print("\nstep 2 - len(contours) = " + str(len(contours)))
print("step 2 - int_count_of_possible_chars = " +
str(int_count_of_possible_chars))
cv2.imshow("2a", img_contours)
return list_of_possible_chars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
cv2.drawContours(imgContours, contours, i, SCALAR_WHITE)
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not compare to other chars (yet) . . .
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
listOfPossibleChars.append(
possibleChar) # and add to list of possible chars
print("\nstep 2 - len(contours) = " +
str(len(contours))) # 2362 with MCLRNF1 image
print("step 2 - intCountOfPossibleChars = " +
str(intCountOfPossibleChars)) # 131 with MCLRNF1 image
cv2.imwrite("./images/2b.png", imgContours)
print(intCountOfPossibleChars)
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
# find all contours
imgContours, contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
# Here we calculate the x,y,w,h,flatdiagonalsize,aspedctratio,area and (x,y) of the center of the rectangle that is bounding the contour.
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(possibleChar):
intCountOfPossibleChars = intCountOfPossibleChars + 1
listOfPossibleChars.append(possibleChar)
cv2.drawContours(imgContours, contours, i, Main.SCALAR_WHITE)
return listOfPossibleChars
def find_vld_chrs_by_cascad(img_thresh, gray):
possible_chars = []
# some bluring
gray = cv2.GaussianBlur(gray, (5, 5), 0)
# find plates by standard Hoar's cascad
plates = cascade.detectMultiScale(gray, scaleFactor=1.01, minNeighbors=3)
# find contours on image
_, contours, _ = cv2.findContours(img_thresh, cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_SIMPLE)
for i in range(len(contours)):
#
possible_char = PossibleChar.PossibleChar(contours[i])
# if contour is a possible char, note this does not compare to other chars (yet) . . .
if DetectChars.check_if_pssbl_chr(possible_char,
[120, 8, 10, 0.25, 1.5]):
for (x, y, w, h) in plates:
if x < possible_char.pos_x < x + w and y < possible_char.center_y < y + h:
possible_chars.append(
possible_char) # and add to list of possible chars
break
return possible_chars
def findPossibleCharsInPlate(imgGrayscale, imgThresh):
'''
This fucntion extracts all the contours from the number plate image and groups the relevant contours into a list
and returns the list
@input: Grayscale and thresholded image of the numberplate
@output: List of relevant contours
'''
listOfPossibleChars = [] # this will be the return value
contours = []
imgThreshCopy = imgThresh.copy()
# find all contours in plate
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours: # for each contour
possibleChar = PossibleChar.PossibleChar(contour)
if checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not
listOfPossibleChars.append(
possibleChar
) # compare to other chars (yet) add to list of possible chars
# end if
# end if
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
if Main.showSteps == True:
cv2.drawContours(imgContours, contours, i, Main.SCALAR_WHITE)
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(possibleChar):
intCountOfPossibleChars = intCountOfPossibleChars + 1
listOfPossibleChars.append(possibleChar)
# end if
# end for
if Main.showSteps == True:
print("\nstep 2 - len(contours) = " +
str(len(contours))) # 2362 with MCLRNF1 image
print("step 2 - intCountOfPossibleChars = " +
str(intCountOfPossibleChars)) # 131 with MCLRNF1 image
cv2.imshow("2a", imgContours)
return listOfPossibleChars
def find_possible_chars_in_scene(img_thresh):
list_of_possible_chars = []
count_of_possible_chars = 0
img_thresh_copy = img_thresh.copy()
img_contours, contours, hierarchy = cv2.findContours(
img_thresh_copy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
height, width = img_thresh.shape
img_contours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
if PlateRecognition.showSteps:
cv2.drawContours(img_contours, contours, i,
PlateRecognition.SCALAR_WHITE)
possible_char = PossibleChar.PossibleChar(contours[i])
if DetectChars.check_if_possible_char(possible_char):
count_of_possible_chars = count_of_possible_chars + 1
list_of_possible_chars.append(possible_char)
return list_of_possible_chars
def findPossibleCharsInPlate(imgGrayscale, imgThresh, char_aspect_ratio_interval):
listOfPossibleChars = [] # this will be the return value
contours = []
imgThreshCopy = imgThresh.copy()
# find all contours in plate
imgContours, contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
return [PossibleChar.PossibleChar(cnt) for cnt in contours if checkIfPossibleChar(PossibleChar.PossibleChar(cnt), char_aspect_ratio_interval)]
def findPossibleCharsInPlate(imgGrayscale, imgThresh):
listOfPossibleChars = []
contours = []
imgThreshCopy = imgThresh.copy()
contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
possibleChar = PossibleChar.PossibleChar(contour)
if checkIfPossibleChar(possibleChar):
listOfPossibleChars.append(possibleChar)
return listOfPossibleChars
def find_possible_chars(img_thresh):
possible_chars = []
count_possible_chars = 0
img_thresh_copy = img_thresh.copy()
img_contours, contours, npa_hierarchy = cv2.findContours(
img_thresh_copy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
for i in range(0, len(contours)):
possible_char = PossibleChar.PossibleChar(contours[i])
if possible_char.if_possible:
count_possible_chars += 1
possible_chars.append(possible_char)
return possible_chars
def findPossibleCharsInPlate(imgGrayscale, imgThresh):
listOfPossibleChars = [] # this will be the return value
contours = []
imgThreshCopy = imgThresh.copy()
# find all contours in plate
contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours: # for each contour
possibleChar = PossibleChar.PossibleChar(contour)
if checkIfPossibleChar(possibleChar): # if contour is a possible char, note this does not compare to other chars (yet) . . .
listOfPossibleChars.append(possibleChar) # add to list of possible chars
return listOfPossibleChars
def get_Possible_chars(grayscale_image, threshold_image):
Possible_Chars = []
contours = []
threshold_image_copy = threshold_image.copy()
contours, npaHierarchy = cv2.findContours(threshold_image_copy,
cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
possibleChar = PossibleChar.PossibleChar(contour)
if checkIfPossibleChar(possibleChar):
Possible_Chars.append(possibleChar)
return Possible_Chars
def find_possible_chars_in_plate(img_grayscale, img_thresh):
list_of_possible_chars = []
img_thresh_copy = img_thresh.copy()
# find all contours in plate
contours, contours, hierarchy = cv2.findContours(
img_thresh_copy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
possible_char = PossibleChar.PossibleChar(contour)
if check_if_possible_char(possible_char):
list_of_possible_chars.append(possible_char)
return list_of_possible_chars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] # this will be the return value
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
#print('Now we start to find the contours in the thresholded image that may be characters:')
contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_SIMPLE) # find all contours
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # for each contour
if Main.showSteps == True: # show steps ###################################################
cv2.drawContours(imgContours, contours, i, Main.SCALAR_YELLOW)
#cv2.imshow('Thresholded',imgContours)
#cv2.waitKey(0)
possibleChar = PossibleChar.PossibleChar(
contours[i]
) # Here we calculate the x,y,w,h,flatdiagonalsize,aspedctratio,area and (x,y) of the center of the rectangle that is bounding the contour.
if DetectChars.checkIfPossibleChar(
possibleChar
): # if contour is a possible char, note this does not compare to other chars (yet) . . .
intCountOfPossibleChars = intCountOfPossibleChars + 1 # increment count of possible chars
listOfPossibleChars.append(
possibleChar) # and add to list of possible chars
#cv2.drawContours(imgContours, contours, i, Main.SCALAR_WHITE)
#print('This contour may be a character :')
#else:
#print('This contour is not a character :')
# end if
# end for
if Main.showSteps == True: # show steps #######################################################
print("\nstep 2 - Total number of contours found in the image are = " +
str(len(contours)))
print("step 2 - number of contours those may be characters = " +
str(intCountOfPossibleChars))
#print("These are the contours those may be characters :")
cv2.imshow("2a", imgContours)
cv2.waitKey(0)
# end if # show steps #########################################################################
return listOfPossibleChars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = [] #Dönüş değeri olacak
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
contours, npaHierarchy = cv2.findContours(imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # Tüm kontürleri bul SIMPLE ile 4 kontür bulunur
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)): # Her bir kontür için
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(possibleChar): # Kontur olası bir karakter ise, bunun diğer karakterlerle (henüz) karşılaştırılmadığını unutma
intCountOfPossibleChars = intCountOfPossibleChars + 1 # Olası karakterlerin sayısını arttır
listOfPossibleChars.append(possibleChar) # Olası listeye ekle
return listOfPossibleChars
def find_possible_chars_in_plate(img_grayscale, img_thresh) -> [PossibleChar]:
list_of_possible_chars = []
contours = []
img_thresh_copy = img_thresh.copy()
# Buscamos todos los contornos en la patente
contours, npa_hierarchy = cv2.findContours(img_thresh_copy, cv2.RETR_LIST,
cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
possible_char = PossibleChar.PossibleChar(contour)
if check_if_possible_char(possible_char):
list_of_possible_chars.append(possible_char)
return list_of_possible_chars
def findPossibleCharsInScene(imgThresh):
listOfPossibleChars = []
intCountOfPossibleChars = 0
imgThreshCopy = imgThresh.copy()
imgContours, contours, npaHierarchy = cv2.findContours(
imgThreshCopy, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
height, width = imgThresh.shape
imgContours = np.zeros((height, width, 3), np.uint8)
for i in range(0, len(contours)):
possibleChar = PossibleChar.PossibleChar(contours[i])
if DetectChars.checkIfPossibleChar(possibleChar):
intCountOfPossibleChars = intCountOfPossibleChars + 1
listOfPossibleChars.append(possibleChar)
return listOfPossibleChars
