def main_6_video(): video, calibration_image = get_capture_and_calibration_image_video6() calibrator = Calibrator.calibrate(calibration_image, 2) visualize_calibration(calibrator, calibration_image) if not calibrator.calibrated: print('System was not calibrated.') return detector = Detector(calibrator) wnd = CvNamedWindow('detection', cv2.WINDOW_NORMAL) video.set_pos(961) ellipses_count = 0 for frame in video.frames(): pos = video.frame_pos() print(pos) t, ellipses = detect_and_draw(detector, frame) ellipses_count = max(ellipses_count, len(ellipses)) utils.put_frame_pos(frame, pos) put_video_duration(frame, video.frame_pos_msec()) put_ellipses_count(frame, ellipses_count) wnd.imshow(frame) cv2.waitKey() cv2.waitKey() video.release() cv2.destroyAllWindows()
def main(): from skimage.feature import peak_local_max from skimage.morphology import watershed import scipy.ndimage as ndi img = realImage() # img = testImage() img = fillHoles(img) thresh = img.copy() with utils.timeit_context(): dst = ndi.distance_transform_edt(img) localMax = peak_local_max(dst, indices=False, min_distance=1, labels=thresh) markers = ndi.label(localMax)[0] labels = watershed(-dst, markers, mask=thresh) segmImg = (labels * (255 / labels.max())).astype(np.uint8) wnd = CvNamedWindow(flags=cv2.WINDOW_NORMAL) segmWnd = CvNamedWindow('segm', flags=cv2.WINDOW_NORMAL) wnd.imshow(img) segmWnd.imshow(segmImg) cvWaitKeys()
def main(): # img = testImage() img = realImage() n = 1 sz = n * 2 + 1 # 3, 5 ... kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (sz, sz)) iterations = 1 mode = None # erode dilate wnd = CvNamedWindow() def images(): while True: if mode == 'dilate': cv2.dilate(img, kernel, dst=img, iterations=iterations) elif mode == 'erode': cv2.erode(img, kernel, dst=img, iterations=iterations) yield img for im in images(): wnd.imshow(im) key = cvWaitKeys(27, '1', '2') if key == 27: break elif key == ord('1'): mode = 'erode' elif key == ord('2'): mode = 'dilate'
def main(): wnd = CvNamedWindow('ORB', flags=cv2.WINDOW_NORMAL) vc = VideoController(delay=-1) detector = cv2.ORB_create(nfeatures=1000) # frames = rect_frames_sequence((200, 200), (40, 50), (5, 5), 50, step=2) frames = ellipse_frames_sequence((200, 200), (65, 75), (40, 50), 23, steps=30, step=2) frame0 = next(frames) keypoints, descrs = detector.detectAndCompute(frame0, None) pts0 = np.reshape([key_pt.pt for key_pt in keypoints], (-1, 1, 2)).astype(np.float32) wnd.imshow(draw_points(frame0.copy(), pts0)) vc.wait_key() lk_params = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)) for frame in frames: pts1, st, err = cv2.calcOpticalFlowPyrLK(frame0, frame, pts0, None, **lk_params) pts1 = pts1[st == 1] wnd.imshow(draw_points(frame.copy(), pts1)) pts0 = pts1.reshape(-1, 1, 2) frame0 = frame if vc.wait_key() == 27: break
def visualize(contours, image, winname): draw_contours(contours, image, (0, 255, 0), thickness=2, draw_measurements=False) wnd = CvNamedWindow(winname, cv2.WINDOW_NORMAL) wnd.imshow(image) cv2.waitKey() wnd.destroy()
def VIS_assemble_ellipses_from_parts(bgr, part, next_part, ellipses): if bgr.shape[0] > 300 or bgr.shape[1] > 300: return green = (0, 255, 0) red = (0, 0, 255) blue = (255, 0, 0) im = bgr.copy() cv2.polylines(im, [part.points], False, green, 2) x, y = part.first_pt im[y - 3:y + 3, x - 3:x + 3] = [0, 255, 0] x, y = part.last_pt im[y - 3:y + 3, x - 3:x + 3] = [0, 127, 0] if next_part: cv2.polylines(im, [next_part.points], False, red, 2) x, y = next_part.first_pt im[y - 3:y + 3, x - 3:x + 3] = [0, 0, 255] x, y = next_part.last_pt im[y - 3:y + 3, x - 3:x + 3] = [0, 0, 127] for poly in ellipses: cv2.polylines(im, [poly.points], False, blue, 2) wnd = CvNamedWindow('DEBUG') wnd.imshow(im) cv2.waitKey() wnd.destroy()
def walk_points_sequence(points, is_closed=False, point_action=None): point_action = point_action or (lambda i, pt: print(f'{i}, {pt}')) max_x = points[..., 0].max() + 20 max_y = points[..., 1].max() + 20 img = np.zeros((max_y, max_x), dtype=np.uint8) cv2.polylines(img, [points], is_closed, 255) # show_goodFeaturesToTrack(img) cv2.circle(img, tuple(points[0, 0]), 3, 255, 1) cv2.circle(img, tuple(points[-1, 0]), 3, 127, -1) wnd = CvNamedWindow(flags=cv2.WINDOW_NORMAL) wnd.imshow(img) if cv2.waitKey() == 27: return for i, pt in enumerate(points): point_action(i, pt) im = img.copy() cv2.circle(im, tuple(pt[0]), 2, 255, 1) wnd.imshow(im) if cv2.waitKey() == 27: return
def VIS_EDGES(edges): if DEBUG.should_not_vis(edges): return wnd = CvNamedWindow('DEBUG EDGES') wnd.imshow(edges) cv2.waitKey() wnd.destroy()
def VIS_POLYGONS(img, polygons): if img.shape[0] > 300 or img.shape[1] > 300: return print('VIS_POLYGONS: polygons count:', len(polygons), [p.len for p in polygons]) if len(polygons) == 0: return tails_colors = ((0, 127, 0), (0, 255, 0)) points_color = (0, 0, 0) separator = DEBUG.separator(img) images = [] im = DEBUG.__draw_polygons(img.copy(), polygons, (0, 255, 0), 1, tails_colors, points_color) images.extend([im, separator]) if len(polygons) > 1: for p in polygons: im = DEBUG.__draw_polygons(img.copy(), [p], (0, 255, 0), 1, tails_colors, points_color) images.extend([im, separator]) wnd = CvNamedWindow('polygons', cv2.WINDOW_NORMAL) wnd.imshow(np.hstack(images)) cv2.waitKey() wnd.destroy()
def VIS_ALL_CONTOURS(img, contours): if img.shape[0] > 300 or img.shape[1] > 300: return print('contours LEN:', len(contours)) if len(contours) == 0: return separator = DEBUG.separator(img) images = [] tails_colors = ((0, 127, 0), (0, 255, 0)) points_color = (0, 0, 0) im = DEBUG.__draw_contours(img.copy(), contours, (0, 255, 0), 1, tails_colors, points_color) images.extend([im, separator]) if len(contours) > 1: for c in contours: im = DEBUG.__draw_contours(img.copy(), [c], (0, 255, 0), 1, tails_colors, points_color) images.extend([im, separator]) print(f'VIS_ALL_CONTOURS: contour len {c.len()}') wnd = CvNamedWindow('contours', cv2.WINDOW_NORMAL) wnd.imshow(np.hstack(images)) cv2.waitKey() wnd.destroy()
def main(): wnd = CvNamedWindow('frames', flags=cv2.WINDOW_NORMAL) vc = VideoController(delay=-1) # frames = rect_frames_sequence((200, 200), (40, 50), (5, 5), 50, step=2) frames = ellipse_frames_sequence((200, 200), (45, 55), (40, 50), 23, steps=30, step=2) frame0 = next(frames) feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7) pts0 = cv2.goodFeaturesToTrack(frame0, mask=None, **feature_params) # TODO: add point at center of rect # additional_pts = ( # [[5 + 40 / 2, 5 + 50 / 2]], # [[4, 4]], # [[3, 3]], # [[5, 5]], # [[2, 2]], # [[0, 0]], # [[-1, -1]], # #------------- # [[47, 57]], # [[49, 59]], # #------------- # [[4, 6]], # [[4, 8]], # [[4, 9]], # [[4, 11]], # [[4, 12]], # [[4, 13]], # ) # pts0 = np.append(pts0, additional_pts, axis=0).astype(np.float32) if pts0 is None: print('No good features to track') return wnd.imshow(draw_points(frame0.copy(), pts0)) vc.wait_key() lk_params = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)) for frame in frames: pts1, st, err = cv2.calcOpticalFlowPyrLK(frame0, frame, pts0, None, **lk_params) pts1 = pts1[st == 1] wnd.imshow(draw_points(frame.copy(), pts1)) pts0 = pts1.reshape(-1, 1, 2) frame0 = frame if vc.wait_key() == 27: break
def main(): video = VideoCapture(video_sources.video_2) workArea = WorkAreaView(video_sources.video_2_work_area_markers) vc = VideoController(10, 'pause') (video_wnd, bin_diff_wnd, gray_diff_wnd, colorDiffWnd, learned_BG_wnd) = Wnd.create('video', 'binary diff', 'gray diff', 'color diff', 'Learned BG') colorAbsDiffWnd = Wnd('color_abs_diff') segmentedWnd = Wnd('segmented') segmenter = Segmenter() frames_iter = workArea.skip_non_area(video.frames()) motionDetector = MotionDetector(next(frames_iter)[0], 3) backgroundModel = BackgroundModel(15) prevBackground = None for frame, _ in frames_iter: motionDetector.detect(frame) if motionDetector.motionEnded(): # calc fgMask mask, gray_diff, color_diff, colorAbsDiff = calcForegroundMask( prevBackground, frame) # bin_diff_wnd.imshow(resize(mask, 0.5)) bin_diff_wnd.imshow(cv2.cvtColor(mask, cv2.COLOR_GRAY2BGR)) # gray_diff_wnd.imshow(resize(gray_diff, .5)) # colorDiffWnd.imshow(resize(color_diff, .5)) # colorAbsDiffWnd.imshow(resize(colorAbsDiff, .5)) markers, objectsCount = segmenter.segment(mask) segmentedWnd.imshow( resize(Segmenter.markersToDisplayImage(markers, objectsCount), .5)) backgroundModel = BackgroundModel(15) if motionDetector.isSilence(): backgroundModel.learn(frame, foregroundMask=None) learned_BG_wnd.imshow(resize(backgroundModel.learned, .5)) if motionDetector.motionStarted(): prevBackground = backgroundModel.learned backgroundModel = None learned_BG_wnd.imshow(resize(prevBackground, .5)) # VIS vis_img = motionDetector.indicateCurrentState(frame.copy()) vis_img = utils.put_frame_pos(vis_img, video.frame_pos(), xy=(2, 55)) video_wnd.imshow(vis_img) # bin_diff_wnd.imshow(resize(motionDetector.bin_diff, .5)) # gray_diff_wnd.imshow(resize(motionDetector.gray_diff, .5)) # VIS END if vc.wait_key() == 27: break video.release()
def main(): img = np.zeros((300, 300, 3), np.uint8) cv2.circle(img, (150, 150), 75, (0, 180, 0), -1) wnd = CvNamedWindow('select ROI') while True: wnd.imshow(img) key = cvWaitKeys(27, ord('r'), ord('s')) if key in (27, -1): break
def visualize_contours(contours, image, winname): contours = sorted(contours, key=lambda c: c.len(), reverse=True) wnd = CvNamedWindow(winname, cv2.WINDOW_NORMAL) for part in contours: cv2.drawContours(image, [part.points()], -1, utils.random_color(), 2) print('part', part.len()) wnd.imshow(image) cv2.waitKey() wnd.destroy(winname)
def main(): def roiSelectedEvent(roi, imageRoi, wnd, image): if roi is None: return predictions = predict_on_image(model, None, imageRoi, 0.95) cv2.imshow('roi', predictions) model = getModel() video = VideoCapture(video_sources.video_2) vc = VideoController(10, 'pause') wnd = Wnd('video', roiSelectedEvent=roiSelectedEvent) for frame in video.frames(): cv2.destroyWindow('roi') wnd.imshow(frame) if vc.wait_key() == 27: break
def VIS_CONTOURS(edges, contours): print(f'DEBUG.VIS_CONTOURS: contours count {len(contours)}') if DEBUG.should_not_vis(edges): return im = np.zeros_like(edges) cv2.drawContours(im, contours, -1, 255, 1) images = [im] for c in contours: im = np.zeros_like(edges) cv2.drawContours(im, [c], -1, 255, 1) images.append(im) wnd = CvNamedWindow('DEBUG CONTOURS') wnd.imshow(np.hstack(images)) cv2.waitKey() wnd.destroy()
def main(): feature_params = dict(maxCorners=100, qualityLevel=0.3, minDistance=7, blockSize=7) lk_params = dict(winSize=(15, 15), maxLevel=2, criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03)) video = VideoCapture(video_sources.video_2) wnd = CvNamedWindow('video') vc = VideoController(delay=50) prev_gray = None po = None tracking = False for frame in video.frames(): if tracking: frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # calculate optical flow p1, st, err = cv2.calcOpticalFlowPyrLK(prev_gray, frame_gray, p0, None, **lk_params) p1 = p1[st == 1] # draw the tracks for pt in p1: a, b = pt.ravel() frame = cv2.circle(frame, (a, b), 5, (0, 255, 0), -1) prev_gray = frame_gray p0 = p1.reshape(-1, 1, 2) wnd.imshow(frame) key = vc.wait_key() if key == 27: break elif not tracking and key == ord('r'): # init tracking roi = cv2.selectROI('roi', frame) cv2.destroyWindow('roi') if roi is None or sum(roi) == 0: continue prev_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) p0 = cv2.goodFeaturesToTrack(prev_gray, mask=roi_mask(prev_gray, roi), **feature_params) if p0 is not None and len(p0) > 0: tracking = True video.release()
def show_contour_parts(contour, parts): points = contour.points() max_x = points[..., 0].max() + 20 max_y = points[..., 1].max() + 20 separator = np.full((max_y, 2), 127, dtype=np.uint8) images = [] for poly in parts: img = np.zeros((max_y, max_x), dtype=np.uint8) poly_points = poly.points if len(poly_points.shape) == 3: poly_points = poly_points[:, 0] cv2.polylines(img, [poly_points], False, 255, 1) for (x, y) in poly_points: r = 2 img[y - r:y + r, x - r:x + r] = 200 images.extend([img, separator]) wnd = CvNamedWindow('parts') if len(images) == 0: return wnd.imshow(np.hstack(images))
def main(): # img = testImage() img = realImage() segmenter = Segmenter() # iters = 1000 # images = [img.copy() for _ in range(iters)] # with utils.timeit_context(): # for i in range(1000): # segmenter.segment2(images[i]) # # images = [img.copy() for _ in range(iters)] # with utils.timeit_context(): # for i in range(1000): # segmenter.segment(images[i]) markers = segmenter.segment(img.copy()) wnd = Wnd('labels') wnd.imshow(segmenter.markersToDisplayImage(markers)) waitKeys()
def main(): video = VideoCapture(video_sources.video_6) diff_wnd = CvNamedWindow('diff') mask_wnd = CvNamedWindow('mask') input_wnd = CvNamedWindow('input') # prev_frame = denoise(video.read()) prev_frame = cv2.cvtColor(denoise(video.read()), cv2.COLOR_BGR2GRAY) vm = VideoController(10) diff = None for frame in video.frames(): # with utils.timeit_context('frame processing'): # frame = denoise(frame) # diff = cv2.absdiff(prev_frame, frame, dst=diff) # ret, mask = cv2.threshold(diff, 45, 255, cv2.THRESH_BINARY) # binary_mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY) # # cn = cv2.countNonZero(binary_mask) # nonzero = cv2.findNonZero(binary_mask) with utils.timeit_context('frame processing'): frame = denoise(frame) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) diff = cv2.absdiff(prev_frame, gray, dst=diff) ret, mask = cv2.threshold(diff, 45, 255, cv2.THRESH_BINARY) # cn = cv2.countNonZero(binary_mask) nonzero = cv2.findNonZero(mask) diff_wnd.imshow(diff) mask_wnd.imshow(mask) input_wnd.imshow(utils.put_frame_pos(frame.copy(), video.frame_pos())) prev_frame = gray if not vm.wait_key(): break video.release() cv2.destroyAllWindows()
class DetectionDebugger: def __init__(self, detector, image, region_selection=None): self.detector = detector self.base_image = image self.buffer_image = np.empty_like(self.base_image) self.region_selection = None self.set_region_selection(region_selection) self.ellipses = self.polygons = self.selected_ellipses = self.selected_polygons = [] self.wnd = CvNamedWindow('test', mouse_callback=self.__mc) def set_region_selection(self, region_selection): if region_selection is None: return start, end = region_selection self.region_selection = RegionSelection(start=start).set_end(end) def __mc(self, evt, x, y, flags, param): if evt != cv2.EVENT_LBUTTONDOWN: return self.__handle_mouse_click((x, y), ctrl_key=flags & cv2.EVENT_FLAG_CTRLKEY) def __handle_mouse_click(self, pt, ctrl_key): if ctrl_key: self.make_region_selection(pt) elif self.region_selection and self.region_selection.point_test( pt) < 0: self.__clear_region_selection() else: pt = self.translate_image_pt_to_region_pt(pt) self.select_nearest(pt) self.__redraw() def __handle_key(self, key): if key == 27: return False should_redraw = False if key == ord('a'): self.__clear_region_selection() should_redraw = True elif key == ord('r'): self.__repeat_detect() should_redraw = True if should_redraw: self.__redraw() return True def translate_image_pt_to_region_pt(self, pt): if self.region_selection: return self.region_selection.translate_image_pt(pt) return pt def select_nearest(self, pt): nearest_polygons = self.find_nearest(pt, self.polygons) self.selected_polygons = nearest_polygons for p in nearest_polygons: print(f'POLY: {p.len}') nearest_ellipses = self.find_nearest(pt, self.ellipses) self.selected_ellipses = nearest_ellipses @staticmethod def find_nearest(pt, polygons): if len(polygons) == 0: return [] polygon_distances = [(p, p.distance_from_point(pt)) for p in polygons] min_dist_polygon = min(polygon_distances, key=lambda item: item[1])[0] return [min_dist_polygon] def make_region_selection(self, pt): self.ellipses = self.polygons = self.selected_ellipses = self.selected_polygons = [] if self.region_selection is None: self.region_selection = RegionSelection(start=pt) else: self.region_selection.set_end(pt) self.__detect() def __clear_region_selection(self): self.region_selection = None self.ellipses = self.polygons = self.selected_ellipses = self.selected_polygons = [] self.__detect() def __repeat_detect(self): # self.ellipses = self.polygons = self.selected_ellipses = self.selected_polygons = [] self.__detect() def __redraw(self): np.copyto(dst=self.buffer_image, src=self.base_image) if self.region_selection and self.region_selection.is_complete(): region_buffer = self.region_selection.get_image_region( self.buffer_image) else: region_buffer = self.buffer_image # draw selection to region_buffer self.__draw_poly_for_presentation(self.selected_ellipses, region_buffer, (0, 255, 0), 2) self.__draw_poly_asis(self.selected_polygons, region_buffer, (0, 0, 255), 2) if self.region_selection: self.region_selection.draw(self.buffer_image) self.wnd.imshow(self.buffer_image) @staticmethod def __draw_poly_asis(polygons, image, color=(0, 255, 0), thickness=2): pts = [p.points for p in polygons] cv2.polylines(image, pts, False, color, thickness) @staticmethod def __draw_poly_for_presentation(polygons, image, color=(0, 255, 0), thickness=2): for p in polygons: p.draw_for_presentation(image, color, thickness) def __detect(self): if self.region_selection: image = self.region_selection.get_image_region( self.base_image).copy() else: image = self.base_image.copy() self.ellipses, self.polygons = self.detector.detect(image) print( f'__detect. ellipses: {len(self.ellipses)}. polygons: {len(self.polygons)}' ) self.selected_ellipses = list(self.ellipses) def start(self): self.__detect() self.__redraw() while self.__handle_key(cv2.waitKey()): pass