def main(args): image = cv2.imread(args["image"]) resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) sd = ShapeDetector() imgray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) ret, thresh = cv2.threshold(imgray, 127, 255, 0) image, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # loop over the contours for c in contours: area = cv2.contourArea(c) if area > 500: [x, y, w, h] = cv2.boundingRect(c) if h > 30 and h < 80 and w > 35: M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) print(shape) if (shape == "rectangle" or shape == "pentagon"): cv2.drawContours(resized, [c], -1, (0, 255, 0), 3) cv2.putText(resized, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) cv2.imshow('final image', resized) cv2.waitKey(0)
def panelSizeEval(im, b_th): image = cv2.imread(im) print("Evaluating image: %s" % im) # resized = imutils.resize(image, width=512, height=384) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, b_th, 255, cv2.THRESH_BINARY)[1] # cv2.imshow("Image", thresh) # cv2.waitKey(0) cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() # loop over the contours sq = 0 cSize = 0 for c in cnts: shape = "unidentified" M = cv2.moments(c) if M["m00"] != 0: shape = sd.detect(c) if shape == "square": ca = cv2.contourArea(c) # print(ca) if (ca > 40000) and (ca < 160000): print(ca) sq += 1 cSize = ca if sq == 0: return 60000 else: return cSize
def panelDetect(image,b_th,ct_th): image = cv2.imread(image) resized = imutils.resize(image, width=640, height=480) ratio = image.shape[0] / float(resized.shape[0]) gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, b_th, 255, cv2.THRESH_BINARY)[1] cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() # loop over the contours sq=0 for c in cnts: shape = "unidentified" M = cv2.moments(c) if M["m00"] != 0: cX = int(round((M["m10"] / M["m00"]))) # * ratio cY = int(round((M["m01"] / M["m00"]))) # * ratio shape = sd.detect(c) if shape == "square": if cv2.contourArea(c)>ct_th: sq +=1 c = c.astype("float") c *= ratio c = c.astype("int") peri = cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, 0.04 * peri, True) cv2.drawContours(image, [c], -1, (0, 255, 0), 1) cv2.putText(image, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX,0.5, (255, 255, 255), 1) if sq == 1: print("Panel Found:",approx) return approx else: return [[[0,0]],[[0,0]],[[0,0]],[[0,0]]]
def detect(imagepath): # load the image and resize it to a smaller factor so that # the shapes can be approximated better image = cv2.imread(imagepath) resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1] # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) sd = ShapeDetector() for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) print(shape)
def main(argv): # Read the image data from argument image = cv2.imread(argv[1]) # Resize if it is necessary(faster but not accurate) # resized = imutils.resize(image, width=800) # ratio = image.shape[0] / float(resized.shape[0]) # Make it Gray scale gray = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2GRAY) # Get the edge by canny effect canny = cv2.Canny(gray.copy(), 80, 120) # Set the kernel for dilation(make the white line thicker) kernel = np.ones((3, 3), np.uint8) dilation = cv2.dilate(canny.copy(), kernel, iterations=7) cv2.imwrite("dilate.jpg", dilation) # Get the contour from dilated picture, EXTERNAL contour used cnts = cv2.findContours(dilation.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cnts = imutils.grab_contours(cnts) # initialize the ShapeDetector class sd = ShapeDetector() oracle = [] for c in cnts: try: # Do if the contourarea is larger than specific area if cv2.contourArea( c) > np.shape(image)[0] / 40 * np.shape(image)[1] / 40: # Get the moments of the shapes M = cv2.moments(c) cX = int((M["m10"] / M["m00"])) cY = int((M["m01"] / M["m00"])) # Detect the shape shape = sd.detect(c) # Put additional information in the image c = c.astype("float") c = c.astype("int") cv2.drawContours(image, [c], -1, (0, 255, 0), 2) cv2.putText(image, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) # Store the shape information to oracle oracle.append([shape, np.array([cX, cY])]) except: continue # Save the image file cv2.imwrite("Shape_recognized.jpg", image) oracle = np.array(oracle) # Create the json file to return the following value to PHP # ["Type of shape", "RowID", "number of shape in the same row"] jsonfile = get_block(image, oracle, (6, 6)) print(jsonfile)
def panelSizeEval(im, b_th): image = cv2.imread(im) resized = imutils.resize(image, width=640, height=480) gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, b_th, 255, cv2.THRESH_BINARY)[1] cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() # loop over the contours sq = 0 cSize = 0 for c in cnts: shape = "unidentified" M = cv2.moments(c) if M["m00"] != 0: shape = sd.detect(c) if shape == "square": ca = cv2.contourArea(c) if (ca > 2000) and (ca < 8000): # print(ca) sq += 1 # cSize = cSize + ca cSize = ca if sq == 0: return 4000 else: return cSize
def process(source_file_path, text): sd = ShapeDetector(source_file_path, text) sd.process() for b in sd.boxes: pprint(vars(b)) for l in sd.lines: pprint(vars(l)) return sd.processed_image, sd.boxes, sd.lines
def getAlarm(): for dweet in dweepy.listen_for_dweets_from('deanDronePI'): #grabbing the relevant data from dweet content1 = dweet["content"] cows = content1["cows"] content1 = dweet["content"] pic = content1["pic"] if pic = 10: cam = Picamera() camera.capture('/home/pi/Desktop/image.jpg') ap = argparse.ArgumentParser() ap.add_argument("-i", "--image", required=True, help="/home/pi/Desktop") args = vars(ap.parse_args()) image = cv2.imread(args["image.jpg"]) smaller = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) gray = cv2.cvtColor(smaller, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1] cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() counted_cows = 0 # loop over the contours for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, c = c.astype("float") c *= ratio c = c.astype("int") cv2.drawContours(image, [c], -1, (0, 255, 0), 2) counted_cows = counted_cows + 1 if counted_cows >= cows: alarm = "false" return alarm else: alarm = "true" return alarm else: alarm = "not yet time" return alarm
def detectgambar(file): # construct the argument parse and parse the arguments #ap = argparse.ArgumentParser() #ap.add_argument("-i", "--image", required=True, # help="path to the input image") #args = vars(ap.parse_args()) # load the image and resize it to a smaller factor so that # the shapes can be approximated better image = cv2.imread(file) resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1] # find contours in the thresholded image and initialize the # shape detector thresh = 255 - thresh cnts = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) sd = ShapeDetector() # loop over the contours for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") c *= ratio c = c.astype("int") if shape == "triangle": cv2.drawContours(image, [c], -1, (0, 0, 255), 2) else: cv2.drawContours(image, [c], -1, (0, 255, 0), 2) cv2.putText(image, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2) # show the output image cv2.imshow("Image", image) cv2.waitKey(0) cv2.destroyAllWindows() #input('Press ENTER to exit')
def start_game(image, cnts): game_board = [] x_coordinates = [] y_coordinates = [] lowestY = 999999 sd = ShapeDetector() cd = ColorDetector() for c in cnts: # compute the center of the contour M = cv2.moments(c) if M["m00"] == 0: M["m00"] = 1 cX = int(M["m10"] / M["m00"]) cY = int(M["m01"] / M["m00"]) shape = sd.detect(c) if shape == "hexagon": # print(str(cX) + ", " + str(cY)) # draw the contour and center of the shape on the image color = cd.determine_color(image, c) cv2.drawContours(image, [c], -1, (0, 255, 0), 2) cv2.circle(image, (cX, cY), 7, (255, 255, 255), -1) cv2.putText(image, color, (cX - 20, cY - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) if cY < lowestY: lowestY = cY game_board.append([color]) x_coordinates.append([cX]) y_coordinates.append(cY) else: for i in range(0, len(y_coordinates)): if cY == y_coordinates[i]: x_coordinates[i].append(cX) game_board[i].append(color) if len(game_board) == 0: return for i in range(0, len(x_coordinates)): swapped = True while swapped: swapped = False for j in range(len(x_coordinates[i]) - 1): if x_coordinates[i][j] > x_coordinates[i][j + 1]: # Swap the elements x_coordinates[i][j], x_coordinates[i][ j + 1] = x_coordinates[i][j + 1], x_coordinates[i][j] game_board[i][j], game_board[i][j + 1] = game_board[i][ j + 1], game_board[i][j] # Set the flag to True so we'll loop again swapped = True game_board = game_board[::-1] x_coordinates = x_coordinates[::-1] y_coordinates = y_coordinates[::-1] solve_game(game_board, x_coordinates, y_coordinates)
def recognize(image): image = imutils.resize(image, width=500) #gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) #blurred = cv2.GaussianBlur(gray, (5, 5), 0) edged = auto_canny(image) cv2.imwrite("edged.png", edged) image = cv2.imread("edged.png") resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1] # find contours in the thresholded image and initialize the # shape detector cv2.imwrite("edged.png", edged) (_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cv2.drawContours(edged, cnts, -1, (0, 255, 0), 3) (_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = sorted([(c, cv2.boundingRect(c)[0]) for c in cnts], key=lambda x: x[1]) sd = ShapeDetector() # loop over the contours for (c, _) in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") c *= ratio c = c.astype("int") cv2.drawContours(image, [c], -1, (0, 255, 0), 2) cv2.imwrite("drawContours.png", image) cv2.putText(image, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) # show the output image print(shape) output = list() output.append(str(shape)) return output
def main(args): ''' # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--image", required=True, help="path to the input image") args = vars(ap.parse_args()) ''' # load the image and resize it to a smaller factor so that # the shapes can be approximated better image = cv2.imread(args["image"]) resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1] # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() # loop over the contours for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") c *= ratio c = c.astype("int") cv2.drawContours(resized, [c], -1, (0, 255, 0), 2) cv2.putText(resized, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) # show the output image cv2.imshow("Image", resized) cv2.waitKey(0)
def detector(img1,img2_color): img1 = cv2.resize(img1,(360,360)) img2 = cv2.cvtColor(img2_color,cv2.COLOR_BGR2GRAY) #img2 = cv2.resize(img2,(360,360) ret,thresh = cv2.threshold(img2,127,255,0) im2, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) sd = ShapeDetector() cnts = [] for cnt in contours: if sd.detect(cnt) == "triangle": cnts.append(cnt) cv2.drawContours(img2_color, contours, -1, (0,255,0), 3) cv2.imshow('Refined', img2_color) cv2.waitKey(0) return None
def contour_id( cnts, fout="ContourShape.txt" ): #take contours and write their shape in file if circle enough sd = ShapeDetector() i = 0 f = open(fout, "w") for c in cnts: if sd.detect(c) == "circle": i = i + 1 for j in range(len(c)): f.write( str(i) + " " + str(c[j, 0, 0]) + " " + str(c[j, 0, 1]) + "\n") f.close()
def detect(image, hsv): resized = imutils.resize(hsv, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (15, 15), 0) thresh = cv2.threshold(blurred, 110, 255, cv2.THRESH_BINARY)[1] # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() # loop over the contours for c in cnts: # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image #peri = cv2.arcLength(c, True) #print(cv2.boundingRect(c)) #approx = cv2.approxPolyDP(c, 0.04 * peri, True) #print("approx:\n", approx) c = c.astype("float") c *= ratio c = c.astype("int") cv2.drawContours(image, [c], -1, (0, 255, 0), 2) return image, cnts
def process_img(image): final = apply_brightness_contrast(image, 12, 50) sd = ShapeDetector() cd = ColorDetector() # convert to gray processed_img = cv2.cvtColor(final, cv2.COLOR_BGR2GRAY) processed_img = cv2.equalizeHist(processed_img) # edge detection processed_img = cv2.Canny(processed_img, threshold1=100, threshold2=200) cnts = cv2.findContours(processed_img.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) game_board = [] x_coordinates = [] y_coordinates = [] lowestY = 999999 cv2.imwrite("./Gray_Image.jpg", image) return image, cnts
def press_next(image, cnts): sd = ShapeDetector() cd = ColorDetector() for c in cnts: M = cv2.moments(c) if M["m00"] == 0: M["m00"] = 1 cX = int(M["m10"] / M["m00"]) cY = int(M["m01"] / M["m00"]) shape = sd.detect(c) if shape == "rectangle": print(str(cX) + ", " + str(cY)) mouse.move(cX, cY, absolute=True, duration=0.12) mouse.click()
def main(args): image = cv2.imread(args["image"]) if image.shape[0] > image.shape[1]: resized = imutils.resize(image, width=240) else: resized = imutils.resize(image, height=240) sd = ShapeDetector() imgray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) (thresh, im_bw) = cv2.threshold(imgray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) image, contours, hierarchy = cv2.findContours(im_bw, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) count = 0; # loop over the contours for c in contours: area = cv2.contourArea(c) if area > 200: [x, y, w, h] = cv2.boundingRect(c) #cv2.drawContours(resized, [c], -1, (0, 255, 0), 2) if h in range(30, 50) and w in range(30,50): M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) - w / 2.5) cY = int((M["m01"] / M["m00"]) + h / 1.5) shape = sd.detect(c) print(shape, cX, cY) if shape in ["square", "rectangle","pentagon"]: # save the crop_image crop_image = resized[y:y + w, x:x + w] #img_name = "Media/well_{0}.png".format(count) #count += 1 img_name = "test.jpg" #compare with raw/images cv2.imwrite(img_name, crop_image) result = match_shape(img_name) # draw contour cv2.drawContours(resized, [c], -1, (255, 0, 0), 2) cv2.putText(resized, result, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) #draw rectangle for well cv2.rectangle(resized, (x-90, y-80), (x+125, y+135), (255, 0, 0), 2) cv2.imshow('final image', resized) cv2.waitKey(0)
def find_marker(image): # convert the image to grayscale, blur it, and detect edges gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(gray, 60, 255, cv2.THRESH_BINARY)[1] # find the contours in the edged image and keep the largest one; # we'll assume that this is our piece of paper in the image cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) sd = ShapeDetector() ratio = 100 / 30 for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) num = 0.01 * cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, num, True) # if len(approx)==5: # print "pentagon" # thing = cv2.contourArea(c, false) if len(approx) == 4: print("rectangle") thing = cv2.contourArea(c, false) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") c *= ratio c = c.astype("int") cv2.drawContours(image, [c], -1, (0, 255, 0), 2) # cv2.putText(image, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, # 0.5, (255, 255, 255), 2) # show the output image cv2.imshow("Image", image) cv2.waitKey(0) # compute the bounding box of the of the paper region and return it return thing
def detector(img1,img2_color): img1 = cv2.resize(img1,(360,360)) img2 = cv2.cvtColor(img2_color,cv2.COLOR_BGR2GRAY) #img2 = cv2.resize(img2,(500,360)) #img2_color = cv2.resize(img2_color,(500,360)) sift = cv2.xfeatures2d.SIFT_create() kp1, des1 = sift.detectAndCompute(img1,None) FLANN_INDEX_KDTREE = 0 index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 10) search_params = dict(checks = 50) flann = cv2.FlannBasedMatcher(index_params, search_params) kp2, des2 = sift.detectAndCompute(img2,None) matches = flann.knnMatch(des1,des2,k=2) ratio_thresh = 0.8 good_matches = [] for m,n in matches: if m.distance < ratio_thresh * n.distance: good_matches.append(m) list_kp2 = [kp2[mat.queryIdx].pt for mat in good_matches] print(list_kp2) if(len(good_matches)>5): ret,thresh = cv2.threshold(img2,127,255,0) im2, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) sd = ShapeDetector() cnts = [] for cnt in contours: if sd.detect(cnt) == "triangle": cnts.append(cnt) cv2.drawContours(img2_color, cnts, -1, (0,0,255), 3) for cnt in cnts: try: ellipse = cv2.fitEllipse(cnt) img2_color = cv2.ellipse(img2_color,ellipse,(0,255,0)) except: pass cv2.imshow('Refined', img2_color) cv2.waitKey(0) return 1 else: return 0
def detect_shape(image): resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it blurred = cv2.GaussianBlur(resized, (5, 5), 0) gray = cv2.cvtColor(blurred, cv2.COLOR_BGR2GRAY) lab = cv2.cvtColor(blurred, cv2.COLOR_BGR2LAB) thresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)[1] cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() for c in cnts: # compute the center of the contour M = cv2.moments(c) if M["m00"] == 0: continue cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) # detect the shape of the contour and label the color shape = sd.detect(c) if shape in ['no_shape', 'rectangle', 'square']: return False # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape and labeled # color on the image c = c.astype("float") c *= ratio c = c.astype("int") text = "{}".format(shape) cv2.drawContours(image, [c], -1, (0, 255, 0), 2) cv2.putText(image, text, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) return True
def processBot(contour,checkpointType): ''' param-contour [Type-list], checkpointType[Type-CheckpointType object] returns-checkPointList[Type-list of Checkpoint objects] It works the same way as Frame.processCheckpoints(). The exact same way as above. ''' #print 'Frame: getCenter called ' checkPointList = [] for c in contour: # compute the center of the contour, then detect the name of the # shape using only the contour Moment = cv2.moments(c) if Moment["m00"] > 0: origin = None if not Frame.runOnce: origin = Frame.townHall.center else: origin = Point(0,0) Frame.runTimeCounter += 1 shapeDetector = ShapeDetector() #shape = shapeDetector.detect(c) shape = CheckpointShape.SQUARE #print "DEtected Shape " + shape point = Point() point.x = int((Moment["m10"] / Moment["m00"]+ 1e-7) * Frame.ratio)#uses moment of inertia concept point.y = int((Moment["m01"] / Moment["m00"]+ 1e-7) * Frame.ratio) dist = float(distance(origin,point)) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image #print "Position: " + point.toString() c = c.astype("float") c *= Frame.ratio c = c.astype("int") area=cv2.contourArea(c) if area > 1600: Frame.draw_contour(c,checkpointType.type, point, checkpointType.contour_color) checkPointList.append(Checkpoint(area, point, dist, 0, shape)) return checkPointList
def get_center(contour,checkpointType): #print 'Frame: getCenter called ' checkPointList = [] for c in contour: # compute the center of the contour, then detect the name of the # shape using only the contour Moment = cv2.moments(c) if Moment["m00"] > 0: origin = None if not Frame.runOnce: origin = Frame.townHall.center else: origin = Point(0,0) Frame.runTimeCounter += 1 shapeDetector = ShapeDetector() #shape = shapeDetector.detect(c) shape = CheckpointShape.SQUARE #print "DEtected Shape " + shape point = Point() point.x = int((Moment["m10"] / Moment["m00"]) )#uses moment of inertia concept point.y = int((Moment["m01"] / Moment["m00"])) dist = float((((origin.x-point.x)*(origin.x-point.x))+((origin.y - point.y )*(origin.x - point.y)))^(1/2)) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image #print "Position: " + point.toString() c = c.astype("float") c *= Frame.ratio c = c.astype("int") area=cv2.contourArea(c) if area > 700: Frame.draw_contour(c,checkpointType.type,point,checkpointType.contour_color) checkPointList.append(Checkpoint(area,point,dist,0,shape)) return checkPointList
resized = imutils.resize(image, width=300) ratio = image.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 111, 245, cv2.THRESH_BINARY_INV)[1] # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) sd = ShapeDetector() # loop over the contours for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour if cv2.contourArea(c) > MIN_THRESH: M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") c *= ratio
# Calculate the shrink ratio ratio = img2proc.shape[0] / float(resized.shape[0]) # Grey scaling gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) # Gaussian blur blurred = cv2.GaussianBlur(gray, (gaussian_size, gaussian_size), 0) # cv2.imshow("Image", blurred) # cv2.waitKey(0) # Set the threshold to filter out the GCP area thresh = cv2.threshold(blurred, th_GCP, 255, cv2.THRESH_BINARY)[1] # Find contours of the filtered areas cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] # Load shape detector sd = ShapeDetector() # Initialize the center of the GCP (cX,cY) coordinates cX = 0 cY = 0 # The total number of the square shape and rectangle shape detected snum = 0 shape = "unidentified" contourSize = 0 for c in cnts: shape = "unidentified" shape = sd.detect(c) # print(shape) if cv2.contourArea(c) >= contour_min_size and cv2.contourArea( c ) <= contour_max_size and shape == "square": # or shape == "rectangle"): print("Contour size: %f" % cv2.contourArea(c))
def get_frame(self): if self.video.isOpened(): check, frame = self.video.read() self.BWl=self.win.get() self.BWh=self.wout.get() self.onoffBW= self.blandwh.get() self.onoffinv= self.inv.get() #frame = cv2.imread("/Users/maria/Desktop/IGEM/qrcode.png") #use this line to test with still pictures #overlay= cv2.imread("/Users/maria/Desktop/IGEM/SQR.jpg") dim = (102, 102) #Resize Size of Square Overlay #overlay= cv2.resize(overlay, dim) #rows,cols,channels = overlay.shape #overlay=cv2.addWeighted(frame[0:0+rows, 0:0+cols],0,overlay,1,1) #frame[0:0+rows, 0:0+cols ] = overlay #frame= cv2.imwrite('combined.png', added_image) img= cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #turn picture to grayscale #overlay= cv2.cvtColor(overlay, cv2.COLOR_BGR2GRAY) #turn picture to grayscale resized = cv2.resize(img, (200, 200))#imutils.resize(img, width=300) ratio = img.shape[0] / float(resized.shape[0]) #barcodes = decode(img) #decoding before black and white !!!!!!!!!!!! #if self.onoffBW == 1: #for i in range(20, 180, 10): (thresh, img) = cv2.threshold(img, self.BWl, self.BWh, cv2.THRESH_BINARY) #turn picture Black and White barcodes = decode(img) #to use to scan for barcodes before inverting image # print(i) # if not not barcodes: # break #for i in range(20, 180, 5): # (thresh, src) = cv2.threshold(img, 100, self.BWh, cv2.THRESH_BINARY) #turn picture Black and White # barcodes = decode(src) #to use to scan for barcodes before inverting image # #print(i) # if not not barcodes: # break #overlay = cv2.threshold(overlay, self.BWl, self.BWh, cv2.THRESH_BINARY)[1] #if self.onoffinv == 1: img = cv2.bitwise_not(img) #Invert color of image!!!!!!!!!!!! #overlay = cv2.bitwise_not(overlay) #Invert color of image #thresh = cv2.threshold(img, self.BWl, self.BWh, cv2.THRESH_BINARY)[1] #img = cv2.blur(img,(5,5)) #BLUR IMAGE barcodesinv = decode(img) #find QR codes (when picture is Black and Wait, seems to work better with out codes) if barcodes: #detection of barcodes without inverting image # loop over the detected barcodes for barcode in barcodes: # extract the bounding box location of the barcode and draw the # bounding box surrounding the barcode on the image (x, y, w, h) = barcode.rect cv2.rectangle(frame, (x, y), (x + w, y + h), (100, 100, 100), 3) # the barcode data is a bytes object so if we want to draw it on # our output image we need to convert it to a string first barcodeData = barcode.data.decode("utf-8") barcodeType = barcode.type #ciphertext=barcodeData #from Crypto.Cipher import AES #import base64 #block_size=16 #key=b'\xebT\xe7Tm\xf3S/\x06\xeb\x005\xc6z\x0f\x1f' #ciphertext = base64.b64decode(ciphertext) #binascii.unhexlify(ciphertext) #puts in into byte format #iv = ciphertext[:block_size] #decipher = AES.new(key, AES.MODE_CBC, iv) #ENCRYPTED=binascii.unhexlify(ciphertext) #DECRYPTED=decipher.decrypt(ciphertext[AES.block_size:]) #DECRYPTED2 = DECRYPTED.rstrip(b"\0") #takes away padding #DECRYPTED3 = DECRYPTED2.decode("utf-8") #plaintext = cipher.decrypt(ciphertext[AES.block_size:]) #print(DECRYPTED3) #barcodeData=DECRYPTED3 # draw the barcode data and barcode type on the image text = "{} ({})".format(barcodeData, barcodeType) cv2.putText(frame, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (100, 100, 100), 2) # print the barcode type and data to the terminal print("[INFO] Found {} barcode\n Your message is: {}".format(barcodeType, barcodeData)) #break #uncomment this line to break loop as soon as QR code is detected if barcodesinv: #detection of barcodes with image inverted # loop over the detected barcodes for barcode in barcodesinv: # extract the bounding box location of the barcode and draw the # bounding box surrounding the barcode on the image (x, y, w, h) = barcode.rect cv2.rectangle(frame, (x, y), (x + w, y + h), (100, 100, 100), 3) # the barcode data is a bytes object so if we want to draw it on # our output image we need to convert it to a string first barcodeData = barcode.data.decode("utf-8") barcodeType = barcode.type # draw the barcode data and barcode type on the image text = "{} ({})".format(barcodeData, barcodeType) cv2.putText(frame, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (100, 100, 100), 2) ## print the barcode type and data to the terminal #print("[INFO] Found {} barcode: {}".format(barcodeType, barcodeData)) self.info = "[INFO] Found {} barcode: {}".format(barcodeType, barcodeData) #break #uncomment <--- this line to break loop as soon as QR code is detected ## Shape Detector cnts = cv2.findContours(img.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) sd = ShapeDetector() if len(cnts)>2: for c in cnts: M = cv2.moments(c) if M["m00"]!=0: #if cv2.moments(c) # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) ) cY = int((M["m01"] / M["m00"]) ) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") #c *= ratio #dim = (60, 60) ##TO RESIZE Squares #overlay= cv2.resize(overlay, dim) #overlay = cv2.threshold(overlay, 100, 255, cv2.THRESH_BINARY)[1] c = c.astype("int") if shape=="square" or shape=="rectangle": if cX>dim[1] and cY>dim[1] and cX<len(img)-dim[1] and cY<len(img)-dim[1]: cv2.drawContours(img, [c], -1, (100, 100, 100), 10) cv2.putText(img, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (100, 100, 100), 2) #overlay=cv2.addWeighted(img[cY-int(rows/2):cY+int(rows/2), cX-int(cols/2):cX+int(cols/2)],0,overlay,1,1) #ADDING squares in the center of other squares #img[cY-int(rows/2):cY+int(rows/2), cX-int(cols/2):cX+int(cols/2)] = overlay return(check, frame)
def detectAreaRatio(self, folder=None): loadImg = LoadImages() if folder == None: folder = "../images/isolated_images/" self.image_list = loadImg.load(folder) # load the image and resize it to a smaller factor so that # the shapes can be approximated better index = 0 index_obj = 0 for img in self.image_list: resized = imutils.resize(img, width=300) ratio = img.shape[0] / float(resized.shape[0]) # convert the resized image to grayscale, blur it slightly, # and threshold it gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) thresh = cv2.threshold(blurred, 60, 255, cv2.THRESH_BINARY)[1] # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) sd = ShapeDetector() # create image objects img_obj = image(img) img_obj.id = index self.image_obj_list.append(img_obj) # loop over the contours for c in cnts: #area = cv2.contourArea(c) #print('area is:', area) if cv2.contourArea(c) <= 200: continue # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) cX = 0 cY = 0 if M["m00"] != 0: cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape on the image c = c.astype("float") c *= ratio c = c.astype("int") cv2.drawContours(img, [c], -1, (0, 255, 0), 2) #cv2.putText(img, shape, (cX, cY), cv2.FONT_HERSHEY_SIMPLEX, # 0.5, (255, 255, 255), 2) # Rotated Rectangle rect = cv2.minAreaRect(c) box = cv2.boxPoints(rect) box = np.int0(box) imgRotRect = cv2.drawContours(img, [box], 0, (0, 0, 255), 2) # calculate the area area_obj = cv2.contourArea(c) area_box = self.findAreaRotRect(box) # create dna_object d_obj = dna_object() d_obj.id = index_obj d_obj.getAttributes(c, area_obj, area_box) self.dna_object_list.append(d_obj) r = d_obj.area_ratio print("# ", index) print("area obj: %.2f" % area_obj) print("area box: %.2f" % area_box) print("area ratio: %.2f" % r) index_obj += 1 #cv2.imshow(str(index), imgRotRect) #cv2.waitKey(0) index += 1
mask = get_mask(hsv, icol) mask2 = get_mask(hsv, icol2) mask = mask + mask2 kernal = np.ones((3, 3), np.uint8) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernal) Change_image = cv2.bitwise_and(Change_image, Change_image, mask=mask) cv2.imshow('img4', Change_image) # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() # loop over the contours for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) try: cX = int((M["m10"] / M["m00"])) cY = int((M["m01"] / M["m00"])) (shape, approx) = sd.detect(c) if len(approx) == 3 or len(approx) == 4: (x, y, w, h) = cv2.boundingRect(approx) cv2.rectangle(Result_image, (x, y), (x + w, y + h), 255, 2)
th2 = cv2.adaptiveThreshold(blurred,255,cv2.ADAPTIVE_THRESH_MEAN_C,\ cv2.THRESH_BINARY,11,2) cv2.imshow('Adaptive Threshold', th2) edges = cv2.Canny(resized,100,200) cv2.imshow('Edges', edges) # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(th2.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() cl = ColorLabeler() # loop over the contours cnt = 0 for c in cnts: # compute the center of the contour, then detect the name of the # shape using only the contour M = cv2.moments(c) #cX = int((M["m10"] / M["m00"]) * ratio) #cY = int((M["m01"] / M["m00"]) * ratio) shape = sd.detect(c, height) color = cl.label(lab, c)
ratio = image.shape[0] / float(resized.shape[0]) # blur the resized image slightly, then convert it to both # grayscale and the L*a*b* color spaces blurred = cv2.GaussianBlur(resized, (5, 5), 0) gray = cv2.cvtColor(blurred, cv2.COLOR_BGR2GRAY) lab = cv2.cvtColor(blurred, cv2.COLOR_BGR2LAB) thresh = cv2.threshold(gray, 60, 255, cv2.THRESH_BINARY)[1] cv2.imshow("Thresh", thresh) # find contours in the thresholded image cnts = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] # initialize the shape detector and color labeler sd = ShapeDetector() cl = ColorLabeler() # loop over the contours for c in cnts: # compute the center of the contour M = cv2.moments(c) cX = int((M["m10"] / M["m00"]) * ratio) cY = int((M["m01"] / M["m00"]) * ratio) # detect the shape of the contour and label the color shape = sd.detect(c) color = cl.label(lab, c) # multiply the contour (x, y)-coordinates by the resize ratio, # then draw the contours and the name of the shape and labeled
# Take each frame _, frame = cap.read() # Convert BGR to HSV hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # define range of blue color in HSV lower_blue = np.array([0, 220, 0]) upper_blue = np.array([15, 255, 200]) # Threshold the HSV image to get only blue colors mask = cv2.inRange(hsv, lower_blue, upper_blue) # Bitwise-AND mask and original image res = cv2.bitwise_and(frame, frame, mask=mask) # find contours in the thresholded image and initialize the # shape detector cnts = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] sd = ShapeDetector() cv2.imshow('frame', frame) cv2.imshow('mask', mask) cv2.imshow('res', res) k = cv2.waitKey(5) & 0xFF if k == 27: break cv2.destroyAllWindows()