import cv2 import numpy as np from skimage import morphology, img_as_ubyte """ (1) The text is an array of chars (in row-major order) where * each char can be one of the following: * 'x': hit * 'o': miss * ' ': don't-care * (2) When the origin falls on a hit or miss, use an upper case * char (e.g., 'X' or 'O') to indicate it. When the origin * falls on a don't-care, indicate this with a 'C'. * The string must have exactly one origin specified. * (3) The advantage of this method is that the text can be input * in a format that shows the 2D layout of the Sel; e.g., :::: AND :::: (10) The sequence string is formatted as follows: * ~ An arbitrary number of operations, each separated * by a '+' character. White space is ignored. * ~ Each operation begins with a case-independent character * specifying the operation: * d or D (dilation) * e or E (erosion) * o or O (opening) * c or C (closing) * r or R (rank binary reduction) * x or X (replicative binary expansion) * b or B (add a border of 0 pixels of this size) * ~ The args to the morphological operations are bricks of hits, * and are formatted as a.b, where a and b are horizontal and * vertical dimensions, rsp. * ~ The args to the reduction are a sequence of up to 4 integers, * each from 1 to 4. * ~ The arg to the expansion is a power of two, in the set * {2, 4, 8, 16}. * (11) An example valid sequence is: * "b32 + o1.3 + C3.1 + r23 + e2.2 + D3.2 + X4" * In this example, the following operation sequence is carried out: * * b32: Add a 32 pixel border around the input image * * o1.3: Opening with vert sel of length 3 (e.g., 1 x 3) * * C3.1: Closing with horiz sel of length 3 (e.g., 3 x 1) * * r23: Two successive 2x2 reductions with rank 2 in the first * and rank 3 in the second. The result is a 4x reduced pix. * * e2.2: Erosion with a 2x2 sel (origin will be at x,y: 0,0) * * d3.2: Dilation with a 3x2 sel (origin will be at x,y: 1,0) * * X4: 4x replicative expansion, back to original resolution """ def kernel(x, y): return np.ones((x, y), np.uint8) def sid_compare(sid_no, sid_mask): for s,es in zip(sid_mask,sid_no): if s!='x' and s!=es: return False return True def segment_by_contours(image, sorted_ctrs, classifier): sid_no = "" for i, ctr in enumerate(sorted_ctrs): # Get bounding box x, y, w, h = cv2.boundingRect(ctr) # Getting ROI if w < h / 2: sid_no = sid_no + "1" continue roi = image[y : y + h, x : x + w] roi = img_as_ubyte(roi < 128) roi = cv2.resize(roi, (32, 32)) # cv2.rectangle(image,(x,y),( x + w, y + h ),(0,255,0),2) cv2.imwrite("sid_no_{}.png".format(i), roi) sid_no = sid_no + str(classifier.predict(roi.reshape(1, -1) / 255.0)[0]) return sid_no def segment_by_sid_len(image, original_image, sid_mask, classifier): sid_no = "" sid_len = len(sid_mask) if sid_mask[0] == "1": move_left = 45 elif sid_mask[0] == "x": move_left = 55 else: move_left = 0 # Remove noise image2 = cv2.morphologyEx(original_image, cv2.MORPH_OPEN, kernel(2, 2), iterations=7) # find biggest block of pixels image1 = cv2.morphologyEx(image2, cv2.MORPH_DILATE, kernel(5, 25), iterations=4) image1=img_as_ubyte(image1>50) cv2.imwrite("sidblock1.png", image1) im2, ctrs, hier = cv2.findContours( image1.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE ) sorted_ctrs = sorted( ctrs, key=lambda ctr: cv2.contourArea(ctr) ) # get bigges contour x, y, w, h = cv2.boundingRect(sorted_ctrs[-1]) image = image[y : y + h, x + 25 - move_left : x + w - 40] #+25,-25 cv2.imwrite("sidblock2.png", image) imgHeight, imgWidth = image.shape[0:2] numWidth = int(imgWidth / (sid_len)) for i in range(0, sid_len): num = image[:, i * numWidth : (i + 1) * numWidth] num = img_as_ubyte(num < 128) num = cv2.resize(num, (32, 32)) # cv2.rectangle(image,(x,y),( x + w, y + h ),(0,255,0),2) cv2.imwrite("sid_no_{}.png".format(i), num) sid_no = sid_no + str(classifier.predict(num.reshape(1, -1) / 255.0)[0]) return sid_no def segment_by_7segments(image,original_image,sid_mask,classifier): block_image = cv2.morphologyEx(original_image, cv2.MORPH_CLOSE, kernel(2, 2), iterations=10) block_image =img_as_ubyte(block_image<50) cv2.imwrite("sid_3rd1.png", block_image) template = cv2.imread("template-8.png", 0) w, h = template.shape[::-1] res = cv2.matchTemplate(block_image, template, cv2.TM_CCOEFF_NORMED) loc = np.where(res >= 0.75) cimg = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR) loc_filtered_x=[] loc_filtered_y=[] for pt in zip(*loc[::-1]): pt=(pt[0]-10,pt[1]-10) loc_filtered_y.append(pt[1]) loc_filtered_x.append(pt[0]) # points.append(pt) #filter points if(len(loc_filtered_x)==0): return "" loc_filtered_x, loc_filtered_y = zip( *sorted(zip(loc_filtered_x, loc_filtered_y)) ) a = np.diff(loc_filtered_x) > int(w/2) a = np.append(a, True) loc_filtered_x = np.array(loc_filtered_x) loc_filtered_y = np.array(loc_filtered_y) points = [loc_filtered_y[a], loc_filtered_x[a]] for pt in zip(*points[::-1]): cv2.rectangle(cimg, pt, (pt[0] + w, pt[1] + h), (0, 255, 255), 2) cv2.imwrite("sid_3rd2.png", cimg) sid_no="" for i,pt in enumerate(zip(*points[::-1])): num=image[pt[1]:pt[1] + h, pt[0]:pt[0]+w] #cv2.imwrite("sid_3no_{}.png".format(i), num) num = img_as_ubyte(num < 128) try: num = cv2.resize(num, (32, 32)) except: return "" cv2.imwrite("sid_3no_{}.png".format(i), num) sid_no = sid_no + str(classifier.predict(num.reshape(1, -1) / 255.0)[0]) return sid_no def getSID(image, classifier, sid_mask): sid_warn = [] sid_err=[] image = 255 - image image_original=image.copy() image = img_as_ubyte(image > 100) cv2.imwrite("enSID0.png", image) # Remove noise image = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel(2, 2), iterations=3) # Closing. Connect non connected parts image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel(5, 3), iterations=4) # Again noise removal after closing # image = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel(8, 8), iterations=1) # don't do too much noise removal. image = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel(3, 3), iterations=1) # Skeletonization image = img_as_ubyte(morphology.thin(image > 128)) cv2.imwrite("enSID1.png", image) # Stub removal (might not be necessary if thinning instead of skeletonize is used above # Making lines stronger image = cv2.morphologyEx(image, cv2.MORPH_DILATE, kernel(5, 5), iterations=1) image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel(10, 10)) # Thining again image = img_as_ubyte(morphology.skeletonize(image > 0.5)) image = cv2.morphologyEx(image, cv2.MORPH_DILATE, kernel(10, 10)) cv2.imwrite("enhancedSID.png", image) im2, ctrs, hier = cv2.findContours( image.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE ) sorted_ctrs = sorted(ctrs, key=lambda ctr: cv2.boundingRect(ctr)[0]) print(len(sid_mask), len(sorted_ctrs)) sid_no = segment_by_contours( image, sorted_ctrs[1:], classifier ) # we remove largest contour that surrounds whole image print(sid_no) if len(sid_no) != len(sid_mask) or not sid_compare(sid_no,sid_mask): sid_warn.append("Trying second SID algorithm.") sid_no = segment_by_7segments(image, image_original, sid_mask, classifier) print(sid_no) if(len(sid_no))!=len(sid_mask): sid_no = segment_by_sid_len(image, image_original, sid_mask, classifier) sid_warn.append("Trying third SID algorithm.") if not sid_compare(sid_no, sid_mask): sid_err=['Wrong SID!'] return (sid_no, sid_err, sid_warn)