def draw_walls(self): left_wall_points = np.array([self.transform(point) for point in self.left_wall_points]) right_wall_points = np.array([self.transform(point) for point in self.right_wall_points]) rect = cv2.minAreaRect(left_wall_points[:, :2].astype(np.float32)) box = cv2.boxPoints(rect) box = np.int0(box) cv2.drawContours(self.grid, [box], 0, 128, -1) rect = cv2.minAreaRect(right_wall_points[:, :2].astype(np.float32)) box = cv2.boxPoints(rect) box = np.int0(box) cv2.drawContours(self.grid, [box], 0, 128, -1) # So I dont have to comment abunch of stuff out for debugging dont_display = True if dont_display: return # Bob Ross it up (just for display) left_f, right_f = self.transform(self.left_f), self.transform(self.right_f) left_b, right_b = self.transform(self.left_b), self.transform(self.right_b) boat = self.transform(self.boat_pos) target = self.transform(self.target) cv2.circle(self.grid, tuple(boat[:2].astype(np.int32)), 8, 255) cv2.circle(self.grid, tuple(target[:2].astype(np.int32)), 15, 255) cv2.circle(self.grid, tuple(self.transform(self.mid_point)[:2].astype(np.int32)), 5, 255) cv2.circle(self.grid, tuple(left_f[:2].astype(np.int32)), 10, 255) cv2.circle(self.grid, tuple(right_f[:2].astype(np.int32)), 10, 255) cv2.circle(self.grid, tuple(left_b[:2].astype(np.int32)), 3, 125) cv2.circle(self.grid, tuple(right_b[:2].astype(np.int32)), 3, 128) cv2.imshow("test", self.grid) cv2.waitKey(0)
def get_centroids (contours, frame): centres = [] if contours: for i in range(len(contours)): moments = cv2.moments(contours[i]) centres.append((int(moments['m10']/moments['m00']), int(moments['m01']/moments['m00']))) if i>0: dist = calculateDistance(centres[i-1][0],centres[i-1][1],centres[i][0],centres[i][1]) area=cv2.contourArea(contours[i]) prevarea=cv2.contourArea(contours[i-1]) if dist < 120: if area > prevarea: rect = cv2.minAreaRect(contours[i]) box = cv2.boxPoints(rect) box = np.int0(box) print(box) frame = cv2.drawContours(frame,[box],0,(0,0,255),2) else : rect = cv2.minAreaRect(contours[i-1]) box = cv2.boxPoints(rect) box = np.int0(box) print(box) frame = cv2.drawContours(frame,[box],0,(0,0,255),2) else: rect = cv2.minAreaRect(contours[i]) box = cv2.boxPoints(rect) box = np.int0(box) frame = cv2.drawContours(frame,[box],0,(0,0,255),2) print(box) return centres, frame
def applyForegroundExtractionMask_Square(self, img, mask, centroid, rotatedRect, marginAdjust): imgAnd = dicerfuncs.makeBinaryImageMaskForImg(mask) color = 255 rotatedRect2 = (rotatedRect[0], (rotatedRect[1][0] * marginAdjust, rotatedRect[1][1] * marginAdjust), rotatedRect[2]) boxpoints = cv2.boxPoints(rotatedRect2) boxpoints = boxpoints.astype(int) cv2.fillConvexPoly(imgAnd, boxpoints, color) mask = cv2.bitwise_and(imgAnd, mask) # mask crop image itself if (True): imgAnd = dicerfuncs.makeBinaryImageMaskForImg(mask) rotatedRect2 = (rotatedRect[0], (rotatedRect[1][0] * marginAdjust + 2, rotatedRect[1][1] * marginAdjust + 2), rotatedRect[2]) boxpoints = cv2.boxPoints(rotatedRect2) boxpoints = boxpoints.astype(int) cv2.fillConvexPoly(imgAnd, boxpoints, color) img = cv2.bitwise_and(imgAnd, img) # actually crop? Note:this causes problems i think because of size changes to shape params if (False): # now lets find where we can crop x, y, w, h = cv2.boundingRect(boxpoints) img = img[y:y + h, x:x + w] mask = mask[y:y + h, x:x + w] return (img, mask)
def processCam(cap): bx = -1 by = -1 # Capture frame-by-frame ret, frame = cap.read() # Our operations on the frame come here #gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) hsv = cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)#HSV #white led ring: 45,2,240 - 130,40,255 lower_lim = np.array([37,10,180])#80,23,235 upper_lim = np.array([106,63,255])#102,167,255 mask = cv2.inRange(hsv, lower_lim, upper_lim) img, contours, heirarchy = cv2.findContours(mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) img = cv2.inRange(hsv, lower_lim, upper_lim) img = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR) contours = findBigContours(contours) # find big contours #biggestContourIndex = findBiggestContour(contours) biggestContourIndex, secondBiggestIndex = findSecondBiggestContour(contours) #bigContours = findBigContours(contours) #biggestContourIndex = findBestAR(bigContours) if(len(contours) != 0): # find box around contour and it's center recta = cv2.minAreaRect(contours[biggestContourIndex]) rectb = cv2.minAreaRect(contours[secondBiggestIndex]) boxa = cv2.boxPoints(recta) boxb = cv2.boxPoints(rectb) rect = cv2.minAreaRect(np.concatenate([boxa,boxb])) box = cv2.boxPoints(rect) bx = int((box[0][0] + box[2][0])/2) by = int((box[0][1] + box[2][1])/2) #x,y,w,h = cv2.boundingRect(contours[biggestContourIndex]) #if(h != 0): # print("aspect ratio: " + str(h/float(w))) #print("center: " + str(bx) + ', ' + str(by)) box = np.int0(box) img = cv2.drawContours(img,[box],0,(0,0,255),1) img = cv2.circle(img,(bx,by),4,(0,255,255),-1) # find centroid from moments #M = cv2.moments(contours[biggestContourIndex]) #if(M['m00'] != 0): # cx = int(M['m10']/M['m00']) # cy = int(M['m01']/M['m00']) # img = cv2.circle(img,(cx,cy),4,(255,255,0),-1) #img = cv2.drawContours(img, contours, biggestContourIndex, (255,255,0), 3) #img = cv2.drawContours(img, contours, secondBiggestIndex, (255,0,0), 3) for i in range(len(contours)): col = cv2.contourArea(contours[i]) / 20 img = cv2.drawContours(img, contours, i, (0,255-col,col), 1) return img, bx, by
def callback(self,data): try: img = self.bridge.imgmsg_to_cv2(data, "bgr8") except CvBridgeError as e: print(e) #imageHSV = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) contours = ThreshAndContour(img, self.upper, self.lower) contours = contours[1] #output = cv2.bitwise_and(img, img, mask=mask) if len(contours) == 0: return None rects = [] #cv2.drawContours(img,contours,-1, (0,255,0), 3) for contour in contours: #adapted from https://github.com/opencv/opencv/blob/master/samples/python/squares.py epsilon = cv2.arcLength(contour, True)*0.05 contour = cv2.approxPolyDP(contour, epsilon, True) if len(contour) == 4 and cv2.isContourConvex(contour): contour = contour.reshape(-1, 2) max_cos = np.max([angle_cos( contour[i], contour[(i+1) % 4], contour[(i+2) % 4] ) for i in range(4)]) if max_cos < 0.1: rects.append(contour) if len(rects) > 1: rects = sorted(contours, key=cv2.contourArea, reverse=True) rect1 = cv2.minAreaRect(rects[0]) rect2 = cv2.minAreaRect(rects[1]) if(rect1[1][0] < rect1[1][1]): #Fix wonky angles from opencv (I think) rect1 = (rect1[0], rect1[1], (rect1[2] + 180) * 180/3.141) else: rect1 = (rect1[0], rect1[1], (rect1[2] + 90) * 180/3.141) if(rect2[1][0] < rect2[1][1]): rect2 = (rect2[0], rect2[1], (rect2[2] + 180) * 180/3.141) else: rect2 = (rect2[0], rect2[1], (rect2[2] + 90) * 180/3.141) box = cv2.boxPoints(rect1) box = np.int0(box) #cv2.drawContours(img,[box],-1,(0,0,255),2) box = cv2.boxPoints(rect2) box = np.int0(box) #cv2.drawContours(img,[box],-1,(0,0,255),2) gateLocation = None gateAxis = None gateAngle = None gateCenter = (int((rect1[0][0] + rect2[0][0])/2), int((rect1[0][1] + rect2[0][1])/2)) cv2.circle(img,gateCenter,5,(0,255,0),3) try: self.image_pub.publish(self.bridge.cv2_to_imgmsg(img,"bgr8")) except CvBridgeError as e: print(e)
def getTagImg(tag, rect, img): """ Extracts the image of the tag from the main image, and rotates it appropriately. """ bottom, left, top, right = cv2.boxPoints(rect) # drawCorners(bottom, left, top, right, imageTrack) try: if dist(left, top) < dist(left, bottom): pos_slope = False theta = math.atan((left[1] - bottom[1]) / (left[0] - bottom[0])) else: pos_slope = True theta = math.atan((right[1] - bottom[1]) / (right[0] - bottom[0])) except ZeroDivisionError: theta = math.atan(float('inf')) # slope is pi/2 height = dist(right, bottom) width = dist(right, top) if pos_slope: width, height = height, width f_center = rect[0][0], rect[0][1] return subimage(img, f_center, theta, width, height)
def update(self, frame): # print "updating %d " % self.id hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) back_project = cv2.calcBackProject([hsv],[0], self.roi_hist,[0,180],1) if args.get("algorithm") == "c": ret, self.track_window = cv2.CamShift(back_project, self.track_window, self.term_crit) pts = cv2.boxPoints(ret) pts = np.int0(pts) self.center = center(pts) cv2.polylines(frame,[pts],True, 255,1) if not args.get("algorithm") or args.get("algorithm") == "m": ret, self.track_window = cv2.meanShift(back_project, self.track_window, self.term_crit) x,y,w,h = self.track_window self.center = center([[x,y],[x+w, y],[x,y+h],[x+w, y+h]]) cv2.rectangle(frame, (x,y), (x+w, y+h), (255, 255, 0), 2) self.kalman.correct(self.center) prediction = self.kalman.predict() cv2.circle(frame, (int(prediction[0]), int(prediction[1])), 4, (255, 0, 0), -1) # fake shadow cv2.putText(frame, "ID: %d -> %s" % (self.id, self.center), (11, (self.id + 1) * 25 + 1), font, 0.6, (0, 0, 0), 1, cv2.LINE_AA) # actual info cv2.putText(frame, "ID: %d -> %s" % (self.id, self.center), (10, (self.id + 1) * 25), font, 0.6, (0, 255, 0), 1, cv2.LINE_AA)
def filter(seg,area,label): """ Apply the filter. The final list is ranked by area. """ good = label[area > TextRegions.minArea] area = area[area > TextRegions.minArea] filt,R = [],[] for idx,i in enumerate(good): mask = seg==i xs,ys = np.where(mask) coords = np.c_[xs,ys].astype('float32') rect = cv2.minAreaRect(coords) box = np.array(cv2.boxPoints(rect)) h,w,rot = TextRegions.get_hw(box,return_rot=True) f = (h > TextRegions.minHeight and w > TextRegions.minWidth and TextRegions.minAspect < w/h < TextRegions.maxAspect and area[idx]/w*h > TextRegions.pArea) filt.append(f) R.append(rot) # filter bad regions: filt = np.array(filt) area = area[filt] R = [R[i] for i in range(len(R)) if filt[i]] # sort the regions based on areas: aidx = np.argsort(-area) good = good[filt][aidx] R = [R[i] for i in aidx] filter_info = {'label':good, 'rot':R, 'area': area[aidx]} return filter_info
def get_filled_contours(img_path,min_rect_size = 30): filled_coordinates = [] img = cv2.imread(img_path) #Make it gray imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #reducing noise ret,thresh = cv2.threshold(imgray,127,255,0) _,contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) #hierarchy fix and skipping outer container hierarchy = hierarchy[0][1:] #the first one is always the outer container skipping it contours = contours[1:] for i,cnt in enumerate(contours): #[0] = next contour at the same hierarchical level #[1] = previous contour at the same hierarchical level #[2] = denotes its first child contour #[3] = denotes index of its parent contour child_index = hierarchy[i][2] isClosedShape = child_index != -1 if isClosedShape: # -1 because we skipped the outer contour firtstChildHierarchy = hierarchy[child_index-1] isFilled = firtstChildHierarchy[0]!=-1 if isFilled: #Finds the minimun area rectangle for the contour rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) width = box[3][0] - box[0][0] if width< min_rect_size: continue contour_list=list(map(lambda x: x[0], cnt)) if not is_boxy(contour_list): continue filled_coordinates.append(formatBox(box)) return filled_coordinates
def barcode_detect(img): image = img # load the image and convert it to grayscale gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) sobelgx = cv2.Sobel(gray,cv2.CV_64F,1,0,ksize=3) sobelgy = cv2.Sobel(gray,cv2.CV_64F,0,1,ksize=3) # subtract the y-gradient from the x-gradient gradient = sobelgx - sobelgy gradient = cv2.convertScaleAbs(gradient) # blur and threshold the image blurred = cv2.blur(gradient, (3, 3)) _, thresh = cv2.threshold(blurred, 225, 255, cv2.THRESH_BINARY) # construct a closing kernel and apply it to the thresholded image kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 7)) closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) # perform a series of erosions and dilations closed = cv2.erode(closed, None, iterations=4) closed = cv2.dilate(closed, None, iterations=4) # find the contours in the thresholded image, then sort the contours # by their area, keeping only the largest one (_, contours, _) = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) c = sorted(contours, key=cv2.contourArea, reverse=True)[0] # compute the rotated bounding box of the largest contour rect = cv2.minAreaRect(c) box = np.int0(cv2.boxPoints(rect)) return box
def get_motions(f, fMask, thickness=1, color=(170, 170, 170)): ''' Iterates over the contours in a mask and draws a bounding box around the ones that encompas an area greater than a threshold. This will return an image of just the draw bock (black bg), and also an array of the box points. ''' rects_mot = [] f_rects = np.zeros(f.shape, np.uint8) # get contours if imutils.is_cv3(): _, cnts, hierarchy = cv2.findContours( fMask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) elif imutils.is_cv2(): cnts, hierarchy = cv2.findContours( fMask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # loop over the contours for c in cnts: # if the contour is too small, ignore it if cv2.contourArea(c) < contourThresh: continue if imutils.is_cv3(): box = cv2.boxPoints(cv2.minAreaRect(c)) elif imutils.is_cv2(): box = cv2.cv.BoxPoints(cv2.minAreaRect(c)) box = np.int0(box) cv2.drawContours(f_rects, [box], 0, color, thickness) rects_mot.append(cv2.boundingRect(c)) return f_rects, rects_mot
def get_hp_bars(binary): _, contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: center, (height, width), angle = cv2.minAreaRect(cnt) if 2 < height < 4 and 5 < width < 80 and 89 < -angle < 91: box = cv2.boxPoints((center, (height, width), angle)) yield np.int0(box)
def show_boxes_in_img(img, boxes_and_label): ''' :param img: :param boxes: must be int :return: ''' boxes_and_label = boxes_and_label.astype(np.int64) img = np.array(img, np.float32) img = np.array(img*255/np.max(img), np.uint8) for box in boxes_and_label: x_c, y_c, w, h, theta, label = box[0], box[1], box[2], box[3], box[4], box[5] category = LABEl_NAME_MAP[label] color = (np.random.randint(255), np.random.randint(255), np.random.randint(255)) rect = ((x_c, y_c), (w, h), theta) rect = cv2.boxPoints(rect) rect = np.int0(rect) cv2.drawContours(img, [rect], -1, color, 3) cv2.putText(img, text=category, org=(x_c, y_c), fontFace=1, fontScale=1, color=(0, 0, 255)) cv2.imshow('img_', img) cv2.waitKey(0)
def run(self): while True: f, orig_img = self.capture.read() orig_img = cv2.flip(orig_img, 1) img = cv2.GaussianBlur(orig_img, (5,5), 0) img = cv2.cvtColor(orig_img, cv2.COLOR_BGR2HSV) img = cv2.resize(img, (len(orig_img[0]) / self.scale_down, len(orig_img) / self.scale_down)) red_lower = np.array([0, 150, 0],np.uint8) red_upper = np.array([5, 255, 255],np.uint8) red_binary = cv2.inRange(img, red_lower, red_upper) dilation = np.ones((15, 15), "uint8") red_binary = cv2.dilate(red_binary, dilation) image, contours, hierarchy = cv2.findContours(red_binary, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) max_area = 0 largest_contour = None for idx, contour in enumerate(contours): area = cv2.contourArea(contour) if area > max_area: max_area = area largest_contour = contour if not largest_contour == None: moment = cv2.moments(largest_contour) if moment["m00"] > 1000 / self.scale_down: rect = cv2.minAreaRect(largest_contour) rect = ((rect[0][0] * self.scale_down, rect[0][1] * self.scale_down), (rect[1][0] * self.scale_down, rect[1][1] * self.scale_down), rect[2]) box = cv2.boxPoints(rect) box = np.int0(box) cv2.drawContours(orig_img,[box], 0, (0, 0, 255), 2) cv2.imshow("ColourTrackerWindow", orig_img) if cv2.waitKey(20) == 27: cv2.destroyWindow("ColourTrackerWindow") self.capture.release() break
def findPlateNumberRegion(img): region = [] # 查找外框轮廓 contours_img, contours, hierarchy = cv2.findContours(img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) print("contours lenth is :%s" % (len(contours))) # 筛选面积小的 for i in range(len(contours)): cnt = contours[i] print('cnt=',cnt) #print(cnt) # 计算轮廓面积 area = cv2.contourArea(cnt) print('area=',area) # 面积小的忽略 if area < 2000: continue # 转换成对应的矩形(最小) rect = cv2.minAreaRect(cnt) print("rect is:%s" % {rect}) # 根据矩形转成box类型,并int化 box = np.int32(cv2.boxPoints(rect)) print('box=',box) # 计算高和宽 height = abs(box[0][1] - box[2][1]) width = abs(box[0][0] - box[2][0]) # 正常情况车牌长高比在2.7-5之间,那种两行的有可能小于2.5,这里不考虑 ratio = float(width) / float(height) if ratio > maxPlateRatio or ratio < minPlateRatio: continue # 符合条件,加入到轮廓集合 region.append(box) return region
def _get_magic_card_crop(original_image): scale_mult = 0.15 mat = cv2.resize(original_image, (0, 0), fx=scale_mult, fy=scale_mult) contour = _get_magic_card_contour(mat) # Obtain shape approximation card = contour[0] peri = cv2.arcLength(card, True) approx = cv2.approxPolyDP(card, 0.02 * peri, True) x, y, w, h = cv2.boundingRect(card) w /= scale_mult h /= scale_mult w = int(w) h = int(h) # Test to see if our approximation is a quadrilateral if len(approx) != 4: rect = rectify(cv2.boxPoints(cv2.minAreaRect(card))) else: # Great! We can safely apply our perspective correction technique rect = rectify(approx) for i in range(4): # Compute all 4 corners on original image (re-apply scaling) rect[i][0] /= scale_mult rect[i][1] /= scale_mult cv2.imwrite(os.path.join(LATEST_DIR, "steps_contours_bon.jpg"), original_image) # Output perspective correction to an image of about the same size output = np.array([[0, 0], [w-1, 0], [w-1, h-1], [0, h-1]], np.float32) transform = cv2.getPerspectiveTransform(rect, output) return cv2.warpPerspective(original_image, transform, (w, h))
def draw_window(frame): # setup initial location of window r,h,c,w = 250,90,400,125 # simply hardcoded the values track_window = (c,r,w,h) # set up the ROI for tracking roi = frame[r:r+h, c:c+w] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.))) roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180]) cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) # Setup the termination criteria, either 10 iteration or move by atleast 1 pt term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1) # apply meanshift to get the new location ret, track_window = cv2.CamShift(dst, track_window, term_crit) # Draw it on image pts = cv2.boxPoints(ret) pts = np.int0(pts) img2 = cv2.polylines(frame,[pts],True, 255,2) io.imshow(img2)
def convex_corners_cross(pil_img, show_plot=False): mask_img = alpha_fill(pil_img) _,contours,_ = cv2.findContours(mask_img,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) contour = contours[0] rect = cv2.minAreaRect(contour) box = cv2.boxPoints(rect) box = numpy.int0(box) hull = cv2.convexHull(contour,returnPoints = False) print(hull) defects = cv2.convexityDefects(contour,box) mask_img = cv2.cvtColor(mask_img, cv2.COLOR_GRAY2RGB) for i in range(defects.shape[0]): s,e,f,d = defects[i,0] start = tuple(contour[s][0]) end = tuple(contour[e][0]) far = tuple(contour[f][0]) cv2.line(mask_img,start,end,[0,255,0],2) cv2.circle(mask_img,far,5,[0,0,255],-1) cv2.imshow('img',mask_img) cv2.waitKey(0) cv2.destroyAllWindows()
def crop_cardboard_old(image): """ :param image: A numpy array representing the full scanned document extracted from the RAW file :return: A subsection of the document representing the cardboard only """ ratio = image.shape[0] / RESIZE_HEIGHT orig = image.copy() image = cv2.resize(image, (int(image.shape[1] / ratio), int(RESIZE_HEIGHT))) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) (_, contours, _) = cv2.findContours(thresh.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) max_area = 0 max_box = None for contour in contours: rect = cv2.minAreaRect(contour) (_, (w, h), _) = rect area = w * h if area > max_area: max_area = area max_box = cv2.boxPoints(rect) max_box = max_box.astype(np.int) cardboard = utils.crop_rectangle_warp(orig, max_box.reshape(4, 2), ratio) return cardboard
def createImage(image_contour, image, counter): rectangle = cv2.minAreaRect(image_contour) boxed = cv2.boxPoints(rectangle) boxed = np.int0(boxed) print(boxed) print("----------------") mins = (np.amin(boxed, axis=0)) max = (np.amax(boxed, axis=0)) """ print(mins[0]) print(mins[1]) print(mins[0],max[0], mins[1],max[0], mins[0],max[1], mins[1],max[1],) """ width = max[0] - mins[0] height = max[1] - mins[1] print('-------------') print(width, height) if (width > 10) & (height > 10): cropped_image = image[mins[1]:mins[1]+height, mins[0]:mins[0]+width] counter += 1 print(counter) """ try: displayImage(cropped_image) except: print('odd nematode') """ return counter
def do_camshift(vec=0): global frame, roiBox # convert the current frame to the HSV color space and perform mean shift hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1) # apply cam shift to the back projection, convert the points to a bounding box, and then draw them (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.boxPoints(r)) cv2.polylines(frame, [pts], True, (0,255,0), 2) centerScr = get_centerScreen(frame) x = centerScr[0] y = centerScr[1] # print "+" in the center of screen cv2.line(frame,(x,y-10),(x,y+10),(0,0,255),2) # print line cv2.line(frame,(x-10,y),(x+10,y),(0,0,255),2) # print line # cv2.line(frame,(x,y),(x+80,y),(0,255,0),2) # print line centerRoi = get_centerRoi(pts) x = centerRoi[0] y = centerRoi[1] # print "+" in the center of ROI cv2.line(frame,(x,y-10),(x,y+10),(0,255,0),2) # print line cv2.line(frame,(x-10,y),(x+10,y),(0,255,0),2) # print line gimbel_move(pts,frame,vec) lineRoiTocenter(centerRoi,centerScr) print_data(vec) tragetAcquired(pts)
def get_rotated_rec(cnt): rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) angle_of_rotation = rect[2] box = np.int0(box) return box, angle_of_rotation
def detect_landmark(color_min, color_max): # Algorithm To Detect the Contour # implemented here # Find the Landmark wrt to Color mask = detect_in_range(color_min, color_max) # Find the Contour to Estimate the bounding box (for pixel estimation) # cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2] _, cnts, hierarchy = cv2.findContours(mask.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # Cannot Find Contour => Bye GG if len(cnts) == 0: return 0, 0, 0, 0 # Find Max cnt = max(cnts, key=cv2.contourArea) # Normal Bounding Box [OpenCV 2.4.X] # xx, yy, ww, hh = cv2.boundingRect(cnt) # Rotating Box [OpenCV 3+] rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) box = np.int0(box) return box
def frame_track(self, cur_frame): vis = cur_frame.copy() hsv = cv2.cvtColor(cur_frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.))) prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1) prob &= mask term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) # get rotated bounding box track_box, self.track_window = cv2.CamShift(prob, self.track_window, term_crit) # get bounding box track_rect_rotate = cv2.boxPoints(track_box) # get rectangle track_rect = cv2.boundingRect(track_rect_rotate) # store them in yaml compatible format track_rect_yaml=track_rect if self.show_backproj: vis[:] = prob[...,np.newaxis] pt1 = (track_rect_yaml[0],track_rect_yaml[1]) pt2 = (track_rect_yaml[0] + track_rect_yaml[2], track_rect_yaml[1] + track_rect_yaml[3]) cv2.rectangle(vis, pt1, pt2, (0, 255, 0), 2) cv2.ellipse(vis, track_box, (0, 0, 255), 2) self.add_frame_to_dataset_based_on_difference(cur_frame, track_rect_yaml) return vis
def test(): # p1 = Point(5, 1) # p2 = Point(1, 4) # l1 = Line(p2, p1) # print(l1.k) # # p1 = Point(5, 4) # p2 = Point(1, 1) # l1 = Line(p1, p2) # print(l1.k) pnts = [(40, 40), (140, 85), (140, 160), (50, 100)] img = np.zeros((200, 200, 3)) a = cv2.minAreaRect(np.asarray(pnts)) img = cv2.line(img, pnts[0], pnts[1], (0, 255, 0), thickness=1) img = cv2.line(img, pnts[1], pnts[2], (0, 255, 0), thickness=1) img = cv2.line(img, pnts[2], pnts[3], (0, 255, 0), thickness=1) img = cv2.line(img, pnts[3], pnts[0], (0, 255, 0), thickness=1) box = cv2.boxPoints(a) def tt(p): return (p[0], p[1]) img = cv2.line(img, tt(box[0]), tt(box[1]), (255, 255, 0), thickness=1) img = cv2.line(img, tt(box[1]), tt(box[2]), (255, 255, 0), thickness=1) img = cv2.line(img, tt(box[2]), tt(box[3]), (255, 255, 0), thickness=1) img = cv2.line(img, tt(box[3]), tt(box[0]), (255, 255, 0), thickness=1) cv2.imshow('test', img.astype(np.uint8)) cv2.waitKey(0)
def estimate_bbox(cnt, img): # calculate bounding box rect = cv2.minAreaRect(cnt) bbox = cv2.boxPoints(rect) bbox = np.int0(bbox) #cv2.drawContours(img, [bbox], 0, (0,255,0), 2) # rotate bounding box to get a vertical rectangle M = cv2.getRotationMatrix2D(rect[0], rect[2], 1) pts = np.ones((4, 3)) pts[:,:-1] = bbox bbox_rot = np.int0(np.dot(pts, M.T)) # resize bounding box to cover the whole document bbox_rot[0][0] -= 15 bbox_rot[0][1] += 120 bbox_rot[1][0] -= 15 bbox_rot[2][0] += 5 bbox_rot[3][0] += 5 bbox_rot[3][1] += 120 # rotate back bounding box to original orientation p = (bbox_rot[1][0], bbox_rot[1][1]) M = cv2.getRotationMatrix2D(p, -rect[2], 1) pts = np.ones((4, 3)) pts[:,:-1] = bbox_rot bbox = np.int0(np.dot(pts, M.T)) return bbox
def find_cutout_candidates(self, red_contours): self.candidates_drawing = np.copy(self.mat) # Eliminate some contours based on how much they look like cutouts cutout_candidates = [] for contour in red_contours: cutout_bounding_rect = cv2.boundingRect(contour) area = cv2.contourArea(contour) min_area_rect = cv2.minAreaRect(contour) cutout_center = (int(min_area_rect[0][0]), int(min_area_rect[0][1])) box = np.int0(cv2.boxPoints(min_area_rect)) rectangularity = area / cv2.contourArea(box) epsilon = max([min_area_rect[1][1], min_area_rect[1][0]]) * 0.1 polygon = cv2.approxPolyDP(contour, epsilon, True) if self.mode == TorpedoesMode.track_target.value: min_rect = 0.5 else: min_rect = self.options["min_cutout_rect"] if rectangularity > min_rect: # and area / self.img_area > self.options["min_cutout_area"]: # if polygon.shape[0] == 4: cutout_candidates.append(Cutout(contour=contour, area=area, bounding_rect=cutout_bounding_rect, center=cutout_center, min_area_rect=min_area_rect, polygon=polygon)) cv2.drawContours(self.candidates_drawing, [contour], -1, (255, 255, 255), 3) # cv2.drawContours(self.candidates_drawing, [polygon], -1, (255,255,255), 2) self.post_if_enabled('cutout candidates', self.candidates_drawing) return cutout_candidates
def findContours(self): n, self.contours, h = cv.findContours(self.thresh, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) shot = False for cntr in self.contours: self.rect = cv.minAreaRect(cntr) self.box = cv.boxPoints(self.rect) self.box = np.int0(self.box) if set(self.box[0]) != set(self.box[1]): cv.drawContours(self.frame, [self.box], 0, (0, 0, 255), 2) self.box = sorted(self.box, key=lambda point: point[1]) topLeft = self.box[0] topRight = self.box[1] print(topLeft) print(topRight) print(abs(topLeft[0] - topRight[0])) midpoint = (int((topLeft[0] + topRight[0]) / 2), int((topLeft[1] + topRight[1]) / 2)) if not shot: shot = self.checkShot(midpoint) cv.circle(self.frame, midpoint, 5, (0, 255, 0), thickness=2, lineType=8, shift=0) self.getTheta(midpoint) return shot
def select_note_heads_whole(image_orig, image_bin, groups,dicts,regions): img, contours, hierarchy = cv2.findContours(image_bin.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) regions_dict = {} for contour in contours: rect = cv2.minAreaRect(contour) box = cv2.boxPoints(rect) box = np.int0(box) (x,y),radius = cv2.minEnclosingCircle(contour) center = (int(x),int(y)) radius = int(radius) if radius==9: print 'rad ',radius cv2.circle(image_orig,center,radius,(0,255,0),2) # cv2.drawContours(image_orig,[box],0,(0,0,255),2) (x,y),(w,h),angle = rect #if angle < -40 and angle > -50 and w > 6 and w<8 and h > 5: # if w<8 and w > 4 and h> 9 and angle > -1: # print '////////////////' # print w,h,angle x,y,w,h = cv2.boundingRect(contour) region = image_bin[y:y+h+1,x:x+w+1] regions_dict[x] = [img_fun.resize_region(region), (x,y,w,h)] # cv2.rectangle(image_orig,(x,y),(x+w,y+h),(0,255,0),2) row = find_row(groups,y) dicts[row][x] = [img_fun.resize_region(region),(x,y,w,h)] r = reg.Region(x,y,w,h) regions.add_region(r) return image_orig,dicts,regions
def create_rectangle(thresh,cnt,cx,cy): thresh = cv2.circle(thresh,(cx,cy), 1, (0,0,0), -1) rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) box = np.int0(box) thresh = cv2.drawContours(thresh,[box],0,(0,0,255),2) return thresh
def draw_inflorescence(res, zoom_ratio): # gray scale gray = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY) # Gaussian filter gray = cv2.GaussianBlur(gray, (7, 7), 0) # detect the edge edged = cv2.Canny(gray, 50, 100) # close the gap between edges edged = cv2.dilate(edged, None, iterations=1) edged = cv2.erode(edged, None, iterations=1) # find contour of the object cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) # sort the contour from left to right (cnts, _) = contours.sort_contours(cnts) # initialize 'pixels per metric' pixelsPerMetric = None # Loop through each contour for c in cnts: # If the area of the current contour is too small, consider it may be noise, and ignore it if cv2.contourArea(c) < 50: continue # Calculate the outcut rectangle according to the contour of the object orig = image.copy() box = cv2.minAreaRect(c) box = \ (cv2.cv.BoxPoints(box) if imutils.is_cv2() else cv2.boxPoints(box)) box = np.array(box, dtype='int') # Sort the contour points according to the order of top-left, top-right, bottom-right and bottom-left, # and draw the BB of outer tangent, which is represented by green line box = perspective.order_points(box) cv2.drawContours(orig, [box.astype('int')], -1, (0, 0, 255), 1) # Draw the four vertices of BB, represented by small red circles for (x, y) in box: cv2.circle(orig, (int(x), int(y)), 1, (0, 0, 255), -1) # Calculate the center point coordinates of top-left # and top-right and bottom-left and bottom-right respectively (tl, tr, br, bl) = box (tltrX, tltrY) = midpoint(tl, tr) (blbrX, blbrY) = midpoint(bl, br) # Calculate the center point coordinates of top-left and top-right and top-righ and bottom-right respectively (tlblX, tlblY) = midpoint(tl, bl) (trbrX, trbrY) = midpoint(tr, br) # Draw the center point of the four edges of BB, represented by a small blue circle # cv2.circle(orig, (int(tltrX), int(tltrY)), 5, (255, 0, 0), -1) # cv2.circle(orig, (int(blbrX), int(blbrY)), 5, (255, 0, 0), -1) # cv2.circle(orig, (int(tlblX), int(tlblY)), 5, (255, 0, 0), -1) # cv2.circle(orig, (int(trbrX), int(trbrY)), 5, (255, 0, 0), -1) # Draw a line between the center points, indicated by a magenta line # cv2.line(orig, (int(tltrX), int(tltrY)), (int(blbrX), int(blbrY)), # ....(255, 0, 255), 2) # cv2.line(orig, (int(tlblX), int(tlblY)), (int(trbrX), int(trbrY)), # ....(255, 0, 255), 2) # Calculate the Euclidean distance between two center points, that is, the distance of the picture height = dist.euclidean((tltrX, tltrY), (blbrX, blbrY)) width = dist.euclidean((tlblX, tlblY), (trbrX, trbrY)) # Initialize the measurement index value, the width of the reference object in the picture # has been calculated by Euclidean distance, and the actual size of the reference object is known # if pixelsPerMetric is None: # ....pixelsPerMetric = dB / args["width"] # Calculate the actual size (width and height) of the target, expressed in feet real_height = round(height * zoom_ratio, 2) real_width = round(width * zoom_ratio, 2) # Draw the result in the image cv2.putText( orig, '{:.1f}'.format(real_width), (int(tltrX - 15), int(tltrY - 10)), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 0), 2, ) cv2.putText( orig, '{:.1f}'.format(real_height), (int(trbrX + 10), int(trbrY)), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 0), 2, ) # show result cv2.imshow('Orig', orig) cv2.waitKey(0) return (real_height, real_width)
hsv_roi = cv.cvtColor(roi, cv.COLOR_BGR2HSV) mask = cv.inRange(hsv_roi, np.array((0., 60., 32.)), np.array( (180., 255., 255))) roi_hist = cv.calcHist([hsv_roi], [0], mask, [180], [0, 180]) cv.normalize(roi_hist, roi_hist, 0, 255, cv.NORM_MINMAX) term_crit = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 1) cv.imshow('roi', roi) while (1): ret, frame = cap.read() if ret == True: hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV) dst = cv.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) ret, track_window = cv.CamShift(dst, track_window, term_crit) pts = cv.boxPoints(ret) print(pts) pts = np.int0(pts) final_image = cv.polylines(frame, [pts], True, (0, 255, 0), 2) cv.imshow('dst', dst) cv.imshow('final_image', final_image) k = cv.waitKey(30) & 0xff if k == 27: break else: break cap.release() cv.destroyAllWindows()
closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) cv2.imshow("Kernel", kernel) cv2.imshow("Closed", closed) #进行腐蚀和膨胀 closed = cv2.erode(closed, None, iterations=4) closed = cv2.dilate(closed, None, iterations=4) cv2.imshow("Closed", closed) #找到轮廓 # find the contours in the thresholded image, then sort the contours # by their area, keeping only the largest one (_, cnts, _) = cv2.findContours(closed.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) c = sorted(cnts, key=cv2.contourArea, reverse=True)[0] # compute the rotated bounding box of the largest contour rect = cv2.minAreaRect(c) box = np.int0(cv2.boxPoints(rect)) # draw a bounding box arounded the detected barcode and display the # image cv2.drawContours(image, [box], -1, (0, 255, 0), 3) cv2.imshow("Image", image) cv2.waitKey(0)
# Look for children with exactly one parent while (hierarchy[0][k][3] != -1): # As long as k has a first_child [2], find that child and look for children again. # http://docs.opencv.org/3.1.0/d9/d8b/tutorial_py_contours_hierarchy.html k = hierarchy[0][k][3] c = c + 1 if hierarchy[0][k][3] != -1: c = c + 1 if c == 1 and MIN_CONTOUR_AREA < area < MAX_CONTOUR_AREA: # Fit a rectangle around the found contour and draw it. rotated_rect = cv2.minAreaRect(contour) #(center, size, angle) rotation = rotated_rect[2] box = cv2.boxPoints(rotated_rect).astype(int) cv2.drawContours(img, [box], -1, (0, 255, 0)) # Fit a circle and draw it circle = cv2.minEnclosingCircle(contour) # (center, size, angle) radius = int(circle[1]) center = tuple(np.array(circle[0], int)) offset_center_x = center[0] + int( (center[0] - width / 2) / width * h_crop_offset) offset_center_y = center[1] + int( (center[1] - height) / height * v_crop_offset) # print() cv2.circle(img, center, radius, (0, 255, 0)) cv2.circle(img, (offset_center_x, offset_center_y), radius // 2, (0, 255, 0))
print('Invalid algorithm choice') sys.exit() imagePaths = sorted(list(paths.list_images(input_dir))) for imagePath in imagePaths: iteration += 1 originimage = cv2.imread(imagePath) image = imutils.resize(originimage, width=400, height=400) image = cv2.bilateralFilter(image, 3, 105, 105) anpr.debug_imshow("Bilateral Filter", image, waitKey=True) (lpText, lpCnt) = anpr.find_and_ocr(iteration, image, psm=args["psm"], clearBorder=args["clear_border"] > 0) if lpText is not None and lpCnt is not None: box = cv2.boxPoints(cv2.minAreaRect(lpCnt)) box = box.astype("int") cv2.drawContours(image, [box], -1, (0, 255, 0), 2) (x, y, w, h) = cv2.boundingRect(lpCnt) cv2.putText(image, cleanup_text(lpText), (x, y - 15), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (0, 255, 0), 2) print("[INFO] Registration number: {}".format(lpText)) anpr.debug_imshow("Output ANPR", image, waitKey=True) anpr.save_result("Final{}.jpg".format(iteration), image) cv2.destroyAllWindows()
cnt = contours[k] dst2 = src.copy() cv2.drawContours(dst2, [cnt], 0, (255,0,0), 3) ##cv2.imshow('dst2', dst2) #3 area = cv2.contourArea(cnt) print('area=', area) x, y, width, height = cv2.boundingRect(cnt) dst3 = dst2.copy() cv2.rectangle(dst3, (x, y), (x+width, y+height), (0,0,255), 2) cv2.imshow('dst3', dst3) #4 rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) box = np.int32(box) print('box=', box) dst4 = dst2.copy() cv2.drawContours(dst4,[box],0,(0,0,255),2) cv2.imshow('dst4', dst4) #5 (x,y),radius = cv2.minEnclosingCircle(cnt) dst5 = dst2.copy() cv2.circle(dst5,(int(x),int(y)),int(radius),(0,0,255),2) cv2.imshow('dst5', dst5) cv2.waitKey() cv2.destroyAllWindows()
def rotate_nms_gpu(dets, iou_thr, device_id=None): """Dispatch to either CPU or GPU NMS implementations. The input can be either a torch tensor or numpy array. GPU NMS will be used if the input is a gpu tensor or device_id is specified, otherwise CPU NMS will be used. The returned type will always be the same as inputs. Arguments: dets (torch.Tensor or np.ndarray): bboxes with scores. iou_thr (float): IoU threshold for NMS. device_id (int, optional): when `dets` is a numpy array, if `device_id` is None, then cpu nms is used, otherwise gpu_nms will be used. Returns: tuple: kept bboxes and indice, which is always the same data type as the input. Example: >>> dets = np.array([[49.1, 32.4, 51.0, 35.9, 0.9], >>> [49.3, 32.9, 51.0, 35.3, 0.9], >>> [49.2, 31.8, 51.0, 35.4, 0.5], >>> [35.1, 11.5, 39.1, 15.7, 0.5], >>> [35.6, 11.8, 39.3, 14.2, 0.5], >>> [35.3, 11.5, 39.9, 14.5, 0.4], >>> [35.2, 11.7, 39.7, 15.7, 0.3]], dtype=np.float32) >>> iou_thr = 0.7 >>> suppressed, inds = nms(dets, iou_thr) >>> assert len(inds) == len(suppressed) == 3 """ assert dets.shape[-1] == 6 # convert dets (tensor or numpy array) to tensor if isinstance(dets, torch.Tensor): is_numpy = False dets_th = dets[:, :5] #ignore score elif isinstance(dets, np.ndarray): is_numpy = True device = 'cpu' if device_id is None else 'cuda:{}'.format(device_id) dets_th = torch.from_numpy(dets).to(device)[:, :5] #ignore score else: raise TypeError( 'dets must be either a Tensor or numpy array, but got {}'.format( type(dets))) # execute cpu or cuda nms if dets_th.shape[0] == 0: inds = dets_th.new_zeros(0, dtype=torch.long) else: if dets_th.is_cuda: dets_th = dets_th.cpu().numpy() # WARNING: convert predicted [top_left, bottom_right] to [center w h] d_w = dets_th[:, 2:3] - dets_th[:, 0:1] d_h = dets_th[:, 3:4] - dets_th[:, 1:2] d_ctr_x = dets_th[:, 0:1] + d_w * 0.5 d_ctr_y = dets_th[:, 1:2] + d_h * 0.5 d_theta = dets_th[:, 4:5] dets_th = np.concatenate([d_ctr_x, d_ctr_y, d_w, d_h, d_theta], axis=-1) for idx in range(dets_th.shape[0]): rot_box = ((dets_th[idx, 0], dets_th[idx, 1]), (dets_th[idx, 2], dets_th[idx, 3]), np.degrees(dets_th[idx, 4])) corner_pt = cv2.boxPoints(rot_box) rot_box_edge = [ corner_pt[1] - corner_pt[0], corner_pt[3] - corner_pt[0] ] np.linalg.norm(rot_box_edge) wh_idx = sorted((np.linalg.norm(edge), idx) for idx, edge in enumerate(rot_box_edge)) long_axis = rot_box_edge[wh_idx[1][1]] theta = np.arctan2(long_axis[1], long_axis[0]) if theta > np.pi / 2.0: theta -= np.pi if theta < -np.pi / 2.0: theta += np.pi dets_th[idx, 2] = float(wh_idx[1][0]) dets_th[idx, 3] = float(wh_idx[0][0]) dets_th[idx, 4] = float(-theta * 180 / np.pi) dets_th = torch.from_numpy(dets_th).to('cuda') # [top_left, bottom_right] as input rotate along box center inds = nms_cuda.rotate_nms(dets_th, iou_thr) else: raise ValueError('RoateNMS Not Support CPU') if is_numpy: inds = inds.cpu().numpy() return dets[inds, :], inds
def test(args): import torch data_loader = IC15TestLoader(root_dir=args.root_dir, long_size=args.long_size) test_loader = torch.utils.data.DataLoader(data_loader, batch_size=1, shuffle=False, num_workers=2, drop_last=True) # Setup Model if args.arch == "resnet50": model = models.resnet50(pretrained=False, num_classes=1, scale=args.scale, train_mode=False) elif args.arch == "resnet101": model = models.resnet101(pretrained=True, num_classes=1, scale=args.scale) elif args.arch == "resnet152": model = models.resnet152(pretrained=True, num_classes=1, scale=args.scale) for param in model.parameters(): param.requires_grad = False if args.gpus > 0: model = model.cuda() if args.resume is not None: if os.path.isfile(args.resume): print("Loading model and optimizer from checkpoint '{}'".format( args.resume)) device = torch.device('cpu') if args.gpus < 0 else None checkpoint = torch.load(args.resume, map_location=device) # model.load_state_dict(checkpoint['state_dict']) d = collections.OrderedDict() for key, value in checkpoint['state_dict'].items(): tmp = key[7:] d[tmp] = value model.load_state_dict(d) print("Loaded checkpoint '{}' (epoch {})".format( args.resume, checkpoint['epoch'])) sys.stdout.flush() else: print("No checkpoint found at '{}'".format(args.resume)) sys.stdout.flush() if args.onnx: import torch.onnx.symbolic_opset9 dummy_input = torch.autograd.Variable(torch.randn(1, 3, 640, 640)).cpu() torch.onnx.export(model, dummy_input, 'dbnet.onnx', verbose=False) model.eval() total_frame = 0.0 total_time = 0.0 for idx, (org_img, img, scale_val) in enumerate(test_loader): print('progress: %d / %d' % (idx, len(test_loader))) sys.stdout.flush() if args.gpus > 0: img = Variable(img.cuda(), volatile=True) org_img = org_img.numpy().astype('uint8')[0] text_box = org_img.copy() if args.gpus > 0: torch.cuda.synchronize() start = time.time() outputs = model(img) probability_map, threshold_map, binarization_map = outputs score = binarization_map[0, 0] text = torch.where(score > 0.9, torch.ones_like(score), torch.zeros_like(score)) text = text.data.cpu().numpy().astype(np.uint8) prob_map = probability_map.cpu().numpy()[0, 0] * 255 thre_map = threshold_map.cpu().numpy()[0, 0] * 255 bin_map = binarization_map.cpu().numpy()[0, 0] * 255 out_path = 'outputs/vis_ic15/' image_name = data_loader.img_paths[idx].split('/')[-1].split('.')[0] print("im_name:", image_name) # cv2.imwrite(out_path + image_name + '_prob.png', prob_map.astype(np.uint8)) # cv2.imwrite(out_path + image_name + '_thre.png' , thre_map.astype(np.uint8)) cv2.imwrite(out_path + image_name + '_bin.png', bin_map.astype(np.uint8)) scale = (org_img.shape[1] * 1.0 / img.shape[1], org_img.shape[0] * 1.0 / img.shape[0]) print("[shape_info:]", text.shape, img.shape, org_img.shape, scale, scale_val) bboxes = [] scale_val = scale_val.cpu().numpy() nLabels, labels, stats, centroids = cv2.connectedComponentsWithStats( text.astype(np.uint8), connectivity=4) img_h, img_w = text.shape for k in range(1, nLabels): # size filtering size = stats[k, cv2.CC_STAT_AREA] if size < 100: continue # make segmentation map segmap = np.zeros(text.shape, dtype=np.uint8) segmap[labels == k] = 255 x, y = stats[k, cv2.CC_STAT_LEFT], stats[k, cv2.CC_STAT_TOP] w, h = stats[k, cv2.CC_STAT_WIDTH], stats[k, cv2.CC_STAT_HEIGHT] # niter = int(math.sqrt(size * min(w, h) / (w * h)) * 2) # sx, ex, sy, ey = x - niter, x + w + niter + 1, y - niter, y + h + niter + 1 # # boundary check # if sx < 0 : sx = 0 # if sy < 0 : sy = 0 # if ex >= img_w: ex = img_w # if ey >= img_h: ey = img_h # kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(1 + niter, 1 + niter)) # segmap[sy:ey, sx:ex] = cv2.dilate(segmap[sy:ey, sx:ex], kernel) np_contours = np.roll(np.array(np.where(segmap != 0)), 1, axis=0).transpose().reshape(-1, 2) rectangle = cv2.minAreaRect(np_contours) box = cv2.boxPoints(rectangle) * 4 box = box / scale_val box = box.astype('int32') bboxes.append(box) # find contours bboxes = np.array(bboxes) num_box = bboxes.shape[0] try: unshrink_bboxes = unshrink(bboxes.reshape((num_box, -1, 2))) except: continue for i in range(unshrink_bboxes.shape[0]): cv2.drawContours(text_box, [unshrink_bboxes[i]], -1, (0, 255, 255), 2) if args.gpus > 0: torch.cuda.synchronize() end = time.time() total_frame += 1 total_time += (end - start) print('fps: %.2f' % (total_frame / total_time)) sys.stdout.flush() for bbox in bboxes: cv2.drawContours(text_box, [bbox.reshape(4, 2)], -1, (0, 255, 0), 2) image_name = data_loader.img_paths[idx].split('/')[-1].split('.')[0] write_result_as_txt(image_name, bboxes.reshape((-1, 8)), 'outputs/submit_ic15/') # text_box = cv2.resize(text_box, (text.shape[1], text.shape[0])) debug(idx, data_loader.img_paths, [[text_box]], 'outputs/vis_ic15/')
def main(): # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-v", "--video", help="path to the (optional) video file") args = vars(ap.parse_args()) # grab the reference to the current frame, list of ROI # points and whether or not it is ROI selection mode global frame, roiPts, inputMode # if the video path was supplied, grab the reference to the camera if not args.get("video", False): camera = cv2.VideoCapture(0) # otherwise, load the video else: camera = cv2.VideoCapture(args["video"]) # setup the mouse callback cv2.namedWindow("frame") cv2.setMouseCallback("frame", selectROI) # initialize the termination criteria for cam shift, indicating # a maximum of ten iterations or movement by at least one pixel # along with the bounding box of the ROI termination = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) roiBox = None # keep looping over the frames while True: # grab the current frame (grabbed, frame) = camera.read() # check to see if we have reached the end of the # video if not grabbed: break # see if the ROI has been computed if roiBox is not None: # convert the current frame to the HSV color space # and perform mean shift hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) backProj = cv2.calcBackProject([hsv], [0], roiHist, [0, 180], 1) # apply cam shift to the back projection, convert the # points to a bounding box, and then draw them (r, roiBox) = cv2.CamShift(backProj, roiBox, termination) pts = np.int0(cv2.boxPoints(r)) cv2.polylines(frame, [pts], True, (0, 255, 0), 2) # show the frame and record if the user presses a key cv2.imshow("frame", frame) key = cv2.waitKey(1) & 0xFF # handle if the 'i' key is pressed, then go into ROI selection mode if key == ord('i') and len(roiPts) < 4: # indicate that we are in input mode and clone the frame inputMode = True orig = frame.copy() # keep looping until 4 reference ROI points have been selected; # press any key to exit ROI selection mode once 4 points have # been selected while len(roiPts) < 4: cv2.imshow("frame", frame) cv2.waitKey(0) # determine the top-left and bottom-right points roiPts = np.array(roiPts) s = roiPts.sum(axis=1) tl = roiPts[np.argmin(s)] br = roiPts[np.argmax(s)] # grab the ROI for the bounding box and convert it # to the HSV color space roi = orig[tl[1]:br[1], tl[0]:br[0]] roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # compute the HSV histogram for the ROI and store the # bounding box roiHist = cv2.calcHist([roi], [0], None, [16], [0, 180]) roiHist = cv2.normalize(roiHist, roiHist, 0, 255, cv2.NORM_MINMAX) roiBox = (tl[0], tl[1], br[0], br[1]) #if the 'q' key is pressed, stop the loop elif key == ord("q"): break
while True: (grabbed, frame) = camera.read() #if not grabbed: #print "not grabbed" #break blue = cv2.inRange(frame, blueLower, blueUpper) blue = cv2.GaussianBlur(blue, (3, 3), 0) _, cnts, _ = cv2.findContours(blue.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) if len(cnts) > 0: cnt = sorted(cnts, key=cv2.contourArea, reverse=True)[0] rect = np.int32(cv2.boxPoints(cv2.minAreaRect(cnt))) cv2.drawContours(frame, [rect], -1, (0, 255, 0), 2) cv2.imshow("Original Feedback", frame) cv2.imshow("HSV Binary Feddback", blue) time.sleep(0.025) if cv2.waitKey(1) & 0xFF == ord("q"): break camera.release() cv2.destroyAllWindows()
cv2.CHAIN_APPROX_SIMPLE) cnts = cnts[0] if imutils.is_cv2() else cnts[1] # sort the contours from left-to-right and initialize the # 'pixels per metric' calibration variable (cnts, _) = contours.sort_contours(cnts) pixelsPerMetric = None # loop over the contours individually for c in cnts: # if the contour is not sufficiently large, ignore it if cv2.contourArea(c) < 100: continue # compute the rotated bounding box of the contour orig = frame.copy() box = cv2.minAreaRect(c) box = cv2.cv.BoxPoints(box) if imutils.is_cv2() else cv2.boxPoints(box) box = np.array(box, dtype="int") # order the points in the contour such that they appear # in top-left, top-right, bottom-right, and bottom-left # order, then draw the outline of the rotated bounding # box box = perspective.order_points(box) cv2.drawContours(orig, [box.astype("int")], -1, (0, 255, 0), 2) # loop over the original points and draw them for (x, y) in box: cv2.circle(orig, (int(x), int(y)), 5, (0, 0, 255), -1) # unpack the ordered bounding box, then compute the midpoint # between the top-left and top-right coordinates, followed by
def parse(imagePath): # 读取图片 img = cv2.imread(imagePath) # 转化成灰度图 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 利用Sobel边缘检测生成二值图 sobel = cv2.Sobel(gray, cv2.CV_8U, 1, 0, ksize=3) # 二值化 ret, binary = cv2.threshold(sobel, 0, 255, cv2.THRESH_OTSU + cv2.THRESH_BINARY) # 膨胀、腐蚀 element1 = cv2.getStructuringElement(cv2.MORPH_RECT, (30, 9)) element2 = cv2.getStructuringElement(cv2.MORPH_RECT, (24, 6)) # 膨胀一次,让轮廓突出 dilation = cv2.dilate(binary, element2, iterations=1) # 腐蚀一次,去掉细节 erosion = cv2.erode(dilation, element1, iterations=1) # 再次膨胀,让轮廓明显一些 dilation2 = cv2.dilate(erosion, element2, iterations=2) # 查找轮廓和筛选文字区域 region = [] image,contours, hierarchy = cv2.findContours(dilation2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) for i in range(len(contours)): cnt = contours[i] # 计算轮廓面积,并筛选掉面积小的 area = cv2.contourArea(cnt) if (area < 1000): continue cv2.drawContours(img, [cnt], 0, (0, 255, 0), 1) # 找到最小的矩形 rect = cv2.minAreaRect(cnt) print ("rect is: ") print (rect) # box是四个点的坐标 box = cv2.boxPoints(rect) box = np.int0(box) # 计算高和宽 height = abs(box[0][1] - box[2][1]) width = abs(box[0][0] - box[2][0]) # 根据文字特征,筛选那些太细的矩形,留下扁的 if (height > width * 1.3): continue region.append(box) # # 绘制轮廓 for box in region: cv2.drawContours(img, [box], 0, (0, 0, 255), 2) cv2.imshow('img', img) cv2.waitKey(0) cv2.destroyAllWindows()
def Demo(scaleim, cam, vector_w, normalValue=40, offset=5): Distance = 1000 ob_in_area = 0 sdetect = 0 frball = 0 frta = 0 frkhoa = 0 nhan_dang = 0 term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) track_window = (0, 0, 95 - 75, 420 - 220) Image_show = cv2.imread('An/imagezero.jpg') out = cv2.VideoWriter('An/result_backup.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 10, (1280, 480)) net = cv2.dnn.readNetFromDarknet("Model/YOLOv3/yolov3.cfg", "Model/YOLOv3/yolov3_best.weights") net.setPreferableBackend(cv2.dnn.DNN_BACKEND_CUDA) net.setPreferableTarget(cv2.dnn.DNN_TARGET_CUDA) classes = [] with open("Model/YOLOv3/obj.names", "r") as f: classes = [line.strip() for line in f.readlines()] layer_names = net.getLayerNames() output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()] # tai anh/video start = time.time() cap = cv2.VideoCapture(cam) frame_id = 0 inv_w_array = [0, 0, 0, 0, 0, 0] while True: ok, frame = cap.read() #frame = QuanLib.gamma_correct() frame_id += 1 if not ok: break img = frame.copy() #gray_img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) image = pyramid(img, scaleim) nearOb = -1 height, width,channels = image.shape # nhandien blob = cv2.dnn.blobFromImage(image, 1/255, (416, 416), (0, 0, 0), True, crop=False) net.setInput(blob) outs = net.forward(output_layers) # hien_man_hinh detector_idxs = [] confidences = [] boxes = [] for o in outs: for detection in o: scores = detection[5:] class_id = np.argmax(scores) confidence = scores[class_id] if confidence > 0: center_x = int(detection[0] * width) center_y = int(detection[1] * height) w = int(detection[2] * width) h = int(detection[3] * height) # Rec coord x = int(center_x - w / 2) # top left x y = int(center_y - h / 2) # top left y boxes.append([x, y, w, h]) confidences.append(float(confidence)) detector_idxs.append(class_id) indexes = cv2.dnn.NMSBoxes(boxes, confidences, 0, 0.4) x=0 y=0 w=0 h=0 for i in range(len(boxes)): if i in indexes: nhan_dang = 1 x,y,w,h = boxes[i] if (((detector_idxs[i] == 2) and (y <= 200)) or (y <= 95)): ob_in_area = 1 w_0 = vector_w[0][detector_idxs[i]] w_1 = vector_w[1][detector_idxs[i]] w_2 = vector_w[2][detector_idxs[i]] w_3 = vector_w[3][detector_idxs[i]] w_4 = vector_w[4][detector_idxs[i]] dis1 = 0 dis2 = 0 dis3 = 0 frball = 0 frta = 0 frkhoa = 0 if (detector_idxs[i] == 0): dis1 = w_0 + w_1 * x + w_2 * y + w_3 * w + w_4 * h frball += 1 elif (detector_idxs[i] == 1): dis2 = 1 / (w_0 + w_1 * y) frta += 1 else: dis3 = w_0 + w_1 * y frkhoa += 1 cv2.rectangle(img, (x, y), (x + w, y + h), (0, 250, 0), 2) cv2.putText(img, str(detector_idxs[i]) + ' ' + str(np.round(confidences[i] * 100, 2)) + '%', (x, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (250, 0, 0), 1, lineType=cv2.LINE_AA) frtotal = max(frball, frta, frkhoa) if (frtotal == 0): nearOb = -1 Distance = 1000 elif (frtotal == frball): nearOb = 0 Distance = dis1 elif (frtotal == frta): nearOb = 1 Distance = dis2 elif (frtotal == frkhoa): nearOb = 2 Distance = dis3 if nearOb == 0: NameOb = 'Marker Ball' elif nearOb == 1: NameOb = 'Ta Chong Rung' elif nearOb == 2: NameOb = 'Khoa do day' else: NameOb = 'Nothing' #Phan cua Tho '''top_left = [x,y] bottom_right = [x+w,y+h] Distance, contour, _ = Tho.distance_estimate(frame.copy(), top_left, bottom_right, 0.2, 200, 400, 14.7) Distance = Distance / 10 cv2.imshow('contour', contour.copy())''' a = 4132.45382956 b = 2.4475897335913714 if w != 0: inv_w_array = inv_w_array[1:6]+[1/w] #print(inv_w_array) Distance = a * QuanLib.butter_lowpass_filter(data=inv_w_array,cutoff=0.7,fs=10,order=2)[5] + b ''' if top_left == [0,0] or bottom_right == [0,0]: Distance = 1000 else: Distance,_,_ = Tho.distance_estimate(img, top_left, bottom_right, 0.2, 300, 900, 14.7) Distance = Distance/10 ''' if (Distance == 1000 or nhan_dang == 0 or np.round(Distance, 2) < 21): dis_string = str(np.round(Distance, 2)) #dis_string = 'Unknow' else: dis_string = str(np.round(Distance, 2)) end = time.time() cv2.putText(img, 'FPS:' + str( np.round(1 / (end - start))) + ' Name:' + NameOb + ' Distance:' + dis_string + ' cm', (20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 1, lineType=cv2.LINE_AA) start = time.time() frame1 = frame[75:95, 220:420].copy() cv2.rectangle(frame, (220, 75), (420, 95), (0, 255, 0), 2) frame2 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY) kernel = np.ones((3, 3), np.uint8) th = cv2.adaptiveThreshold(frame2, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, \ cv2.THRESH_BINARY_INV, 51, 4) opening1 = cv2.morphologyEx(th, cv2.MORPH_OPEN, kernel) opening = cv2.morphologyEx(opening1, cv2.MORPH_CLOSE, kernel) ret, track_window = cv2.CamShift(opening, track_window, term_crit) pts = np.int0(cv2.boxPoints(ret)) y1 = pts[0][0] y2 = pts[1][0] y3 = pts[2][0] y4 = pts[3][0] if (not (y1 == 0 and y2 == 0 and y3 == 0 and y4 == 0)) or (max(y1, y2, y3, y4) >= 150) or ( min(y1, y2, y3, y4) <= 50): opening[:, 0:min(y1, y2, y3, y4) - 10] = 0 opening[:, max(y1, y2, y3, y4) + 10:200] = 0 resu = opening[:, max(min(y1, y2, y3, y4) - 10, 0):min(max(y1, y2, y3, y4) + 10, 200)].copy() edges = cv2.Canny(opening, 50, 200, apertureSize=3) feat = np.sum(edges / 255) #print(feat) if sdetect == 1: if ob_in_area == 1: cv2.putText(frame, 'Obstacle', (70, 100), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 0, 0), 2, lineType=cv2.LINE_AA) cv2.putText(img, 'Lightning rods: Unknow', (20, 45), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, lineType=cv2.LINE_AA) cv2.rectangle(frame, (220, 75), (420, 95), (255, 0, 0), 2) elif ((feat <= 37) or (feat >= 43)): cv2.putText(frame, 'Error', (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2, lineType=cv2.LINE_AA) cv2.putText(img, 'Lightning rods: Error', (20, 45), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, lineType=cv2.LINE_AA) cv2.rectangle(frame, (220, 75), (420, 95), (0, 0, 255), 2) else: cv2.putText(frame, 'Normal', (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 0), 2, lineType=cv2.LINE_AA) cv2.putText(img, 'Lightning rods: Normal', (20, 45), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1, lineType=cv2.LINE_AA) cv2.rectangle(frame, (220, 75), (420, 95), (0, 255, 0), 2) Image_show = combineImage(img, frame, Image_show, scaleim=1) cv2.namedWindow('result', cv2.WINDOW_NORMAL) cv2.imshow('result', Image_show) Distance = 1000 nhan_dang = 0 k = cv2.waitKey(5) & 0xff if k == 27: break elif (k == 115): sdetect = 1 elif (k == 99): ob_in_area = 0 frball = 0 frta = 0 frkhoa = 0 out.write(Image_show) cap.release() cv2.destroyAllWindows()
hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, lower_color, upper_color) roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180]) cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) # Setup the termination criteria, either 10 iteration or move by atleast 1 pt term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) while True: ret ,frame = cap.read() if ret == True: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1) # apply meanshift to get the new location ret, bounding_window = cv2.CamShift(dst, bounding_window, term_crit) # Draw the poly pts = cv2.boxPoints(ret) pts = np.int0(pts) feed = cv2.polylines(frame,[pts],True, 255,2) feed = cv2.flip(feed, 1) cv2.imshow('video feed',feed) if cv2.waitKey(1) == 13: #13 is the Enter Key break cv2.destroyAllWindows() cap.release()
def findTape(contours, image, centerX, centerY): screenHeight, screenWidth, channels = image.shape #Seen vision targets (correct angle, adjacent to each other) targets = [] if len(contours) >= 2: #Sort contours by area size (biggest to smallest) cntsSorted = sorted(contours, key=lambda x: cv2.contourArea(x), reverse=True) biggestCnts = [] for cnt in cntsSorted: # Get moments of contour; mainly for centroid M = cv2.moments(cnt) # Get convex hull (bounding polygon on contour) hull = cv2.convexHull(cnt) # Calculate Contour area cntArea = cv2.contourArea(cnt) # calculate area of convex hull hullArea = cv2.contourArea(hull) # Filters contours based off of size if (checkContours(cntArea, hullArea)): ### MOSTLY DRAWING CODE, BUT CALCULATES IMPORTANT INFO ### # Gets the centeroids of contour if M["m00"] != 0: cx = int(M["m10"] / M["m00"]) cy = int(M["m01"] / M["m00"]) else: cx, cy = 0, 0 if (len(biggestCnts) < 13): #### CALCULATES ROTATION OF CONTOUR BY FITTING ELLIPSE ########## rotation = getEllipseRotation(image, cnt) # Calculates yaw of contour (horizontal position in degrees) yaw = calculateYaw(cx, centerX, H_FOCAL_LENGTH) # Calculates yaw of contour (horizontal position in degrees) pitch = calculatePitch(cy, centerY, V_FOCAL_LENGTH) ##### DRAWS CONTOUR###### # Gets rotated bounding rectangle of contour rect = cv2.minAreaRect(cnt) # Creates box around that rectangle box = cv2.boxPoints(rect) # Not exactly sure box = np.int0(box) # Draws rotated rectangle cv2.drawContours(image, [box], 0, (23, 184, 80), 3) # Calculates yaw of contour (horizontal position in degrees) yaw = calculateYaw(cx, centerX, H_FOCAL_LENGTH) # Calculates yaw of contour (horizontal position in degrees) pitch = calculatePitch(cy, centerY, V_FOCAL_LENGTH) # Draws a vertical white line passing through center of contour cv2.line(image, (cx, screenHeight), (cx, 0), (255, 255, 255)) # Draws a white circle at center of contour cv2.circle(image, (cx, cy), 6, (255, 255, 255)) # Draws the contours cv2.drawContours(image, [cnt], 0, (23, 184, 80), 1) # Gets the (x, y) and radius of the enclosing circle of contour (x, y), radius = cv2.minEnclosingCircle(cnt) # Rounds center of enclosing circle center = (int(x), int(y)) # Rounds radius of enclosning circle radius = int(radius) # Makes bounding rectangle of contour rx, ry, rw, rh = cv2.boundingRect(cnt) boundingRect = cv2.boundingRect(cnt) # Draws countour of bounding rectangle and enclosing circle in green cv2.rectangle(image, (rx, ry), (rx + rw, ry + rh), (23, 184, 80), 1) cv2.circle(image, center, radius, (23, 184, 80), 1) # Appends important info to array if not biggestCnts: biggestCnts.append([cx, cy, rotation]) elif [cx, cy, rotation] not in biggestCnts: biggestCnts.append([cx, cy, rotation]) # Sorts array based on coordinates (leftmost to rightmost) to make sure contours are adjacent biggestCnts = sorted(biggestCnts, key=lambda x: x[0]) # Target Checking for i in range(len(biggestCnts) - 1): #Rotation of two adjacent contours tilt1 = biggestCnts[i][2] tilt2 = biggestCnts[i + 1][2] #x coords of contours cx1 = biggestCnts[i][0] cx2 = biggestCnts[i + 1][0] cy1 = biggestCnts[i][1] cy2 = biggestCnts[i + 1][1] # If contour angles are opposite if (np.sign(tilt1) != np.sign(tilt2)): centerOfTarget = math.floor((cx1 + cx2) / 2) #ellipse negative tilt means rotated to right #Note: if using rotated rect (min area rectangle) # negative tilt means rotated to left # If left contour rotation is tilted to the left then skip iteration if (tilt1 > 0): if (cx1 < cx2): continue # If left contour rotation is tilted to the left then skip iteration if (tilt2 > 0): if (cx2 < cx1): continue #Angle from center of camera to target (what you should pass into gyro) yawToTarget = calculateYaw(centerOfTarget, centerX, H_FOCAL_LENGTH) #Make sure no duplicates, then append if not targets: targets.append([centerOfTarget, yawToTarget]) elif [centerOfTarget, yawToTarget] not in targets: targets.append([centerOfTarget, yawToTarget]) #Check if there are targets seen if (len(targets) > 0): # pushes that it sees vision target to network tables networkTable.putBoolean("tapeDetected", True) #Sorts targets based on x coords to break any angle tie targets.sort(key=lambda x: math.fabs(x[0])) finalTarget = min(targets, key=lambda x: math.fabs(x[1])) # Puts the yaw on screen #Draws yaw of target + line where center of target is cv2.putText(image, "Yaw: " + str(finalTarget[1]), (40, 40), cv2.FONT_HERSHEY_COMPLEX, .6, (255, 255, 255)) cv2.line(image, (finalTarget[0], screenHeight), (finalTarget[0], 0), (255, 0, 0), 2) currentAngleError = finalTarget[1] # pushes vision target angle to network tables networkTable.putNumber("tapeYaw", currentAngleError) else: # pushes that it deosn't see vision target to network tables networkTable.putBoolean("tapeDetected", False) cv2.line(image, (round(centerX), screenHeight), (round(centerX), 0), (255, 255, 255), 2) return image
def test_img(img_name): img = cv2.imread(img_name, cv2.IMREAD_GRAYSCALE) img_start = cv2.imread(img_name) white_black(img_name, "res2.jpg", 0.85) img = cv2.imread("res2.jpg", cv2.IMREAD_GRAYSCALE) blur = cv2.blur(img, (3, 3)) # blur the image ret, thresh = cv2.threshold(blur, 50, 255, cv2.THRESH_BINARY) contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) hull = [] # calculate points for each contour for i in range(len(contours)): hull.append(cv2.convexHull(contours[i], False)) drawing = np.zeros((thresh.shape[0], thresh.shape[1], 3), np.uint8) canvas = np.ones((img.shape[0], img.shape[1], 3), np.uint8) * 100 for i in range(len(contours)): color_contours = (0, 255, 0) #color = (255, 0, 0) cv2.drawContours(drawing, contours, i, color_contours, 1, 8, hierarchy) #cv2.drawContours(canvas, hull, i, color, 1, 8) cv2.imshow('img1', img) cv2.waitKey(0) cv2.imshow('countur', drawing) cv2.waitKey(0) # Проходя через все контуры, найденные на изображении. font = cv2.FONT_HERSHEY_COMPLEX page = [] rotrect = cv2.minAreaRect(contours[0]) for cnt in contours: if cv2.arcLength(cnt, True) > 800: approx = cv2.approxPolyDP(cnt, 0.012 * cv2.arcLength(cnt, True), True) cv2.drawContours(canvas, [approx], 0, (0, 0, 255), 5) n = approx.ravel() i = 0 for j in n: if (i % 2 == 0): help_arr = [n[i], n[i + 1]] page.append(help_arr) x = n[i] y = n[i + 1] string = str(x) + " " + str(y) cv2.putText(canvas, string, (x, y), font, 0.5, (0, 255, 0)) i = i + 1 rotrect = cv2.minAreaRect(cnt) # РЕДАГУВАННЯ МАСИВУ ДЛЯ ВІДПОВІДНОСТІ # тут треба повороти # коробочка по фрейду box = cv2.boxPoints(rotrect) box = np.int0(box) cv2.drawContours(canvas, [box], 0, (0, 255, 255), 2) cv2.imshow('box', canvas) cv2.waitKey(0) # матриця переходу і трансформація (x1, y1), (x2, y2), angle = rotrect box1 = [[0, 0], [0, y2], [x2, y2], [x2, 0]] box1 = forvard_back(box1) box1 = max_X_sort(box1) box = np.array(box, np.float32) box1 = np.array(box1, np.float32) page = aprox_in_array(find_near(page, box), page) page = np.array(page, np.float32) matrix = cv2.getPerspectiveTransform(page, box1) result = cv2.warpPerspective(img_start, matrix, (int(x2), int(y2))) # Wrap the transformed image cv2.imshow('img transform', result) cv2.imwrite("res.jpg", result) cv2.waitKey(0) # висвітлення фону паперу, приберання малих косяків та підведення ліній # increasing the contrast 20% image = Image.open("res.jpg") new_image = ImageEnhance.Contrast(image).enhance(1.2) result = np.array(new_image) cv2.imwrite("res.jpg", result) white_black("res.jpg", "res2.jpg", 0.85) result = cv2.imread("res2.jpg") cv2.imshow('bw-result', result) cv2.waitKey(0) cv2.destroyAllWindows() # thickness gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY) gray = cv2.bitwise_not(gray) cv2.imshow('gray invert', gray) cv2.waitKey(0) edges = cv2.Canny(result, 50, 150, apertureSize=3) minLineLength = 1 maxLineGap = 1 lines = cv2.HoughLinesP(edges, 1, np.pi / 180, 20, minLineLength, maxLineGap) for l in lines: for x1, y1, x2, y2 in l: cv2.line(result, (x1, y1), (x2, y2), (0, 0, 0), 1) cv2.imshow('with countur', result) cv2.waitKey(0) cv2.destroyAllWindows()
for index in txt_name: four_points_list = load_kitti_annotation(label_folder, index) #标注 label_list = [] for pts in four_points_list: # cv2.line(img,(pts[0],pts[1]),(pts[2],pts[3]),127,1) # cv2.line(img,(pts[2],pts[3]),(pts[4],pts[5]),255,1) # cv2.line(img,(pts[4],pts[5]),(pts[6],pts[7]),255,1) # cv2.line(img,(pts[0],pts[1]),(pts[6],pts[7]),255,1) #求最小外界矩形 cnt = np.array([[pts[0], pts[1]], [pts[2], pts[3]], [pts[4], pts[5]], [pts[6], pts[7]]]) # 必须是array数组的形式 rect = cv2.minAreaRect(cnt) # 得到最小外接矩形的(中心(x,y), (宽,高), 旋转角度) # box = cv2.cv.BoxPoints(rect) # OpenCV 2. 获取最小外接矩形的4个顶点 box = cv2.boxPoints(rect) # OpenCV 3.x 获取最小外接矩形的4个顶点 # cv2.line(img,(box[0][0],box[0][1]),(box[1][0],box[1][1]),127,1) # cv2.line(img,(box[1][0],box[1][1]),(box[2][0],box[2][1]),127,1) # cv2.line(img,(box[2][0],box[2][1]),(box[3][0],box[3][1]),127,1) # cv2.line(img,(box[3][0],box[3][1]),(box[0][0],box[0][1]),127,1) orient_rec_labels = str(int(box[0][0])) + ',' + str(int(box[0][1])) + ',' + \ str(int(box[1][0])) + ',' + str(int(box[1][1])) + ',' + \ str(int(box[2][0])) + ',' + str(int(box[2][1])) + ',' + \ str(int(box[3][0])) + ',' + str(int(box[3][1])) + ',' + \ str(pts[8]) #判断矩形框是否超出图像范围(靠近边缘也删除) i = 0 flag_append = True for i in range(0, 4):
def vision(cap): ret, frame = cap.read() global h_div global s_div global v_div global xTarget global yTarget # show the original frame (Testing only) #cv2.imshow('Original',frame) #Convert to HSV hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) h, s, v = cv2.split(hsv) hue = cv2.absdiff(h, 90) hue = cv2.subtract(90, hue) hue = cv2.divide(hue, h_div) # saturation = cv2.divide(s, s_div) value = cv2.divide(v, v_div) #targetyness = cv2.multiply(hue,saturation) targetyness = cv2.multiply(hue, value) ret, targetyness = cv2.threshold(targetyness, 200, 255, 0) mask = targetyness #Show the mask (Testing Only) #cv2.imshow('mask',mask) #Find the contours of the combined image discardImage, contours, hierarchy = cv2.findContours( targetyness, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) #Make sure that a contour region is found if len(contours) > 1: #find Biggest Contour region areas = [cv2.contourArea(c) for c in contours] max_index = np.argmax(areas) cnt = contours[max_index] #Find the smallest bounding box of the rectangle rect = cv2.minAreaRect(cnt) box = cv2.boxPoints(rect) box = np.int0(box) #find center of target for RoboRIO xCenter = (box[0][0] + box[1][0] + box[2][0] + box[3][0]) / 4 yCenter = (box[0][1] + box[1][1] + box[2][1] + box[3][1]) / 4 #These Calculations and draw settings are to help the driver lock onto the target xLocked = abs(xTarget - xCenter) < xError yLocked = abs(yTarget - yCenter) < yError #This here is just for drawing lines on the screen if (xLocked): cv2.line(frame, (xTarget, 0), (xTarget, 480), (0, 0, 255), 3) else: cv2.line(frame, (xTarget, 0), (xTarget, 480), (255, 0, 0), 3) if (yLocked): cv2.line(frame, (0, yCenter), (640, yCenter), (0, 0, 255), 3) else: cv2.line(frame, (0, yCenter), (640, yCenter), (255, 0, 0), 3) if (xLocked and yLocked): cv2.drawContours(frame, [box], 0, (0, 0, 255), 2) else: cv2.drawContours(frame, [box], 0, (0, 255, 0), 2) msg = '(' + str(xCenter) + ',' + str(yCenter) + ')\n' else: msg = '( 0,0)\n' #show final image (Testing only) #cv2.imshow("Show",frame) #Quit if q is pressed if cv2.waitKey(1) & 0xFF == ord('q'): print exitKey return msg, frame, mask
def getFrontground(img_path): # 1.1 载入图像 img = cv2.imread(img_path) height, width = img.shape[:2] # 获取图像的高和宽 print(height, width) # cv2.imshow('Origin', img) # 1.2 滤波降噪 blured = cv2.blur(img, (5, 5)) # 进行滤波去掉噪声,参数二为低通滤波器的大小 # cv2.imshow('Blur', blured) # 1.3 mask是掩码图像,用来确定哪些区域是背景,哪些区域是前景 mask = np.zeros((height+2, width+2), np.uint8) # 掩码长和宽都比输入图像多两个像素点,满水填充不会超出掩码的非零边缘 # 为什么要加2可以这么理解:当从0行0列开始泛洪填充扫描时,mask多出来的2可以保证扫描的边界上的像素都会被处理 # 1.4 进行泛洪填充 cv2.floodFill(blured, mask, (width-1, height-1), (255, 255, 255), (1, 1, 1), (1, 1, 1), 8) # cv2.imshow('floodfill', blured) # 1.5 转换为灰度图 gray = cv2.cvtColor(blured, cv2.COLOR_BGR2GRAY) # cv2.imshow('gray', gray) # 1.6 定义结构元素 kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(50, 50)) # 1.7 开闭运算,先开运算去除背景噪声,再继续闭运算填充目标内的孔洞 opened = cv2.morphologyEx(gray, cv2.MORPH_OPEN, kernel) closed = cv2.morphologyEx(opened, cv2.MORPH_CLOSE, kernel) # cv2.imshow('closed', closed) # 1.8 求二值图 ret, binary = cv2.threshold(closed, 250, 255, cv2.THRESH_BINARY) # cv2.imshow('binary', binary) # 1.9 找到前景物轮廓 _, contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # 注意,contours[0]表示外轮廓,contours[1]表示内轮廓 # 1.10 绘制轮廓 draw_img = cv2.drawContours(img.copy(), contours, -1, (0, 0, 255), 3) cv2.imshow('result', draw_img) # 1.11 遍历像素点是否在轮廓内,改变轮廓外的像素点 color = (255, 255, 255) for h in range(height): for w in range(width): try: test = cv2.pointPolygonTest(contours[1], (w, h), False) if test == -1 or test == 0: img[h, w] = color except: test = cv2.pointPolygonTest(contours[0], (w, h), False) if test == 1: img[h, w] = color cv2.imshow('handle', img) # 1.12 使用轮廓建立最小矩形区域 for c in contours: # 计算包围目标的最小矩形区域 rect = cv2.minAreaRect(c) # 计算矩形的 4 点坐标,返回结果为float数据类型 points = cv2.boxPoints(rect) # 转换为int类型 box = np.int0(points) # 1.13 根据box将对图片进行裁剪 Xs = [i[0] for i in box] Ys = [i[1] for i in box] x1 = min(Xs) x2 = max(Xs) y1 = min(Ys) y2 = max(Ys) height = y2 - y1 width = x2 - x1 crop_img = img[y1:y1+height, x1:x1+width] cv2.imshow('crop_img', crop_img) cv2.waitKey(0) cv2.destroyAllWindows() return crop_img
def siamese_track(state, im, mask_enable=False, refine_enable=False, device='cpu', debug=False): p = state['p'] net = state['net'] avg_chans = state['avg_chans'] window = state['window'] target_pos = state['target_pos'] target_sz = state['target_sz'] wc_x = target_sz[1] #+ p.context_amount * sum(target_sz) hc_x = target_sz[0] #+ p.context_amount * sum(target_sz) s_x = np.sqrt(wc_x * hc_x) scale_x = p.exemplar_size / s_x # d_search = (p.instance_size - p.exemplar_size) / 2 # pad = d_search / scale_x # s_x = s_x + 2 * pad s_x = s_x * 2 crop_box = [ target_pos[0] - round(s_x) / 2, target_pos[1] - round(s_x) / 2, round(s_x), round(s_x) ] if debug: im_debug = im.copy() crop_box_int = np.int0(crop_box) cv2.rectangle(im_debug, (crop_box_int[0], crop_box_int[1]), (crop_box_int[0] + crop_box_int[2], crop_box_int[1] + crop_box_int[3]), (255, 0, 0), 2) cv2.imshow('search area', im_debug) cv2.waitKey(0) # extract scaled crops for search region x at previous target position x_crop = Variable( get_subwindow_tracking(im, target_pos, p.instance_size, round(s_x), avg_chans).unsqueeze(0)) if mask_enable: score, delta, mask = net.track_mask(x_crop.to(device)) else: score, delta = net.track(x_crop.to(device)) delta = delta.permute(1, 2, 3, 0).contiguous().view(4, -1).data.cpu().numpy() score = F.softmax(score.permute(1, 2, 3, 0).contiguous().view(2, -1).permute(1, 0), dim=1).data[:, 1].cpu().numpy() delta[0, :] = delta[0, :] * p.anchor[:, 2] + p.anchor[:, 0] delta[1, :] = delta[1, :] * p.anchor[:, 3] + p.anchor[:, 1] delta[2, :] = np.exp(delta[2, :]) * p.anchor[:, 2] delta[3, :] = np.exp(delta[3, :]) * p.anchor[:, 3] def change(r): return np.maximum(r, 1. / r) def sz(w, h): pad = (w + h) * 0.5 sz2 = (w + pad) * (h + pad) return np.sqrt(sz2) def sz_wh(wh): pad = (wh[0] + wh[1]) * 0.5 sz2 = (wh[0] + pad) * (wh[1] + pad) return np.sqrt(sz2) # size penalty target_sz_in_crop = target_sz * scale_x # if predicted size < 127, then scale penalty = 127 / predicted_size, if predicted_size > 127, then scale penalty = predicted_size / 127 s_c = change(sz(delta[2, :], delta[3, :]) / (sz_wh(target_sz_in_crop))) # scale penalty # put penalty on aspect ratio change, the same way as the size change r_c = change((target_sz_in_crop[0] / target_sz_in_crop[1]) / (delta[2, :] / delta[3, :])) # ratio penalty penalty = np.exp(-(r_c * s_c - 1) * p.penalty_k) pscore = penalty * score # pscore = score # cos window (motion model) pscore = pscore * (1 - p.window_influence) + window * p.window_influence best_pscore_id = np.argmax(pscore) best_pscore = pscore[best_pscore_id] state['best_pscore'] = best_pscore pred_in_crop = delta[:, best_pscore_id] / scale_x lr = penalty[best_pscore_id] * score[best_pscore_id] * p.lr # lr for OTB res_x = pred_in_crop[0] + target_pos[0] res_y = pred_in_crop[1] + target_pos[1] res_w = target_sz[0] * (1 - lr) + pred_in_crop[2] * lr res_h = target_sz[1] * (1 - lr) + pred_in_crop[3] * lr target_pos = np.array([res_x, res_y]) target_sz = np.array([res_w, res_h]) # for Mask Branch if mask_enable: best_pscore_id_mask = np.unravel_index(best_pscore_id, (5, p.score_size, p.score_size)) delta_x, delta_y = best_pscore_id_mask[2], best_pscore_id_mask[1] if refine_enable: mask = net.track_refine( (delta_y, delta_x)).to(device).sigmoid().squeeze().view( p.out_size, p.out_size).cpu().data.numpy() else: mask = mask[0, :, delta_y, delta_x].sigmoid(). \ squeeze().view(p.out_size, p.out_size).cpu().data.numpy() def crop_back(image, bbox, out_sz, padding=-1): a = (out_sz[0] - 1) / bbox[2] b = (out_sz[1] - 1) / bbox[3] c = -a * bbox[0] d = -b * bbox[1] mapping = np.array([[a, 0, c], [0, b, d]]).astype(np.float) crop = cv2.warpAffine(image, mapping, (out_sz[0], out_sz[1]), flags=cv2.INTER_LINEAR, borderMode=cv2.BORDER_CONSTANT, borderValue=padding) return crop s = crop_box[2] / p.instance_size sub_box = [ crop_box[0] + (delta_x - p.base_size / 2) * p.total_stride * s, crop_box[1] + (delta_y - p.base_size / 2) * p.total_stride * s, s * p.exemplar_size, s * p.exemplar_size ] s = p.out_size / sub_box[2] back_box = [ -sub_box[0] * s, -sub_box[1] * s, state['im_w'] * s, state['im_h'] * s ] mask_in_img = crop_back(mask, back_box, (state['im_w'], state['im_h'])) target_mask = (mask_in_img > p.seg_thr).astype(np.uint8) if cv2.__version__[-5] == '4': contours, _ = cv2.findContours(target_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) else: _, contours, _ = cv2.findContours(target_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cnt_area = [cv2.contourArea(cnt) for cnt in contours] if len(contours) != 0 and np.max(cnt_area) > 100: contour = contours[np.argmax(cnt_area)] # use max area polygon polygon = contour.reshape(-1, 2) # pbox = cv2.boundingRect(polygon) # Min Max Rectangle prbox = cv2.boxPoints( cv2.minAreaRect(polygon)) # Rotated Rectangle # box_in_img = pbox rbox_in_img = prbox else: # empty mask location = cxy_wh_2_rect(target_pos, target_sz) rbox_in_img = np.array( [[location[0], location[1]], [location[0] + location[2], location[1]], [location[0] + location[2], location[1] + location[3]], [location[0], location[1] + location[3]]]) target_pos[0] = max(0, min(state['im_w'], target_pos[0])) target_pos[1] = max(0, min(state['im_h'], target_pos[1])) target_sz[0] = max(10, min(state['im_w'], target_sz[0])) target_sz[1] = max(10, min(state['im_h'], target_sz[1])) state['target_pos'] = target_pos state['target_sz'] = target_sz state['score'] = score[best_pscore_id] state['mask'] = mask_in_img if mask_enable else [] state['ploygon'] = rbox_in_img if mask_enable else [] return state
def UniversalProcess(self, inframe): inimg = inframe.getCvBGR() outimg = inimg #change to hsv hsv = cv2.cvtColor(inimg, cv2.COLOR_BGR2HSV) arrayForHSV = list(self.stringForHSV) #threshold colors to detect - Green: First value decides color, second val determines intensity, third val decides brightness lowerThreshold = np.array([self.lowerH, self.lowerS, self.lowerV]) upperThreshold = np.array([self.upperH, self.upperS, self.upperV]) if len(arrayForHSV) > 15 and arrayForHSV[4] == "h": stringForH = self.stringForHSV.lstrip("set hrange") stringHSpace = stringForH.replace("...", " ") stringH = stringHSpace.split(" ") self.lowerH = int(stringH[0]) self.upperH = int(stringH[1]) lowerThreshold = np.array([self.lowerH, self.lowerS, self.lowerV]) upperThreshold = np.array([self.upperH, self.upperS, self.upperV]) #jevois.sendSerial("hello") if len(arrayForHSV) > 15 and arrayForHSV[4] == "s": stringForS = self.stringForHSV.lstrip("set srange") stringSSpace = stringForS.replace("...", " ") stringS = stringSSpace.split(" ") self.lowerS = int(stringS[0]) self.upperS = int(stringS[1]) lowerThreshold = np.array([self.lowerH, self.lowerS, self.lowerV]) upperThreshold = np.array([self.upperH, self.upperS, self.upperV]) if len(arrayForHSV) > 15 and arrayForHSV[4] == "v": stringForV = self.stringForHSV.lstrip("set vrange") stringVSpace = stringForV.replace("...", " ") stringV = stringVSpace.split(" ") self.lowerV = int(stringV[0]) self.upperV = int(stringV[1]) lowerThreshold = np.array([self.lowerH, self.lowerS, self.lowerV]) upperThreshold = np.array([self.upperH, self.upperS, self.upperV]) #jevois.sendSerial(str(lowerThreshold)) #jevois.sendSerial(str(upperThreshold)) oKernel = np.ones((2, 2), np.uint8) cKernel = np.ones((4, 4), np.uint8) #cKernel = np.array([ #[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], #[1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], #[0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0], #[0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0], #[0, 0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]], dtype = np.uint8) #check if color in range mask = cv2.inRange(hsv, lowerThreshold, upperThreshold) result = cv2.bitwise_and(inimg, inimg, mask=mask) #create blur on image to reduce noise blur = cv2.GaussianBlur(mask, (5, 5), 0) ret, thresh = cv2.threshold(blur, 65, 255, cv2.THRESH_BINARY) #closes of noise from inside object closing = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, cKernel) #takes away noise from outside object opening = cv2.morphologyEx(closing, cv2.MORPH_OPEN, oKernel) #find contours contours, _ = cv2.findContours(opening, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) cntArray = [] for contour in contours: peri = cv2.arcLength(contour, True) approx = cv2.approxPolyDP(contour, 0.04 * peri, True) cntArea = cv2.contourArea(contour) if cntArea > 75 and cntArea < 800: cntArray.append(contour) sortedArray = self.sortContours(cntArray) if len(sortedArray) == 0: jevois.sendSerial('{"Distance":-11, "Angle":-100}') #outimg = cv2.cvtColor(opening, cv2.COLOR_GRAY2BGR) outimg = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) return result boxColor = (240, 255, 255) target = cv2.minAreaRect(sortedArray[0]) points_A = cv2.boxPoints(target) points_1 = np.int0(points_A) cv2.drawContours(result, [points_1], 0, boxColor, 2) targetX = target[0][0] targetY = target[0][1] yawAngle = (targetX - 159.5) * 0.203125 #get actual thing later distance = -12 yawAngle = str(yawAngle) distance = str(distance) JSON = '{"Distance":' + distance + ', "Angle":' + yawAngle + '}' jevois.sendSerial(JSON) #jevois.sendSerial(yawAngle) #outimg = cv2.cvtColor(opening, cv2.COLOR_GRAY2BGR) outimg = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR) return result
def __getitem__(self, index): img_path = self.img_files[index] seg_mask_path = self.seg_mask_files[index] ins_mask_path = self.ins_mask_files[index] # First try # data = np.array(Image.open(img_path)) # label_seg = np.array(Image.open(seg_mask_path)) # label_ins = np.array(Image.open(ins_mask_path)) # return torch.from_numpy(data).float(), torch.from_numpy(label_seg).float(), torch.from_numpy(label_ins).float() # Second try # data = torch.Tensor(Image.open(img_path).convert('RGB')) # data = self.to_tensor(Image.open(img_path).convert('RGB')) # label_seg = torch.Tensor(Image.open(seg_mask_path).convert('L')) # label_seg = self.to_tensor(Image.open(seg_mask_path).convert('L')) # label_ins = self.to_tensor(Image.open(ins_mask_path).convert('L')) # label_ins = torch.Tensor(Image.open(ins_mask_path).convert('L')) # Original try data = np.asarray(Image.open(img_path).convert('L')) data = torch.Tensor(data[np.newaxis]) data_shape = np.ones((1024, 1024), dtype=np.uint8) * 255 fullname = os.path.join(ins_mask_path) xmldoc = minidom.parse(fullname) itemlist = xmldoc.getElementsByTagName('robndbox') ins = np.zeros((0, 1024, 1024), dtype=np.uint8) for rec in itemlist[:10]: x = float(rec.getElementsByTagName('cx')[0].firstChild.nodeValue) y = float(rec.getElementsByTagName('cy')[0].firstChild.nodeValue) w = float(rec.getElementsByTagName('w')[0].firstChild.nodeValue) h = float(rec.getElementsByTagName('h')[0].firstChild.nodeValue) theta = float( rec.getElementsByTagName('angle')[0].firstChild.nodeValue) rect = ([x, y], [w, h], math.degrees(theta)) box = np.int0(cv2.boxPoints(rect)) gt = np.zeros_like(data_shape) gt = cv2.fillPoly(gt, [box], 1) ins[:, gt != 0] = 0 ins = np.concatenate([ins, gt[np.newaxis]]) sem = np.zeros_like(data_shape, dtype=bool) sem[np.sum(ins, axis=0) != 0] = True sem = np.stack([~sem, sem]).astype(np.uint8) label_ins = torch.Tensor(ins) label_seg = torch.Tensor(sem) # # Worked for report # data = np.asarray(Image.open(img_path).convert('RGB')).transpose((2,0,1)) # data = torch.Tensor(data) # label_ins = np.asarray(Image.open(ins_mask_path).convert('L')) # label_ins = torch.Tensor(label_ins[np.newaxis]) # label_seg = np.asarray(Image.open(seg_mask_path).convert('L')) # label_seg = torch.Tensor(label_seg[np.newaxis]) filename = self.filenames[index] if self.train: return data, label_seg, label_ins else: return data, filename
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) plt.axis("off") # show the figure plt.show() method_1_original_image = original_image.copy() method_2_original_image = original_image.copy() # loop over the contours individually for (index, contour) in enumerate(contours): # if the contour is not sufficiently large, ignore it if cv2.contourArea(contour) < 100: continue # compute the rotated bounding box of the contour box = cv2.minAreaRect(contour) box_points = cv2.boxPoints(box) box_points = np.array(box_points, dtype="int") # show the original coordinates print("Object #{}:".format(index + 1)) print(box_points) # draw the contours cv2.drawContours(method_1_original_image, [box_points], -1, (0, 255, 0), 2) cv2.drawContours(method_2_original_image, [box_points], -1, (0, 255, 0), 2) # show compare contour sorting fig = plt.figure("Contours") images = ("Method 1 Contours", method_1_original_image), ("Method 2 Contours", method_2_original_image) # show the image
cv2.imwrite('edges2.png', edges) # 輪郭抽出 contours, hierarchy = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # 面積でフィルタリング rects = [] for cnt, hrchy in zip(contours, hierarchy[0]): if cv2.contourArea(cnt) < 200: continue # 面積が小さいものは除く #if hrchy[3] == -1: # continue # ルートノードは除く # 輪郭を囲む長方形を計算する。 rect = cv2.minAreaRect(cnt) rect_points = cv2.boxPoints(rect).astype(int) rects.append(rect_points) # x-y 順でソート rects = sorted(rects, key=lambda x: (x[0][1], x[0][0])) # 描画する。 for i, rect in enumerate(rects): color = np.random.randint(0, 255, 3).tolist() cv2.drawContours(img, rects, i, color, 2) #cv2.putText(img, str(i), tuple(rect[0]), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2) print('rect:\n', rect) cv2.imwrite('img.png', img)
angles=np.array(angles)) rotated_rectangles = [ east.get_cv_rotated_rect(bbox, angle * -1) for (bbox, angle) in zip(boxes, angles) ] if frame is not None: if in_det is not None: rec_received = 0 rec_pushed = len(rotated_rectangles) if rec_pushed: print("====== Pushing for recognition, count:", rec_pushed) cropped_stacked = None for idx, rotated_rect in enumerate(rotated_rectangles): # Draw detection crop area on input frame points = np.int0(cv2.boxPoints(rotated_rect)) cv2.polylines(frame, [points], isClosed=True, color=(255, 0, 0), thickness=1, lineType=cv2.LINE_8) # TODO make it work taking args like in OpenCV: # rr = ((256, 256), (128, 64), 30) rr = dai.RotatedRect() rr.center.x = rotated_rect[0][0] rr.center.y = rotated_rect[0][1] rr.size.width = rotated_rect[1][0] rr.size.height = rotated_rect[1][1] rr.angle = rotated_rect[2] cfg = dai.ImageManipConfig()
def getDetBoxes_core(textmap, linkmap, text_threshold, link_threshold, low_text): # prepare data linkmap = linkmap.copy() textmap = textmap.copy() img_h, img_w = textmap.shape """ labeling method """ ret, text_score = cv2.threshold(textmap, low_text, 1, 0) ret, link_score = cv2.threshold(linkmap, link_threshold, 1, 0) text_score_comb = np.clip(text_score + link_score, 0, 1) nLabels, labels, stats, centroids = cv2.connectedComponentsWithStats( text_score_comb.astype(np.uint8), connectivity=4) det = [] mapper = [] for k in range(1, nLabels): # size filtering size = stats[k, cv2.CC_STAT_AREA] if size < 10: continue # thresholding if np.max(textmap[labels == k]) < text_threshold: continue # make segmentation map segmap = np.zeros(textmap.shape, dtype=np.uint8) segmap[labels == k] = 255 segmap[np.logical_and(link_score == 1, text_score == 0)] = 0 # remove link area x, y = stats[k, cv2.CC_STAT_LEFT], stats[k, cv2.CC_STAT_TOP] w, h = stats[k, cv2.CC_STAT_WIDTH], stats[k, cv2.CC_STAT_HEIGHT] niter = int(math.sqrt(size * min(w, h) / (w * h)) * 2) sx, ex, sy, ey = x - niter, x + w + niter + 1, y - niter, y + h + niter + 1 # boundary check if sx < 0: sx = 0 if sy < 0: sy = 0 if ex >= img_w: ex = img_w if ey >= img_h: ey = img_h kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1 + niter, 1 + niter)) segmap[sy:ey, sx:ex] = cv2.dilate(segmap[sy:ey, sx:ex], kernel) # make box np_contours = np.roll(np.array(np.where(segmap != 0)), 1, axis=0).transpose().reshape(-1, 2) rectangle = cv2.minAreaRect(np_contours) box = cv2.boxPoints(rectangle) # align diamond-shape w, h = np.linalg.norm(box[0] - box[1]), np.linalg.norm(box[1] - box[2]) box_ratio = max(w, h) / (min(w, h) + 1e-5) if abs(1 - box_ratio) <= 0.1: l, r = min(np_contours[:, 0]), max(np_contours[:, 0]) t, b = min(np_contours[:, 1]), max(np_contours[:, 1]) box = np.array([[l, t], [r, t], [r, b], [l, b]], dtype=np.float32) # make clock-wise order startidx = box.sum(axis=1).argmin() box = np.roll(box, 4 - startidx, 0) box = np.array(box) det.append(box) mapper.append(k) return det, labels, mapper
_, cnts, _ = cv2.findContours(dilation, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) #cnts = imutils.grab_contours(cnts) (cnts, _) = contours.sort_contours(cnts) width = 2.2 ## in inches print(len(cnts)) for c in cnts: if cv2.contourArea(c) < 20000: continue box = cv2.minAreaRect( c) ## will get the center,width,height,angle of rotations box = cv2.boxPoints(box) ## will get the corners box = np.array(box, dtype="int") box = perspective.order_points(box) cv2.drawContours(original, [box.astype("int")], -1, (0, 255, 0), 10) for (x, y) in box: cv2.circle(original, (int(x), int(y)), 5, (0, 0, 255), -1) ## draw the corners (topleft, topright, bottomright, bottomleft) = box ## Top right ,top right , bottom right , bottom left (topleft_toprightX, topleft_toprightY) = midpoint( topleft, topright) ## midpoint of top row of rectangele (bottomleft_bottomrightX, bottomleft_bottomrightY) = midpoint( bottomleft, bottomright) ## midpoint of bottom row of rectangle
def get_plant_height(image, zoom_ratio): image_height = get_height(image) image_width = get_width(image) # define range of orange color in HSV hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) hsv2 = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) hsv3 = cv2.cvtColor(image, cv2.COLOR_BGR2HSV) lower_orange = np.array([11, 43, 46]) upper_orange = np.array([26, 255, 255]) lower_purple = np.array([100, 50, 50]) upper_purple = np.array([200, 200, 200]) lower_green = np.array([30, 200, 100]) upper_green = np.array([100, 255, 190]) mask = cv2.inRange(hsv, lower_orange, upper_orange) mask2 = cv2.inRange(hsv2, lower_green, upper_green) mask3 = cv2.inRange(hsv3, lower_purple, upper_purple) res = cv2.add(mask, mask3) cv2.imshow('res', res) a = np.zeros(get_width(image)) stem_top = [] stem_bottom = [] cv2.imshow('image', image) # corp_threshold = int(560 * (4 / 5)) # print(a) # mask[0:corp_threshold] = a # mask[550:560] = a if zoom_ratio < 0.25: mask = cv2.erode(mask, None, iterations=3) mask = cv2.dilate(mask, None, iterations=2) j = 0 cv2.imshow('mask', mask) for i in range(image_height): for k in range(image_width): if mask[i][k] == 255: stem_top = [k, i] # print(stem_top) j = 1 break if j == 1: break stem_bottom = [145, 535] orig = image.copy() else: kernel = np.ones((10, 1), np.uint8) # 1, 13 # cv2.imshow("mask2", mask) res = cv2.erode(res, None, iterations=1) res[0:100] = a res[493:image_height] = a # print(res.shape) cv2.imshow('res1', res) res = cv2.erode(res, kernel, iterations=1) cv2.imshow('res2', res) kernel2 = np.ones((10, 1), np.uint8) res = cv2.dilate(res, kernel2, iterations=2) cv2.imshow('res2', res) j = 0 for i in range(image_height): for k in range(image_width): if res[i][k] == 255: stem_top = [k, i] # print(stem_top) j = 1 break if j == 1: break mask2[0:445] = a kernel = np.ones((1, 10), np.uint8) mask2 = cv2.erode(mask2, kernel, iterations=1) # cv2.imshow("mask", mask2) mask2 = cv2.dilate(mask2, kernel, iterations=2) # cv2.imshow("mask1", mask2) cnts = cv2.findContours(mask2.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) cnts = imutils.grab_contours(cnts) (cnts, _) = contours.sort_contours(cnts) for c in cnts: if cv2.contourArea(c) < 10: continue orig = image.copy() box = cv2.minAreaRect(c) box = \ (cv2.cv.BoxPoints(box) if imutils.is_cv2() else cv2.boxPoints(box)) box = np.array(box, dtype='int') box = perspective.order_points(box) cv2.drawContours(orig, [box.astype('int')], -1, (0, 255, 0), 2) (tl, tr, br, bl) = box midX = (tl[0] + tr[0]) / 2 midY = (tl[1] + bl[1]) / 2 stem_bottom = [midX, midY] plant_height = dist.euclidean((stem_top[0], stem_top[1]), (stem_bottom[0], stem_bottom[1])) real_plant_height = plant_height * zoom_ratio real_plant_height = round(real_plant_height, 2) cv2.line(orig, (int(stem_top[0]), int(stem_top[1])), (int(stem_bottom[0]), int(stem_bottom[1])), (0, 0, 255), 2) cv2.putText( orig, '{:.2f}'.format(real_plant_height), (int(stem_top[0]), int(stem_top[1])), cv2.FONT_HERSHEY_SIMPLEX, 0.65, (0, 0, 0), 2, ) cv2.imshow('orig', orig) cv2.waitKey(0) return real_plant_height
def draw_emo_v2(bg, face, txt): """绘制表情图,利用opencv,智能识别表情插入位置 Args: bg: 底图 face: 前脸 txt: 文本 Returns: Image Raises: """ bg_img = cv2.imread(bg) f_img = cv2.imread(face) # 读入背景的灰度图,方便进行处理 bg_img_gray = cv2.cvtColor(bg_img, cv2.COLOR_BGR2GRAY) #Otsu 滤波,产生二值化的图片 ret2,th_bg = cv2.threshold(bg_img_gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU) #第一步,找出图片中的熊猫轮廓 # 将熊猫弄成白色 th_bg_inv = cv2.bitwise_not(th_bg) # 找轮廓 image,cnts,hierarchy = cv2.findContours(th_bg_inv,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE) areas_s_idx = contours_sort_idx(cnts) bg_mask = th_bg_inv.copy() # 将熊猫区域内填充黑色,形成mask cv2.drawContours(bg_mask, cnts, areas_s_idx[0], (255,255,255), cv2.FILLED) # bg_mask = cv2.bitwise_not(bg_mask) # 使用下面的方式进行抠图,把原图与一个黑色的图片叠加,mask为蒙版,蒙版中白色的地方会进行add,黑色区域的像素会被删除(变成黑色) face_bg_cntimg=cv2.add(th_bg, th_bg, mask=bg_mask) # 产生的face_cntimg中,只有表情所在的轮廓是白的,其他都是黑的,可能存在噪点,通过面积排序去除干扰 image,face_bg_cnts,hierarchy = cv2.findContours(face_bg_cntimg,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE) image = bg_img.copy() areas_s_idx = contours_sort_idx(face_bg_cnts) rect = cv2.minAreaRect(face_bg_cnts[areas_s_idx[0][0]]) box = cv2.boxPoints(rect) # 将box缩小一下,让图片插入的位置更好看 offset = 15 box[0][0] = box[0][0] + offset box[0][1] = box[0][1] - offset box[1][0] = box[1][0] + offset box[1][1] = box[1][1] + offset box[2][0] = box[2][0] - offset box[2][1] = box[2][1] + offset box[3][0] = box[3][0] - offset box[3][1] = box[3][1] - offset roi = bg_img[int(box[1][1]):int(box[0][1]), int(box[0][0]):int(box[2][0])] f_img_resize = cv2.resize(f_img, roi.shape[-2::-1]) # 单纯的add对这种黑白图片,效果很糟糕 # roi = cv2.add(roi, f_img_resize) # 读入表情的灰度图,方便进行处理 fg_img_gray = cv2.cvtColor(f_img_resize, cv2.COLOR_BGR2GRAY) #Otsu 滤波,产生二值化的图片 ret2,mask = cv2.threshold(fg_img_gray,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU) mask_inv = cv2.bitwise_not(mask) # 背景图,去掉表情中的黑色部分的像素 img1_bg = cv2.bitwise_and(roi, roi, mask = mask) # 表情图,去掉图片中的白色部分 img2_fg = cv2.bitwise_and(f_img_resize, f_img_resize, mask = mask_inv) dst = cv2.add(img1_bg, img2_fg) bg_img[int(box[1][1]):int(box[0][1]), int(box[0][0]):int(box[2][0])] = dst image_result = Image.fromarray(cv2.cvtColor(bg_img,cv2.COLOR_BGR2RGB)) # 创建底图 target = Image.new( 'RGBA', (CONST_IMG_WIDTH, CONST_IMG_HEIGH), (255, 255, 255, 255)) # 表情背景贴到底图上 target.paste(image_result, (0, 0)) target = draw_text_v4(txt, target, off_set=(5, 200), allign='center') return target
def getBoxes(y_pred, detection_threshold=0.7, text_threshold=0.4, link_threshold=0.4, size_threshold=10): box_groups = [] for y_pred_cur in y_pred: # Prepare data textmap = y_pred_cur[..., 0].copy() linkmap = y_pred_cur[..., 1].copy() img_h, img_w = textmap.shape _, text_score = cv2.threshold(textmap, thresh=text_threshold, maxval=1, type=cv2.THRESH_BINARY) _, link_score = cv2.threshold(linkmap, thresh=link_threshold, maxval=1, type=cv2.THRESH_BINARY) n_components, labels, stats, _ = cv2.connectedComponentsWithStats( np.clip(text_score + link_score, 0, 1).astype('uint8'), connectivity=4) boxes = [] for component_id in range(1, n_components): # Filter by size size = stats[component_id, cv2.CC_STAT_AREA] if size < size_threshold: continue # If the maximum value within this connected component is less than # text threshold, we skip it. if np.max(textmap[labels == component_id]) < detection_threshold: continue # Make segmentation map. It is 255 where we find text, 0 otherwise. segmap = np.zeros_like(textmap) segmap[labels == component_id] = 255 segmap[np.logical_and(link_score, text_score)] = 0 x, y, w, h = [ stats[component_id, key] for key in [ cv2.CC_STAT_LEFT, cv2.CC_STAT_TOP, cv2.CC_STAT_WIDTH, cv2.CC_STAT_HEIGHT ] ] # Expand the elements of the segmentation map niter = int(np.sqrt(size * min(w, h) / (w * h)) * 2) sx, sy = max(x - niter, 0), max(y - niter, 0) ex, ey = min(x + w + niter + 1, img_w), min(y + h + niter + 1, img_h) segmap[sy:ey, sx:ex] = cv2.dilate( segmap[sy:ey, sx:ex], cv2.getStructuringElement(cv2.MORPH_RECT, (1 + niter, 1 + niter))) # Make rotated box from contour contours = cv2.findContours(segmap.astype('uint8'), mode=cv2.RETR_TREE, method=cv2.CHAIN_APPROX_SIMPLE)[-2] contour = contours[0] box = cv2.boxPoints(cv2.minAreaRect(contour)) # Check to see if we have a diamond w, h = np.linalg.norm(box[0] - box[1]), np.linalg.norm(box[1] - box[2]) box_ratio = max(w, h) / (min(w, h) + 1e-5) if abs(1 - box_ratio) <= 0.1: l, r = contour[:, 0, 0].min(), contour[:, 0, 0].max() t, b = contour[:, 0, 1].min(), contour[:, 0, 1].max() box = np.array([[l, t], [r, t], [r, b], [l, b]], dtype=np.float32) else: # Make clock-wise order box = np.array(np.roll(box, 4 - box.sum(axis=1).argmin(), 0)) boxes.append(2 * box) box_groups.append(np.array(boxes)) return box_groups