def red_filtering(self, frame): # Adapted from # https://stackoverflow.com/questions/42840526/opencv-python-red-ball-detection-and-tracking # # convert the input stream into HSV color space hsv_conv_img = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # then the image is blurred hsv_blurred_img = cv2.medianBlur(hsv_conv_img, 9, 3) # because hue wraps up and to extract as many "red objects" as possible, # we define lower and upper boundaries for brighter and for darker red shades bright_red_mask = cv2.inRange(hsv_blurred_img, self.bright_red_lower_bounds, self.bright_red_upper_bounds) dark_red_mask = cv2.inRange(hsv_blurred_img, self.dark_red_lower_bounds, self.dark_red_upper_bounds) # after masking the red shades out, I add the two images weighted_mask = cv2.addWeighted(bright_red_mask, 1.0, dark_red_mask, 1.0, 0.0) # then the result is blurred blurred_mask = cv2.GaussianBlur(weighted_mask, (9, 9), 3, 3) # some morphological operations (closing) to remove small blobs erode_element = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)) dilate_element = cv2.getStructuringElement(cv2.MORPH_RECT, (8, 8)) eroded_mask = cv2.erode(blurred_mask, erode_element) dilated_mask = cv2.dilate(eroded_mask, dilate_element) return dilated_mask
def get_letter_type(self, img_hsv=None, bgColor=None, img=None): if img_hsv is None: img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) if bgColor is None: for key, colors in self.BG_COLOR.items(): temp = cv2.inRange(img_hsv, *colors) if np.sum(temp == 255) / img_hsv.size > 0.05: bgColor = key break if bgColor == 'yellow': temp = cv2.inRange(img_hsv, *self.LETTER_COLOR['black']) if np.sum(temp == 255) / img_hsv.size > 0.005: return self.LETTER_TYPE_PENDING else: return self.LETTER_TYPE_ERROR elif bgColor == 'gray': temp = cv2.inRange(img_hsv, *self.LETTER_COLOR['black']) if np.sum(temp == 255) / img_hsv.size > 0.005: return self.LETTER_TYPE_UNCHECK else: return self.LETTER_TYPE_EMPTY elif bgColor == 'white': return self.LETTER_TYPE_ALREADY elif bgColor == 'green': return self.LETTER_TYPE_FINISHED return self.LETTER_TYPE_UNEXCEPTED
def get_contours(img, range_list): """ 根据颜色提取图像 """ # 从BGR转换到HSV hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) mask = [] for hsv_range in range_list: if len(mask) > 0: mask += cv2.inRange(hsv, hsv_range[0], hsv_range[1]) else: mask = cv2.inRange(hsv, hsv_range[0], hsv_range[1]) _, binary = cv2.threshold(mask, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) # 定义结构元素 kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (10, 10)) # 开闭运算,先开运算去除背景噪声,再继续闭运算填充目标内的孔洞 opened = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel) closed = cv2.morphologyEx(opened, cv2.MORPH_CLOSE, kernel) # 在binary中发现轮廓,轮廓按照面积从小到大排列 contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) return contours
def boxDetection2411(rgbaImg, width, height): """ Takes RGBA image along with height and width and returns positions of cubes in reference frame """ rgba = bytes(rgbaImg) # Make a new image object from the bytes img = Image.frombytes('RGBA', (width, height), rgba) opencv_img = np.array(img) # Converting RGBA image to RGB(dropping alpha channel) rgbImage = cv2.cvtColor(opencv_img, cv2.COLOR_RGBA2RGB) # Converting RGB image to HSV(For Color detection) hsvFrame = cv2.cvtColor(rgbImage, cv2.COLOR_RGB2HSV) # Converting RGB image to BGR imageFrame = cv2.cvtColor(rgbImage, cv2.COLOR_RGB2BGR) # Set range for red color and define mask red_lower = np.array([0, 70, 50], np.uint8) red_upper = np.array([10, 255, 255], np.uint8) red_mask = cv2.inRange(hsvFrame, red_lower, red_upper) # Set range for green color and define mask green_lower = np.array([40, 52, 72], np.uint8) green_upper = np.array([70, 255, 255], np.uint8) green_mask = cv2.inRange(hsvFrame, green_lower, green_upper)
def skin_extract(image): img_HSV = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) #skin color range for hsv color space HSV_mask = cv2.inRange(img_HSV, (0, 15, 0), (17, 170, 255)) #cv2.imshow('HSV mask_before',HSV_mask) #cv2.imwrite('HSV mask_before.jpg',HSV_mask) HSV_mask = cv2.morphologyEx(HSV_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8)) #cv2.imshow('HSV mask',HSV_mask) #cv2.imwrite('HSV mask.jpg',HSV_mask) #converting from gbr to YCbCr color space img_YCrCb = cv2.cvtColor(image, cv2.COLOR_BGR2YCrCb) #skin color range for hsv color space YCrCb_mask = cv2.inRange(img_YCrCb, (0, 135, 85), (255, 180, 135)) #cv2.imshow('YCrCb_mask_before',YCrCb_mask) #cv2.imwrite('YCrCb_mask_before.jpg',YCrCb_mask) YCrCb_mask = cv2.morphologyEx(YCrCb_mask, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8)) #cv2.imshow('YCrCb_mask',YCrCb_mask) #cv2.imwrite('YCrCb_mask.jpg',YCrCb_mask) #merge skin detection (YCbCr and hsv) global_mask = cv2.bitwise_and(YCrCb_mask, HSV_mask) #cv2.imshow('global_mask_before',YCrCb_mask) cv2.imwrite('global_mask_befores.jpg', YCrCb_mask) global_mask = cv2.medianBlur(global_mask, 3) global_mask = cv2.morphologyEx(global_mask, cv2.MORPH_OPEN, np.ones((4, 4), np.uint8)) #cv2.imshow('global_mask',YCrCb_mask) cv2.imwrite('global_mask.jpg', YCrCb_mask) return YCrCb_mask
def base(): if request.method == 'GET': return "<h1>Crop AI</h1>" if request.method == 'POST': if 'InputImg' not in request.files: print("No file part") return redirect(request.url) file = request.files['InputImg'] if file.filename == '': print('No selected file') return redirect(request.url) if file and allowed_file(file.filename): filestr = request.files['InputImg'].read() img = cv2.imdecode(np.fromstring(filestr, np.uint8), cv2.IMREAD_COLOR) img = cv2.resize(img, (96, 96), interpolation=cv2.INTER_AREA) hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # find the green color mask_green = cv2.inRange(hsv, (36, 0, 0), (86, 255, 255)) # find the brown color mask_brown = cv2.inRange(hsv, (8, 60, 20), (145, 255, 255)) # find the yellow color in the leaf mask_yellow = cv2.inRange(hsv, (5, 42, 143), (145, 255, 255)) # find the black color in the leaf mask_black = cv2.inRange(hsv, (100, 100, 100), (127, 127, 127)) # find any of the four colors(green or brown or yellow or black) in the image mask = cv2.bitwise_or(mask_green, mask_brown) mask = cv2.bitwise_or(mask, mask_yellow) mask = cv2.bitwise_or(mask, mask_black) # Bitwise-AND mask and original image res = cv2.bitwise_and(img, img, mask=mask) # Gaussian blur with 3x3 kernel blur_img = cv2.GaussianBlur(res, (3, 3), 0) # Histogram equalization B, G, R = cv2.split(blur_img) output_R = cv2.equalizeHist(R) output_G = cv2.equalizeHist(G) output_B = cv2.equalizeHist(B) img = cv2.merge((output_R, output_G, output_B)) img = img / 255 img_array = np.expand_dims(img, axis=0) output = label_dictionary[model.predict(img_array)[0].argmax()] return output
def getArmorColor(raw_frame, rects): ''' 从机器人目标检测中筛选出所有蓝色方机器人目标 :param rects: rects[0]=x_center, rects[1]=y_center, rects[2]=width, rects[3]=height raw_frame: 摄像头拍摄的原图 :return: red_armour: 红色机器人目标所在的rects ''' Red = 1 Blue = 2 Others = 3 hsv = cv.cvtColor(raw_frame, cv.COLOR_BGR2HSV) #对原图处理 保留蓝色 frame_blue = cv.inRange(hsv, (100, 43, 46), (124, 255, 255)) #对原图处理 保留红色 frame_red = cv.inRange(hsv, (156, 43, 46), (180, 255, 255)) # #对原图处理 保留蓝色 # frame_blue = cv.inRange(hsv,(130, 100, 0),(255, 255, 65)) # #对原图处理 保留红色 # frame_red = cv.inRange(hsv,(0,0,140),(70, 70, 255)) # cv.imshow("frame_blue",frame_blue) # cv.imshow("frame_red",frame_red) armor_color = [] threshold = 100 for rect in rects: start_x, start_y, end_x, end_y = [int(i) for i in rect] blue_count = 0 red_count = 0 # start_x=rect[0]-rects[2]/2 # end_x=rect[0]+rects[2]/2 # # start_y=rect[1]-rects[3]/2 # end_y=rect[1]+rects[3]/2 for x in range(start_x, end_x): for y in range(start_y, end_y): if frame_blue[y][x] != 0: blue_count = blue_count + 1 if frame_red[y][x] != 0: red_count = red_count + 1 if (blue_count > threshold) and (blue_count > red_count): armor_color.append(Blue) elif (red_count > threshold) and (red_count > blue_count): armor_color.append(Red) else: armor_color.append(Others) return armor_color
def process(): """ turn the image into hsv and make red mask to do CHT """ image = cv2.imread("camImage.png") #blur to improve circle detection through noise #get HSV mapping for red values hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) #create mask for lower red HSV threshold mask_lower = cv2.inRange(hsv, RED_MIN_LOWER, RED_MAX_LOWER) #create mask for upper red HSV threshold mask_upper = cv2.inRange(hsv, RED_MIN_UPPER, RED_MAX_UPPER) #combine both masks mask = cv2.addWeighted(mask_lower, 1.0, mask_upper, 1.0, 0.0) kernel = np.ones((5, 5), np.uint8) #erode and dilate then dilate and erode mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel) cv2.imwrite("hsvMask.png", mask) #apply Gaussian Blur to improve detection and remove some noise blur = cv2.GaussianBlur(mask, (11, 11), 0) cv2.imwrite("blurredImg.png", blur) #perform CHT circles = cv2.HoughCircles(blur, cv2.cv.CV_HOUGH_GRADIENT, 1, 40, 800, 150, 20, 0) try: circles = np.uint16(np.around(circles)) except AttributeError: print("No Circles Found! Adjust parameters of CHT.") try: for i in circles[0, :]: # draw the outer circle cv2.circle(image, (i[0], i[1]), i[2], (0, 255, 0), 2) # draw the center of the circle cv2.circle(image, (i[0], i[1]), 2, (0, 0, 255), 3) except TypeError: print("No Circles Found! Adjust parameters of CHT") #write out image with drawn circles cv2.imwrite("detectedCircles.png", image)
def _filter_red(self, frame): hsv_img = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) frame_threshed1 = cv2.inRange(hsv_img, self._LOWER_RED_MIN, self._LOWER_RED_MAX) frame_threshed2 = cv2.inRange(hsv_img, self._UPPER_RED_MIN, self._UPPER_RED_MAX) frame_threshed_red = cv2.bitwise_or(frame_threshed1, frame_threshed2) # close gaps in red objects kernel = np.ones((5, 5), np.uint8) frame_threshed_red = cv2.morphologyEx(frame_threshed_red, cv2.MORPH_CLOSE, kernel) frame_threshed_red = cv2.bitwise_not(frame_threshed_red) return frame_threshed_red
def identify(image): mask_y = cv2.inRange(image, y_lower, y_upper) y = cv2.countNonZero(mask_y) mask_r = cv2.inRange(image, r_lower, r_upper) r = cv2.countNonZero(mask_r) print(y, r) if y > r: return "Banana" else: return "Apple"
def color_segmenter(frame): frame = np.array(frame) hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # low_colors = [[90, 100,50], [40, 100, 50], [0,100,50],[0,0,0],[0,0,230],[220,25,153]] # high_colors = [[120, 255,255], [60,255,255], [20, 255, 255],[180,255,20],[255,5,255],[240,50,178]] low_colors = [[90, 100, 50], [30, 85, 85], [0, 100, 50], [0, 0, 0], [0, 0, 200], [0, 0, 66]] high_colors = [[120, 255, 255], [102, 255, 255], [20, 255, 255], [180, 255, 20], [145, 60, 255], [255, 33, 200]] color_names = ["blue", "green", "red", "black", "white", "gray"] #dont change value without consulting in group #whitw-lower v-180 ans = ("UNK", 0) path = "color-cars/" # red_low=[170,100,50] # red_high=[180,255,255] red_low = [160, 150, 90] red_high = [180, 255, 255] for x in range(len(color_names)): if (x == 2): mask1 = cv2.inRange(hsv_frame, np.array(low_colors[x]), np.array(high_colors[x])) mask2 = cv2.inRange(hsv_frame, np.array(red_low), np.array(red_high)) color_mask = mask1 + mask2 else: color_mask = cv2.inRange(hsv_frame, np.array(low_colors[x]), np.array(high_colors[x])) #color_region=cv2.bitwise_and(frame,frame, mask=color_mask) color_mask = np.array(color_mask) flatten_array = color_mask.flatten() ad = np.unique(flatten_array, return_counts=True) if (len(ad[1]) == 1): continue elif (ad[1][1] > ans[1]): ans = (color_names[x], ad[1][1]) #cv2.imwrite(path + str(img_name) + "_" + str(color_names[x]) + str(".jpg"), color_mask) return (ans[0])
def _get_balls(self, image, color, bounds, cam_id = 1): # converting the input stream into HSV color space hsv_conv_img = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) bright_mask = cv2.inRange(hsv_conv_img, bounds[0], bounds[1]) blurred_mask = cv2.GaussianBlur(bright_mask, (9, 9), 3, 3) # some morphological operations (closing) to remove small blobs erode_element = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3)) dilate_element = cv2.getStructuringElement(cv2.MORPH_RECT, (8, 8)) eroded_mask = cv2.erode(blurred_mask, erode_element) dilated_mask = cv2.dilate(eroded_mask, dilate_element) detected_circles = cv2.HoughCircles(dilated_mask, cv2.HOUGH_GRADIENT, **HOUGH_PARAMS) balls = [] if detected_circles is not None: for circle in detected_circles[0, :]: x = circle[0] y = circle[1] r = circle[2] circled_orig = cv2.circle(image, (x, y), r, (0, 255, 0), thickness=2) # locate detected balls # https_www.pyimagesearch.com/?url=https%3A%2F%2Fwww.pyimagesearch.com%2F2015%2F01%2F19%2Ffind-distance-camera-objectmarker-using-python-opencv%2F distance = self.find_position(x, y, r, cam_id) balls.append((x, y, r, color)) cv2.imshow('circled_orig', circled_orig) cv2.waitKey(0) return balls
def get_red_armour(raw_frame, rects): ''' 从机器人目标检测中筛选出所有红色方机器人目标 :param rects: rects[0]=x_center, rects[1]=y_center, rects[2]=width, rects[3]=height raw_frame: 摄像头拍摄的原图 :return: red_armour: 红色机器人目标所在的rects ''' #对原图处理 保留红色 frame = cv.inRange(raw_frame, (0, 0, 140), (70, 70, 255)) red_armour = [] threshold = 10 for rect in rects: account = 0 start_x = rect[0] - rects[2] / 2 end_x = rect[0] + rects[2] / 2 start_y = rect[1] - rects[3] / 2 end_y = rect[1] + rects[3] / 2 for x in range(start_x, end_x): for y in range(start_y, end_y): if frame[y][x] != 0: account = account + 1 if account >= threshold: red_armour.append(rect) return red_armour
def _get_balls(self, filename, color, cam_id): # print('looking for ' + color) image = cv2.imread(filename) bounds = COLOR_BOUNDS[color] hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) bright = cv2.inRange(hsv, bounds[0], bounds[1]) blur = cv2.GaussianBlur(bright, (9, 9), 3, 3) # cv2.imshow('circled_orig', blur) # cv2.waitKey(0) detected_circles = cv2.HoughCircles(blur, cv2.HOUGH_GRADIENT, **HOUGH_PARAMS) balls = [] if detected_circles is not None: for circle in detected_circles[0, :]: x = circle[0] y = circle[1] r = circle[2] # circled_orig = cv2.circle(image, (x, y), r, (0, 255, 0), thickness = 2) # locate detected balls distance = self._find_distance(x, y, r, cam_id) balls.append(distance) # balls.append((x, y, r, color)) # balls.append() # cv2.imshow('circled_orig', circled_orig) # cv2.waitKey(0) # print('found') # print(balls) return balls
def get_text(self, img, color=None, lowerb=None, upperb=None, reg=None): if color is None: color = 'black' if lowerb is None: lowerb = self.hsv_color[color][0] if upperb is None: upperb = self.hsv_color[color][1] temp = Image.fromarray(img) text = pytesseract.image_to_string(temp, config=self.TESSERACT_CONFIG) if len(img.shape) == 3 and img.shape[2] == 3: dilate_kernel = np.ones((2, 2), np.uint8) hsv_img = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) bi_img = cv2.inRange(hsv_img, lowerb, upperb) bi_img = cv2.dilate(bi_img, dilate_kernel, iterations=1) bi_img = Image.fromarray(255 - bi_img) text += pytesseract.image_to_string(bi_img, config=self.TESSERACT_CONFIG) if reg is None: return text else: match = re.search(reg, text) if match is None: raise NotFound() else: return match
def line_slice(roi_kreuzung, dieser_frame, offset): """ Zeichnet auf auf einem Schnit am gegebenen Y-Offset im Kamerabild die gefundenen Linienstückchen als grüne Rechtecke ein. Wird die eine Linie zu breit, wird das Rechteck rot eingefärbt. Das Zentrum aller Linienstückchen in einem Schnitt wird mit einem Punkt markiert. """ yoffset = PIXEL_HOEHE - (PIXEL_HOEHE - 200) - 20 - offset # Horizontalen Streifen an y-Position "offset" herausschneiden roi_line = dieser_frame[PIXEL_HOEHE - 20 - offset:PIXEL_HOEHE - 1 - offset, 0:PIXEL_BREITE - 1] # in HSV-Farbschema umwandeln hsv = cv2.cvtColor(roi_line, cv2.COLOR_BGR2HSV) # Maske erstellen (Monochromes Bild: Linie weiß, alles andere schwarz) black_mask = cv2.inRange(hsv, black_lower_limit, black_upper_limit) # Konturen extrahieren _, konturen, _ = cv2.findContours(black_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) cx = 0 cy = yoffset + 5 cnt = 0 farbe = GRUEN # Liste der X-Positionen der Zentren der gefundenen Linienstücke ret = [] is_kreuzung = False for kontur in konturen: # Rechteck um die Kontur erhalten x, y, w, h = cv2.boundingRect(kontur) # zu kleine Konturen wegfiltern if w > 10: # zu große Konturen rot einfärben if w > 150: farbe = ROT is_kreuzung = True # sonst grün einfärben else: farbe = GRUEN # Rechteck um die Kontur zeichnen cv2.rectangle(roi_kreuzung, (x, y + yoffset), (x + w, y + yoffset + h), farbe, 2) # Summe aller x-Positionen der Zentren der gefundenen Rechtecke bilden cx = cx + int(x + w / 2) # Anzahl der gefundenen Rechecke mitzählen cnt = cnt + 1 # Rote Rechtecke: X-Position ist 0 (Mitte des Kamerabildes) if is_kreuzung: ret.append(0) # Grüne Rechtecke: Abweichung von Bildmitte an Liste anfügen else: ret.append(cx - PIXEL_BREITE / 2) # keine Linienstücke gefunden: Durchnitt aller X-Positionen ist Bildmitte if cx is 0: cx = (PIXEL_BREITE - 1) / 2 # Linienstückchen gefunden: Durchschnitt aller X-Positionen errechnen else: cx = cx / cnt # Kreis zeichnen an durchschnittlicher X-Position aller gefundenen Linienstückchen cv2.circle(roi_kreuzung, (int(cx), int(cy)), 5, farbe, -1) # Ergebnisliste zurückgeben: Liste der Abweichung der Linie von Mitte in Pixel return ret
def getCropMask(color, depth, hue): ''' 拿到掩模 ''' ### H-[65 98] S-[33 255] V-[117 255] ### ## 原 [30,100,40] ## [100,255,255] hsv = cv2.cvtColor(color, cv2.COLOR_BGR2HSV) lower_g = np.array([hue-20,33,30]) upper_g = np.array([hue+20,255,255]) mask = cv2.inRange(hsv, lower_g, upper_g) mask = cv2.medianBlur(mask, 5) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5,5)) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) ''' 去除掩模小的连通域 ''' if(cv2.__version__[0] == '4'): contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) else: _, contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) boundaries = [] for con in contours: if(cv2.contourArea(con) > 1000): boundaries.append(con) cv2.drawContours(mask, [con], 0, 255, -1) else: cv2.drawContours(mask, [con], 0, 0, -1) ''' 将掩模与深度做与运算 ''' depth_bin = np.uint8(depth>0)*255 mask = cv2.bitwise_and(mask, depth_bin) return(mask)
def red_detect(frame): # オレンジ色を検出し、画像加工を施す。 hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) lower = (0, 230, 150) upper = (30, 255, 255) red = cv2.inRange(hsv, lower, upper) kernal = np.ones((5, 5), "uint8") red = cv2.dilate(red, kernal) res = cv2.bitwise_and(frame, frame, mask=red) (ret, contours, hierarchy) = cv2.findContours( red, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) x = 0 y = 0 w = 0 h = 0 for pic, contour in enumerate(contours): area = cv2.contourArea(contour) if (area > 100): x, y, w, h = cv2.boundingRect(contour) frame = cv2.rectangle( frame, (x, y), (x + w, y + h), (0, 0, 255), 2) cv2.putText(frame, "RED color", (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255)) cv2.drawMarker(frame, (480, 350), (255, 255, 0), markerType=cv2.MARKER_SQUARE, markerSize=5, thickness=10) cv2.drawMarker(frame, ((x + w//2), (y + h//2)), (255, 255, 0), markerType=cv2.MARKER_SQUARE, markerSize=5, thickness=10) cv2.arrowedLine(frame, (480, 350), ((x + w//2), (y + h//2)), (255, 0, 0), 5) cv2.rectangle(frame, (330, 200), (630, 500), (0, 255, 0), 1) return frame, x, y, w, h # 動画データとピクセル(x,y,z,h)を返す
def img_color_filter(img): hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV) # color orange low_hsv = np.array([11, 43, 46]) up_hsv = np.array([25, 255, 255]) mask = cv.inRange(hsv, lowerb=low_hsv, upperb=up_hsv) cv.imshow("filter", mask)
def get_balls(image, color, bounds, camera): hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) bright = cv2.inRange(hsv, bounds[0], bounds[1]) blur = cv2.GaussianBlur(bright, **GAUSS_PARAMS) # detected_circles = cv2.HoughCircles(blurred_mask, cv2.HOUGH_GRADIENT, 1, 20, param1=50, param2=30, minRadius=0, maxRadius=0) detected_circles = cv2.HoughCircles(blur, cv2.HOUGH_GRADIENT, **HOUGH_PARAMS) balls = [] if detected_circles is not None: for circle in detected_circles[0, :]: x = circle[0] y = circle[1] r = circle[2] # locate detected balls position, distance = find_position(x, y, r, camera) circled_orig = cv2.circle(image, (x, y), r, (0, 255, 0), thickness=1) font = cv2.FONT_HERSHEY_SIMPLEX # x = x - 10 print(x, y) cv2.putText(circled_orig, str(format(distance, '.2f')), (x, y), font, 0.5, (255, 255, 255), 2, cv2.LINE_AA) balls.append((x, y, r, color)) display_image(circled_orig) return balls
def detectColor(): def empty(a): pass cv2.namedWindow("TrackBars") cv2.resizeWindow("TrackBars", 640, 240) cv2.createTrackbar("Hue Min", "TrackBars", 0, 179, empty) cv2.createTrackbar("Sat Min", "TrackBars", 0, 255, empty) cv2.createTrackbar("Val Min", "TrackBars", 0, 255, empty) cv2.createTrackbar("Hue Max", "TrackBars", 179, 179, empty) cv2.createTrackbar("Sat Max", "TrackBars", 255, 255, empty) cv2.createTrackbar("Val Max", "TrackBars", 255, 255, empty) while True: img = cv2.imread("./lambo.jpeg") imgHSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) h_min = cv2.getTrackbarPos("Hue Min", "TrackBars") h_max = cv2.getTrackbarPos("Hue Max", "TrackBars") s_min = cv2.getTrackbarPos("Sat Min", "TrackBars") s_max = cv2.getTrackbarPos("Sat Max", "TrackBars") v_min = cv2.getTrackbarPos("Val Min", "TrackBars") v_max = cv2.getTrackbarPos("Val Max", "TrackBars") #print(v_min) # lower1 = np.array([h_min, s_min, v_min]) # upper1 = np.array([h_max, s_max, v_max]) lower = np.array([000, 000, 186]) upper = np.array([179, 255, 255]) mask = cv2.inRange(imgHSV, lower, upper) imgResult = cv2.bitwise_and(img, img, mask=mask) cv2.imshow("Original", img) cv2.imshow("HSV", imgHSV) cv2.imshow("Mask", mask) cv2.imshow("Result", imgResult) cv2.waitKey(0)
def detect_red(self, img): thresh = cv2.inRange(img, (0, 0, 100), (10, 10, 255)) if (sum(sum(thresh)) == 0): #If it is obscured return None #Return none kernel = np.ones((5, 5), np.uint8) result = cv2.dilate(thresh, kernel, iterations=3) return self.getCoM(result) #Positions returned
def get_white(src): # 白色 lower_white = np.array([0, 0, 221]) upper_white = np.array([180, 45, 255]) hsv = cv2.cvtColor(src, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, lower_white, upper_white) return mask
def select_yellow(image): hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV) lower = np.array([20, 60, 60]) upper = np.array([38, 174, 250]) mask = cv2.inRange(hsv, lower, upper) return mask
def dupImageByColor(in_frame, hue, sat, val, torg, t): out_img = cv2.cvtColor(in_frame, cv2.COLOR_BGR2HSV) # out_img = cv2.inRange(out_img, (hue[0], sat[0], val[0]), (hue[1], sat[1], val[1])) out_img = cv2.blur(out_img, (3, 3)) # # masking out the area that we wanted by just taking an entire slice of the area and leave it in the 'out' image #out_img = out_img[_y1:_y2, _x1:_x2] # also draw this slice on the original image in Red (BGR) #cv2.rectangle(out_img, _mask_p1, _mask_p2, (0,0,255), 1) # Now, let's find the contour - we only keeping/using contours for this time contours, _ = cv2.findContours(out_img, mode=cv2.RETR_EXTERNAL, method=cv2.CHAIN_APPROX_SIMPLE) maxcontourarea = 0.0 if len(contours) > 0: c = max(contours, key=cv2.contourArea) maxcontourarea = cv2.contourArea(c) #for c in contours: # cv2.drawContours(out_img, c, 0, (0,150,150), 1) # out_img = cv2.cvtColor(out_img, cv2.COLOR_HSV2BGR) # cv2.putText(in_frame, str(t) + ": " + str(maxcontourarea), torg, cv2.FONT_HERSHEY_PLAIN, 1, (0,0,0)) return (out_img, maxcontourarea)
def AnalisFrame(color, rango_bajos, rango_altos): Pcolor = 0 PorcentajeBlack = 0 #Detectamos los píxeles que estén dentro del rango que hemos establecido: mask = cv2.inRange(hsv, rango_bajos, rango_altos) #print(len(mask)) #Mostramos la imagen original y la máscara: #cv2.imshow("Original", img) #Mostramos la imagen original y la máscara: #cv2.imshow(color, mask) cv2.imwrite('messigray.png', mask) foto = Image.open('messigray.png') datos = list(foto.getdata()) for dato in datos: if (int(dato) > 0): #print(dato) Pcolor += 1 else: PorcentajeBlack += 1 foto.close() Porcentajecolor = Pcolor * 100 / (Pcolor + PorcentajeBlack) AnalisisColor = [color, Porcentajecolor] AnalisListColor.append(AnalisisColor) PorcentajePixel.append(Porcentajecolor) # Resultados Por scala """
def find_game_frame(screen): global game_frame img = np.array(screen) thresh = cv2.inRange(img, WINDOW_BORDER_COLOR, WINDOW_BORDER_COLOR) contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if len(contours) == 0: return window_border = max(contours, key=cv2.contourArea) x0, y0, w, h = cv2.boundingRect(window_border) window_crop = thresh[y0:y0 + h, x0:x0 + w] window_thresh = cv2.bitwise_not(window_crop) contours, _ = cv2.findContours(window_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if len(contours) == 0: return game_border = max(contours, key=cv2.contourArea) x1, y1, w, h = cv2.boundingRect(game_border) if w * h < 540 * 405: return game_frame = (x0 + x1, y0 + y1, w, h)
def findend(): global endpoint hsv_image = cv2.cvtColor(img_maze, cv2.COLOR_BGR2HSV) # define range of red color in HSV lower_red = np.array([0,100,100]) upper_red = np.array([135,255,255]) # Threshold the HSV image to get only blue colors mask = cv2.inRange(hsv_image, lower_red, upper_red) # Bitwise-AND mask and original image res = cv2.bitwise_and(hsv_image,hsv_image, mask= mask) cimg=res res=cv2.cvtColor(res, cv2.COLOR_RGB2GRAY) circles = cv2.HoughCircles(res,cv2.HOUGH_GRADIENT,1,30,param1=50,param2=10,minRadius=0,maxRadius=0) #circles = np.uint16(np.around(circles)) for i in circles[0,:]: # draw the outer circle cv2.circle(cimg,(i[0],i[1]),i[2],(255,0,0),2) # draw the center of the circle cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3) endpoint = (i[0],i[1])
def maskDisplay(self, hsvarr, img): imgHSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) lower = np.array([hsvarr[0], hsvarr[2], hsvarr[4]]) upper = np.array([hsvarr[1], hsvarr[3], hsvarr[5]]) mask = cv2.inRange(imgHSV, lower, upper) imgresult = cv2.bitwise_and(img, img, mask=mask) cv2.imshow("Masked Feed", imgresult)
def traitement_image(img_bw): global Photo_traitee global canvas_photoTraitee global hsv couleur = "#3F875C" hsv = [75, 130, 90] H = hsv[0] S = hsv[1] V = hsv[2] HMin = H - 15 HMax = H + 15 SMin = S - 70 SMax = S + 70 VMin = V - 90 VMax = V + 90 minHSV = np.array([HMin, SMin, VMin]) maxHSV = np.array([HMax, SMax, VMax]) #img = cv2.imread(img_bw) imageHSV = cv2.cvtColor(img_bw, cv2.COLOR_BGR2HSV) maskHSV = cv2.inRange(imageHSV, minHSV, maxHSV) resultHSV = cv2.bitwise_and(img_bw, img_bw, mask=maskHSV) img_gray = cv2.cvtColor(resultHSV, cv2.COLOR_RGB2GRAY) (thresh, img_bw) = cv2.threshold(img_gray, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU) #path_file=('static/%s.jpg' %uuid.uuid4().hex), cv2.imwrite('static/photo.jpg', img_bw) return json.dumps('static/photo.jpg')