def draw(latticesize, defectsize): pngfolder = r'\\icnas2.cc.ic.ac.uk\kjs18\GitHub\RPMv3\Latticeimages' latticedim = latticesize for file in os.listdir(pngfolder): if str(latticedim) in file: lattice = os.path.join(pngfolder, file) image = os.path.join(pngfolder, file) #SETS ARGUEMENTS #ap = argparse.ArgumentParser() #ap.add_argument("-i", "--image", help = "path to the image file") #ap.add_argument("-l", "--lattice", help = "path to the image file") #args = vars(ap.parse_args()) #TAKES LATTICE IMAGE lattice = cv2.imread(lattice) print( "Click vertices in following order: (1) top left (2) top right (3) bottom left (4) bottom right (5) centre of where the defect box is - for odd vertex box, click on a vertex, for even, click in the middle of 4 vertices" ) # initiates click event for the lattice image cv2.imshow("click", lattice) cv2.setMouseCallback("click", click_event_lattice) cv2.waitKey(-1) #SETS MIN AND MAX FOR EACH CLICK Xmin, Ymin, X1, Y1, X2, Y2, Xmax, Ymax, Xc, Yc = verts[0][0], verts[0][ 1], verts[1][0], verts[1][1], verts[2][0], verts[2][1], verts[3][ 0], verts[3][1], verts[4][0], verts[4][1] #calculates lattice length and dimension latticelength = Xmax - Xmin vertexlengthX = (X1 - Xmin) / (latticesize) vertexlengthY = (Y2 - Ymin) / (latticesize) print(latticesize) vertexlengthY = (Ymax - Ymin) / latticesize dimension = latticesize #DRAWS CIRCLES ON THE VERTICES for i in range( 2 * dimension + 1 ): #creates x range and y range for vertex coordinates coordinates Xlist.append(int(Xmin + ((Xmax - Xmin) / (2 * dimension)) * (i))) Ylist.append(int(Ymin + ((Ymax - Ymin) / (2 * dimension)) * (i))) C = [] for i in range(len(Xlist)): #creates a list of the vertex coordinates for j in range(len(Ylist)): C.append((Xlist[i - 1], Ylist[j - 1])) for vertex in C: cv2.circle(lattice, (vertex[0], vertex[1]), circle_radius, (0, 0, 0), -1) for vertex in C: cv2.circle(lattice, (vertex[0], vertex[1]), circle_radius, (0, 0, 0), -1) #SHOWS THE RESULT AND WAITS FOR A KEY TO PROCEED cv2.imshow("lattice w/ vertex", lattice) cv2.waitKey(-1) #SETS THE UPPER LIMIT FOR A CONNECTION TO BE A PERCENTAGE OF THE ISLAND DISTANCE line_length_upper = ((Xmax - Xmin) / dimension) * 0.8 line_length_lower = ((Xmax - Xmin) / dimension) * 0.4 barsize = (Xmax - Xmin) / dimension #READS THE MFM FILE AND CONVERTS IT TO GREYSCALE image = cv2.imread(image) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) gray_lattice = cv2.cvtColor(lattice, cv2.COLOR_BGR2GRAY) #DRAWS CROSSES ON THE VERTICES TO SEPERATE BLOBS WHICH ARE MERGED for vertex in C: cv2.line(gray, (int((vertex[0] - line_length_upper)), int((vertex[1] - line_length_upper))), (int(vertex[0] + line_length_upper), int(vertex[1] + line_length_upper)), 158, 1) cv2.line(gray, (int((vertex[0] - line_length_upper)), int((vertex[1] + line_length_upper))), (int(vertex[0] + line_length_upper), int(vertex[1] - line_length_upper)), 158, 1) #DRAWS GREY RECTANGLES AROUND THE EDGE OF THE LATTICE. cv2.rectangle(gray, (0, int(Ymin - line_length_upper * 0.5)), (10000, 0), 158, -1) cv2.rectangle(gray, (0, int(Ymax + line_length_upper * 0.5)), (10000, 10000), 158, -1) cv2.rectangle(gray, (int(Xmin - line_length_upper * 0.5), 0), (0, 10000), 158, -1) cv2.rectangle(gray, (int(Xmax + line_length_upper * 0.5), 0), (10000, 10000), 158, -1) #Draws grey vertex box. cv2.rectangle(gray, (int(Xc - (0.5 * defectsize * barsize)), int(Yc - (0.5 * defectsize * barsize))), (int(Xc + (0.5 * defectsize * barsize)), int(Yc + (0.5 * defectsize * barsize))), 158, -1) #ALLOWS THE USER TO CONTROL THE LEVEL OF THRESHOLD TO MAKE WHITE SPOTS BLACK. (NEED TO MOVE THIS TO A FUNCTION) cv2.namedWindow("WHITE SPOTS TO BLACK (ESC WHEN DONE)") hh = 'Max' hl = 'Min' wnd = "WHITE SPOTS TO BLACK (ESC WHEN DONE)" cv2.createTrackbar("Max", wnd, 0, 255, nothing) while (1): hul = cv2.getTrackbarPos("Max", wnd) #ret,thresh1 = cv2.threshold(image,hul,huh,cv2.THRESH_BINARY) ret, whitedetect = cv2.threshold(gray, hul, 250, cv2.THRESH_BINARY_INV) #ret,thresh3 = cv2.threshold(image,hul,huh,cv2.THRESH_TRUNC) #ret,thresh4 = cv2.threshold(image,hul,huh,cv2.THRESH_TOZERO) #ret,thresh5 = cv2.threshold(image,hul,huh,cv2.THRESH_TOZERO_INV) # cv2.imshow(wnd) #cv2.imshow("thresh1",thresh1) cv2.imshow('original', gray) cv2.moveWindow('original', 0, 0) cv2.imshow(wnd, whitedetect) #cv2.imshow("thresh3",thresh3) #cv2.imshow("thresh4",thresh4) #cv2.imshow("thresh5",thresh5) k = cv2.waitKey(1) & 0xFF if k == ord('m'): mode = not mode elif k == 27: break cv2.destroyAllWindows() #Rectangle drawing #ALLOWS THE USER TO CONTROL THE LEVEL OF THRESHOLD TO MAKE BLACK SPOTS BLACK. (NEED TO MOVE THIS TO A FUNCTION) cv2.namedWindow("BLACK SPOTS TO BLACK (ESC WHEN DONE)") hh = 'Max' hl = 'Min' wnd = "BLACK SPOTS TO BLACK (ESC WHEN DONE)" cv2.createTrackbar("Max", wnd, 0, 255, nothing) while (1): hul = cv2.getTrackbarPos("Max", wnd) #ret,thresh1 = cv2.threshold(image,hul,huh,cv2.THRESH_BINARY) ret, blackdetect = cv2.threshold(gray, hul, 250, cv2.THRESH_BINARY_INV) blackdetect = cv2.bitwise_not(blackdetect) #ret,thresh3 = cv2.threshold(image,hul,huh,cv2.THRESH_TRUNC) #ret,thresh4 = cv2.threshold(image,hul,huh,cv2.THRESH_TOZERO) #ret,thresh5 = cv2.threshold(image,hul,huh,cv2.THRESH_TOZERO_INV) # cv2.imshow(wnd) #cv2.imshow("thresh1",thresh1) cv2.imshow('ORIGINAL', gray) cv2.moveWindow('ORIGINAL', 0, 0) cv2.imshow(wnd, blackdetect) #cv2.imshow("thresh3",thresh3) #cv2.imshow("thresh4",thresh4) #cv2.imshow("thresh5",thresh5) k = cv2.waitKey(1) & 0xFF if k == ord('m'): mode = not mode elif k == 27: break cv2.destroyAllWindows() #Rectangle drawing #ALLOWS THE USER TO CONTROL THE LEVEL OF THRESHOLD FOR THE LATTICE. (NEED TO MOVE THIS TO A FUNCTION) cv2.namedWindow("Lattice threshold (esc when done)") hh = 'Max' hl = 'Min' wnd = "Lattice threshold (esc when done)" cv2.createTrackbar("Max", wnd, 0, 255, nothing) while (1): hul = cv2.getTrackbarPos("Max", wnd) ret, latticethresh = cv2.threshold(gray_lattice, hul, 250, cv2.THRESH_BINARY) #ret,blackdetect = cv2.threshold(gray_lattice,hul,huh,cv2.THRESH_BINARY_INV) #ret,thresh3 = cv2.threshold(image,hul,huh,cv2.THRESH_TRUNC) #ret,thresh4 = cv2.threshold(image,hul,huh,cv2.THRESH_TOZERO) #ret,thresh5 = cv2.threshold(image,hul,huh,cv2.THRESH_TOZERO_INV) # cv2.imshow(wnd) #cv2.imshow("thresh1",thresh1) cv2.imshow('Lattice', lattice) cv2.moveWindow('Lattice', 0, 0) cv2.imshow(wnd, latticethresh) #cv2.imshow("thresh3",thresh3) #cv2.imshow("thresh4",thresh4) #cv2.imshow("thresh5",thresh5) k = cv2.waitKey(1) & 0xFF if k == ord('m'): mode = not mode elif k == 27: break cv2.destroyAllWindows() #Rectangle drawing #PARAMETERS FOR THE BLOB DETECTION params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 1 params.maxThreshold = 300 # Filter by Area. params.filterByArea = True params.minArea = 20 # Filter by Circularity params.filterByCircularity = False params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = False params.minConvexity = 0.87 # Filter by Inertia params.filterByInertia = False params.minInertiaRatio = 0.01 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) #DETECTS DARK AND WHITE BLOBS AND STORES THEM TO ARRAYS keypoints_dark = detector.detect(blackdetect) keypoints_light = detector.detect(whitedetect) keypoints_total = keypoints_light + keypoints_dark #DRAWS CIRCLES ON THE ORIGINAL IMAGE WHERE THE BLOBS ARE im_with_keypoints = cv2.drawKeypoints( gray, keypoints_total, np.array([]), (46, 155, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) for vertex in C: im_with_keypoints = cv2.circle(im_with_keypoints, (vertex[0], vertex[1]), circle_radius, (0, 0, 0), -1) final_im = im_with_keypoints # Draw detected blobs as red circles. # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures # the size of the circle corresponds to the size of blob #PARAMETERS FOR THE NEXT PART. IslandProperties = [] BarCoordinates = [] BarCoordinatesend = [] mxfinal = [] myfinal = [] connectdots(keypoints_dark, keypoints_light, im_with_keypoints, latticethresh, line_length_lower, line_length_upper, IslandProperties) redo(im_with_keypoints, IslandProperties) cv2.imshow("", im_with_keypoints) cv2.waitKey(-1) again = input("redo again? Y/N") if again == "Y": redo(im_with_keypoints, IslandProperties) else: again = "N" print(IslandProperties) cv2.imshow("", im_with_keypoints) cv2.waitKey(-1) grid(IslandProperties, im_with_keypoints, vertexlengthX, dimension, vertexlengthY, Xmin, Ymin, C)
def get_diagnostic_data(region, mask): rCopy = region.copy() rCopy = np.divide(rCopy, 256) rCopy = rCopy.astype('uint8') vis = rCopy.copy() vis = cv2.cvtColor(vis, cv2.COLOR_GRAY2BGR) nMask = np.where(mask > 0, [1], [0]).astype('uint8') rCopy *= nMask rCopy = np.where(rCopy > 0, [255], [0]).astype('uint8') rCopy = cv2.Canny(rCopy, 200, 255) rCopy = cv2.GaussianBlur(rCopy, (1, 1), 7) # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 0 params.maxThreshold = 255 # Filter by Area. params.filterByArea = True params.minArea = 400 params.maxArea = 2300 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.5 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.1 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.01 detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(rCopy) # Draw detected blobs as red circles. # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob #vis = cv2.drawKeypoints(vis, keypoints, np.array([]), (0, 255, 0),cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) intensities = [] for keypoint in keypoints: cy = int(round(keypoint.pt[1])) cx = int(round(keypoint.pt[0])) rad = int(round(keypoint.size / 2.)) rad = int(round(rad * 0.75)) w, h = region.shape y, x = np.ogrid[-cx:w - cx, -cy:h - cy] mask = x**2 + y**2 <= rad**2 vis = cv2.circle(vis, (cx, cy), rad, (0, 255, 0), 1) colorIntensity = ((np.power(2, 16) - 1) - np.average(region[mask])) / (np.power(2, 16) - 1) if colorIntensity == np.nan or colorIntensity == np.inf: continue """The intensity value of each cell is found by first taking the average pixel value of each pixel inside the cell region. This value is then subtracted from 255 so that the final intensity value will increase with the darkness of the cell. Finally, the intensity value is divided by the maximum value a pixel can attain, which normalizes the intensity value to be between 0 and 1.""" intensities.append(colorIntensity) debug = [vis, rCopy] return debug, intensities
def get_target(cap): """ Vind een kleur in het zichtveld van de camera. 0 voor links en 1 voor rechts. -1 voor geen beweging. :param cap: De opencv camera :return: De richting waarin zich het doel bevind """ cap.set(3, 320) cap.set(4, 240) if not cap.isOpened(): # sudo modprobe bcm2835-v4l2 print("CAPTURE DEVICE NOT FOUND") exit(2) ret_cam, resized = cap.read() resized = cv2.blur(resized, (10, 10)) ycc = cv2.cvtColor(resized, cv2.COLOR_BGR2YCrCb) mask = cv2.inRange(ycc, lower_red, upper_red) params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 10 params.maxThreshold = 200 params.blobColor = 255 w, h, c = resized.shape # Filter by Area. params.filterByArea = True params.minArea = int(((w + h) / 4) + 1) # Filter by Circularity params.filterByCircularity = False params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = False params.minConvexity = 0.01 # Filter by Inertia params.filterByInertia = False params.minInertiaRatio = 0.1 # Create a detector with the parameters detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(mask) # get biggest blob if len(keypoints) > 0: max = 0 pos = 0 max_pos = 0 for keypoint in keypoints: if keypoint.size > max: max = keypoint.size max_pos = pos pos += 1 biggest_target = keypoints[max_pos] target_position = biggest_target.pt[0] / resized.shape[1] # if no blobs are found else: target_position = -1 return target_position
def main(): global payload # argument parsing parser = argparse.ArgumentParser() parser.add_argument('--headless', help='run the pygame headlessly', action='store_true') parser.add_argument("--color_depth", help="integer number of colors to use to draw temps", type=int) parser.add_argument('--max_temp', help='initial max temperature', type=int) parser.add_argument( '--ambient_offset', help='value to offset ambient temperature by to get rolling MAXTEMP', type=int) parser.add_argument( '--ambient_time', help='length of ambient temperature collecting intervals in seconds', type=int) parser.add_argument('--blob_min_threshold', help='blod detection min threshold', type=int) parser.add_argument('--blob_max_threshold', help='blod detection min threshold', type=int) parser.add_argument('--blob_filterbyarea', help='blod detection filter by area', action='store_true') parser.add_argument('--blob_min_area', help='blod detection filter by area min area', type=int) parser.add_argument('--blob_filterbycircularity', help='blod detection filter by circularity', action='store_true') parser.add_argument( '--blob_min_circularity', help='blod detection filter by circularity min circularity', type=float) parser.add_argument('--blob_filterbyconvexity', help='blod detection filter by convexity', action='store_true') parser.add_argument( '--blob_min_convexity', help='blod detection filter by convexity min convexity', type=float) parser.add_argument('--blob_filterbyinertia', help='blod detection filter by inertia', action='store_true') parser.add_argument('--blob_min_inertiaratio', help='blod detection filter by inertia inertia ratio', type=float) parser.add_argument('--csv_save_interval', help='csv file saving interval in seconds', type=int) args = parser.parse_args() print(args) COLOR_DEPTH = args.color_depth MAX_TEMP = args.max_temp AMBIENT_OFFSET = args.ambient_offset AMBIENT_TIME = args.ambient_time BLOB_MIN_THRESHOLD = args.blob_min_threshold BLOB_MAX_THRESHOLD = args.blob_max_threshold BLOB_FILTERBYAREA = args.blob_filterbyarea BLOB_MIN_AREA = args.blob_min_area BLOB_FILTERBYCIRCULARITY = args.blob_filterbycircularity BLOB_MIN_CIRCULARITY = args.blob_min_circularity BLOB_FILTERBYCONVEXITY = args.blob_filterbyconvexity BLOB_MIN_CONVEXITY = args.blob_min_convexity BLOB_FILTERBYINERTIA = args.blob_filterbyinertia BLOB_MIN_INERTIARATIO = args.blob_min_inertiaratio CSV_SAVE_INTERVAL = args.csv_save_interval # create data folders if they don't exist if not os.path.exists(get_filepath('../data')): os.makedirs(get_filepath('../data')) i2c_bus = busio.I2C(board.SCL, board.SDA) # For headless pygame if args.headless: os.putenv('SDL_VIDEODRIVER', 'dummy') else: os.putenv('SDL_FBDEV', '/dev/fb1') pygame.init() # initialize the sensor sensor = adafruit_amg88xx.AMG88XX(i2c_bus) points = [(math.floor(ix / 8), (ix % 8)) for ix in range(0, 64)] grid_x, grid_y = np.mgrid[0:7:32j, 0:7:32j] # sensor is an 8x8 grid so lets do a square height = 240 width = 240 # the list of colors we can choose from black = Color("black") colors = list(black.range_to(Color("white"), COLOR_DEPTH)) # create the array of colors colors = [(int(c.red * 255), int(c.green * 255), int(c.blue * 255)) for c in colors] displayPixelWidth = width / 30 displayPixelHeight = height / 30 lcd = pygame.display.set_mode((width, height)) lcd.fill((255, 0, 0)) pygame.display.update() pygame.mouse.set_visible(False) lcd.fill((0, 0, 0)) pygame.display.update() # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds if BLOB_MIN_THRESHOLD: params.minThreshold = BLOB_MIN_THRESHOLD if BLOB_MAX_THRESHOLD: params.maxThreshold = BLOB_MAX_THRESHOLD # Filter by Area. if BLOB_FILTERBYAREA: params.filterByArea = BLOB_FILTERBYAREA params.minArea = BLOB_MIN_AREA # Filter by Circularity if BLOB_FILTERBYCIRCULARITY: params.filterByCircularity = BLOB_FILTERBYCIRCULARITY params.minCircularity = BLOB_MIN_CIRCULARITY # Filter by Convexity if BLOB_FILTERBYCONVEXITY: params.filterByConvexity = BLOB_FILTERBYCONVEXITY params.minConvexity = BLOB_MIN_CONVEXITY # Filter by Inertia if BLOB_FILTERBYINERTIA: params.filterByInertia = BLOB_FILTERBYINERTIA params.minInertiaRatio = BLOB_MIN_INERTIARATIO # Set up the detector with default parameters. detector = cv2.SimpleBlobDetector_create(params) # initialize centroid tracker ct = CentroidTracker() # a dictionary to map each unique object ID to a TrackableObject trackableObjects = {} # the total number of objects that have moved either up or down total_down = 0 total_up = 0 total_down_old = 0 total_up_old = 0 # let the sensor initialize time.sleep(.1) # press key to exit screencap = True # array to hold mode of last 10 minutes of temperatures mode_list = [] # thread for saving data save_thread = threading.Thread(target=csv_save, args=(CSV_SAVE_INTERVAL, )) save_thread.start() print('sensor started!') while (screencap): start = time.time() # read the pixels pixels = [] for row in sensor.pixels: pixels = pixels + row payload = [ str(datetime.now().isoformat()), ct.get_count(), total_up, total_down ] mode_result = stats.mode([round(p) for p in pixels]) mode_list.append(int(mode_result[0])) # instead of taking the ambient temperature over one frame of data take it over a set amount of time MAX_TEMP = float(np.mean(mode_list)) + AMBIENT_OFFSET pixels = [ map_value(p, np.mean(mode_list) + 1, MAX_TEMP, 0, COLOR_DEPTH - 1) for p in pixels ] # perform interpolation bicubic = griddata(points, pixels, (grid_x, grid_y), method='cubic') # draw everything for ix, row in enumerate(bicubic): for jx, pixel in enumerate(row): try: pygame.draw.rect( lcd, colors[constrain(int(pixel), 0, COLOR_DEPTH - 1)], (displayPixelHeight * ix, displayPixelWidth * jx, displayPixelHeight, displayPixelWidth)) except: print("Caught drawing error") surface = pygame.display.get_surface() myfont = pygame.font.SysFont("comicsansms", 25) img = pygame.surfarray.array3d(surface) img = np.swapaxes(img, 0, 1) # Read image img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) img_not = cv2.bitwise_not(img) # Detect blobs. keypoints = detector.detect(img_not) img_with_keypoints = cv2.drawKeypoints( img, keypoints, np.array([]), (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) # draw a horizontal line in the center of the frame -- once an # object crosses this line we will determine whether they were # moving 'up' or 'down' pygame.draw.line(lcd, (255, 255, 255), (0, height // 2), (width, height // 2), 2) pygame.display.update() for i in range(0, len(keypoints)): x = keypoints[i].pt[0] y = keypoints[i].pt[1] # print circle around blob pygame.draw.circle(lcd, (200, 0, 0), (int(x), int(y)), round(keypoints[i].size), 2) # update our centroid tracker using the detected centroids objects = ct.update(keypoints) # loop over the tracked objects for (objectID, centroid) in objects.items(): # check to see if a trackable object exists for the current # object ID to = trackableObjects.get(objectID, None) # if there is no existing trackable object, create one if to is None: to = TrackableObject(objectID, centroid) # otherwise, there is a trackable object so we can utilize it # to determine direction else: # the difference between the y-coordinate of the *current* # centroid and the mean of *previous* centroids will tell # us in which direction the object is moving (negative for # 'up' and positive for 'down') y = [c[1] for c in to.centroids] direction = centroid[1] - np.mean(y) to.centroids.append(centroid) # check to see if the object has been counted or not if not to.counted: # if the direction is negative (indicating the object # is moving up) AND the centroid is above the center # line, count the object # the historical centroid must present in the lower half of the screen if direction < 0 and centroid[ 1] < height // 2 and count_within_range( y, height // 2, height) > 0: total_up += 1 to.counted = True # if the direction is positive (indicating the object # is moving down) AND the centroid is below the # center line, count the object # the historical centroid must present in the upper half of the screen elif direction > 0 and centroid[ 1] > height // 2 and count_within_range( y, 0, height // 2) > 0: total_down += 1 to.counted = True # store the trackable object in our dictionary trackableObjects[objectID] = to # update counter in top left textsurface1 = myfont.render("IN: " + str(total_up), False, (255, 255, 255)) textsurface2 = myfont.render('OUT: ' + str(total_down), False, (255, 255, 255)) lcd.blit(textsurface1, (0, 0)) lcd.blit(textsurface2, (0, 25)) total_up_old = total_up total_down_old = total_down pygame.display.update() for event in pygame.event.get(): if event.type == pygame.KEYDOWN: print('terminating...') screencap = False break # for running the save on for a certain amount of time # if time.time() - start_time >= 10: # print('terminating...') # screencap = False # empty mode_list every AMBIENT_TIME seconds if len(mode_list) > AMBIENT_TIME: mode_list = [] time.sleep(max(1. / 25 - (time.time() - start), 0)) # Release everything if job is finished cv2.destroyAllWindows()
def run(): with picamera.PiCamera() as camera: # Set the camera parameters x = 400 # camera.resolution = (int(640), x) camera.resolution = (544, x) # Various optional camera settings below: camera.iso = 100 camera.framerate = 30 camera.awb_mode = 'off' camera.exposure_mode = "off" # camera.framerate = Fraction (1,6) #red/blue camera ratios from 0 to 8 # camera.awb_gains = (Red_gain,Blue_gain) # Need to sleep to give the camera time to get set up properly time.sleep(1) with picamera.array.PiRGBArray(camera) as stream: # Loop constantly while True: # Grab data from the camera, in colour format # NOTE: This comes in BGR rather than RGB, which is important # for later! camera.capture(stream, format='bgr', use_video_port=True) image = stream.array image1 = image # Get the individual colour components of the image b, g, r = cv2.split(image) f = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY) # blurred_f = ndimage.gaussian_filter(f, 3) # filter_blurred_f = ndimage.gaussian_filter(blurred_f, 1) # alpha = 10 # sharpened = blurred_f + alpha * (blurred_f - filter_blurred_f) # image1= contrast_stretch(image1) # image1 = image1.astype(np.uint8) ex = ndimage.sobel(f, axis=0, mode='constant') ey = ndimage.sobel(f, axis=1, mode='constant') edges = np.hypot(ex.astype(float), ey.astype(float)) edges = edges.astype(np.uint8) print(edges.shape) ################################# # maskr = cv2.resize(mask,None,fx=rsize, fy=rsize, interpolation = cv2.INTER_CUBIC) # imgr = cv2.resize(image,None,fx=rsize, fy=rsize, interpolation = cv2.INTER_CUBIC) image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) Hstart = cv2.getTrackbarPos('Hstart', 'Trackbars') Hend = cv2.getTrackbarPos('Hend', 'Trackbars') Sstart = cv2.getTrackbarPos('Sstart', 'Trackbars') Send = cv2.getTrackbarPos('Send', 'Trackbars') Vstart = cv2.getTrackbarPos('Vstart', 'Trackbars') Vend = cv2.getTrackbarPos('Vend', 'Trackbars') lower_range = np.array([Hstart, Sstart, Vstart], dtype=np.uint8) upper_range = np.array([Hend, Send, Vend], dtype=np.uint8) mask = cv2.inRange(image, lower_range, upper_range) result = cv2.bitwise_and(image, image, mask=mask) # imgr = cv2.resize(result,None,fx=rsize, fy=rsize, interpolation = cv2.INTER_CUBIC) ################################################################ blob = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY) # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = cv2.getTrackbarPos( 'minThreshold', 'Trackbars1') params.maxThreshold = cv2.getTrackbarPos( 'maxThreshold', 'Trackbars1') # Filter by Area. params.filterByArea = True params.minArea = cv2.getTrackbarPos('MinArea', 'Trackbars1') # Filter by Circularity params.filterByCircularity = True params.minCircularity = cv2.getTrackbarPos( 'Circularity', 'Trackbars1') / 10 # Filter by Convexity params.filterByConvexity = True params.minConvexity = cv2.getTrackbarPos( 'Convexity', 'Trackbars1') / 100 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = cv2.getTrackbarPos( 'InertiaRatio', 'Trackbars1') / 100 detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(blob) # Draw detected blobs as red circles. # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob image_blob = cv2.drawKeypoints( blob, keypoints, np.array([]), (0, 255, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) detector = cv2.SimpleBlobDetector_create(params) #get info from Trackbars Exposure_Comp = cv2.getTrackbarPos("Exposure Comp", "Trackbars") Red_gain = cv2.getTrackbarPos("Red Gain", "Trackbars") Blue_gain = cv2.getTrackbarPos("Blue Gain", "Trackbars") Frame_rate = cv2.getTrackbarPos("Frame Rate", "Trackbars") Contrast = cv2.getTrackbarPos('Contrast', "Trackbars") Brightness = cv2.getTrackbarPos('Brightness', "Trackbars") ISO = cv2.getTrackbarPos('ISO', "Trackbars") Exp = cv2.getTrackbarPos('Exposure', "Trackbars") Saturation = cv2.getTrackbarPos('Saturation', "Trackbars") Sharpness = cv2.getTrackbarPos('Sharpness', "Trackbars") Effects = cv2.getTrackbarPos('Effects', "Trackbars") #scale camera settings camera.exposure_compensation = Exposure_Comp - 25 camera.awb_gains = (Red_gain / 10, Blue_gain / 10) camera.framerate = Frame_rate camera.contrast = Contrast - 100 camera.brightness = Brightness camera.exposure_mode = exposure_number[Exp] camera.saturation = Saturation - 100 camera.sharpness = Sharpness - 100 camera.image_effect = effect_number[Effects] # Label images label(image1, 'RGB') label(b, 'B') label(r, 'R') # Combine ready for display # combined = disp_multiple(blankimg,sharpened,result,image_blob) combined = disp_multiple(blankimg, result, image, edges) # write video cv2.putText(combined, "Exposure Compensation:", (10, 25), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.exposure_compensation), (450, 25), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Blue", (10, 55), font, 1, (256, 0, 0), 2) cv2.putText(combined, "/", (80, 55), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Red Gain:", (110, 55), font, 1, (0, 0, 256), 2) cv2.putText(combined, str(Red_gain / 10), (470, 55), font, 1, (0, 0, 256), 2) cv2.putText(combined, "/", (450, 55), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(Blue_gain / 10), (400, 55), font, 1, (256, 0, 0), 2) cv2.putText(combined, "Frame Rate:", (10, 85), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.framerate), (450, 85), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Contrast:", (10, 115), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.contrast), (450, 115), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Brightness:", (10, 145), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.brightness), (450, 145), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Saturation:", (10, 175), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.saturation), (450, 175), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Sharpness:", (10, 205), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.sharpness), (450, 205), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Exposure:", (10, 235), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.exposure_mode), (355, 235), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Image Effect:", (10, 265), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.image_effect), (355, 265), font, 1, (256, 256, 256), 2) cv2.putText(combined, "ISO:", (10, 295), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(camera.iso), (355, 295), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Exposure Speed:", (10, 325), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(round(camera.exposure_speed / 1000000, 4)), (355, 325), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Analog Gain:", (10, 355), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(round(float(camera.analog_gain), 2)), (355, 355), font, 1, (256, 256, 256), 2) cv2.putText(combined, "Digital Gain:", (10, 385), font, 1, (256, 256, 256), 2) cv2.putText(combined, str(round(float(camera.digital_gain), 2)), (355, 385), font, 1, (256, 256, 256), 2) cv2.putText(combined, "B", (460, 450), font, 2, (255, 0, 0), 4) cv2.putText(combined, "R", (1020, 50), font, 2, (0, 0, 255), 4) # use for video recording # out.write(combined) # Display cv2.imshow('Public Lab', combined) stream.truncate(0) # press ESC to break c = cv2.waitKey(7) % 0x100 if c == 27: break # cleanup or things will get messy cv2.destroyAllWindows() cap.release() out.release()
def blob_parameter(state_type): ''' blob_parameter function for making detector for some blob shapes(circle or triangle) & setting parameter of detector * Input state_type : recognition type in recognition_list (ex : 'parking') * Output blob_detector : blob detector that has parameters setted by recognition type ''' if state_type == 'traffic_light': # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() params.minThreshold = 0 params.maxThreshold = 256 params.filterByArea = True params.minArea = 500 params.maxArea = 2300 params.filterByCircularity = True params.minCircularity = 0.4 params.filterByConvexity = True params.minConvexity = 0.1 params.filterByInertia = True params.minInertiaRatio = 0.01 elif state_type == 'intersection' or state_type == 'construction' or state_type == 'turnel': # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() params.minThreshold = 10 params.maxThreshold = 200 params.filterByArea = True params.minArea = 500 params.filterByCircularity = True params.minCircularity = 0.1 params.filterByConvexity = False params.minConvexity = 0.1 params.filterByInertia = True params.minInertiaRatio = 0.01 else: # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() params.minThreshold = 0 params.maxThreshold = 256 params.filterByArea = True params.minArea = 1000 params.maxArea = 35000 params.filterByCircularity = True params.minCircularity = 0.5 params.filterByConvexity = True params.minConvexity = 0.1 params.filterByInertia = True params.minInertiaRatio = 0.01 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: blob_detector = cv2.SimpleBlobDetector(params) else: blob_detector = cv2.SimpleBlobDetector_create(params) return blob_detector
def __init__(self, port="COM4", baudrate=9600): """ -Pupilometer object takes serial port and baudrate as parameters in constructor. -example specification of serial ports in Windows: COM1, COM2... -example specification of serial ports in Ubuntu: /dev/ttyUSB0, /dev/ttyUSB1... -example specification of serial ports in Debian(Raspberry Pi): /dev/ttyACM0, /dev/ttyACM1... -If the computer is Unix based Operating System; it can be checked from terminal 'ls /dev/tty*' during the plugging in the serial cable(mostly USB cables are machine end side) -Baudrate is related to the frequency of the sending and receiving messages from/to micro-controller or a machine. So it is mandatory to test it, it will affect the frame per seconds in the camera manner of the program. Baudrates to be tested are; 9600, 19200, 28800, 38400, 57600, 76800, 115200 """ self.port = port # specify the serial bus self.baud = baudrate # specify the baudrate cv2.namedWindow( 'image' ) # for sliders to come up in same window with the camera feed cv2.createTrackbar( 'thr_left', 'image', 0, 255, nothing) # create slider for threshold value (left eye) cv2.createTrackbar( 'thr_right', 'image', 0, 255, nothing) # create slider for threshold value (right eye) # specify haarcascade classifiers self.eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml') self.face_cascade = cv2.CascadeClassifier( 'haarcascade_frontalface_default.xml') # set blob detector parameters self.detector_params = cv2.SimpleBlobDetector_Params() self.detector_params.filterByArea = True self.detector_params.maxArea = 1500 self.detector = cv2.SimpleBlobDetector_create(self.detector_params) self.cap = cv2.VideoCapture( 0) # specify the camera that we're going to use and open it. time.sleep(1) # warm up the camera a bit # To use the serial bus comment out this section. # TODO: set the baudrate closer to the camera fps frequincy. Values between 4800 and 115200 must be tested. # self.serial_dev = serial.Serial(self.port, self.baud, timeout=0.1) # TODO: add a microcontroller and comment out this section # Bunch of global variables inside of a class self.right_pupil_area = 0 self.left_pupil_area = 0 self.left = None self.right = None self.eyes = None self.eye_center = 0 self.frame = None self.left_eye_keypoints = [] self.left_eye_wp = 0 self.left_eye_processed = None self.right_eye_keypoints = [] self.right_eye_wp = 0 self.right_eye_processed = None self.luminance = 0 self.data = { "name": "", "surname": "", "phone_num": "" } # initial dictionary
def __init__(self, img, feature): # sharpening gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) blurred = cv2.bilateralFilter(gray_image, 9, 75, 75) gray_image = cv2.addWeighted(gray_image, 1.5, blurred, -0.5, 0) gray_image = cv2.bilateralFilter(gray_image, 9, 75, 75) # Extract ROI x, y, w, h = cv2.boundingRect(gray_image) # (x=0,y=0,w=1920,h=1080) #print("x,y,w,h: ", x,y,w,h) self.roi = img[y + int(h / 2.5):y + h - int(h / 2.5), x + int(w / 2.5):x + w - int(w / 2.5)] # Draw a bounding of ROI self.img_with_bounding = img.copy() cv2.rectangle(self.img_with_bounding, (x + int(w / 2.5), y + int(h / 2.5)), (x + w - int(w / 2.5), y + h - int(h / 2.5)), (0, 0, 255), 2) # Find Needle position self.gray_roi = cv2.cvtColor(self.roi, cv2.COLOR_BGR2GRAY) x, y, w, h = cv2.boundingRect(self.gray_roi) #print("xr,yr,wr,hr: ", x,y,w,h) self.needle_pose = np.array([[w / 2, h / 2]]) # Otsu's thresholding ret, self.th = cv2.threshold(self.gray_roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) # Otsu's thresholding after Gaussian filtering self.blur = cv2.GaussianBlur(self.gray_roi, (5, 5), 0) ret2, self.th2 = cv2.threshold(self.blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) # Morphological filtering kernel = np.ones((2, 2), np.uint8) self.dilation = cv2.dilate(self.th, kernel, iterations=1) #opening = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel) if feature == 'ORB': # Initiate ORB object orb = cv2.ORB_create(nfeatures=5000, scaleFactor=1.1, nlevels=10, scoreType=cv2.ORB_FAST_SCORE, patchSize=100) # find the keypoints with ORB keypoints = orb.detect(self.gray_roi, None) # compute the descriptors with ORB keypoints, descriptors = orb.compute(self.gray_roi, keypoints) self.point2f = cv2.KeyPoint_convert(keypoints) # retval = cv2.ORB.getMaxFeatures(orb) # print('retval: ',retval) # print('number of Kp: ', len(keypoints)) elif feature == 'FAST': # Initiate FAST object with default values fast = cv2.FastFeatureDetector_create(10, True, 2) # TYPE_5_8 = 0, TYPE_7_12 = 1, TYPE_9_16 = 2 # find and draw the keypoints keypoints = fast.detect(self.th2, None) self.point2f = cv2.KeyPoint_convert(keypoints) elif feature == 'BLOB': # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 10 params.maxThreshold = 200 # Filter by Area. params.filterByArea = True params.minArea = 5 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.5 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.01 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(self.gray_roi) self.point2f = cv2.KeyPoint_convert(keypoints) else: print('Error in feature type') sys.exit(1) # draw only the location of the keypoints without size or orientation self.final_keypoints = cv2.drawKeypoints(self.roi, keypoints, None, color=(0, 255, 0), flags=0) # split channel b_channel, g_channel, r_channel = cv2.split(self.final_keypoints) alpha_channel = np.ones( b_channel.shape, dtype=b_channel.dtype) * 50 #creating a dummy alpha channel image. img_BGRA = cv2.merge((b_channel, g_channel, r_channel, alpha_channel)) # Create new layers layer_1 = np.zeros((h, w, 4)) layer_2 = np.zeros((h, w, 4)) # Draw a blue line with thickness of 1 px on layer_1 cv2.line(layer_1, (int(w / 2) - 20, int(h / 2)), (int(w / 2) + 20, int(h / 2)), (255, 0, 0, 255), 1) cv2.line(layer_1, (int(w / 2), int(h / 2) - 20), (int(w / 2), int(h / 2) + 20), (255, 0, 0, 255), 1) # cv2.line(layer_1,(int(w/2)-60,int(h/2)),(int(w/2)-20,int(h/2)),(255,0,0,255),1) # cv2.line(layer_1,(int(w/2)-40,int(h/2)-20),(int(w/2)-40,int(h/2)+20),(255,0,0,255),1) # Draw a red closed circle on layer_2 cv2.circle(layer_2, (int(w / 2), int(h / 2)), 10, (0, 0, 255, 255), 1) # copy the first layer into the resulting image self.reimg = img_BGRA[:] #overlay each drawing parts cnd = layer_1[:, :, 3] > 0 self.reimg[cnd] = layer_1[cnd] cnd = layer_2[:, :, 3] > 0 self.reimg[cnd] = layer_2[cnd]
def extract_binary_masks_blob(A, neuron_radius, dims, num_std_threshold=1, minCircularity=0.5, minInertiaRatio=0.2, minConvexity=.8): """ Function to extract masks from data. It will also perform a preliminary selectino of good masks based on criteria like shape and size Parameters: ---------- A: scipy.sparse matris contains the components as outputed from the CNMF algorithm neuron_radius: float neuronal radius employed in the CNMF settings (gSiz) num_std_threshold: int number of times above iqr/1.349 (std estimator) the median to be considered as threshold for the component minCircularity: float parameter from cv2.SimpleBlobDetector minInertiaRatio: float parameter from cv2.SimpleBlobDetector minConvexity: float parameter from cv2.SimpleBlobDetector Returns: -------- masks: np.array pos_examples: neg_examples: """ params = cv2.SimpleBlobDetector_Params() params.minCircularity = minCircularity params.minInertiaRatio = minInertiaRatio params.minConvexity = minConvexity # Change thresholds params.blobColor = 255 params.minThreshold = 0 params.maxThreshold = 255 params.thresholdStep = 3 params.minArea = np.pi * ((neuron_radius * .75)**2) params.filterByColor = True params.filterByArea = True params.filterByCircularity = True params.filterByConvexity = True params.filterByInertia = True detector = cv2.SimpleBlobDetector_create(params) masks_ws = [] pos_examples = [] neg_examples = [] for count, comp in enumerate(A.tocsc()[:].T): print(count) comp_d = np.array(comp.todense()) gray_image = np.reshape(comp_d, dims, order='F') gray_image = (gray_image - np.min(gray_image)) / \ (np.max(gray_image) - np.min(gray_image)) * 255 gray_image = gray_image.astype(np.uint8) # segment using watershed markers = np.zeros_like(gray_image) elevation_map = sobel(gray_image) thr_1 = np.percentile(gray_image[gray_image > 0], 50) iqr = np.diff(np.percentile(gray_image[gray_image > 0], (25, 75))) thr_2 = thr_1 + num_std_threshold * iqr / 1.35 markers[gray_image < thr_1] = 1 markers[gray_image > thr_2] = 2 edges = watershed(elevation_map, markers) - 1 # only keep largest object label_objects, _ = ndi.label(edges) sizes = np.bincount(label_objects.ravel()) if len(sizes) > 1: idx_largest = np.argmax(sizes[1:]) edges = (label_objects == (1 + idx_largest)) edges = ndi.binary_fill_holes(edges) else: print('empty component') edges = np.zeros_like(edges) masks_ws.append(edges) keypoints = detector.detect((edges * 200.).astype(np.uint8)) if len(keypoints) > 0: pos_examples.append(count) else: neg_examples.append(count) return np.array(masks_ws), np.array(pos_examples), np.array(neg_examples)
def localize_object_dominant_color(frame): ##IMG : String of file path ##crop values! y1 = 0 y2 = 470 x1 = 143 x2 = 530 frame = frame[y1:y2, x1:x2] ##crop that bitch ##KEEP ORIGINAL COLOR COPY original = frame.copy() original = cv2.cvtColor(original, cv2.COLOR_BGR2HSV) ##WE WANT TO FIND HSV DOMINANT COLOR frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) ##BACKGROUND IMAGES REQURED################ BgmImg1 = cv2.imread('BACKGROUND/EmptyTable_6.jpg', 0) BgmImg1 = BgmImg1[y1:y2, x1:x2] BgmImg2 = cv2.imread('BACKGROUND/EmptyTable_7.jpg', 0) BgmImg2 = BgmImg2[y1:y2, x1:x2] BgmImg3 = cv2.imread('BACKGROUND/EmptyTable_8.jpg', 0) BgmImg3 = BgmImg3[y1:y2, x1:x2] ########################################### BgmImg = np.mean(np.array([BgmImg1, BgmImg2, BgmImg3]), axis=0) #~~~~~~~~~trial code BgmImg = cv2.GaussianBlur(BgmImg, (21, 21), 0) ##~~~~~~~~~~~~`end highlight = np.abs(frame.astype(np.int) - BgmImg.astype(np.int)) ##threshold highlight[highlight > 20] = 255 highlight[highlight < 20] = 0 ##compatable with cv2 type highlight = highlight.astype(np.uint8) ##invert colors highlight = cv2.bitwise_not(highlight) ###BLOB DETECTOR # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 10; params.maxThreshold = 200; # Filter by Area. params.filterByArea = True params.minArea = 50 # Filter by Circularity params.filterByCircularity = False # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.87 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.01 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(highlight) im_with_keypoints = cv2.drawKeypoints(original, keypoints, np.array([]), (0, 0, 255)) keypoint = keypoints[0].pt ''' #commented code here useful for debugging blob misstakes #Draw detected blobs as red circles. cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob cv2.imshow("t",im_with_keypoints ) cv2.waitKey(0) time.sleep(30) ''' frame = crop_blob(original,keypoint,10) ##original already converted to HSV cv2.imwrite("im_with_keypoints.jpg",frame) d = get_dominant_color_in_HSV(frame) return d
def process(self, frame): with open(self.inputs["config"]) as f: cfg = json.load(f) tuning = cfg["cvTuning"] mat = np.array([[1, 0, frame.shape[1] / 2], [0, 1, frame.shape[0] / 2], [0, 0, 1]]) dist = np.array(cfg["distortion"]) undistorted = cv2.undistort(frame, mat, dist) out_image = self.inputs["bridge"].cv2_to_imgmsg(undistorted, "mono8") # out_image = self.inputs["bridge"].cv2_to_imgmsg(self.hot_mask, "mono8") self.inputs["debug"].publish(out_image) frame = undistorted blur = tuning["blur"] if self.ping_mode: fg = self.get_ping_foreground(frame, tuning) else: fg = self.fgbg.apply(frame) if self.frame_count < 10: return fg = fg.astype(np.uint8) fgcopy = fg.copy() in_color_copy = cv2.cvtColor(fgcopy, cv2.COLOR_GRAY2RGB) # return in_color_copy # kernel = np.ones((1, 1), np.uint8) # fg = cv2.erode(fg, kernel, iterations=1) # fg = cv2.blur(fg, (blur, blur)) # fg = cv2.blur(fg, (blur, blur)) # fg = cv2.blur(fg, (blur, blur)) # fg = cv2.blur(fg, (blur, blur)) if tuning["threshold"]: fg[fg > 0] = 255 in_color = cv2.cvtColor(fg, cv2.COLOR_GRAY2RGB) params = cv2.SimpleBlobDetector_Params() params.filterByCircularity = False params.filterByConvexity = False params.minDistBetweenBlobs = tuning["minDistBetweenBlobs"] params.filterByArea = True params.minArea = tuning["minArea"] params.maxArea = tuning["maxArea"] params.filterByColor = False params.filterByInertia = False params.blobColor = 255 detector = cv2.SimpleBlobDetector_create(params) with Timer("blobs"): keypoints = detector.detect(fg) ar = PoseArray() ar.header.frame_id = "/map" ar.header.stamp = rospy.Time.now() # timestamp in ms now = time.time() millis = int((now - self.start_time) * 1000) if millis > 0x7fffffff: # OSC integers are limited to 32 bits, so once every ~24 days # we have to reset the timestamp counter to zero. self.start_time = now millis = 0 oscmsg = OSC.OSCMessage() oscmsg.setAddress("/blobs") oscmsg.append(self.config["osc"]["sourceId"]) oscmsg.append(millis) track_list = list() # im_with_keypoints = cv2.drawKeypoints(in_color, keypoints, np.array( # []), (255, 0, 0), cv2.DRAW_MATCHES_FLAGS_DEFAULT) keypoints = map(lambda k: k.pt, keypoints) tracks, ids = self.tracker.update(keypoints) oscmsg.append(len(tracks)) self.draw_points(in_color, keypoints, (255, 0, 0), solid=True) self.draw_points(in_color, tracks, (0, 0, 255), rad=4) for i, k in enumerate(tracks): x, y = self.photo_to_world(*k) size = 1 # TODO oscmsg.append(ids[i]) oscmsg.append(x) oscmsg.append(y) oscmsg.append(size) pose = Pose() pose.position = Point(x, y, 0) ar.poses.append(pose) cv2.putText( in_color, "%s %d, %d" % (ids[i], x, y), (int(k[0] + 4), int(k[1] - 4)), cv2.FONT_HERSHEY_SIMPLEX, 0.32, (0, 0, 255), ) # ntracks = self.tracker.update(np.array(track_list)) # rospy.loginfo("TRACKER %d %d", len(keypoints), len(ntracks)) osc_config = cfg.get('osc', {}) if osc_config.get('send'): hosts = osc_config["hosts"] port = osc_config["port"] clients = list() if not self.osc_clients: for host in hosts: try: client = OSC.OSCClient() client.connect((host, port)) except: sys.stderr.write('could not connect: %r\n' % osc_config) else: clients.append(client) self.osc_clients = clients if self.osc_clients: #sys.stderr.write('send %r\n' % oscmsg) for client in self.osc_clients: try: client.send(oscmsg) except Exception as e: client_address = client.address() if client_address is None: continue addr_str = '{0}:{1}'.format(*client_address) if addr_str in self.last_ip_err_time and monotonic( ) - self.last_ip_err_time[addr_str] < 10: continue sys.stderr.write( 'could not send OSC packet to ({0}): {1}\n'.format( addr_str, e)) self.last_ip_err_time[addr_str] = monotonic() else: self.osc_client = None if osc_config.get('record'): with open(osc_config['record'], 'a') as file: #sys.stderr.write('record %r\n' % oscmsg) file.write(json.dumps(list(oscmsg)) + '\n') self.inputs["pose_pub"].publish(ar) # ret, thresh = cv2.threshold(fg, 127, 255, 0) # im2, contours, hierarchy = cv2.findContours(thresh, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # for i, c in enumerate(contours): # color = tuple(map(lambda x: x * 255, colorsys.hsv_to_rgb(float(i + 1) * 360.0 / len(contours), 1, 1))) # rospy.loginfo("NEAT %s", str(color)) # cv2.drawContours(in_color, [c], 0, color, 1) return in_color
def detectBlocksInDepthImage(self): # #---------- hard coded color HSV range------- # green_lower = np.array([30, 15, 100]) # green_upper = np.array([100, 100, 200]) # green = [green_lower, green_upper] # black_lower = np.array([100, 0, 40]) # black_upper = np.array([180, 80, 80]) # black = [black_lower, black_upper] # red_lower = np.array([150, 160, 100]) # red_upper = np.array([200, 255, 150]) # red = [red_lower, red_upper] # orange_lower = np.array([0, 150, 180]) # orange_upper = np.array([20, 255, 230]) # orange = [orange_lower, orange_upper] # yellow_lower = np.array([21, 200, 231]) # yellow_upper = np.array([40, 255, 255]) # yellow = [yellow_lower, yellow_upper] # blue_lower = np.array([100, 90, 120]) # blue_upper = np.array([130, 180, 200]) # blue = [blue_lower, blue_upper] # purple_lower = np.array([121, 30, 130]) # purple_upper = np.array([186, 88, 180]) # purple = [purple_lower, purple_upper] # pink_lower = np.array([150, 150, 180]) # how to differentiate pinnk and orange # pint_upper = np.array([200, 209, 203]) # pink = [pink_lower, pint_upper] # color_all = [green, black, red, orange, yellow, blue, purple, pink] # color_strings = [ "green", "black", "red", "orange", "yellow", "blue", "purple", "pink" ] """ TODO: Implement a blob detector to find blocks in the depth image """ rgb_frame = self.currentVideoFrame print('-----size of rgb_frame') print rgb_frame.shape hsv_frame = cv2.cvtColor(rgb_frame, cv2.COLOR_RGB2HSV) self.captureDepthFrame() self.convertDepthFrame() depth_frame = self.DepthCM # depth_frame_crop = depth_frame[93:435, 135:475] params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 10 # params.minThreshold = 50; params.maxThreshold = 300 # Filter by Area. params.filterByArea = True # params.minArea = 1000 # params.maxArea = 40000 params.minArea = 250 params.maxArea = 1500 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.1 # params.maxCircularity = 0.85 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.01 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.01 detector = cv2.SimpleBlobDetector_create(params) # print('----detector good-----') keypoints = detector.detect(depth_frame) # print('----keypoints good-----') # cv2.imshow('depth_frame',depth_frame) # cv2.waitKey(0) im_with_keypoints = cv2.drawKeypoints( depth_frame, keypoints, np.array([]), (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) imgplot = plt.imshow(im_with_keypoints) plt.show() # cv2.imshow("Keypoints", im_with_keypoints) # cv2.waitKey(0) #####---------------range, this can be done only with h value, can relax the bound # orange, h: 7, [0, 10] # yellow, h: 30 [20, 35] # green, h: 57, [50, 80] # blue, h: 113 [110, 120] #####-----------if h > 125, need additional info to decide the color, use r value # pink, h: 168, [165, 172], r: [190,255] # red, h: 174, [173, 180], r: [110, 189] ###-------problems # purple, h: 144 [136, 145], r: [80, 109] # black, h: 135 [150, 170], r: [0, 79] orange_h_l = np.array(0) orange_h_u = np.array(10) orange = [orange_h_l, orange_h_u] yellow_h_l = np.array(20) yellow_h_u = np.array(35) yellow = [yellow_h_l, yellow_h_u] green_h_l = np.array(50) green_h_u = np.array(80) green = [green_h_l, green_h_u] blue_h_l = np.array(110) blue_h_u = np.array(130) blue = [blue_h_l, blue_h_u] color_all_h = [orange, yellow, green, blue] color_strings_h = ["orange", "yellow", "green", "blue"] pink_r_l = np.array(190) pink_r_u = np.array(255) pink = [pink_r_l, pink_r_u] # red_r_l = np.array(110) red_r_l = np.array(146) red_r_u = np.array(189) red = [red_r_l, red_r_u] # purple_r_l = np.array(80) purple_r_l = np.array(110) purple_r_u = np.array(145) # purple_r_u = np.array(109) purple = [purple_r_l, purple_r_u] black_r_l = np.array(0) black_r_u = np.array(109) # black_r_u = np.array(79) black = [black_r_l, black_r_u] color_all_r = [pink, red, purple, black] color_strings_r = ["pink", "red", "purple", "black"] depth_frame_1layer = self.currentDepthFrame # 1 layer depth frame for depth value points = [] keypoints_depth = [] keypoints_color = [] keypoints_orientation = [] y_lower_bound = 90 y_upper_bound = 470 x_lower_bound = 90 x_upper_bound = 470 for keyPoint in keypoints: # ----- find the rgb value print('------keyPoint.pt-----') print keyPoint.pt # print np.matmul(self.depth2rgb_affine, np.append([keyPoint.pt],[1])) if np.round(keyPoint.pt[0])>=x_lower_bound and np.round(keyPoint.pt[0])<=x_upper_bound and np.round(keyPoint.pt[1])>=y_lower_bound and np.round(keyPoint.pt[1])<=y_upper_bound \ and depth_frame_1layer[int(np.round(keyPoint.pt[1]))][int(np.round(keyPoint.pt[0]))]<=720: #add another depth value info to make sure keyPoint_hsv = hsv_frame[int(np.round(keyPoint.pt[1]))][int( np.round(keyPoint.pt[0]))][0:] # x keyPoint_rgb = rgb_frame[int(np.round(keyPoint.pt[1]))][int( np.round(keyPoint.pt[0]))][0:] # x keyPoint_d = depth_frame_1layer[int(np.round( keyPoint.pt[1]))][int(np.round(keyPoint.pt[0]))] keypoints_depth.append(keyPoint_d) print('--keyPoint_LOCATION-----') print keyPoint.pt print('--keyPoint_hsv-----') print keyPoint_hsv print('--keyPoint_rgb-----') print keyPoint_rgb # ----- decide the color of each blob if keyPoint_hsv[ 0] <= 130: # can determine the color from h value for ind_clr_h, colr_range_h in enumerate(color_all_h): if (keyPoint_hsv[0] >= colr_range_h[0]) and ( keyPoint_hsv[0] <= colr_range_h[1]): print('-----color name------') print color_strings_h[ind_clr_h] #---------save the color name-------- keypoints_color.append(color_strings_h[ind_clr_h]) break else: # decide color from r value for ind_clr_r, colr_range_r in enumerate(color_all_r): if (keyPoint_rgb[0] >= colr_range_r[0]) and ( keyPoint_rgb[0] <= colr_range_r[1]): print('-----color name------') print color_strings_r[ind_clr_r] #---------save the color name-------- keypoints_color.append(color_strings_r[ind_clr_r]) break #------now figure out the orientation keyPoint_hsv_lower = np.zeros((3, ), dtype=int) keyPoint_hsv_upper = np.zeros((3, ), dtype=int) thereshold = 25 for i in range(3): # Hue range is [0,179] if keyPoint_hsv[i] <= thereshold: keyPoint_hsv_lower[i] = 0 else: keyPoint_hsv_lower[i] = keyPoint_hsv[i] - thereshold # tmp = 255 - thereshold if i == 0: if keyPoint_hsv[i] >= 179 - thereshold: keyPoint_hsv_upper[i] = 179 else: keyPoint_hsv_upper[ i] = keyPoint_hsv[i] + thereshold else: if keyPoint_hsv[i] >= 255 - thereshold: keyPoint_hsv_upper[i] = 255 else: keyPoint_hsv_upper[ i] = keyPoint_hsv[i] + thereshold # keyPoint_hsv_lower = keyPoint_hsv - 20 # print keyPoint_hsv_lower # print np.clip(keyPoint_hsv_lower, 0, 0) # keyPoint_hsv_upper = keyPoint_hsv + 20 # print keyPoint_hsv_upper # print np.clip(keyPoint_hsv_upper, 0, 255) # Threshold the HSV image to get only current colors # problem: backgraound is black, first crop image to only board hsv_frame_crop = hsv_frame[int(np.round(keyPoint.pt[1])) - 25:int(np.round(keyPoint.pt[1])) + 25, int(np.round(keyPoint.pt[0])) - 25:int(np.round(keyPoint.pt[0])) + 25] # imgplot = plt.imshow(rgb_frame_crop) # plt.show() # imgplot = plt.imshow(hsv_frame_crop) # plt.show() mask = cv2.inRange(hsv_frame_crop, keyPoint_hsv_lower, keyPoint_hsv_upper) # imgplot = plt.imshow(mask) # plt.show() kernel = np.ones((4, 4), np.uint8) closing = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel) closingHSV = cv2.bitwise_and(hsv_frame_crop, hsv_frame_crop, mask=closing) # imgplot = plt.imshow(closing) # plt.show() # print('----closing_hsv-----') # print closingHSV # -----how to convert to grayscale closing_bgr = cv2.cvtColor(closingHSV, cv2.COLOR_HSV2BGR) # imgplot = plt.imshow(closing_bgr) # plt.show() closing_gray = cv2.cvtColor(closing_bgr, cv2.COLOR_BGR2GRAY) # cv2.imwrite("/home/student/Desktop/Untitled/gray.png",closing_gray) # imgplot = plt.imshow(closing_gray) # plt.show() ret, thresh = cv2.threshold(closing_gray, 50, 255, cv2.THRESH_BINARY) # print('----closing_bgr-----') # print closing_bgr # print('----closing_gray-----') # print closing_gray.shape # print('----thresh-----') # print thresh # plt.imshow(thresh, cmap="Greys") # plt.show() im2, contours, hierarchy = cv2.findContours( thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) len_contours = len(contours) list_contours = np.zeros((len_contours, 1), dtype=int) for i in range(len(contours)): list_contours[i] = len(contours[i]) ind_maxlen = np.argmax(list_contours) rect = cv2.minAreaRect(contours[ind_maxlen]) print('---orientation----') print rect[2] #-------save the orientation keypoints_orientation.append(rect[2]) # cnt = contours[i] # print('--contours[i]----') # print cnt # rect = cv2.minAreaRect(cnt) # print rect[2] # img, contours, hierarchy = cv2.findContours(opening,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) # for i in range(len(contours)): # cnt = contours[i] # rect = cv2.minAreaRect(cnt) # # self.phi_img[self.centroids_cnt] = rect[2] # print('---angle') # print rect[2] points.append(np.array([keyPoint.pt[0], keyPoint.pt[1], 1])) return points, keypoints_depth, keypoints_color, keypoints_orientation
#cv2.createTrackbar("Low Sat", "Banana", 45, 255, nothing) #cv2.createTrackbar("Low Value", "Banana", 45, 255, nothing) #cv2.createTrackbar("Up Hue", "Banana", 25, 255, nothing) #cv2.createTrackbar("Up Sat", "Banana", 255, 255, nothing) #cv2.createTrackbar("Up Value", "Banana", 255, 255, nothing) #cv2.namedWindow("Plum") #cv2.createTrackbar("Low Hue", "Plum", 130, 255, nothing) #cv2.createTrackbar("Low Sat", "Plum", 15, 255, nothing) #cv2.createTrackbar("Low Value", "Plum", 0, 255, nothing) #cv2.createTrackbar("Up Hue", "Plum", 200, 255, nothing) #cv2.createTrackbar("Up Sat", "Plum", 180, 255, nothing) #cv2.createTrackbar("Up Value", "Plum", 190, 255, nothing) #Creates detector with parameters params = cv2.SimpleBlobDetector_Params() params.filterByArea = True params.minArea = 1000 #will depend on camera distance params.filterByColor = True params.blobColor = 255 #light colours params.filterByConvexity = True params.minConvexity = 0.4 #higher = more uniform round lower = more bumpy max: 1 params.filterByInertia = True params.minInertiaRatio = 0.4 #higher = more uniform round lower = more oval like max:1 detector = cv2.SimpleBlobDetector_create(params) #Bananas are annoying cause they're a different shape so we need to make different parameters for it params_banana = cv2.SimpleBlobDetector_Params() params_banana.filterByArea = True params_banana.minArea = 650
def findBall(self): # Threshold image in HSV space for reddish colors HSVHighThreshMAX = ballSide.BALL_MAX HSVHighThreshMAX[0] = 180 imgHSVMaskHigh = cv2.inRange(self.imgHSV, ballSide.BALL_MIN, HSVHighThreshMAX) HSVLowThreshMIN = ballSide.BALL_MIN HSVLowThreshMIN[0] = 0 HSVLowThreshMAX = ballSide.BALL_MAX HSVLowThreshMAX[0] = HSVLowThreshMAX[0] % 180 imgHSVMaskLow = cv2.inRange(self.imgHSV, HSVLowThreshMIN, HSVLowThreshMAX) imgHSVMask = cv2.bitwise_or(imgHSVMaskLow, imgHSVMaskHigh) # Use HSV threshold to mask BGR image imgBGR = cv2.bitwise_and(self.img, self.img, mask=imgHSVMask) # Threshold BGR image img = cv2.inRange(imgBGR, ballSide.BALL_MIN_BGR, ballSide.BALL_MAX_BGR) # Threshold using depth # kDepth = np.ones((5,5),np.uint8) # depthMask = cv2.inRange(self.depth,110,170) # depthMask = cv2.dilate(depthMask,kDepth,iterations = 1) # img = cv2.bitwise_and(img,img,mask = depthMask) # Close the image kClose = np.ones((3, 3), np.uint8) img = cv2.morphologyEx(img, cv2.MORPH_OPEN, kClose) # Blur the image # img = cv2.medianBlur(img,3) img = cv2.GaussianBlur(img, (5, 5), 0) # Set up ROI ROIhorz = 0.85 ROIvert = 0.7 leftW = int(self.w * (1 - ROIhorz) / 2) rightW = int(self.w * (0.5 + ROIhorz / 2)) topW = int(self.h * (1 - ROIvert) / 2) botW = int(self.h * (0.5 + ROIvert / 2)) # Mask the ROI img[:, :leftW] = 0 img[:, rightW:] = 0 img[:topW, :] = 0 img[botW:, :] = 0 self.imgThreshBall = img # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() params.filterByColor = False # Change thresholds params.minThreshold = 0 params.maxThreshold = 255 # Filter by Area. params.filterByArea = True params.minArea = 10 params.maxArea = 90 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.3 # Filter by Convexity params.filterByConvexity = False params.minConvexity = 0.15 params.maxConvexity = 1 # Filter by Inertia params.filterByInertia = False params.minInertiaRatio = 0.4 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) blobs = detector.detect(img) # import pdb; pdb.set_trace() score = 0 ind = 0 if len(blobs) > 0: for i in range(len(blobs)): if blobs[i].response > score: score = blobs[i].response ind = i return np.int0(blobs[i].pt) else: return None
ACTIVE_INTERSECT = 0 ### FOR test_dilate.py ### INPUT_MASK = os.path.join(DATA_PATH, 'outpy_blur2x2.mp4') OUTPUT_MASK_BLOB_DETECTION = os.path.join(OUTPUT_PATH, 'output_blobs.mp4') BLUR_KERNEL = (5, 5) EROSION_KERNEL = (2, 2) EROSION_ITERATIONS = 1 DILATION_KERNEL = (5, 5) DILATION_ITERATIONS = 5 # params for blob detector BLOB_DET_PARAMS = cv2.SimpleBlobDetector_Params() BLOB_DET_PARAMS.minThreshold = 10 BLOB_DET_PARAMS.maxThreshold = 200 BLOB_DET_PARAMS.filterByArea = True BLOB_DET_PARAMS.minArea = 1 #adding a filter by inertia BLOB_DET_PARAMS.filterByInertia = True BLOB_DET_PARAMS.minInertiaRatio = 0.001 ### DIFF VIDEOS DIFF_VIDEO_1 = os.path.join(DATA_PATH, 'outpy_blur2x2.mp4') DIFF_VIDEO_2 = os.path.join(DATA_PATH, 'output_mask_blur_2x2_new_intersect.mp4') DIFF_OUTPUT = os.path.join(DATA_PATH, 'diff_output.mp4')
def blob_detection(): ''' https://www.learnopencv.com/blob-detection-using-opencv-python-c/ ''' # get image img_path = r'C:\Partition\Bren\Pictures\dorritoMan.jpg' #img_path = r'C:\Partition\Bren\Projects\dev\python\standalone_tools\examples\BlobTest.jpg' #img = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE) img = cv2.imread(img_path) img = img / 255.0 # get bgr channels (not rgb!) b_channel = img[:, :, 0] g_channel = img[:, :, 1] r_channel = img[:, :, 2] # threshold using blue channel ret, mask = cv2.threshold(b_channel, 0.2, 1.0, cv2.THRESH_BINARY) #mask_inv = cv2.bitwise_not(mask) mask_inv = 1.0 - mask # multiply red and green channels img = r_channel * g_channel * mask_inv # normalise img = img - img.min() img = img * (1.0 / img.max()) # adjust gamma img_8bit = numpy.uint8(img * 255) img_8bit = adjust_gamma(img_8bit, gamma=1.0) # blur test #img = cv2.blur(img,(10,20)) # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 10 params.maxThreshold = 200 # Filter by Area. params.filterByArea = True params.minArea = 10 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.87 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.01 # Create a detector with the parameters ver = (cv2.__version__).split('.') print ver if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. #img_8bit = numpy.uint8(img*255) keypoints = detector.detect(img_8bit) print keypoints # Draw detected blobs as red circles. # cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS ensures the size of the circle corresponds to the size of blob im_with_keypoints = cv2.drawKeypoints( img_8bit, keypoints, numpy.array([]), (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) # Show keypoints cv2.imshow("Keypoints", im_with_keypoints) cv2.waitKey(0)
def blob_detect( image, #-- The frame (cv standard) hsv_min, #-- minimum threshold of the hsv filter [h_min, s_min, v_min] hsv_max, #-- maximum threshold of the hsv filter [h_max, s_max, v_max] blur=0, #-- blur value (default 0) blob_params=None, #-- blob parameters (default None) search_window=None, #-- window where to search as [x_min, y_min, x_max, y_max] adimensional (0.0 to 1.0) starting from top left corner imshow=False): #- Blur image to remove noise if blur > 0: image = cv2.blur(image, (blur, blur)) #- Show result if imshow: cv2.imshow("Blur", image) cv2.waitKey(0) #- Search window if search_window is None: search_window = [0.0, 0.0, 1.0, 1.0] #- Convert image from BGR to HSV hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) #- Apply HSV threshold mask = cv2.inRange(hsv, hsv_min, hsv_max) #- Show HSV Mask if imshow: cv2.imshow("HSV Mask", mask) #- dilate makes the in range areas larger mask = cv2.dilate(mask, None, iterations=2) #- Show HSV Mask if imshow: cv2.imshow("Dilate Mask", mask) cv2.waitKey(0) mask = cv2.erode(mask, None, iterations=2) #- Show dilate/erode mask if imshow: cv2.imshow("Erode Mask", mask) cv2.waitKey(0) #- Cut the image using the search mask mask = apply_search_window(mask, search_window) if imshow: cv2.imshow("Searching Mask", mask) cv2.waitKey(0) #- build default blob detection parameters, if none have been provided if blob_params is None: # Set up the SimpleBlobdetector with default parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 0 params.maxThreshold = 100 # Filter by Area. params.filterByArea = True params.minArea = 30 params.maxArea = 20000 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.5 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.5 else: params = blob_params #- Apply blob detection detector = cv2.SimpleBlobDetector_create(params) # Reverse the mask: blobs are black on white reversemask = 255 - mask if imshow: cv2.imshow("Reverse Mask", reversemask) cv2.waitKey(0) keypoints = detector.detect(reversemask) return keypoints, reversemask
def detect(paper, m, sheet): defect="无" paper1 = paper time0 = time.time() paper_gray = cv2.cvtColor(paper, cv2.COLOR_BGR2GRAY) gaus = cv2.GaussianBlur(paper_gray,(5, 5), 0) blur = cv2.blur(paper_gray,(5, 5), 0) edge = cv2.Canny(gaus, 15, 30) edge1 = cv2.Canny(blur, 15, 30) # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 3 params.maxThreshold = 200 # Filter by Area. params.filterByArea = True params.minArea = 50 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.87 # Filter by Inertia params.filterByInertia = True params.minInertiaRatio = 0.01 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(paper_gray) if (len(keypoints)): defect='有' paper = cv2.drawKeypoints(paper_gray, keypoints, np.array([]), (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) hole_pos = [] i = 0 for x1 in keypoints[:]: hole_pos.append([int(keypoints[i].pt[0]), int(keypoints[i].pt[1])]) i = i + 1 cv2.imwrite("./result/hole/" + str(m) + ".jpg", paper) sheet.cell(row=m+1, column=5, value=len(hole_pos)) sheet.cell(row=m+1, column=6, value=str(hole_pos)) else: sheet.cell(row=m+1, column=5, value=0) sheet.cell(row=m+1, column=6, value='NONE') #闭操作 dilated = cv2.dilate(edge, None, iterations=2) # 膨胀 eroded = cv2.erode(dilated, None, iterations=1) # 腐蚀 lines = cv2.HoughLinesP(eroded,1,np.pi/180,100,minLineLength=80,maxLineGap=20)#100 80 20 if lines is None: #print('No folds!') sheet.cell(row=m+1, column=3, value=0) sheet.cell(row=m+1, column=4, value='NONE') sheet.cell(row=m+1, column=7, value=0) sheet.cell(row=m+1, column=8, value='NONE') else: defect='有' lines1 = lines[:, 0, :] # 提取为二维 x = lines1.shape[0] size = paper.shape foldxy = [] if x>200: lines = cv2.HoughLinesP(edge1, 1, np.pi / 180, 20, minLineLength=2, maxLineGap=5) lines1 = lines[:, 0, :] # 提取为二维 for x1, y1, x2, y2 in lines1[:]: if (x1 < size[1] * 0.05 and x2 < size[1] * 0.05) or (x1 > size[1] * 0.95 and x2 > size[1] * 0.95) or ( y1 < size[0] * 0.05 and y2 < size[0] * 0.05) or (y1 > size[0] * 0.95 and y2 > size[0] * 0.95): pass else: foldxy.append([x1, y1, x2, y2]) #print(len(foldxy)) for x1, y1, x2, y2 in foldxy[:]: cv2.line(paper1, (x1, y1), (x2, y2), (255, 255, 0), 1) cv2.line(paper, (x1, y1), (x2, y2), (255, 255, 0), 1) cv2.imwrite("./result/stripe/" + str(m) + ".jpg", paper1) sheet.cell(row=m+1, column=3, value=0) sheet.cell(row=m+1, column=4, value='NONE') sheet.cell(row=m+1, column=7, value=len(foldxy)) sheet.cell(row=m+1, column=8, value=str(foldxy)) else: for x1, y1, x2, y2 in lines1[:]: if (x1 < size[1] * 0.05 and x2 < size[1] * 0.05) or (x1 > size[1] * 0.95 and x2 > size[1] * 0.95) or ( y1 < size[0] * 0.05 and y2 < size[0] * 0.05) or ( y1 > size[0] * 0.95 and y2 > size[0] * 0.95): pass else: foldxy.append([x1, y1, x2, y2]) for x1, y1, x2, y2 in foldxy[:]: cv2.line(paper1, (x1, y1), (x2, y2), (0, 255, 0), 2) cv2.line(paper, (x1, y1), (x2, y2), (0, 255, 0), 2) cv2.imwrite("./result/fold/" + str(m) + ".jpg", paper1) sheet.cell(row=m+1, column=3, value=len(foldxy)) sheet.cell(row=m+1, column=4, value=str(foldxy)) sheet.cell(row=m+1, column=7, value=0) sheet.cell(row=m+1, column=8, value='NONE') time1 = time.time() print(str(m)+'.time: %.3f' %(time1-time0)) sheet.cell(row=m+1, column=9, value=defect) #cv2.imshow(str(m), paper) if defect=='有': cv2.imwrite("./result/defect_yes/" + str(m) + ".jpg", paper) else: cv2.imwrite("./result/defect_no/" + str(m) + ".jpg", paper) return paper
def process_image(im): global previous_measurement, false_positives # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 5 params.maxThreshold = 200 # Filter by Area. params.filterByArea = True params.minArea = 100 params.maxArea = 1000000000 # Filter by Circularity params.filterByCircularity = False params.minCircularity = 0.1 # Filter by Convexity params.filterByConvexity = False params.minConvexity = 0.87 # Filter by Inertia params.filterByInertia = False params.minInertiaRatio = 0.01 # Create a detector with the parameters detector = cv2.SimpleBlobDetector_create(params) # Detect blobs. keypoints = detector.detect(im) #print("{} blob(s) found".format(len(keypoints))) if len(keypoints) == 0: return None, None, False # Get largest keypoint largest = None for kp in keypoints: if largest is None or kp.size > largest.size: largest = kp #print("Largest keypoint at {}".format(largest.pt)) # Calculate offset x, y = largest.pt x_size, y_size = len(im[0]), len(im) #print("Image size is {}x{}".format(x_size, y_size)) offset = (x / x_size)-0.5, (y / y_size)-0.5 #print("Offset from center is {}".format(offset)) # Detect false positive if x and y coordinate more then 50px off ignore = False if previous_measurement is not None: if abs(previous_measurement.pt[0] - x) > false_positive_offset or \ abs(previous_measurement.pt[1] - y) > false_positive_offset or \ abs(previous_measurement.size - largest.size) > false_positive_offset: ignore = True false_positives.append(largest) else: previous_measurement = largest else: previous_measurement = largest if ignore and len(false_positives) > 5: print("Resetting false positives") false_positives = [] previous_measurement = largest return largest, offset, ignore
mins: np.ndarray maxes: np.ndarray mins, maxes = adjusted_mins_maxes() if not calibrating: ranges[active_user, 0] = mins ranges[active_user, 1] = maxes else: for n in range(3): if mins[n] < ranges[active_user, 0, n]: ranges[active_user, 0, n] = mins[n] if maxes[n] > ranges[active_user, 1, n]: ranges[active_user, 1, n] = maxes[n] calibrating = True p = cv.SimpleBlobDetector_Params() p.filterByColor = False p.filterByConvexity = False p.filterByArea = True p.minArea = 100 detector = cv.SimpleBlobDetector_create(p) while True: _, large_frame = cap.read() resized_unflipped = cv.resize(large_frame, (0, 0), fx=0.5, fy=0.5) resized_flipped = cv.flip(resized_unflipped, 1) resized_flipped_hsv = cv.cvtColor(resized_flipped, cv.COLOR_BGR2HSV) fs = resized_flipped_hsv.shape center_row = fs[0] // 2 center_column = fs[1] // 2 cv.rectangle(resized_flipped, (center_column - 5, center_row - 5), (center_column + 5, center_row + 5), (255, 255, 255), 1)
def __init__(self, parent): self._BITMAP_NIGHT = wx.Bitmap(u"night.jpg", wx.BITMAP_TYPE_ANY) self._BITMAP_DAY = wx.Bitmap(u"day.jpg", wx.BITMAP_TYPE_ANY) self._BITMAP_DIM = wx.Bitmap(u"dim.jpg", wx.BITMAP_TYPE_ANY) self._BITMAP_BRIGHT = wx.Bitmap(u"bright.jpg", wx.BITMAP_TYPE_ANY) self._BITMAP_OFF = wx.Bitmap(u"off.jpg", wx.BITMAP_TYPE_ANY) self._BITMAP_NONE = wx.Bitmap(u"AHC.jpg", wx.BITMAP_TYPE_ANY) ########################################################################################################################################################### wx.Frame.__init__(self, parent, id=wx.ID_ANY, title=wx.EmptyString, pos=wx.DefaultPosition, size=wx.Size(840, 490), style=0 | wx.TAB_TRAVERSAL) self.SetSizeHintsSz(wx.DefaultSize, wx.DefaultSize) bsH1 = wx.BoxSizer(wx.HORIZONTAL) self._bitmapCapture = wx.StaticBitmap(self, wx.ID_ANY, self._BITMAP_NONE, wx.DefaultPosition, wx.Size(640, 480), 0) bsH1.Add(self._bitmapCapture, 0, wx.ALL, 5) bsV11 = wx.BoxSizer(wx.VERTICAL) self._bitmapLightState = wx.StaticBitmap(self, wx.ID_ANY, self._BITMAP_BRIGHT, wx.DefaultPosition, wx.DefaultSize, 0) bsV11.Add(self._bitmapLightState, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL, 5) self._cbOverrideAutoDim = wx.CheckBox(self, wx.ID_ANY, u"Override", wx.DefaultPosition, wx.DefaultSize, 0) bsV11.Add(self._cbOverrideAutoDim, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL, 5) _rboxDimChoices = [u"DIM", u"BRIGHT"] self._rboxDim = wx.RadioBox(self, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.DefaultSize, _rboxDimChoices, 1, wx.RA_SPECIFY_COLS) self._rboxDim.SetSelection(0) self._rboxDim.Enable(False) bsV11.Add(self._rboxDim, 0, wx.ALL | wx.EXPAND, 5) self._bitmapDayNightMode = wx.StaticBitmap(self, wx.ID_ANY, self._BITMAP_NIGHT, wx.DefaultPosition, wx.DefaultSize, 0) bsV11.Add(self._bitmapDayNightMode, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL, 5) self._cbOverrideAutoMode = wx.CheckBox(self, wx.ID_ANY, u"Override", wx.DefaultPosition, wx.DefaultSize, 0) bsV11.Add(self._cbOverrideAutoMode, 0, wx.ALL | wx.ALIGN_CENTER_HORIZONTAL, 5) self._buttonClose = wx.Button(self, wx.ID_ANY, u"Close", wx.DefaultPosition, wx.DefaultSize, 0) bsV11.Add(self._buttonClose, 0, wx.ALL | wx.EXPAND, 5) bsH1.Add(bsV11, 1, wx.EXPAND, 5) self.SetSizer(bsH1) self.Layout() self.Centre(wx.BOTH) # Connect Events self._cbOverrideAutoDim.Bind(wx.EVT_CHECKBOX, self.OverrideAutoDim) self._rboxDim.Bind(wx.EVT_RADIOBOX, self.ManualDimAndBright) self._cbOverrideAutoMode.Bind(wx.EVT_CHECKBOX, self.OverrideAutoMode) self._buttonClose.Bind(wx.EVT_BUTTON, self.onClose) ########################################################################################################################################################### thresholdStep = 8.0 minThreshold = 191.0 maxThreshold = 255.0 minRepeatability = 2 minDistBetweenBlobsProportional = 0.02 minBlobAreaProportional = 0.0001 maxBlobAreaProportional = 0.2 minBlobCircularity = 0.2 imageSize = (640, 480) self._roi_minX = int(0.4 * imageSize[0]) self._roi_maxX = int(1.0 * imageSize[0]) self._roi_minY = int(0.5 * imageSize[1]) self._roi_maxY = int(0.9 * imageSize[1]) minDistBetweenBlobs = min(imageSize) * minDistBetweenBlobsProportional area = imageSize[0] * imageSize[1] minBlobArea = area * minBlobAreaProportional maxBlobArea = area * maxBlobAreaProportional detectorParams = cv2.SimpleBlobDetector_Params() detectorParams.minDistBetweenBlobs = minDistBetweenBlobs detectorParams.thresholdStep = thresholdStep detectorParams.minThreshold = minThreshold detectorParams.maxThreshold = maxThreshold detectorParams.minRepeatability = minRepeatability detectorParams.filterByArea = True detectorParams.minArea = minBlobArea detectorParams.maxArea = maxBlobArea detectorParams.filterByColor = True detectorParams.blobColor = 255 detectorParams.filterByCircularity = True detectorParams.minCircularity = minBlobCircularity detectorParams.filterByInertia = False detectorParams.filterByConvexity = False self._detector = cv2.SimpleBlobDetector_create(detectorParams) self._running = True self._pause = False # For pausing Capture Loop self._lightStates = [1] * 5 # 0: Not Detected & 1: Detected self._nightMode = True self._modeOverride = False self._currentBitmapLightState = 1 # 0 : OFF, 1 : DIM, 2 : BRIGHT self._currentBitmapDayNightMode = 0 # 0 : Night, 1 : Day self._pi = pigpio.pi() self._capture = cv2.VideoCapture(0) self._bitmapCapture.SetBitmap(self._BITMAP_NONE) self._captureThread = threading.Thread(target=self._runCaptureLoop) self._captureThread.start()
import cv2 as cv import numpy as np if __name__ == '__main__': img = cv.imread('Imagem.jpg') imgGray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) imgCanny = cv.Canny(imgGray,100,200) parameters = cv.SimpleBlobDetector_Params() #change thresholds parameters.minThreshold = 50 parameters.maxThreshold = 250 #Filter by area parameters.filterByArea = True parameters.minArea = 10 #filter by circularity parameters.filterByCircularity = True parameters.minCircularity = 0.1 #filter by convexity parameters.filterByConvexity = True parameters.minConvexity = 0.50 #filter by inertia parameters.filterByInertia = True parameters.minInertiaRatio = 0.01
def callback(self, image_msg): if self.state == "end": returnr if self.mode == 'tuning': cv2.namedWindow('ColorFilter') ilowH, ihighH, ilowS, ihighS, ilowV, ihighV = self.filter_tuning # create trackbars for color change cv2.createTrackbar('lowH','ColorFilter',ilowH,255,callback) cv2.createTrackbar('highH','ColorFilter',ihighH,255,callback) cv2.createTrackbar('lowS','ColorFilter',ilowS,255,callback) cv2.createTrackbar('highS','ColorFilter',ihighS,255,callback) cv2.createTrackbar('lowV','ColorFilter',ilowV,255,callback) #cv2.createTrackbar('highV','image',ihighV,255,callback) # get trackbar positions ilowH = cv2.getTrackbarPos('lowH', 'ColorFilter') ihighH = cv2.getTrackbarPos('highH', 'ColorFilter') ilowS = cv2.getTrackbarPos('lowS', 'ColorFilter') ihighS = cv2.getTrackbarPos('highS', 'ColorFilter') ilowV = cv2.getTrackbarPos('lowV', 'ColorFilter') #ihighV = cv2.getTrackbarPos('highV', 'ColorFilter') self.filter_tuning = ilowH, ihighH, ilowS, ihighS, ilowV, ihighV else: ilowH, ihighH, ilowS, ihighS, ilowV, ihighV = self.filter_color[self.detecting_color] if self.selecting_sub_image == "compressed": np_arr = np.fromstring(image_msg.data, np.uint8) frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR) else: frame = self._cv_bridge.imgmsg_to_cv2(image_msg, "bgr8") # HSV hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) lower_hsv = np.array([ilowH, ilowS, ilowV]) higher_hsv = np.array([ihighH, ihighS, ihighV]) mask = cv2.inRange(hsv, lower_hsv, higher_hsv) ColorFilter = frame ColorFilter = cv2.bitwise_and(ColorFilter, ColorFilter, mask=mask) cv_image_gray = cv2.cvtColor(ColorFilter, cv2.COLOR_RGB2GRAY) ret,cv_image_binary = cv2.threshold(cv_image_gray,1,255,cv2.THRESH_BINARY_INV) # cv2.imshow('image', cv_image_binary), cv2.waitKey(1) params=cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 0 params.maxThreshold = 255 # Filter by Area. params.filterByArea = True params.minArea = 100 params.maxArea = 800 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.6 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.6 det=cv2.SimpleBlobDetector_create(params) keypts=det.detect(cv_image_binary) frame=cv2.drawKeypoints(frame,keypts,np.array([]),(0,255,255),cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) mean_x = 0.0 mean_y = 0.0 col1 = 300 col2 = 640 low1 = 0 low2 = 200 frame = cv2.line(frame, (col1, low1), (col1, low2), (255, 255, 0), 5) frame = cv2.line(frame, (col1, low2), (col2, low2), (255, 255, 0), 5) frame = cv2.line(frame, (col2, low2), (col2, low1), (255, 255, 0), 5) frame = cv2.line(frame, (col2, low1), (col1, low1), (255, 255, 0), 5) # if detected more than 1 red light for i in range(len(keypts)): point_col = int(keypts[i].pt[0]) point_low = int(keypts[i].pt[1]) print 'detected' if point_col > col1 and point_low < low2: print 'yes' if self.detecting_color == 'green': if self.red_count > 0: self.red_count = 0 self.state = "end" message = Traffic_light() message.color = "fast" message.position_x = point_col message.position_y = point_low self._pub.publish(message) else: self.red_count = 0 message = Traffic_light() message.color = "green" message.position_x = point_col message.position_y = point_low self._pub.publish(message) if self.detecting_color == 'red': self.red_count = 30 message = Traffic_light() message.color = self.detecting_color message.position_x = point_col message.position_y = point_low self._pub.publish(message) if self.red_count == 1: message = Traffic_light() message.color = "green" message.position_x = 100 message.position_y = 100 self._pub.publish(message) if self.red_count > 0: self.red_count -= 1 if self.detecting_color == 'red': self.detecting_color = 'green' elif self.detecting_color == 'green': self.detecting_color = 'red' # showing image if self.showing_image == 'yes': cv2.imshow("ColorFilter", ColorFilter), cv2.waitKey(1) cv2.imshow("detecting stop bar", frame), cv2.waitKey(1)
def image_callback(self, data): try: image = self.bridge.imgmsg_to_cv2(data, "bgr8") except CvBridgeError as e: print(e) # print("hello") # print(nav_data) # # mark features in cartesian image # orb = cv2.ORB_create() # kp = orb.detect(cartesian_image, None) # kp, des = orb.compute(cartesian_image, kp) # print(type(kp[0])) # marked_image = cv2.drawKeypoints(cartesian_image,kp,None,color=(0,255,0), flags=0) # Setup SimpleBlobDetector parameters. params = cv2.SimpleBlobDetector_Params() # Change thresholds # params.minThreshold = 10; # params.maxThreshold = 200; # Filter by Area. params.filterByArea = True params.minArea = 1 # Filter by Circularity # params.filterByCircularity = True # params.minCircularity = 0.1 # Filter by Convexity # params.filterByConvexity = True # params.minConvexity = 0.87 # Filter by Inertia # params.filterByInertia = True # params.minInertiaRatio = 0.3 # Create a detector with the parameters ver = (cv2.__version__).split('.') if int(ver[0]) < 3: detector = cv2.SimpleBlobDetector(params) else: detector = cv2.SimpleBlobDetector_create(params) image = cv2.threshold(image, 150, 255, cv2.THRESH_BINARY)[1] keypoints = detector.detect(image) pts = [[float(p.pt[0]), float(p.pt[1])] for p in keypoints] # print(pts) # transform feature points from image frame to cartesian camera frame if (self.max_fov): origin_row = self.origin_row origin_col = self.origin_col # print(pts) polar_points = [] for point in pts: r = (self.height - point[1]) * self.max_range / self.height # in metres theta = (point[0] - self.origin_col) * self.max_fov / ( self.origin_col) # in degrees polar_point = self.cartesian_transform([r, theta]) polar_points.append(polar_point) my_awesome_pointcloud = PointCloud() # transform points to global frame, first rotate, then translate final_points = [] yaw = self.nav_yaw translation_vector = np.array([self.nav_x, self.nav_y]) for point in polar_points: rotation_matrix = np.array([[math.cos(yaw), -math.sin(yaw)], [math.sin(yaw), math.cos(yaw)]]) point_vector = np.array([point[0], point[1]]) rotated_point = np.matmul(rotation_matrix, point_vector) translated_point = np.add(rotated_point, translation_vector) translated_point = np.append(translated_point, [0.0]) translated = translated_point.tolist() my_awesome_pointcloud.points.append(Point32(*translated)) final_points.append(translated) #header header = std_msgs.msg.Header() header.stamp = rospy.Time.now() header.frame_id = 'base_link' my_awesome_pointcloud.header = header #create pcl from points #scaled_polygon_pcl = pcl2.create_cloud_xyz32(header, final_points) #publish4 self.pcl_pub.publish(my_awesome_pointcloud) rospy.loginfo("happily publishing sample pointcloud.. !") #self.pcl_pub.publish(scaled_polygon_pcl) # print(pts) marked_image = cv2.drawKeypoints(image, keypoints, None, color=(0, 255, 0), flags=0) # hello_float = Float64MultiArray() # hello_float.data = pts # self.features_pub.publish(hello_float) # show image cv2.imshow("Image window", marked_image) cv2.waitKey(3) try: self.image_pub.publish( self.bridge.cv2_to_imgmsg(marked_image, "bgr8")) except CvBridgeError as e: print(e)
def circleposition(cap,transform,newcameramtx,mtx,dist,mask,maskcorners): thresh = 0 maxValue = 255 #print "CAP type" + str(type(cap)) [oldx,oldy] = [0,0] #print "maskcorners %s" % str(maskcorners) params = cv2.SimpleBlobDetector_Params() # Change thresholds #params.minThreshold = 10; #params.maxThreshold = 200; # Filter by Area. params.filterByArea = True params.minArea = 75 # Filter by Circularity #params.filterByCircularity = True #params.minCircularity = 0.8 # Filter by Convexity params.filterByConvexity = True params.minConvexity = 0.87 # Filter by Inertia #params.filterByInertia = True #params.minInertiaRatio = 0.01 ret, frame = cap.read() detector = cv2.SimpleBlobDetector_create(params) h, w = frame.shape[:2] done = False l=[[1,1],[1,1],[1,1]] while True: time1 = time.clock() ret, frame = cap.read() if frame is None: return #time1 = time.clock() frame = cv2.undistort(frame, mtx, dist, None, newcameramtx) #time2 = time.clock() #print 'undistort %0.3f' % (time2-time1) #cv2.imshow('frame',frame) #cv2.waitKey(3000) ffframe=frame #fframe=cv2.flip(frame,0) #ffframe=cv2.flip(fframe,1) ulx = maskcorners[0][0] #-60 ##sorg for ikke at ryge udenfor billede uly = maskcorners[0][1] #-60 brx = maskcorners[2][0] #+ 60 bry = maskcorners[2][1] #+ 60 #ffframe = ffframe[uly:bry,ulx:brx] #cv2.imshow('cropped',ffframe) #cv2.waitKey(3000) #time1 = time.clock() gray = cv2.cvtColor(ffframe, cv2.COLOR_BGR2GRAY) #time2 = time.clock() #print 'cvtColur %0.3f' % (time2-time1) #cv2.imshow('gray',gray) #cv2.waitKey(10) #time1 = time.clock() th, dst = cv2.threshold(gray, thresh, maxValue, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU) #time2 = time.clock() #print 'treshold %0.3f' % (time2-time1) #cv2.imshow('dst',dst) #cv2.waitKey(10) out=dst #out = np.zeros_like(dst) #out[mask] = dst[mask] #cv2.imshow('mask',out) #cv2.waitKey(10) # Detect blobs. dtime1 = time.clock() keypoints = detector.detect(out) dtime2 = time.clock() print('detector %0.6f' % (dtime2-dtime1)) #print "keypoints" + str(keypoints) if len(keypoints) > 0: keypoint = [keypoints[-1]] else: keypoint = None #print "keypoint" + str(keypoint) if keypoint is not None: #print keypoint[0].pt circle = keypoint[0].pt #print "im alive" im_with_keypoints = cv2.drawKeypoints(ffframe, keypoints, np.array([]), (0,0,255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) cv2.imshow("im_with_keypoints", im_with_keypoints) #cv2.imshow("out", out) #cv2.waitKey(1) print("point diff") print(np.absolute(circle[0]-l[2][0])) print(np.absolute(circle[1]-l[2][1])) #if (np.absolute(c) > 12 or np.absolute(circle[1]-l[2][1]) > 12): ## and (np.absolute(circle[0]-l[2][0]) < 100 or np.absolute(circle[1]-l[2][1]) < 100): l.append([int(circle[0]),int(circle[1])]) l=l[1:] #else: # raise Exception("hej") else: print("else") continue adpoint = l[2] #adpoint[0]=adpoint[0]+ulx #adpoint[1]=adpoint[1]+uly point = np.array([adpoint],dtype='float32') point = np.array([point]) #time1 = time.clock() #pointUndist = cv2.undistortPoints(point, mtx, dist, None, newcameramtx) #time2= time.clock() #print 'undistortPoints %0.3f' % (time2-time1) [[[pux,puy]]] = point #Undist #pux=w-pux #puy=h-puy pointUndist = np.array([[[pux,puy]]],dtype='float32') pointOut = cv2.perspectiveTransform(pointUndist, transform) [[[x,y]]]=point #[[[xu,yu]]]=pointUndist [[[xo,yo]]]=pointOut #yield [[x,y],[xo,yo],[xu,yu]] time2 = time.clock() print('findcircle clocktime %0.6f' % (time2-time1)) yield [xo,yo]
def analyze(): global frame, frame_cnt, frame_cnt_cond global analysis, analysis_cnt global analysis_time, analysis_delta global align, finish, exit global ana_obj, ana_pos, ana_pas global ana_idx, ana_seq global thr_val this = None this_cnt = 0 rx0, ry0, rx1, ry1 = ana_roi # hsv_grid = [np.array([0,0,30]), np.array([200,50,160])] # hsv_high = [np.array([0,40,0]), np.array([72,255,255])] kern_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) kern_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)) par = cv2.SimpleBlobDetector_Params() par.minThreshold = 50 par.maxThreshold = 400 par.filterByArea = True par.minArea = 1000 par.maxArea = 70000 par.filterByColor = False par.filterByCircularity = False par.minCircularity = 0.2 par.filterByConvexity = False par.minConvexity = 0.8 par.filterByInertia = False par.minInertiaRatio = 0.5 detector = cv2.SimpleBlobDetector_create(par) while not exit: with frame_cnt_cond: while frame_cnt == this_cnt: frame_cnt_cond.wait() this = frame.copy() this_cnt = frame_cnt mark = time() roi = this[ry0:ry1, rx0:rx1] hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # msk_grid = cv2.inRange(hsv, hsv_grid[0], hsv_grid[1]) # msk_high = cv2.inRange(hsv, hsv_high[0], hsv_high[1]) # msk = cv2.bitwise_not(cv2.bitwise_or(msk_grid, msk_high)) # res = cv2.bitwise_and(roi, roi, mask=msk) # h, s, v = hsv[:, :, 0], hsv[:, :, 1], hsv[:, :, 2] h, s, v = cv2.split(hsv) ret, ht = cv2.threshold(h, thr_val[0], 255, cv2.THRESH_BINARY) # ret, ht = cv2.threshold(ht, thr_val[1], 0, cv2.THRESH_BINARY_INV) ret, st = cv2.threshold(s, thr_val[2], 255, cv2.THRESH_BINARY_INV) ret, vt = cv2.threshold(v, thr_val[3], 255, cv2.THRESH_BINARY_INV) # thr = cv2.merge((ht, st, vt)) thr = cv2.merge((ht, st, vt)) # hsv1 = cv2.cvtColor(thr, cv2.COLOR_BGR2HSV) # h1, s1, v1 = cv2.split(hsv1) # thr = cv2.threshold(v1, 200, 255, cv2.THRESH_BINARY) # thr = cv2.cvtColor(v1, cv2.COLOR_GRAY2BGR) # cv2.bitwise_and(thr, thr, ht, mask = ht) # cv2.bitwise_and(thr, thr, st, mask = st) thr = cv2.bitwise_and(thr, cv2.cvtColor(vt, cv2.COLOR_GRAY2BGR)) thr = cv2.bitwise_and(thr, cv2.cvtColor(st, cv2.COLOR_GRAY2BGR)) thr = cv2.bitwise_and(thr, cv2.cvtColor(ht, cv2.COLOR_GRAY2BGR)) # cv2.bitwise_and(, thr, mask = st) # cv2.bitwise_and(thr, thr, mask = ht) # ret, thr = cv2.threshold(s, 80, 250, cv2.THRESH_TOZERO) # gry = cv2.cvtColor(thr, cv2.COLOR_BGR2GRAY) mor = cv2.morphologyEx(thr, cv2.MORPH_OPEN, kern_open) img = cv2.morphologyEx(mor, cv2.MORPH_CLOSE, kern_close) # img = cv2.cvtColor(mor, cv2.COLOR_GRAY2RGB) # img = thr kpt = detector.detect(img) img = cv2.drawKeypoints(img, kpt, np.array([]), \ (255, 255, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) # filter channel display options if analyze_filter_id == 0: img = h elif analyze_filter_id == 1: img = s elif analyze_filter_id == 2: img = v elif analyze_filter_id == 3: img = ht elif analyze_filter_id == 4: img = st elif analyze_filter_id == 5: img = vt # split = align - rx0 # limit = finish - rx0 # purge = ignore - rx0 pos = [0] * len(kpt) for idx, kp in enumerate(kpt): xf, yf = kp.pt x, y = int(round(xf)), int(round(yf)) # interesting = False pos[idx] = (x, y) # print(pos[idx]) radius = 20 if kp.size < thr_val[4]: ovtext(img, "%3d" % kp.size, (x - 30, y - 15), (255, 0, 0)) cv2.line(img, (x - radius, y), (x + radius, y), (255, 0, 0), 2) cv2.line(img, (x, y - radius), (x, y + radius), (255, 0, 0), 2) else: if 150 < pos[idx][0] < 570 and 150 < pos[idx][1] < 570: ovtext(img, "%3d" % kp.size, (x - 30, y - 15), (0, 0, 255)) # crosshair cv2.line(img, (x - radius, y), (x + radius, y), (0, 0, 255), 7) cv2.line(img, (x, y - radius), (x, y + radius), (0, 0, 255), 7) ana_pos = pos[idx] else: ovtext(img, "%3d" % kp.size, (x - 30, y - 15), (255, 255, 255)) analysis = img analysis_cnt += 1 prev = analysis_time analysis_time = time() analysis_delta = (analysis_time - mark) * 1000
def detect(camera): rawCapture = PiRGBArray(camera) # Takes picture camera.capture(rawCapture, format="bgr") img = rawCapture.array # Converting to HSV hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # Color Bounds and Masks for red, blue and green lower_red_u = np.array([152, 15, 114]) upper_red_u = np.array([175, 120, 255]) mask_red_u = cv2.inRange(hsv, lower_red_u, upper_red_u) lower_red_l = np.array([0, 10, 114]) upper_red_l = np.array([17, 120, 255]) mask_red_l = cv2.inRange(hsv, lower_red_l, upper_red_l) mask_red = cv2.bitwise_or(mask_red_l, mask_red_u) lower_blue = np.array([96, 10, 114]) upper_blue = np.array([125, 120, 255]) mask_blue = cv2.inRange(hsv, lower_blue, upper_blue) lower_green = np.array([50, 10, 114]) upper_green = np.array([80, 120, 255]) mask_green = cv2.inRange(hsv, lower_green, upper_green) kernal = np.ones((5, 5), np.uint8) mask_red = cv2.dilate(mask_red, kernal, iterations=2) mask_blue = cv2.dilate(mask_blue, kernal, iterations=2) mask_green = cv2.dilate(mask_green, kernal, iterations=2) # Blob implementation params = cv2.SimpleBlobDetector_Params() params.minThreshold = 20 params.maxThreshold = 200 params.filterByArea = False params.minArea = .1 params.filterByColor = False params.blobColor = 200 params.filterByCircularity = False params.minCircularity = 0.1 params.filterByConvexity = False params.minConvexity = 0.5 params.filterByInertia = False params.minInertiaRatio = 0.01 mask = cv2.bitwise_or(mask_red, mask_blue) mask = cv2.bitwise_or(mask, mask_green) detector = cv2.SimpleBlobDetector(params) keypoints_red = detector.detect(mask_red) keypoints_blue = detector.detect(mask_blue) keypoints_green = detector.detect(mask_green) keypoints = [] try: for key in keypoints_red: keypoints.append([key.pt[0], key.pt[1], 0]) except: print "Red LED not found" try: for key in keypoints_blue: keypoints.append([key.pt[0], key.pt[1], 1]) except: print 'Blue LED not found' try: for key in keypoints_green: keypoints.append([key.pt[0], key.pt[1], 2]) except: print 'Green LED not found' return keypoints
def main(): global new_img_available, low_hue, low_sat, low_val, high_hue, high_sat, high_val, color, min_area, max_area, min_circularity, max_circularity, min_inertia_ratio, max_inertia_ratio, min_convexity, max_convexity, min_dist_between_blobs rospy.init_node("go_to_green_square") # Create a subscriber that starts listening for incoming messages # of the type Image on the usb_cam/image_raw topic rospy.Subscriber("usb_cam/image_raw", Image, get_image) blob_position_pub = rospy.Publisher("blob_location", Point, queue_size=1) bridge = cv_bridge.core.CvBridge() cv2.namedWindow("Thresholded image", cv2.WINDOW_AUTOSIZE) cv2.namedWindow('blob_detector/go_to_green_square') cv2.namedWindow("Blob parameters", cv2.WINDOW_AUTOSIZE) # Here we create the sliders that regulate the range of colour we wish to filter cv2.createTrackbar("low_hue", "Thresholded image", low_hue, 179, update_low_hue) cv2.createTrackbar("high_hue", "Thresholded image", high_hue, 179, update_high_hue) cv2.createTrackbar("low_sat", "Thresholded image", low_sat, 255, update_low_sat) cv2.createTrackbar("high_sat", "Thresholded image", high_sat, 255, update_high_sat) cv2.createTrackbar("low_val", "Thresholded image", low_val, 255, update_low_val) cv2.createTrackbar("high_val", "Thresholded image", high_val, 255, update_high_val) cv2.createTrackbar("color", "Blob parameters", color, 255, update_color) cv2.createTrackbar("min_area", "Blob parameters", min_area, 307200, update_min_area) cv2.createTrackbar("max_area", "Blob parameters", max_area, 307200, update_max_area) cv2.createTrackbar("min_circularity", "Blob parameters", min_circularity, 100, update_min_circularity) cv2.createTrackbar("max_circularity", "Blob parameters", max_circularity, 100, update_max_circularity) cv2.createTrackbar("min_inertia_ratio", "Blob parameters", min_inertia_ratio, 100, update_min_inertia_ratio) cv2.createTrackbar("max_inertia_ratio", "Blob parameters", max_inertia_ratio, 100, update_max_inertia_ratio) cv2.createTrackbar("min_convexity", "Blob parameters", min_convexity, 100, update_min_convexity) cv2.createTrackbar("max_convexity", "Blob parameters", max_convexity, 100, update_max_convexity) cv2.createTrackbar("min_dist_between_blobs", "Blob parameters", min_dist_between_blobs, 640, update_min_dist_between_blobs) blob_parameters = cv2.SimpleBlobDetector_Params() # Set all filters either on or off blob_parameters.filterByColor = True blob_parameters.filterByArea = True blob_parameters.filterByCircularity = True blob_parameters.filterByInertia = True blob_parameters.filterByConvexity = True while not rospy.is_shutdown(): # Only show a fresh image when we have one from the camera # This is a way of optimising performance if new_img_available: # Convert the image from Image message to OpenCV image format cv_image = bridge.imgmsg_to_cv2(new_img_msg, desired_encoding='bgr8') cv2.imshow('blob_detector/go_to_green_square', cv_image) # Show the image for 1 ms. Without this line, the program will not work. cv2.waitKey(1) # Set the boolean to False, indicating that we have used up the camera image new_img_available = False hsv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV) # Create arrays from lower and upper hue, saturation and value limits # because the thresholding function cv2.inRange() takes numpy arrays as input lower_limits = np.array([low_hue, low_sat, low_val]) upper_limits = np.array([high_hue, high_sat, high_val]) # Threshold the image using the defined value ranges that are changable with sliders thresholded_image = cv2.inRange(hsv_image, lower_limits, upper_limits) thresholded_image = cv2.bitwise_and(cv_image, cv_image, mask=thresholded_image) # Show the thresholded image in the same frame where we placed the sliders cv2.imshow("Thresholded image", thresholded_image) blob_parameters.blobColor = color # Detect either black or white objects # Filter by size blob_parameters.minArea = min_area blob_parameters.maxArea = max_area # Filter by shape blob_parameters.minCircularity = min_circularity / 100 blob_parameters.maxCircularity = max_circularity / 100 blob_parameters.minInertiaRatio = min_inertia_ratio / 100 blob_parameters.maxInertiaRatio = max_inertia_ratio / 100 blob_parameters.minConvexity = min_convexity / 100 blob_parameters.maxConvexity = max_convexity / 100 # Set the minimum distance that needs to be between two blobs # in order for them both to be detected blob_parameters.minDistBetweenBlobs = min_dist_between_blobs # Define the blob detector detector = cv2.SimpleBlobDetector_create(blob_parameters) # Use the blob detector to detect shapes on the thresholded image keypoints = detector.detect(thresholded_image) # Only attempt to access attributes of the detected shapes if any are found if len(keypoints) > 0: first_blob = keypoints[0] x_coord = int(first_blob.pt[0]) y_coord = int(first_blob.pt[1]) blob_size = int(first_blob.size) print(x_coord, y_coord, blob_size) blob_position = Point() blob_position.x = x_coord blob_position.y = y_coord blob_position_pub.publish(blob_position) # If the letter Q is pressed on the keyboard, end the while-loop if cv2.waitKey(1) & 0xFF == ord('q'): break
im = cv2.cvtColor(im, cv2.COLOR_BGR2HSV) mask = np.zeros_like(im) mask[:, :, 0] = cv2.inRange(im, green_filter[0], green_filter[1]) mask[:, :, 0] = cv2.dilate(mask[:, :, 0], kernel) mask[:, :, 1] = cv2.inRange(im, red_filter[0], red_filter[1]) mask[:, :, 1] = cv2.dilate(mask[:, :, 1], kernel) mask[:, :, 2] = cv2.inRange(im, purple_filter[0], purple_filter[1]) mask[:, :, 2] = cv2.dilate(mask[:, :, 2], kernel) return mask params = cv2.SimpleBlobDetector_Params() # Change thresholds params.minThreshold = 0 params.maxThreshold = 11 # Filter by Area. params.filterByArea = True params.minArea = 400 params.maxArea = 1500 # Filter by Circularity params.filterByCircularity = True params.minCircularity = 0.5 params.maxCircularity = 1.0
def getKeypoints(img): kernel = np.ones((5, 5), np.uint8) tempImg = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel) params = cv2.SimpleBlobDetector_Params() detector = cv2.SimpleBlobDetector_create(params) return detector.detect(tempImg)