Python cv2.approxPolyDP() Examples
The following are 30
code examples of cv2.approxPolyDP().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
cv2
, or try the search function
.
![](https://www.programcreek.com/common/static/images/search.png)
Example #1
Source File: chapter2.py From OpenCV-Computer-Vision-Projects-with-Python with MIT License | 19 votes |
def FindHullDefects(self, segment): _,contours,hierarchy = cv2.findContours(segment, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # find largest area contour max_area = -1 for i in range(len(contours)): area = cv2.contourArea(contours[i]) if area>max_area: cnt = contours[i] max_area = area cnt = cv2.approxPolyDP(cnt,0.01*cv2.arcLength(cnt,True),True) hull = cv2.convexHull(cnt, returnPoints=False) defects = cv2.convexityDefects(cnt, hull) return [cnt,defects]
Example #2
Source File: squares.py From OpenCV-Python-Tutorial with MIT License | 9 votes |
def find_squares(img): img = cv2.GaussianBlur(img, (5, 5), 0) squares = [] for gray in cv2.split(img): for thrs in xrange(0, 255, 26): if thrs == 0: bin = cv2.Canny(gray, 0, 50, apertureSize=5) bin = cv2.dilate(bin, None) else: retval, bin = cv2.threshold(gray, thrs, 255, cv2.THRESH_BINARY) bin, contours, hierarchy = cv2.findContours(bin, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: cnt_len = cv2.arcLength(cnt, True) cnt = cv2.approxPolyDP(cnt, 0.02*cnt_len, True) if len(cnt) == 4 and cv2.contourArea(cnt) > 1000 and cv2.isContourConvex(cnt): cnt = cnt.reshape(-1, 2) max_cos = np.max([angle_cos( cnt[i], cnt[(i+1) % 4], cnt[(i+2) % 4] ) for i in xrange(4)]) if max_cos < 0.1: squares.append(cnt) return squares
Example #3
Source File: load_saved_model.py From document-ocr with Apache License 2.0 | 7 votes |
def mask_to_bbox(mask, image, num_class, area_threhold=0, out_path=None, out_file_name=None): bbox_list = [] im = copy.copy(image) mask = mask.astype(np.uint8) for i in range(1, num_class, 1): c_bbox_list = [] c_mask = np.zeros_like(mask) c_mask[np.where(mask==i)] = 255 bimg , countours, hier = cv2.findContours(c_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) for cnt in countours: area = cv2.contourArea(cnt) if area < area_threhold: continue epsilon = 0.005 * cv2.arcLength(cnt,True) approx = cv2.approxPolyDP(cnt,epsilon,True) (x, y, w, h) = cv2.boundingRect(approx) c_bbox_list.append([x, y, x+w, y+h]) if out_path is not None: color = COLOR_LIST[i-1] im=cv2.rectangle(im, pt1=(x, y), pt2=(x+w, y+h),color=color, thickness=2) bbox_list.append(c_bbox_list) if out_path is not None: outf = os.path.join(out_path, out_file_name) cv2.imwrite(outf, im) return bbox_list
Example #4
Source File: ocr_controller.py From JusticeAI with MIT License | 6 votes |
def _find_document_corners(resized_img): contours = _compute_all_contours(resized_img) resized_height, resized_width = _get_img_dimensions(resized_img) full_resized_image_area = resized_height * resized_width # Default to the smallest possible document area and save any larger document areas largest_document_area = full_resized_image_area * ALIGNMENT_PERCENT_AREA_DOCUMENT_MUST_COVER # Default to largest: no modification to the image if no document is found largest_document_corners = _get_corner_array(resized_height, resized_width) for contour in contours: contour_perimeter = cv2.arcLength(contour, True) approximate_polygonal_contour = cv2.approxPolyDP(contour, 0.03 * contour_perimeter, True) # All pages have 4 corners and are convex if (len(approximate_polygonal_contour) == 4 and cv2.isContourConvex(approximate_polygonal_contour) and cv2.contourArea(approximate_polygonal_contour) > largest_document_area): largest_document_area = cv2.contourArea(approximate_polygonal_contour) largest_document_corners = approximate_polygonal_contour return largest_document_corners
Example #5
Source File: detect_tables.py From namsel with MIT License | 6 votes |
def find_boxes(tiff_fl, blur=False): im = Image.open(tiff_fl).convert('L') a = np.asarray(im) if blur: a = cv.GaussianBlur(a, (5, 5), 0) contours, hierarchy = cv.findContours(a.copy(), mode=cv.RETR_TREE, method=cv.CHAIN_APPROX_SIMPLE) border_boxes = [] # n = np.ones_like(a) for j,cnt in enumerate(contours): cnt_len = cv.arcLength(cnt, True) orig_cnt = cnt.copy() cnt = cv.approxPolyDP(cnt, 0.02*cnt_len, True) if len(cnt) == 4 and ((a.shape[0]-3) * (a.shape[1] -3)) > cv.contourArea(cnt) > 1000 and cv.isContourConvex(cnt): cnt = cnt.reshape(-1, 2) max_cos = np.max([angle_cos( cnt[i], cnt[(i+1) % 4], cnt[(i+2) % 4] ) for i in xrange(4)]) if max_cos < 0.1: b = cv.boundingRect(orig_cnt) x,y,w,h = b border_boxes.append(b) # cv.rectangle(n, (x,y), (x+w, y+h), 0) # cv.drawContours(n, [cnt], -1,0, thickness = 5) # Image.fromarray(n*255).show() return border_boxes
Example #6
Source File: __init__.py From rubiks-cube-tracker with MIT License | 6 votes |
def __init__(self, rubiks_parent, index, contour, heirarchy, debug): self.rubiks_parent = rubiks_parent self.index = index self.contour = contour self.heirarchy = heirarchy peri = cv2.arcLength(contour, True) self.approx = cv2.approxPolyDP(contour, 0.1 * peri, True) self.area = cv2.contourArea(contour) self.corners = len(self.approx) self.width = None self.debug = debug # compute the center of the contour M = cv2.moments(contour) if M["m00"]: self.cX = int(M["m10"] / M["m00"]) self.cY = int(M["m01"] / M["m00"]) # if self.cX == 188 and self.cY == 93: # log.warning("CustomContour M %s" % pformat(M)) else: self.cX = None self.cY = None
Example #7
Source File: Dataloader.py From Text_Segmentation_Image_Inpainting with GNU General Public License v3.0 | 6 votes |
def draw_contour(img, mask): a, b, c = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE) for cnt in b: approx = cv2.approxPolyDP(cnt, 0, True) cv2.drawContours(img, [approx], 0, (255, 255, 255), -1) return img
Example #8
Source File: find_milkbox.py From PyCV-time with MIT License | 5 votes |
def contour_proc(frame, debug=False): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) if debug: cv2.imshow('gray', gray) # blur the result from edge detection to ensure continuity edge = cv2.Canny(gray, 30, 100) edge = cv2.blur(edge, (2,2)) if debug: cv2.imshow('blured edge', edge) # convert image to black and white and show it thresh1, thresh = cv2.threshold(edge, 60, 255, cv2.THRESH_BINARY) if debug: cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0,255,0), 3) if debug: cv2.imshow('cpframe', cpframe) # ================== TODO =================== # Modify these code to suit your need contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 400] contours = [cv2.approxPolyDP(ctr, 3 , True) for ctr in contours] contours = [ctr for ctr in contours if len(ctr) == 5] parallelograms = find_milkbox(contours) # ============================================ # draw on the frame cv2.drawContours(frame, parallelograms, -1, (0,255,0), 3) return frame
Example #9
Source File: test.py From object-localization with MIT License | 5 votes |
def main(): model = create_model() model.load_weights(WEIGHTS_FILE) for filename in glob.glob(IMAGES): unscaled = cv2.imread(filename) image = cv2.resize(unscaled, (IMAGE_SIZE, IMAGE_SIZE)) feat_scaled = preprocess_input(np.array(image, dtype=np.float32)) region = np.squeeze(model.predict(feat_scaled[np.newaxis,:])) output = np.zeros(region.shape, dtype=np.uint8) output[region > 0.5] = 1 contours, _ = cv2.findContours(output, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: approx = cv2.approxPolyDP(cnt, EPSILON * cv2.arcLength(cnt, True), True) x, y, w, h = cv2.boundingRect(approx) x0 = np.rint(x * unscaled.shape[1] / output.shape[1]).astype(int) x1 = np.rint((x + w) * unscaled.shape[1] / output.shape[1]).astype(int) y0 = np.rint(y * unscaled.shape[0] / output.shape[0]).astype(int) y1 = np.rint((y + h) * unscaled.shape[0] / output.shape[0]).astype(int) cv2.rectangle(unscaled, (x0, y0), (x1, y1), (0, 255, 0), 1) cv2.imshow("image", unscaled) cv2.waitKey(0) cv2.destroyAllWindows()
Example #10
Source File: util.py From SpaceNet_Off_Nadir_Solutions with Apache License 2.0 | 5 votes |
def mask_to_polygons(mask, epsilon=0.0, min_area=0): # __author__ = Konstantin Lopuhin # https://www.kaggle.com/lopuhin/dstl-satellite-imagery-feature-detection/full-pipeline-demo-poly-pixels-ml-poly # first, find contours with cv2: it's much faster than shapely contours, hierarchy = contours_hierarchy(mask) if epsilon == 0.0: approx_contours = contours else: approx_contours = [cv2.approxPolyDP(cnt, epsilon, True) for cnt in contours] if not contours: return Polygon(), [], [] cnt_children = defaultdict(list) child_contours = set() assert hierarchy.shape[0] == 1 # http://docs.opencv.org/3.1.0/d9/d8b/tutorial_py_contours_hierarchy.html for idx, (_, _, _, parent_idx) in enumerate(hierarchy[0]): if parent_idx != -1: child_contours.add(idx) cnt_children[parent_idx].append(approx_contours[idx]) # create actual polygons filtering by area (removes artifacts) all_polygons = [] for idx, cnt in enumerate(approx_contours): if idx not in child_contours and cv2.contourArea(cnt) >= min_area: assert cnt.shape[1] == 1 poly = shapely.geometry.Polygon( shell=cnt[:, 0, :], holes=[c[:, 0, :] for c in cnt_children.get(idx, []) if cv2.contourArea(c) >= min_area]) all_polygons.append(poly) #DO ALL polygon validation on returned poly return all_polygons
Example #11
Source File: whale176-rectangle.py From PyCV-time with MIT License | 5 votes |
def imgproc(frame): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('gray', gray) blur = cv2.blur(gray, (5, 5)) edge = cv2.Canny(blur, 10, 100) edge = cv2.blur(edge, (2, 2)) cv2.imshow('blured edge', edge) # convert image to black and white and show it thresh1, thresh = cv2.threshold(edge, 60, 120, cv2.THRESH_BINARY) cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0, 255, 0), 3) cv2.imshow('cpframe', cpframe) # ================== TODO =================== # Modify these code to suit your need contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 100] contours = [cv2.approxPolyDP(ctr, 5, True) for ctr in contours] contours = [ctr for ctr in contours if len(ctr) == 4] contours = [ctr for ctr in contours if cv2.isContourConvex(ctr)] # ============================================ # draw on the frame cv2.drawContours(frame, contours, -1, (0, 255, 0), 3) return frame
Example #12
Source File: whale176-5angle.py From PyCV-time with MIT License | 5 votes |
def imgproc(frame): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('gray', gray) blur = cv2.blur(gray, (5, 5)) edge = cv2.Canny(blur, 10, 100) edge = cv2.blur(edge, (2, 2)) cv2.imshow('blured edge', edge) # convert image to black and white and show it thresh1, thresh = cv2.threshold(edge, 60, 120, cv2.THRESH_BINARY) cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0, 255, 0), 3) cv2.imshow('cpframe', cpframe) # ================== TODO =================== # Modify these code to suit your need # pentagon contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 100] contours = [cv2.approxPolyDP(ctr, 9, True) for ctr in contours] contours = [ctr for ctr in contours if len(ctr) == 5] contours = [ctr for ctr in contours if cv2.isContourConvex(ctr)] # ============================================ # draw on the frame cv2.drawContours(frame, contours, -1, (0, 255, 0), 3) return frame
Example #13
Source File: whale176-circle.py From PyCV-time with MIT License | 5 votes |
def imgproc(frame): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('gray', gray) blur = cv2.blur(gray, (5, 5)) edge = cv2.Canny(blur, 10, 100) edge = cv2.blur(edge, (2, 2)) cv2.imshow('blured edge', edge) # convert image to black and white and show it thresh1, thresh = cv2.threshold(edge, 60, 120, cv2.THRESH_BINARY) cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0, 255, 0), 3) cv2.imshow('cpframe', cpframe) # ================== TODO =================== # Modify these code to suit your need contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 20] contours = [cv2.approxPolyDP(ctr, 5, True) for ctr in contours] contours = [ctr for ctr in contours if len(ctr) > 10] contours = [ctr for ctr in contours if cv2.isContourConvex(ctr)] # ============================================ # draw on the frame cv2.drawContours(frame, contours, -1, (0, 255, 0), 3) return frame
Example #14
Source File: process_image.py From RealTime-DigitRecognition with GNU General Public License v3.0 | 5 votes |
def get_output_image(path): img = cv2.imread(path,2) img_org = cv2.imread(path) ret,thresh = cv2.threshold(img,127,255,0) im2,contours,hierarchy = cv2.findContours(thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) for j,cnt in enumerate(contours): epsilon = 0.01*cv2.arcLength(cnt,True) approx = cv2.approxPolyDP(cnt,epsilon,True) hull = cv2.convexHull(cnt) k = cv2.isContourConvex(cnt) x,y,w,h = cv2.boundingRect(cnt) if(hierarchy[0][j][3]!=-1 and w>10 and h>10): #putting boundary on each digit cv2.rectangle(img_org,(x,y),(x+w,y+h),(0,255,0),2) #cropping each image and process roi = img[y:y+h, x:x+w] roi = cv2.bitwise_not(roi) roi = image_refiner(roi) th,fnl = cv2.threshold(roi,127,255,cv2.THRESH_BINARY) # getting prediction of cropped image pred = predict_digit(roi) print(pred) # placing label on each digit (x,y),radius = cv2.minEnclosingCircle(cnt) img_org = put_label(img_org,pred,x,y) return img_org
Example #15
Source File: document.py From web-document-scanner with MIT License | 5 votes |
def detect_edge(self, image, enabled_transform = False): dst = None orig = image.copy() gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) blurred = cv2.GaussianBlur(gray, (5, 5), 0) edged = cv2.Canny(blurred, 0, 20) _, contours, _ = cv2.findContours(edged, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) contours = sorted(contours, key=cv2.contourArea, reverse=True) for cnt in contours: epsilon = 0.051 * cv2.arcLength(cnt, True) approx = cv2.approxPolyDP(cnt, epsilon, True) if len(approx) == 4: target = approx cv2.drawContours(image, [target], -1, (0, 255, 0), 2) if enabled_transform: approx = rect.rectify(target) # pts2 = np.float32([[0,0],[800,0],[800,800],[0,800]]) # M = cv2.getPerspectiveTransform(approx,pts2) # dst = cv2.warpPerspective(orig,M,(800,800)) dst = self.four_point_transform(orig, approx) break return image, dst
Example #16
Source File: eval.py From document-ocr with Apache License 2.0 | 5 votes |
def mask_to_bbox(mask, image, num_class, out_path=None, out_file_name=None): bbox_list = [] im = copy.copy(image) mask = mask.astype(np.uint8) for i in range(1, num_class, 1): c_bbox_list = [] c_mask = np.zeros_like(mask) c_mask[np.where(mask==i)] = 255 bimg , countours, hier = cv2.findContours(c_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) for cnt in countours: area = cv2.contourArea(cnt) if area < 50: continue epsilon = 0.005 * cv2.arcLength(cnt,True) approx = cv2.approxPolyDP(cnt,epsilon,True) (x, y, w, h) = cv2.boundingRect(approx) c_bbox_list.append([x, y, x+w, y+h]) if out_path is not None: color = COLOR_LIST[i-1] im=cv2.rectangle(im, pt1=(x, y), pt2=(x+w, y+h),color=color, thickness=2) bbox_list.append(c_bbox_list) if out_path is not None: outf = os.path.join(out_path, out_file_name) print(outf) cv2.imwrite(outf, im) return bbox_list
Example #17
Source File: page.py From doc2text with MIT License | 5 votes |
def find_likely_rectangles(contours, sigma): contours = sorted(contours, key=cv2.contourArea, reverse=True)[:10] possible = [] for c in contours: # approximate the contour peri = cv2.arcLength(c, True) approx = cv2.approxPolyDP(c, sigma * peri, True) box = make_box(approx) possible.append(box) return possible
Example #18
Source File: find_contour.py From PyCV-time with MIT License | 5 votes |
def imgproc(frame): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('gray', gray) # convert image to black and white and show it thresh1, thresh = cv2.threshold(gray, 60, 255, cv2.THRESH_BINARY) cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0,255,0), 3) cv2.imshow('cpframe', cpframe) # do various tests and modification contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 100] contours = [cv2.approxPolyDP(ctr, 5 , True) for ctr in contours] contours = [ctr for ctr in contours if cv2.isContourConvex(ctr)] # draw on the frame cv2.drawContours(frame, contours, -1, (0,255,0), 3) return frame
Example #19
Source File: geometries.py From deeposlandia with MIT License | 5 votes |
def extract_geometry_vertices(mask, structure_size=(10, 10), approx_eps=0.01): """Extract polygon vertices from a boolean mask with the help of OpenCV utilities, as a numpy array Parameters ---------- mask : numpy.array Image mask where to find polygons structure_size : tuple Size of the cv2 structuring artefact, as a tuple of horizontal and vertical pixels approx_eps : double Approximation coefficient, aiming at building more simplified polygons (this coefficient lies between 0 and 1, the larger the value is, the more important the approximation is) Returns ------- numpy.array List of polygons contained in the mask, identified by their vertices """ structure = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, structure_size) denoised = cv2.morphologyEx(mask, cv2.MORPH_OPEN, structure) grown = cv2.morphologyEx(denoised, cv2.MORPH_CLOSE, structure) _, contours, hierarchy = cv2.findContours( grown, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE ) polygons = [ cv2.approxPolyDP( c, epsilon=approx_eps * cv2.arcLength(c, closed=True), closed=True ) for c in contours ] return polygons, hierarchy
Example #20
Source File: digital_display_ocr.py From display_ocr with GNU General Public License v2.0 | 5 votes |
def find_display_contour(edge_img_arr): display_contour = None edge_copy = edge_img_arr.copy() contours,hierarchy = cv2.findContours(edge_copy, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) top_cntrs = sorted(contours, key = cv2.contourArea, reverse = True)[:10] for cntr in top_cntrs: peri = cv2.arcLength(cntr,True) approx = cv2.approxPolyDP(cntr, 0.02 * peri, True) if len(approx) == 4: display_contour = approx break return display_contour
Example #21
Source File: EdgeBased.py From ImageProcessingProjects with MIT License | 5 votes |
def filter_contours(contours, min_area=100, max_area=300, angle_thresh=15.0): filtered = [] for cnt in contours: if len(cnt) < 5: continue # rect = cv2.minAreaRect(cnt) (x, y), (major, minor), angle = cv2.fitEllipse(cnt) area = cv2.contourArea(cnt) # cv2.ellipse(image, ((x,y), (major,minor), angle), (0,255,0), 2) if abs(angle - 90) < angle_thresh: c = cv2.approxPolyDP(cnt, 0.01*cv2.arcLength(cnt, False), False) filtered.append(c) return filtered
Example #22
Source File: createosmanomaly.py From images-to-osm with MIT License | 5 votes |
def writeShape(wayNumber, finalShape, image, bbTop,bbHeight,bbLeft,bbWidth) : nPts = int(finalShape.length) if ( nPts > 5000) : nPts = 5000 fitContour = np.zeros((nPts,1,2), dtype=np.int32) if ( nPts > 3): for t in range(0,nPts) : pt = finalShape.interpolate(t) fitContour[t,0,0] = pt.x fitContour[t,0,1] = pt.y fitContour = [ fitContour ] fitContour = [ cv2.approxPolyDP(cnt,2,True) for cnt in fitContour] image = np.copy(imageNoMasks) cv2.drawContours(image, fitContour,-1, (0,255,0), 2) if ( showFigures ): fig.add_subplot(2,2,3) plt.title(featureName + " " + str(r['scores'][i]) + " Fit") plt.imshow(image[bbTop:bbTop+bbHeight,bbLeft:bbLeft+bbWidth]) while ( os.path.exists( "anomaly/add/{0:06d}.osm".format(wayNumber) )) : wayNumber += 1 debugFileName = os.path.join( inference_config.ROOT_DIR, "anomaly","add","{0:06d}.jpg".format(wayNumber)) io.imsave(debugFileName,image[bbTop:bbTop+bbHeight,bbLeft:bbLeft+bbWidth],quality=100) osmFileName = os.path.join( inference_config.ROOT_DIR, "anomaly","add","{0:06d}.osm".format(wayNumber)) writeOSM( osmFileName,featureName, fitContour[0],tilePixel, qkRoot) if (showFigures ): plt.show(block=False) plt.pause(0.05) return wayNumber
Example #23
Source File: find_polygon.py From PyCV-time with MIT License | 5 votes |
def imgproc(frame): # convert color to gray scale and show it gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) cv2.imshow('gray', gray) blur = cv2.blur(gray, (5,5)) edge = cv2.Canny(blur, 30, 100) edge = cv2.blur(edge, (2,2)) cv2.imshow('blured edge', edge) # convert image to black and white and show it thresh1, thresh = cv2.threshold(edge, 60, 255, cv2.THRESH_BINARY) cv2.imshow('thresh', thresh) # find contours! contours, hry = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # draw all the contours cpframe = frame.copy() cv2.drawContours(cpframe, contours, -1, (0,255,0), 3) cv2.imshow('cpframe', cpframe) # ================== TODO =================== # Modify these code to suit your need contours = [ctr for ctr in contours if cv2.contourArea(ctr) > 100] contours = [cv2.approxPolyDP(ctr, 5 , True) for ctr in contours] contours = [ctr for ctr in contours if cv2.isContourConvex(ctr)] # ============================================ # draw on the frame cv2.drawContours(frame, contours, -1, (0,255,0), 3) return frame
Example #24
Source File: squares.py From PyCV-time with MIT License | 5 votes |
def find_squares(img): img = cv2.GaussianBlur(img, (5, 5), 0) squares = [] for gray in cv2.split(img): for thrs in xrange(0, 255, 26): if thrs == 0: bin = cv2.Canny(gray, 0, 50, apertureSize=5) bin = cv2.dilate(bin, None) else: retval, bin = cv2.threshold(gray, thrs, 255, cv2.THRESH_BINARY) contours, hierarchy = cv2.findContours(bin, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) for cnt in contours: cnt_len = cv2.arcLength(cnt, True) cnt = cv2.approxPolyDP(cnt, 0.02*cnt_len, True) if len(cnt) == 4 and cv2.contourArea(cnt) > 1000 and cv2.isContourConvex(cnt): cnt = cnt.reshape(-1, 2) max_cos = np.max([angle_cos( cnt[i], cnt[(i+1) % 4], cnt[(i+2) % 4] ) for i in xrange(4)]) if max_cos < 0.1: squares.append(cnt) return squares
Example #25
Source File: calibration.py From DE3-ROB1-CHESS with Creative Commons Attribution 4.0 International | 5 votes |
def detect(c): """ Used by find_cross function to detect the edges and vertices of possible polygons in an image. :param c: :return: """ peri = cv2.arcLength(c, True) area = cv2.contourArea(c) approx = cv2.approxPolyDP(c, 0.02 * peri, True) return len(approx), peri, area
Example #26
Source File: utils.py From answer-sheet-scan with MIT License | 5 votes |
def detect_cnt_again(poly, base_img): """ 继续检测已截取区域是否涵盖了答题卡区域 :param poly: ndarray :param base_img: ndarray :return: ndarray """ # 该多边形区域是否还包含答题卡区域的flag flag = False # 计算多边形四个顶点,并且截图,然后处理截取后的图片 top_left, bottom_left, top_right, bottom_right = get_corner_node_list(poly) roi_img = get_roi_img(base_img, bottom_left, bottom_right, top_left, top_right) img = get_init_process_img(roi_img) # 获得面积最大的轮廓 cnt = get_max_area_cnt(img) # 如果轮廓面积足够大,重新计算多边形四个顶点 if cv2.contourArea(cnt) > roi_img.shape[0] * roi_img.shape[1] * SHEET_AREA_MIN_RATIO: flag = True poly = cv2.approxPolyDP(cnt, cv2.arcLength((cnt,), True) * 0.1, True) top_left, bottom_left, top_right, bottom_right = get_corner_node_list(poly) if not poly.shape[0] == 4: raise PolyNodeCountError # 多边形顶点和图片顶点,主要用于纠偏 base_poly_nodes = np.float32([top_left[0], bottom_left[0], top_right[0], bottom_right[0]]) base_nodes = np.float32([[0, 0], [base_img.shape[1], 0], [0, base_img.shape[0]], [base_img.shape[1], base_img.shape[0]]]) transmtx = cv2.getPerspectiveTransform(base_poly_nodes, base_nodes) if flag: img_warp = cv2.warpPerspective(roi_img, transmtx, (base_img.shape[1], base_img.shape[0])) else: img_warp = cv2.warpPerspective(base_img, transmtx, (base_img.shape[1], base_img.shape[0])) return img_warp
Example #27
Source File: core.py From robosat with MIT License | 5 votes |
def simplify(polygon, eps): """Simplifies a polygon to minimize the polygon's vertices. Args: polygon: the polygon made up of a list of vertices. eps: the approximation accuracy as max. percentage of the arc length, in [0, 1] """ assert 0 <= eps <= 1, "approximation accuracy is percentage in [0, 1]" epsilon = eps * cv2.arcLength(polygon, closed=True) return cv2.approxPolyDP(polygon, epsilon=epsilon, closed=True)
Example #28
Source File: cv_handler2.py From Rule-based_Expert_System with GNU General Public License v2.0 | 5 votes |
def get_contours(img): gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) for i in range(1, len(contours)): approx = cv2.approxPolyDP(contours[i], 0.01 * cv2.arcLength(contours[i], True), True) contours[i] = approx return contours
Example #29
Source File: geometry_utils.py From open-mcr with GNU General Public License v3.0 | 5 votes |
def approx_poly(contour: np.ndarray) -> Polygon: """Approximate the simple polygon for the contour. Returns a polygon in clockwise order.""" perimeter = cv2.arcLength(contour, True) simple = cv2.approxPolyDP(contour, 0.05 * perimeter, True) polygon = contour_to_polygon(simple) return polygon_to_clockwise(polygon)
Example #30
Source File: buildings.py From xy with MIT License | 5 votes |
def approximate_contours(contours): print 'approximate_contours' result = [] for x in contours: epsilon = 0.005 * cv2.arcLength(x, True) approx = cv2.approxPolyDP(x, epsilon, True) result.append(approx) return result