def thresh_callback(val, src_gray): threshold = val rng.seed(12345) canny_output = cv2.Canny(src_gray, threshold, threshold * 2) contours, hierarchy = cv2.findContours(canny_output, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2:] contours_poly = [None] * len(contours) boundRect = [None] * len(contours) centers = [None] * len(contours) radius = [None] * len(contours) for i, c in enumerate(contours): contours_poly[i] = cv2.approxPolyDP(c, 3, True) boundRect[i] = cv2.boundingRect(contours_poly[i]) centers[i], radius[i] = cv2.minEnclosingCircle(contours_poly[i]) drawing = np.zeros((canny_output.shape[0], canny_output.shape[1], 3), dtype=np.uint8) for i in range(len(contours)): color = (rng.randint(0, 256), rng.randint(0, 256), rng.randint(0, 256)) cv2.drawContours(drawing, contours_poly, i, color) cv2.rectangle(drawing, (int(boundRect[i][0]), int(boundRect[i][1])), \ (int(boundRect[i][0]+boundRect[i][2]), int(boundRect[i][1]+boundRect[i][3])), color, 2) cv2.circle(drawing, (int(centers[i][0]), int(centers[i][1])), int(radius[i]), color, 2)
def detect_ball(frame): x, y, radius = -1, -1, -1 hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_frame, HSV_lower, HSV_upper) mask = cv2.erode(mask, None, iterations=0) mask = cv2.dilate(mask, None, iterations=12) im2, contours, hierarchy = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) center = (-1, -1) # only proceed if at least one contour was found if len(contours) > 0: # find the largest contour in the mask, then use # it to compute the minimum enclosing circle and # centroid c = max(contours, key=cv2.contourArea) ((x, y), radius) = cv2.minEnclosingCircle(c) xList.append(x) # x coordinates xPath.append((x - xStart) / pathLength) # path traveled M = cv2.moments(mask) center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) # check that the radius is larger than some threshold if radius > minRadius: #outline ball cv2.circle(frame, (int(x), int(y)), int(radius), (255, 0, 0), 2) #show ball center cv2.circle(frame, center, 5, (0, 255, 0), -1) return center[0], center[1], radius
def watershedf(): image = threshold() D = ndimage.distance_transform_edt(image) localMax = peak_local_max(D, indices=False, min_distance=20, labels=image) markers = ndimage.label(localMax, structure=np.ones((3, 3)))[0] labels = watershed((-1) * D, markers, mask=image) original_image = image for label in np.unique(labels): if label == 0: continue mask = np.zeros(image.shape, dtype="uint8") mask[labels == label] = 255 cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) c = max(cnts, key=cv2.contourArea) ((x, y), r) = cv2.minEnclosingCircle(c) cv2.circle(original_image, (int(x), int(y)), int(r), (0, 255, 0), 2) cv2.putText(original_image, "#{}".format(label), (int(x) - 10, int(y)), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2) image = original_image show_img(ImageTk.PhotoImage(Img.fromarray(image)))
def center_of_mass(image): threshold = thresh # Convert image to gray and blur it src_gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY) src_gray = cv.blur(src_gray, (3, 3)) # Edge detection canny_output = cv.Canny(src_gray, threshold, threshold * 2) contours, _ = cv.findContours(canny_output, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) # For every found contour we now apply approximation to polygons with accuracy +-3 and stating that the curve must be closed. # After that we find a bounding rect for every polygon and save it to boundRect. # At last we find a minimum enclosing circle for every polygon and save it to center and radius vectors. contours_poly = [None] * len(contours) boundRect = [None] * len(contours) centers = [None] * len(contours) radius = [None] * len(contours) for i, c in enumerate(contours): i = 0 contours_poly[i] = cv.approxPolyDP(c, 3, True) boundRect[i] = cv.boundingRect(contours_poly[i]) centers[i], radius[i] = cv.minEnclosingCircle(contours_poly[i]) return centers[0]
def maxThreshCalc(img): if len(img) > 0: c = max(img, key=cv2.contourArea) ((x, y), radius) = cv2.minEnclosingCircle(c) return radius
def circle(surfaces_body, img): ''' 外接圆的计算、绘制 参数: surfaces_body:二维列表surfaces_body[i]中代表存储标号为i+1的堆石块体的信息,surfaces_body[i][0]以二维0-1数组(n,m)存储堆石块体的连通域,surfaces[i][1:]存储该连通域的多个轮廓顶点坐标 img:二维np数组(n,2),存储原始图像 返回值: circles:二维列表,circles[i]存储外接圆的信息,第一个元素表示圆心横坐标,第二个元素表示圆心纵坐标,第三个元素表示最小外接圆的半径 img:二维np数组(n,2),存储绘制有所有堆石最小外接圆的图像图像 ''' circles = [] for i in range(len(surfaces_body)): radius_max = 0 for j in surfaces_body[i][1:]: #计算外接圆 (rx, ry), radius = cv2.minEnclosingCircle(np.float32(j)) #保留半径最大的外接圆 if radius_max == 0: circles.append([rx, ry, radius]) radius_max = radius if radius_max <= radius and radius_max != 0: circles[i] = [rx, ry, radius] radius_max = radius center = (int(circles[i][1]), int(circles[i][0])) radius = int(circles[i][2]) #筛选细碎分割面的外接圆 if radius >= (max(img.shape) / 20): img = cv2.circle(img, center, radius, (255, 0, 0), 2) #绘制外接圆 return circles, img
def ConvexHull_Cal(contour): IsTriangle = lambda a, b, c: a + b > c and a + c > b and b + c > a #任意两边和必须大于第三边 point_list = [] convex_angle_ls = [] concave_angle_ls = [] epsilon = 0.003 * cv2.arcLength(contour, True) contour = cv2.approxPolyDP(contour, epsilon, True) #轮廓近似,Douglas-Peucker算法 hull = cv2.convexHull(contour, returnPoints=False) defects = cv2.convexityDefects(contour, hull) _, radius = cv2.minEnclosingCircle(contour) if defects is not None: for i in range(defects.shape[0]): s, e, f, _ = defects[i, 0] sta = tuple(contour[s][0]) end = tuple(contour[e][0]) far = tuple(contour[f][0]) point_list.append([sta, far, end]) #下面的角边标示含义见文件夹里的图片说明 if len(point_list) >= 2: for it_1, it_2 in zip(point_list, point_list[1:] + point_list[:1]): CA = scfun.Eucledian_Distance(it_1[1], it_1[2]) #far to end AB = scfun.Eucledian_Distance(it_1[2], it_2[1]) #end to next far #凸包的角度 if radius <= CA + AB < 2 * radius: BC = scfun.Eucledian_Distance(it_1[1], it_2[1]) #far to 2nd far,为底边 if IsTriangle(CA, AB, BC): angle = acos((CA**2 + AB**2 - BC**2) / (2 * CA * AB)) convex_angle_ls.append(angle) #凹陷的角度 DC = scfun.Eucledian_Distance(it_1[0], it_1[1]) #sta to far if radius <= DC + CA < 2 * radius: DA = scfun.Eucledian_Distance(it_1[0], it_1[2]) #sta to end,为底边 if IsTriangle(DC, CA, DA): angle = acos((CA**2 + DC**2 - DA**2) / (2 * CA * DC)) concave_angle_ls.append(angle) convex_angle = [x for x in convex_angle_ls if pi / 18 <= x <= pi / 6] #凸包角度:10度至30度 convex_len = len(convex_angle) concave_angle = [ x for x in concave_angle_ls if pi / 18 <= x <= pi / 3.5 ] concave_len = len(concave_angle) result = [convex_len, concave_len] else: result = [0, 0] return result
def main(): global pub, coo, cap, cX, cY coo.x = 0 coo.y = 0 cap = cv2.VideoCapture(0) while not rospy.is_shutdown(): while (cap.isOpened()): ret, frame = cap.read() # cv2.imshow('frame',frame) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) lower_bound = np.array([25, 50, 50]) upper_bound = np.array([50, 255, 255]) mask = cv2.inRange(hsv, lower_bound, upper_bound) res = cv2.bitwise_and(frame, frame, mask=mask) kernel_e = np.ones((3, 3), dtype=np.uint8) res2 = cv2.erode(res, kernel=kernel_e, iterations=2) res3 = cv2.dilate(res2, kernel=kernel_e, iterations=2) # blur=cv.GaussianBlur(res3,(5,5),0) blur_gray = cv2.cvtColor(res3, cv2.COLOR_BGR2GRAY) _, cnts, _ = cv2.findContours(blur_gray, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) x = 0 y = 0 radius = 0 for i in cnts: if len(i) > 50: #M = cv.moments(i) #cX = int(M["m10"] / M["m00"]) #cY = int(M["m01"] / M["m00"]) (x, y), radius = cv2.minEnclosingCircle(i) #cv2.drawContours(res3, [i], -1, (0, 255, 0), 2) #cv2.circle(res3, (cX, cY), 7, (255, 255, 255), -1) #cv2.putText(res3, "center", (cX - 20, cY - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) coo.x = x coo.y = y coo.radius = radius pub.publish(coo) # cv2.drawContours(res3, [i], -1, (0, 255, 0), 2) # cv2.circle(res3, (cX, cY), 7, (255, 255, 255), -1) # cv2.putText(res3, "center", (cX - 20, cY - 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2) # cv.imshow('at',at) # cv2.imshow('res',res) # cv2.imshow('res2',res2) cv2.imshow('res3', res3) # cv2.imshow('blur', blur_gray) # cv2.imshow('res3', res3) # # cv.imshow('gray', gray) # cv2.imshow('mask',mask) # cv2.imshow('hsv',hsv) if cv2.waitKey(1) & 0xFF == ord('q'): cap.release() cv2.destroyAllWindows()
def selectContours(img, contours, range): for c in contours: area = cv2.contourArea(c) ((x, y), radius) = cv2.minEnclosingCircle(c) if area > range: # If area of found contour is greater than 1000 execute cx, cy = contourCenter(c) # Center of center cv2.circle(img, (cx, cy), int(radius), (0, 0, 255), thickness=5) # Draw a circle around found contour return img
def Gestures_Detect(hand, sample_list, fourier_des_ls): ndefects = 0 sign, large_cout = Find_Contour(hand, sample_list, fourier_des_ls) if sign == False: ndefects = 11 #返回contours为空的信息,只作调试用 center = tuple([a // 2 for a in reversed(hand.shape)]) #返回图像的中心坐标 return hand, ndefects, center black2 = np.ones(hand.shape, np.uint8) #创建黑色幕布 cv2.drawContours(black2, large_cout, -1, (255, 255, 255), 2) #绘制白色轮廓 cv2.imshow('large_cout', black2) hull = cv2.convexHull(large_cout, returnPoints=False) defects = cv2.convexityDefects(large_cout, hull) _, radius = cv2.minEnclosingCircle(large_cout) if defects is not None: for i in range(defects.shape[0]): s, e, f, _ = defects[i, 0] sta = tuple(large_cout[s][0]) end = tuple(large_cout[e][0]) far = tuple(large_cout[f][0]) B = scfun.Eucledian_Distance(sta, far) C = scfun.Eucledian_Distance(end, far) #过滤掉角边太短的角 if B + C > radius: A = scfun.Eucledian_Distance(sta, end) #底边 angle = acos((B**2 + C**2 - A**2) / (2 * B * C)) if angle <= pi / 2.5: ndefects += 1 else: ndefects = 12 ''' test=scfun.Fourier_Descriptor(large_cout[:,0,:],Normalize=True) similar=scfun.Eucledian_Distance(test,fourier_des_ls[0]) print('{:.5f} {:.5f}'.format(similar,log(similar))) ''' M = cv2.moments(large_cout) center = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00'])) #手部的质心坐标 x, y, w, h = cv2.boundingRect(large_cout) hand = cv2.cvtColor(hand, cv2.COLOR_GRAY2BGR) #将灰度图像转换为BGR以显示绿色方框 hand = cv2.rectangle(hand, (x, y), (x + w, y + h), (0, 255, 0), 2) return hand, ndefects, center
def GetCircle(img): #ClearBlackEdge - GaussianBlur - Binary - Erode -FindCountour time0_start = time.time() img = ClearBlackEdge(img) #去黑边 time0_end = time.time() t0 = time0_end - time0_start #print('black:',t0) time2_start = time.time() blur = cv2.GaussianBlur(img,(9,9),0) #高斯平滑 ret3, binary = cv2.threshold(blur,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU) #双峰二值化,不过现在有一种情况有点问题,后续鲤鱼进一步改进 kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (300, 300)) #定义一直贼大的矩形核 grad = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel) #用刚才那个贼大的核,做个闭操作 out = cv2.erode(grad, None, iterations=10) #膨胀10次 time2_end = time.time() t2 = time2_end-time2_start #print(t2) #以上骚操作,都是为了把圆盘变成个实心圆 #边缘检测得到一些外围的候选 time1_start = time.time() contours, hier = cv2.findContours(out, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) time1_end = time.time() t1 = time1_end-time1_start #print('edge:',t1) height, width = img.shape allCenter = [] allRadius = [] #这个循环是为了过滤掉一些不太外围候选,得到外围 for c in contours : (x, y), radius = cv2.minEnclosingCircle(c) if width/3 < x < width/3*2 and 0.1*width < radius < 0.8*width: allCenter.append((int(x), int(y))) allRadius.append(int(radius)+100) else: pass # for i in range(len(allCenter)): # img = cv2.circle(img, allCenter[i], allRadius[i], (0, 0, 255), 10) return img, height, width, allCenter, allRadius #返回值是去了黑边的大图及其长宽,外围中心与半径
def image_processing(frame): green_lower = (29, 86, 6) green_upper = (64, 255, 255) blurred = cv2.GaussianBlur(frame, (11, 11), 0) hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, green_lower, green_upper) mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, None, iterations=2) contour = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) contour = imutils.grab_contours(contour) if len(contour) > 0: c = max(contour, key=cv2.contourArea) ((x, y), radius) = cv2.minEnclosingCircle(c) m = cv2.moments(c) center = (int(m["m10"] / m["m00"]), int(m["m01"] / m["m00"])) if radius > 15: cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 0), 2) cv2.circle(frame, center, 5, (255, 0, 0), -1) return frame
def get_angle_and_pos(orig_img, filtered_imgs): X = [] Y = [] for i in range(2): imgray = cv2.cvtColor(filtered_imgs[i], cv2.COLOR_BGR2GRAY) _, thresh = cv2.threshold(imgray, 255, 255, 255) contours, _ = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) radius_lst = [] X_lst = [] Y_lst = [] if len(contours) > 0: for ctr in contours: (x, y), radius = cv2.minEnclosingCircle(ctr) x, y = (int(x), int(y)) radius_lst.append(int(radius)) X_lst.append(x) Y_lst.append(y) idx = radius_lst.index(max(radius_lst)) radius = (radius_lst[idx]) X.append(X_lst[idx]) Y.append(Y_lst[idx]) cv2.circle(orig_img, (X[i], Y[i]), radius, (0, 255, 0), 2) cv2.circle(orig_img, (X[i], Y[i]), 4, (0, 255, 0), 3) else: return 0, 0, 0, orig_img if len(filtered_imgs) == 2: d = np.sqrt(np.power(X[0] - X[1], 2) + np.power(Y[0] - Y[1], 2)) angle = np.arctan2(Y[0] - Y[1], X[0] - X[1]) xs = X[0] - np.cos(angle) * d / 2 ys = Y[0] - np.sin(angle) * d / 2 cv2.circle(orig_img, (int(xs), int(ys)), 4, (0, 255, 0), 3) else: xs = X[0] ys = Y[0] angle = 0 return xs, ys, angle, orig_img
def draw_circle(self, img, descirptor_in_use): """获取外接轮廓 :param res: 输入图像,傅里叶描述子 :return: 重绘图像 """ contour_reconstruct = np.fft.ifft(descirptor_in_use) # 傅里叶反变换 contour_reconstruct = np.array( [contour_reconstruct.real, contour_reconstruct.imag]) contour_reconstruct = np.transpose(contour_reconstruct) # 转换矩阵 contour_reconstruct = np.expand_dims(contour_reconstruct, axis=1) # 改变数组维度在axis=1轴上加1 if contour_reconstruct.min() < 0: contour_reconstruct -= contour_reconstruct.min() contour_reconstruct *= img.shape[0] / contour_reconstruct.max() contour_reconstruct = contour_reconstruct.astype(np.int32, copy=False) x, y, w, h = cv2.boundingRect(contour_reconstruct) # 外接矩形 cv2.rectangle(img, (x, y), (x + w, y + h), (255, 225, 0), 3) rect = cv2.minAreaRect(contour_reconstruct) # 最小外接矩形 box = np.int0(cv2.boxPoints(rect)) # 矩形的四个角点取整 cv2.drawContours(img, [box], 0, (0, 255, 255), 3) (x, y), radius = cv2.minEnclosingCircle(contour_reconstruct) # 最小外接圆 (x, y, radius) = np.int0((x, y, radius)) # 圆心和半径取整 cv2.circle(img, (x, y), radius, (0, 255, 0), 2) ellipse = cv2.fitEllipse(contour_reconstruct) # 拟合椭圆 cv2.ellipse(img, ellipse, (0, 0, 255), 2) df = pd.DataFrame(np.random.rand(10, 4), columns=[u'外接矩形', u'最小外接矩阵', u'外接圆', u'椭圆']) fig = df.plot(figsize=(6, 6)) # 创建图表对象,并复制给fig plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) plt.xlabel(u'图像轮廓', fontsize=20) plt.show() return img
def readFrame(): ret, frame = camera.read() if ret: # Process frame @ lower quality level frame = imutils.resize(frame, width=600) blurred = cv.GaussianBlur(frame, (11, 11), 0) hsv = cv.cvtColor(blurred, cv.COLOR_BGR2HSV) mask = cv.inRange(hsv, colorUpLower, colorUpUpper) mask = cv.erode(mask, None, iterations=2) mask = cv.dilate(mask, None, iterations=2) cv.imshow('Mask', mask) # Pull contours to draw contours = cv.findContours( mask.copy(), cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) contours = imutils.grab_contours(contours) center = None if len(contours) > 0: maxC = max(contours, key=cv.contourArea) ((x, y), radius) = cv.minEnclosingCircle(maxC) M = cv.moments(maxC) center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) if radius > RADIUS: cv.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) cv.circle(frame, center, 5, (0, 0, 255), -1) global frame_count_up frame_count_up = frame_count_up + 1 frame = cv.flip(frame, 1) cv.imshow('Frame', frame)
Mask = cv2.inRange(hsv, Lower_hsv, Upper_hsv) Mask = cv2.erode(Mask, kernel, iterations=1) Mask = cv2.morphologyEx(Mask, cv2.MORPH_OPEN, kernel) Mask = cv2.dilate(Mask, kernel, iterations=1) # Find contours for the pointer after idetifying it cnts,_ = cv2.findContours(Mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) center = None # Ifthe contours are formed if len(cnts) > 0: # sorting the contours to find biggest cnt = sorted(cnts, key = cv2.contourArea, reverse = True)[0] # Get the radius of the enclosing circle around the found contour ((x, y), radius) = cv2.minEnclosingCircle(cnt) # Draw the circle around the contour cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) # Calculating the center of the detected contour M = cv2.moments(cnt) center = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00'])) # Now checking if the user wants to click on any button above the screen if center[1] <= 65: if 40 <= center[0] <= 140: # Clear Button bpoints = [deque(maxlen=512)] gpoints = [deque(maxlen=512)] rpoints = [deque(maxlen=512)] ypoints = [deque(maxlen=512)] blue_index = 0
def Identificar_objeto(c, crop_img_contour, img): #logica para processar os dados de cada contorno encontrado # id do objeto i = 0 tabela = [] for cnt in c: (x, y), _ = cv2.minEnclosingCircle( cnt) #função que ajuda a descobrir o centro do objeto center = (int(x), int(y)) cv2.putText(crop_img_contour, str(i), center, cv2.FONT_HERSHEY_SIMPLEX, 3, (255, 255, 255), 8, cv2.LINE_AA) #escreve o Id do objeto no centro box = [] rect = cv2.minAreaRect( cnt) #acha os pontos do retangulo q vai delimitar o objeto box_float = cv2.boxPoints(rect) box = np.int0(box_float) #conversão para manipulação #modo como o openCV numera os vértices ###3### #2###4# ###1## cv2.drawContours(crop_img_contour, [box], 0, (225, 0, 255), 2) #desenhar o retangulo #distancias entres os pontos pra saber qual o melhor lado pra pegar # distancia 0 garra anti horaria # distancia 1 garra horaria distancia_0 = math.sqrt((box[0][0] - box[1][0])**2 + (box[0][1] - box[1][1])**2) distancia_1 = math.sqrt((box[0][0] - box[3][0])**2 + (box[0][1] - box[3][1])**2) #delimitador de tamanho max de face limite = 300 if ((distancia_0 > limite) and (distancia_1 > limite)): cv2.putText(crop_img_contour, "IMPOSSIVEL", center, cv2.FONT_HERSHEY_SIMPLEX, 3, (0, 0, 255), 8, cv2.LINE_AA) else: #escolher a face de menor tamanho, pq uma delas pode ser fora do limite permitido (maior que a garra) #lógica para converter ângulo em ãngulo_braco (a logica muda de acordo com o sentido de giro)... o braço entende de -90 a 90 if (distancia_0 > distancia_1): angulo = Angulo(box[0], box[3], center, img) angulo_braco = math.fabs(angulo) - 90 angulo_braco = round(angulo_braco, 2) else: angulo = Angulo(box[0], box[1], center, img) angulo_braco = 90 - angulo angulo_braco = round(angulo_braco, 2) #para evitar angulos grandes e o braço girar mais do que deve. Essa logica inverte a face que o braço vai pegar if angulo_braco > 90: angulo_braco = angulo_braco - 180 if angulo_braco < -90: angulo_braco = angulo_braco + 180 #converter de pixls (x e y) para dados reais (braço) centro_conv_X, centro_conv_Y = Conversao_centro(center) #correção necessário, pois o ponto de giro não é fixo... lógica desenvolvida por mapeamento e obtenção de padrão de erro if angulo_braco < 0: centro_conv_X = centro_conv_X + (0.1625 * angulo_braco) centro_conv_X = round(centro_conv_X, 3) #organizar para alimentar o dataframe objeto = [] objeto.append(i) objeto.append(centro_conv_X) objeto.append(centro_conv_Y) objeto.append(angulo_braco) tabela.append(objeto) i += 1 return crop_img_contour, tabela
#encontra contornos na mascara e inicializa #(x, y) contornos = cv.findContours(mascara.copy(), cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)[-2] centro = None centroC = None centroF = None #continua apenas se foi encontrado um contorno if len(contornos) > 0: #encontra maior contorno na mascara, e usa para #computar circundacao minima e ponto centro c = max(contornos, key=cv.contourArea) ((x, y), raio) = cv.minEnclosingCircle(c) M = cv.moments(c) centro = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) #procede apenas se raio tiver um tamanho minimo if raio > 10: #Desenha circulo e centroide no frame #Atualiza a lista de pontos rastreados cv.circle(frame, (int(x), int(y)), int(raio), (0, 255, 255), 2) cv.circle(frame, centro, 5, (0, 0, 255), -1) #atualiza fila de pontos pontos.appendleft(centro) #percorre setn de pontos e, havendo, s=desenha linha
def steerPoint(): bpoints = [deque(maxlen=1024)] gpoints = [deque(maxlen=1024)] rpoints = [deque(maxlen=1024)] ypoints = [deque(maxlen=1024)] #assigning index values blue_index = 0 green_index = 0 red_index = 0 yellow_index = 0 kernel = np.ones((5, 5), np.uint8) colors = [(255, 0, 0), (0, 255, 0), (0, 0, 255), (0, 255, 255)] colorIndex = 0 #starting the painting window setup paintWindow = np.zeros((471, 636, 3)) + 255 paintWindow = cv2.circle(paintWindow, (75, 45), 25, (0, 0, 0), 2) paintWindow = cv2.circle(paintWindow, (225, 45), 20, colors[0], -1) paintWindow = cv2.circle(paintWindow, (280, 45), 20, colors[1], -1) paintWindow = cv2.circle(paintWindow, (335, 45), 20, colors[2], -1) paintWindow = cv2.circle(paintWindow, (390, 45), 20, colors[3], -1) cv2.putText(paintWindow, "CLEAR", (55, 50), cv2.FONT_HERSHEY_DUPLEX, 0.4, (0, 0, 0), 1, cv2.LINE_AA) cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() #Flipping the frame just for convenience frame = cv2.flip(frame, 1) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) #HSV value for blue object u_hue = 153 u_saturation = 255 u_value = 255 l_hue = 64 l_saturation = 72 l_value = 49 Upper_hsv = np.array([u_hue, u_saturation, u_value]) Lower_hsv = np.array([l_hue, l_saturation, l_value]) #detect the object and remove background environment mask = cv2.inRange(hsv, Lower_hsv, Upper_hsv) mask = cv2.erode(mask, kernel, iterations=1) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) mask = cv2.dilate(mask, kernel, iterations=1) cnts, _ = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) center = None # Ifthe contours(boundry detection of the object) are formed if len(cnts) > 0: # sorting the contours to find biggest contour cnt = sorted(cnts, key=cv2.contourArea, reverse=True)[0] # Get the radius of the enclosing circle around the found contour ((x, y), radius) = cv2.minEnclosingCircle(cnt) # Draw the circle around the contour cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) # Calculating the center of the detected contour M = cv2.moments(cnt) center = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00'])) #checking if any button above the screen is clicked/cursor hovered to if center[1] <= 80: if 75 <= center[0] <= 125: # Clear Button bpoints = [deque(maxlen=512)] gpoints = [deque(maxlen=512)] rpoints = [deque(maxlen=512)] ypoints = [deque(maxlen=512)] blue_index = 0 green_index = 0 red_index = 0 yellow_index = 0 paintWindow[78:, :, :] = 255 elif 225 <= center[0] <= 265: colorIndex = 0 # Blue elif 280 <= center[0] <= 320: colorIndex = 1 # Green elif 335 <= center[0] <= 375: colorIndex = 2 # Red elif 390 <= center[0] <= 430: colorIndex = 3 # Yellow else: if colorIndex == 0: bpoints[blue_index].appendleft(center) elif colorIndex == 1: gpoints[green_index].appendleft(center) elif colorIndex == 2: rpoints[red_index].appendleft(center) elif colorIndex == 3: ypoints[yellow_index].appendleft(center) else: bpoints.append(deque(maxlen=512)) blue_index += 1 gpoints.append(deque(maxlen=512)) green_index += 1 rpoints.append(deque(maxlen=512)) red_index += 1 ypoints.append(deque(maxlen=512)) yellow_index += 1 points = [bpoints, gpoints, rpoints, ypoints] #draw on the whiteboard with the color selected for i in range(len(points)): for j in range(len(points[i])): for k in range(1, len(points[i][j])): if points[i][j][k - 1] is None or points[i][j][k] is None: continue cv2.line(frame, points[i][j][k - 1], points[i][j][k], colors[i], 2, cv2.LINE_AA) cv2.line(paintWindow, points[i][j][k - 1], points[i][j][k], colors[i], 2, cv2.LINE_AA) #convert frame into jpg format ret, jpeg = cv2.imencode('.jpg', paintWindow) #For saving whiteboard as image if keyboard.is_pressed('s'): file_name = "Trace_Image_" + time.strftime('%Y%m%d%H%M%S') + ".jpg" cv2.imwrite(file_name, paintWindow) #return frames in form of image yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + jpeg.tobytes() + b'\r\n')
def detectFilament(c_img): # contours = sorted(contours, key=cv2.contourArea, reverse=True)[:10] ret, th = cv2.threshold(c_img, 5, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) contours_thresh, hierarchy_tresh = cv2.findContours( th.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) mask = np.zeros_like(c_img) cv2.drawContours(mask, contours_thresh, -1, 255, -1) #black out the cell c_img_masked = cv2.bitwise_and(c_img, c_img, mask=mask) c_img_masked_not = cv2.bitwise_not(c_img_masked.copy(), c_img_masked.copy()) ##cv2.imshow('Output', c_img) #SHOW THE RAW PICTURE ##cv2.waitKey(0) #kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (4,4)) c_img_masked_dilate = cv2.dilate(c_img_masked_not, np.ones((11, 11)), 2) c_img_masked_dilate_not = cv2.bitwise_not(c_img_masked_dilate.copy(), c_img_masked_dilate.copy()) #dilate = cv2.dilate(c_img_masked, kernel, iterations=5) #blur_mask = cv2.GaussianBlur(c_img_masked,(5,5),0) edges = cv2.Canny(c_img_masked, 40, 200) c_img_masked = cv2.bitwise_and(edges, c_img_masked_dilate_not.copy()) ret2, th2 = cv2.threshold(c_img_masked, 30, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) contours, hierarchy = cv2.findContours(th2.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) for c in contours: area = cv2.contourArea(c) # Fill very small contours with zero (erase small contours). if area < 10: cv2.fillPoly(th2, pts=[c], color=0) continue #th2 = cv2.morphologyEx(th2, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10,10))); #this one actually closes the filaments individually th2 = cv2.morphologyEx( th2, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (20, 20))) ##close the filaments to get an area contours_isolated, hierarchy_isolated = cv2.findContours( th2, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) if (len(contours_isolated)) > 0: cnt = max(contours_isolated, key=cv2.contourArea) (x, y), radius = cv2.minEnclosingCircle(cnt) center = (int(x), int(y)) radius = int(radius) cv2.circle(th2, center, radius, 255, 2) # print("we have: ",len(contours)) cv2.drawContours(c_img_masked, contours_isolated, -1, 255, 3) #contour our actual filament # cv2.imshow('Output', c_img_masked) # cv2.waitKey(0) return contours_isolated #returns the contour of the actual filament
def callback(self, data): lower_grey = np.array([0, 0, 46]) upper_grey = np.array([180, 43, 220]) try: cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8") except CvBridgeError as e: print e # cv2.imshow("camera_raw", cv_image) # cv2.waitKey(3) # Guess Processing blurred = cv2.GaussianBlur(cv_image, (11, 11), 0) # cv2.imshow("blurred", blurred) # bgr to hsv hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) # clear everything except the target mask = cv2.inRange(hsv, lower_grey, upper_grey) # cv2.imshow("hsv_raw", mask) # lvbo mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, None, iterations=2) # show the ball in 2 bits pic cv2.bitwise_not(mask, mask) cv2.imshow("not mask", mask) cv2.waitKey(3) cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] self.findball = len(cnts) if self.findball: c = max(cnts, key = cv2.contourArea) ((x, y), radius) = cv2.minEnclosingCircle(c) M = cv2.moments(c) try: center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) self.ball_center = center self.x_diff = self.ball_center[0] - 399 self.y_diff = self.ball_center[1] - 500 if self.y_diff > -20: self.y_diff = 0 if self.x_diff < 10 and self.x_diff > -10: self.x_diff = 0 if radius > 35: radius = 0 else : radius = 1 self.linear_speed = radius * 0.2 self.angular_speed = - self.signal(self.x_diff) * 0.1 # print radius except: pass else: self.linear_speed = 0 self.angular_speed = 0.2
# cv_show('gray', gray) # 自适应阈值图 ret, res = cv.threshold(gray, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU) # cv_show('res', res) # 寻找轮廓 ret, contours, hie = cv.findContours(res, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) # 排序轮廓 cnts = sorted(contours, key=cv.contourArea, reverse=True)[:5] cnt = cnts[0] # 获取矩形参数 x, y, w, h = cv.boundingRect(cnt) # 绘制矩形 img1 = cv.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2) # 获取最小外切圆 (x, y), radius = cv.minEnclosingCircle(cnt) # 绘制圆形 img2 = cv.circle(img, (int(x), int(y)), int(radius), (0, 255, 0), 2) cv_show('img', img) cv.imwrite('result.jpg', img) print("矩形中心点:") print((float((x + w) / 2), float(y + h) / 2)) print("\n圆形圆心:") print((x, y)) # 矩形四个极点 leftTop = tuple(cnt[cnt[:, :, 0].argmin()][0]) righTop = tuple(cnt[cnt[:, :, 0].argmax()][0]) upTop = tuple(cnt[cnt[:, :, 1].argmin()][0]) downTop = tuple(cnt[cnt[:, :, 1].argmax()][0])
cv2.contourArea() The function computes a contour area. Similarly to moments , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels. Also, the function will most certainly give a wrong results for contours with self-intersections. ''' print('Периметр контура внешней окружности: ' + str(cv2.arcLength(outside, True))) print('Площадь контура внешней окружности: ' + str(cv2.contourArea(outside))) # Получим координаты внешнего ограничивающего прямоугольника: x, y, w, h = cv2.boundingRect(outside) # Нарисуем внешний огр.прямоугольник: cv2.rectangle(circle, (x, y), (x + w, y + h), (0, 255, 0), 2) print('Площадь внешнего ограничивающего прямоугольника: ' + str(w * h)) # Получим координаты внешней описанной окружности: (x, y), radius = cv2.minEnclosingCircle(outside) center = (int(x), int(y)) radius = int(radius) # Нарисуем внешнюю ограничивающую окружность: cv2.circle(circle, center, radius, (0, 0, 255), thickness=2) print('Площадь внешней ограничивающей окружности: ' + str(pi * (radius**2)) + '\n') print('Периметр контура внутренней окружности: ' + str(cv2.arcLength(inside, True))) print('Площадь контура внутренней окружности: ' + str(cv2.contourArea(inside))) # Получим координаты внутреннего ограничивающего прямоугольника: x, y, w, h = cv2.boundingRect(inside) # Нарисуем внутренний огр.прямоугольник: cv2.rectangle(circle, (x, y), (x + w, y + h), (133, 21, 199), 2) print('Площадь внутреннего ограничивающего прямоугольника: ' + str(w * h))
cv.CHAIN_APPROX_SIMPLE)[-2] center = None if key == 'magenta': pag.click() elif key == 'anil': break # only proceed if at least one contour was found if len(cnts) > 0: # find the largest contour in the mask, then use # it to compute the minimum enclosing circle and # centroid c = max(cnts, key=cv.contourArea) ((x, y), radius) = cv.minEnclosingCircle(c) M = cv.moments(c) center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) # only proceed if the radius meets a minimum size. Correct this value for your obect's size if radius > 0.5: # draw the circle and centroid on the frame, # then update the list of tracked points cv.circle(frame, (int(x), int(y)), int(radius), colors[key], 2) pag.moveTo(x = (center[0] - 10), y=(center[1] - 10)) #cv.putText(frame,key + " ball", (int(x-radius),int(y-radius)), cv2.FONT_HERSHEY_SIMPLEX, 0.6,colors[key],2) #Mostra imagem na linha
def main(): cap = cv2.VideoCapture(0) # define range of blue color in HSV lower_blue = np.array([110,50,50]) upper_blue = np.array([130,255,255]) pts = deque(maxlen=512) blackboard = np.zeros((480, 640, 3), dtype=np.uint8) digit = np.zeros((200, 200, 3), dtype=np.uint8) results = "" while cap.isOpened(): ret, img = cap.read() img = cv2.flip(img, 1) hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) kernel = np.ones((5, 5), np.uint8) mask = cv2.inRange(hsv, lower_blue, upper_blue) mask = cv2.erode(mask, kernel, iterations=2) mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel) mask = cv2.dilate(mask, kernel, iterations=1) res = cv2.bitwise_and(img, img, mask=mask) cnts, heir = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2:] center = None if len(cnts) >= 1: cnt = max(cnts, key=cv2.contourArea) if cv2.contourArea(cnt) > 200: ((x, y), radius) = cv2.minEnclosingCircle(cnt) cv2.circle(img, (int(x), int(y)), int(radius), (0, 255, 255), 2) cv2.circle(img, center, 5, (0, 0, 255), -1) M = cv2.moments(cnt) center = (int(M['m10'] / M['m00']), int(M['m01'] / M['m00'])) pts.appendleft(center) for i in range(1, len(pts)): if pts[i - 1] is None or pts[i] is None: continue cv2.line(blackboard, pts[i - 1], pts[i], (255, 255, 255), 7) cv2.line(img, pts[i - 1], pts[i], (0, 0, 255), 2) elif len(cnts) == 0: if len(pts) != []: blackboard_gray = cv2.cvtColor(blackboard, cv2.COLOR_BGR2GRAY) blur1 = cv2.medianBlur(blackboard_gray, 15) blur1 = cv2.GaussianBlur(blur1, (5, 5), 0) thresh1 = cv2.threshold(blur1, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1] blackboard_cnts = cv2.findContours(thresh1.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)[1] if len(blackboard_cnts) >= 1: cnt = max(blackboard_cnts, key=cv2.contourArea) print(cv2.contourArea(cnt)) if cv2.contourArea(cnt) > 1000: x, y, w, h = cv2.boundingRect(cnt) digit = blackboard_gray[y:y + h, x:x + w] image_processed = process_image(digit) image_deep = model.predict(np.reshape(image_processed, (-1, 28, 28, 1))) results = np.argmax(image_deep, axis = 1) print(results) cv2.putText(img, "The Number Is : " + str(results), (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255 ,0, 0), 2) pts = deque(maxlen=512) blackboard = np.zeros((480, 640, 3), dtype=np.uint8) cv2.imshow("Main Frame", img) k = cv2.waitKey(10) if k == 27: break
def detect_squares(frame): global crop_image, mask, dilate_kernel, squares gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) black = gray.copy() black[:] = 0 test = black.copy() # gray = cv2.adaptiveThreshold(gray,255,cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY,11,1) edges = cv2.Canny(gray, 50, 220, apertureSize=3) edges = cv2.dilate(edges, dilate_kernel, iterations=1) squares = [] centroidSquare = Square() contours, hierarchy = cv2.findContours(edges, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) try: hierarchy = hierarchy[0] except: pass for ind in range(len(contours)): cnt = contours[ind] area = cv2.contourArea(cnt) perimeter = cv2.arcLength(cnt, False) approx = cv2.approxPolyDP(cnt, 0.1 * perimeter, True) if area > 150 and area < 3300 and perimeter < 200: if len(approx) == 4: # # Skip if this contour has a parent # if hierarchy[ind][3] == -1: # cv2.drawContours( # frame, [approx], -1, (255, 255, 0), thickness=-1) # continue cv2.drawContours(test, [approx], -1, (255), thickness=-1) ((x, y), radius) = cv2.minEnclosingCircle(cnt) # # OR # M = cv2.moments(cnt) # x = int(M['m10']/M['m00']) # y = int(M['m01']/M['m00']) # radius = 20 if (radius <= 0): radius = 1 squr = Square() squr.x = int(x) squr.y = int(y) squr.area = area squr.contour = cnt squr.approx = approx squr.radius = int(radius) squr.perimeter = perimeter squares.append(squr) # try: # clr = frame[squr.y, squr.x] # # Skip squares whose color we cant get (mostly center going out of the frame) # except: # continue # squr.color_name, squr.color = getNearestColor( # (int(clr[2]), int(clr[1]), int(clr[0]))) # center = (squr.x, squr.y) # # cv2.drawContours(black, [approx], -1, (255), thickness=-1) # cv2.circle(frame, center, int(radius), squr.color, -1) # cv2.putText(frame, squr.color_name, # center, # cv2.FONT_HERSHEY_SIMPLEX, # 1, # (255, 255, 0)) # Doing average for radius, area and x,y centroidSquare.x += x centroidSquare.y += y centroidSquare.area += area centroidSquare.radius += radius length = len(squares) if length > 0: # calc centeroid if squares are detected centroidSquare.x = int(centroidSquare.x / length) centroidSquare.y = int(centroidSquare.y / length) # This should not work as its not linear centroidSquare.area = int(centroidSquare.area / length) centroidSquare.radius = int(centroidSquare.radius / length) squares = clean_squares(black, frame, centroidSquare, squares) opticalFlow(black, frame, squares) # Draw optical flow if mask is not None: frame = cv2.add(frame, mask) drawSquares(frame, squares) # Draw centroid #cv2.circle(frame, (centroidSquare.x, centroidSquare.y), # centroidSquare.radius, (255, 255, 255), 1) # print(len(contours)) cv2.imshow('black', black) cv2.imshow('Out', frame) cv2.imshow('test', test)
def find_candidate_targets(frame): global queue_frames _frame = frame # Blur the frame to remove noise if _is_blur: _frame = cv2.medianBlur(_frame, _blur_kernalsize) # Convert frame from RGB color space to HSV color base frame_hsv = cv2.cvtColor(_frame, cv2.COLOR_BGR2HSV) # Define the boundary of target color in HSV color space # Infrared light appear white-ish in frame mask = cv2.inRange(frame_hsv, lower_boundary, upper_boundary) # Eroded the frmae if _is_erode: mask = cv2.erode(mask, None, iterations=_erode_iterations) # Dilate the frame if _is_dilate: mask = cv2.dilate(mask, None, iterations=_dilate_iterations) put_frame(mask) feedback_frame = get_feedback_frame() # Find contours in the mask # contours: 輪廓 # cv2.RETR_EXTERNAL: only check the contours # cv2.CHAIN_APPROX_SIMPLE: only keep the coordinate value (x, y), ignore directional data contours = cv2.findContours(feedback_frame, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] # Convert the mask from gray-scale back to bgr for better support of showing in GUI feedback_frame = cv2.cvtColor(feedback_frame, cv2.COLOR_GRAY2BGR) # If there exists contour if len(contours) > 0: targets = [] # create Target object for each contours for contour in contours: # Form the minimum circle contain the above largest contour # Get x, y, and radius of largest contour ((x, y), radius) = cv2.minEnclosingCircle(contour) # only proceed if the radius meets a minimum size if radius > min_radius: # Calculate the centroid of largest contour and find its center m = cv2.moments(contour) m00 = m["m00"] # if m00 is 0, which will result in division by zero error later, just use original x and y will be good enough # e.g. if the contour shape is a balanced butterfly shape, m00 will highly likely be zero if m00 == 0: centroid_x = int(x) centroid_y = int(y) else: centroid_x = int(m["m10"] / m00) centroid_y = int(m["m01"] / m00) target = Target(x=centroid_x, y=centroid_y, radius=radius) targets.append(target) if len(targets) > 0: return { "result": True, "targets": targets, "pro_processing_frame": feedback_frame } return {"result": False, "pro_processing_frame": feedback_frame}
def overlay_images(overview_dl_fh, overview_ef_fh, zoom_fh, output_fh, circle=False, box=True, convex=False, debug=False): """ Overlay drop image in convex, circle or box shape on overview image from Rockimager @param overview_dl_fh: Overview drop location file path @param overview_ef_fh: Overview file path @param zoom_fh: Drop file path @param output_fh: Overlay output file path @param circle: bool, Shape circle cut out @param box: bool, Shape box overlay @param convex: bool, Shape convex cut out @param debug: Show images during processing @return: overlayed image """ # This is the main function of the script overview_dl = cv2.imread(overview_dl_fh) zoom = cv2.imread(zoom_fh) overview_ef = cv2.imread(overview_ef_fh) if debug: cv2.imshow("dl, ef, zoom Press Any Key to Close", np.concatenate([overview_dl, overview_ef, zoom])) cv2.imshow("dl, ef, zoom Press Any Key to Close", np.concatenate([overview_dl, overview_ef, zoom])) cv2.waitKey(0) dark_red = np.array([0, 2, 57]) light_red = np.array([69, 92, 255]) b_x, b_y, b_w, b_h, img_is_normal_sized = get_drop_location_box(overview_dl, dark_red, light_red, debug=debug) if debug: print("b_x, b_y, b_w, b_h, img_is_normal_sized", b_x, b_y, b_w, b_h, img_is_normal_sized) if img_is_normal_sized: if circle or convex: # convert drop image to grey image zoom_grey = cv2.cvtColor(zoom, cv2.COLOR_RGB2GRAY) # invert image make dark pixels brighter (edge of drop) _, zoom_grey = cv2.threshold(zoom_grey, 175, 255, cv2.THRESH_BINARY_INV) # blur the image (fill gaps, reduce noise) zoom_blur_grey = cv2.GaussianBlur(zoom_grey, (5, 5), 0) # (make mask) high contrast dark black and bright white color _, zoom_sharp_grey = cv2.threshold(zoom_blur_grey, 0, 255, cv2.THRESH_BINARY_INV) # find edges of mask edges = cv2.Canny(zoom_sharp_grey, 0, 255) # find contour points of mask cnts, hierarchy, _, _, _ = find_image_features(edges, mask_color=False, percent_arc_length=0.01, bilateral=False, contour_method=cv2.CHAIN_APPROX_NONE, retreival_method=cv2.RETR_TREE) # create blank image for masking drop image black_white_mask = np.zeros((zoom_grey.shape[0], zoom_grey.shape[1]), np.uint8) if circle: cnt = find_biggest_contour(image=zoom, contours=cnts, max_area=zoom.shape[0] * zoom.shape[1]) (circle_x, circle_y), radius = cv2.minEnclosingCircle(cnt) (circle_x, circle_y, radius) = (int(circle_x), int(circle_y), int(radius)) circle_mask = np.zeros((zoom_grey.shape[0], zoom_grey.shape[1]), np.uint8) cv2.circle(circle_mask, (circle_x, circle_y), radius, COLOR_WHITE, -1) overview_ef = align_drop_to_overview(b_x, b_y, b_w, b_h, zoom, overview_ef, circle_mask, debug=debug) elif convex: # make convex shapes that fit biggest contour point set hull = [] for i in range(len(cnts)): hull.append(cv2.convexHull(cnts[i], False)) # draw them on a mask for i in range(len(hull)): cv2.drawContours(black_white_mask, hull, i, COLOR_WHITE, -1, 8) # find contours of that mask (adds some smoothing) cnts_mask, hierarchy_mask, _, _, _ = find_image_features(black_white_mask, mask_color=False, percent_arc_length=3, retreival_method=cv2.RETR_TREE, bilateral=False, blur_image=True, blur_iterations=30) # create final convex shape mask black_white_mask_2 = np.zeros((zoom_grey.shape[0], zoom_grey.shape[1]), np.uint8) # make convex shapes that fit biggest contour point set hull = [] for i in range(len(cnts_mask)): hull.append(cv2.convexHull(cnts_mask[i], False)) # draw them on a mask for i in range(len(hull)): cv2.drawContours(black_white_mask_2, hull, i, COLOR_WHITE, -1, 8) overview_ef = align_drop_to_overview(b_x, b_y, b_w, b_h, zoom, overview_ef, black_white_mask_2, debug=debug) elif box: overview_ef = align_drop_to_overview(b_x, b_y, b_w, b_h, zoom, overview_ef, debug=debug) elif box: overview_ef = align_drop_to_overview(b_x, b_y, b_w, b_h, zoom, overview_ef, debug=debug) else: overview_ef = overview_ef cv2.imwrite(output_fh, overview_ef) return overview_ef
contornosF = cv.findContours(mascaraFecha.copy(), cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE) #encontra contornos na mascara e inicializa #(x, y) contornos = cv.findContours(mascara.copy(), cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)[-2] centro = None #continua apenas se foi encontrado um contorno if len(contornos) > 0: #encontra maior contorno na mascara, e usa para #computar circundacao minima e ponto centro c = max(contornos, key=cv.contourArea) ((x, y), raio) = cv.minEnclosingCircle(c) M = cv.moments(c) centro = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) #procede apenas se raio tiver um tamanho minimo if raio > 10: #Desenha circulo e centroide no frame #Atualiza a lista de pontos rastreados cv.circle(frame, (int(x), int(y)), int(raio), (0, 255, 255), 2) cv.circle(frame, centro, 5, (0, 0, 255), -1) #atualiza fila de pontos pontos.appendleft(centro) #percorre setn de pontos e, havendo, s=desenha linha
def gameControllerFunction(topLeft, centerLeft, bottomLeft, topCenter, middle, bottomCenter, topRight, centerRight, bottomRight): print("Booting the Video stream,") vs = cv2.VideoCapture(0) # start the video stream. time.sleep(2.0) # set sleep time to 2.0 seconds while True: frame = vs.read() # Read off the frame from the video stream ret, frame = frame # Use this if you want to load in your video output = "None" key = None if frame is None: # If there is no frame, save my pc from going through any stress at all break # otherwise, if we have a frame, we proceed with the following code # so much easier than open cv, keeping aspect ratio intact frame = imutils.resize(frame, width=700) # i want the mirror view, it's very helpful especially if i'm streaming frame = cv2.flip(frame, 1) windowDetails = cv2.getWindowImageRect('frame') # print(windowDetails) totalWidth = windowDetails[2] totalHeight = windowDetails[3] verLine1 = { 'start': (totalWidth//3, 0), 'end': (totalWidth//3, totalHeight) } verLine2 = { 'start': (totalWidth//3 * 2, 0), 'end': (totalWidth//3 * 2, totalHeight) } horLine1 = { 'start': (0, totalHeight//3), 'end': (totalWidth, totalHeight//3) } horLine2 = { 'start': (0, totalHeight//3 * 2), 'end': (totalWidth, totalHeight//3 * 2) } # processing the frame # blurr helps to reduce high frequency noise, definately helps model blurred = cv2.GaussianBlur(frame, (11, 11), 0) # convert my color to the HSV format hsv = cv2.cvtColor(blurred, cv2.COLOR_BGR2HSV) # Create a mask # mask other regions except colors in range of upper to lower (thresholding) mask = cv2.inRange(hsv, lower_color_boundary, upper_color_boundary) # Reduce noise caused by thresholding mask = cv2.erode(mask, None, iterations=2) # foreground the found object i.e futher reduce noise. mask = cv2.dilate(mask, None, iterations=2) contours = cv2.findContours( mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # find contours # Grab the contours using imutils contours = imutils.grab_contours(contours) center = None # center is initially set to none if len(contours) > 0: # if the contours list is not empty proceed # select contour with maximum Area, most likely our object contour = max(contours, key=cv2.contourArea) # pick up co-ordinates for drawing a circle around the object ((x, y), radius) = cv2.minEnclosingCircle(contour) M = cv2.moments(contour) # Extract moments from the contour. # Obtain the centre of mass of the object. center = (int(M["m10"] / M["m00"]), int(M["m01"] / M["m00"])) if radius > 10: # if we have a reasonable radius for the proposed object detected # Draw a circle to bound the Object cv2.circle(frame, (int(x), int(y)), int(radius), (0, 255, 255), 2) # Draw a filled in dot at the centre of the circle cv2.circle(frame, center, 5, (0, 0, 225), -1) if center: if center[0] <= totalWidth//3: if center[1] <= totalHeight//3: output = "Top Left" key = topLeft elif center[1] >= totalHeight//3*2: output = "Bottom Left" key = bottomLeft else: output = "Center Left" key = centerLeft elif center[0] >= totalWidth//3*2: if center[1] <= totalHeight//3: output = "Top Right" key = topRight elif center[1] >= totalHeight//3*2: output = "Bottom Right" key = bottomRight else: output = "Center Right" key = centerRight else: if center[1] <= totalHeight//3: output = "Top Center" key = topCenter elif center[1] >= totalHeight//3*2: output = "Bottom Center" key = bottomCenter else: output = "Center" key = middle if key: key_arr = key.split('+') # Key Presses for k in key_arr: pyautogui.keyDown(k.strip()) time.sleep(0.08) for k in key_arr: pyautogui.keyUp(k.strip()) # Drawing the grid cv2.putText(frame, output, (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2, cv2.LINE_4) cv2.line(frame, verLine1['start'], verLine1['end'], (255, 255, 255), 5) cv2.line(frame, verLine2['start'], verLine2['end'], (255, 255, 255), 5) cv2.line(frame, horLine1['start'], horLine1['end'], (255, 255, 255), 5) cv2.line(frame, horLine2['start'], horLine2['end'], (255, 255, 255), 5) cv2.imshow("frame", frame) # let's see the frame X frame # Closing a video frame key = cv2.waitKey(1) # wait for the cv key if key == ord("q"): # If the x button is pressed break # Break from the loop vs.release() # Let opencv release the video loader cv2.destroyAllWindows() # Destroy all windows to close it