class App: def __init__(self, src): self.cap = video.create_capture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.clear() self.tracker.add_target(self.frame, rect) def run(self): img = cv2.imread('image.jpg') while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() w, h = getsize(self.frame) vis = np.zeros((h, w * 2, 3), np.uint8) vis[:h, :w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:, w:] = target.image draw_keypoints(vis[:, w:], target.keypoints) x0, y0, x1, y1 = target.rect cv2.rectangle(vis, (x0 + w, y0), (x1 + w, y1), (0, 255, 0), 2) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] #cv2.fillPoly(vis, [np.int32(tracked.quad)], 255) cv2.polylines(vis, [np.int32(tracked.quad)], True, (255, 0, 0), 2) xt, yt = tracked.quad[3] font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(vis, 'Planar track', (xt, yt), font, 1, (0, 0, 255), 2) cv2.circle(vis, (xt, yt), 30, (0, 255, 0), 2) #for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): # cv2.line(vis, (x0+w, y0), (x1, y1), (0, 255, 0)) draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv2.imshow('plane', vis) ch = cv2.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == 27: break
def __init__(self, src): self.cap = cv2.VideoCapture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect)
def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect)
class App: def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv.namedWindow('plane', cv.WINDOW_NORMAL) cv.createTrackbar('focal', 'plane', 25, 50, common.nothing) cv.resizeWindow('plane', 1920, 1080) self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.add_target(self.frame, rect) def run(self): while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() vis = self.frame.copy() if playing: tracked = self.tracker.track(self.frame) for tr in tracked: cv.polylines(vis, [np.int32(tr.quad)], True, (255, 255, 255), 2) for (x, y) in np.int32(tr.p1): cv.circle(vis, (x, y), 2, (255, 255, 255)) self.draw_overlay(vis, tr) self.rect_sel.draw(vis) cv.imshow('plane', vis) ch = cv.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == ord('c'): self.tracker.clear() if ch == 27: break def draw_overlay(self, vis, tracked): x0, y0, x1, y1 = tracked.target.rect quad_3d = np.float32([[x0, y0, 0], [x1, y0, 0], [x1, y1, 0], [x0, y1, 0]]) fx = 0.5 + cv.getTrackbarPos('focal', 'plane') / 50.0 h, w = vis.shape[:2] K = np.float64([[fx*w, 0, 0.5*(w-1)], [0, fx*w, 0.5*(h-1)], [0.0,0.0, 1.0]]) dist_coef = np.zeros(4) _ret, rvec, tvec = cv.solvePnP(quad_3d, tracked.quad, K, dist_coef) verts = ar_verts * [(x1-x0), (y1-y0), -(x1-x0)*0.3] + (x0, y0, 0) verts = cv.projectPoints(verts, rvec, tvec, K, dist_coef)[0].reshape(-1, 2) for i, j in ar_edges: (x0, y0), (x1, y1) = verts[i], verts[j] cv.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (255, 255, 0), 2)
class App: def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') cv2.createTrackbar('focal', 'plane', 25, 50, common.nothing) self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.add_target(self.frame, rect) def run(self): while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() vis = self.frame.copy() if playing: tracked = self.tracker.track(self.frame) for tr in tracked: cv2.polylines(vis, [np.int32(tr.quad)], True, (255, 255, 255), 2) for (x, y) in np.int32(tr.p1): cv2.circle(vis, (x, y), 2, (255, 255, 255)) self.draw_overlay(vis, tr) self.rect_sel.draw(vis) cv2.imshow('plane', vis) ch = cv2.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == ord('c'): self.tracker.clear() if ch == 27: break def draw_overlay(self, vis, tracked): x0, y0, x1, y1 = tracked.target.rect quad_3d = np.float32([[x0, y0, 0], [x1, y0, 0], [x1, y1, 0], [x0, y1, 0]]) fx = 0.5 + cv2.getTrackbarPos('focal', 'plane') / 50.0 h, w = vis.shape[:2] K = np.float64([[fx*w, 0, 0.5*(w-1)], [0, fx*w, 0.5*(h-1)], [0.0,0.0, 1.0]]) dist_coef = np.zeros(4) ret, rvec, tvec = cv2.solvePnP(quad_3d, tracked.quad, K, dist_coef) verts = ar_verts * [(x1-x0), (y1-y0), -(x1-x0)*0.3] + (x0, y0, 0) verts = cv2.projectPoints(verts, rvec, tvec, K, dist_coef)[0].reshape(-1, 2) for i, j in ar_edges: (x0, y0), (x1, y1) = verts[i], verts[j] cv2.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (255, 255, 0), 2)
def __init__(self, src): self.cap = video.create_capture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') cv2.createTrackbar('focal', 'plane', 25, 50, common.nothing) self.rect_sel = common.RectSelector('plane', self.on_rect)
def __init__(self, src): image = cv.imread(src, 1) small = cv.resize(image, (0,0), fx=0.125, fy=0.125) # resizing the image, as high resolution image taken self.frame = small self.paused = False self.tracker = PlaneTracker() cv.namedWindow('Selected Region') # cv.setMouseCallback('Selected Region', self.draw_circle_corner) self.rect_sel = common.RectSelector('Selected Region', self.on_rect)
def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv.namedWindow('plane', cv.WINDOW_NORMAL) cv.createTrackbar('focal', 'plane', 25, 50, common.nothing) cv.resizeWindow('plane', 1920, 1080) self.rect_sel = common.RectSelector('plane', self.on_rect)
class CompareImage: """ This lets you compare multiple template images to some arbitrary image, and return True or False if it's a 'match', where the match is fairly loosly defined. The class doesn't have to be too accurate, as long as there are few false negatives. """ def __init__(self, features_detect=1500): self.tracker = PlaneTracker(0.025, 10, max_features_detect=1500) self.__templates = [] # Keep track of templates being tracked def add_template(self, img): """ This will add a template image to compare other images to. It will add the whole image, then many other smaller parts of the image, to try to capture more images. """ if img is None: return h, w, _ = img.shape self.__templates.append(img) # Track the whole image self.tracker.add_target(img, (0, 0, w, h)) # # Track the center quarter of the image # self.tracker.add_target(img, (int(w * .25), # int(h * .25), # int(w * .75), # int(h * .75))) # # # Track the right half of the image # self.tracker.add_target(img, (int(w * .5), # int(h * .5), # int(w * 1), # int(h * 1))) # # # Track the left half of the image # self.tracker.add_target(img, (int(w * 0), # int(h * 0), # int(w * .5), # int(h * .5))) def get_template(self): return self.__templates def is_match(self, img, min_match_ratio): """ This will compare the img to the images that are currently being compared""" self.tracker.track(img) for tracked in self.tracker.history[0]: if tracked.match_ratio >= min_match_ratio: return True return False
class App: def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.clear() self.tracker.add_target(self.frame, rect) def run(self): while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() w, h = getsize(self.frame) vis = np.zeros((h, w * 2, 3), np.uint8) vis[:h, :w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:, w:] = target.image draw_keypoints(vis[:, w:], target.keypoints) x0, y0, x1, y1 = target.rect cv.rectangle(vis, (x0 + w, y0), (x1 + w, y1), (0, 255, 0), 2) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] cv.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2) for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): cv.line(vis, (x0 + w, y0), (x1, y1), (0, 255, 0)) draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv.imshow('plane', vis) ch = cv.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == 27: break
class App: def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') cv2.moveWindow('plane', 100, 100) self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.clear() self.tracker.addTargetSamples(self.frame, rect) def run(self): while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() w, h = getsize(self.frame) vis = np.zeros((h, w*2, 3), np.uint8) vis[:h,:w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:,w:] = target.image draw_keypoints(vis[:,w:], target.keypoints) x0, y0, x1, y1 = target.rect cv2.rectangle(vis, (x0+w, y0), (x1+w, y1), (0, 255, 0), 2) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] cv2.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2) for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): cv2.line(vis, (x0+w, y0), (x1, y1), (0, 255, 0)) draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv2.imshow('plane', vis) ch = cv2.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == 27: break
def __init__(self, src): self.cap = video.create_capture(src, presets["book"]) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow("plane") self.rect_sel = common.RectSelector("plane", self.on_rect)
def __init__(self, src): self.cap = video.create_capture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect)
def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') cv2.createTrackbar('focal', 'plane', 25, 50, common.nothing) self.rect_sel = common.RectSelector('plane', self.on_rect)
def __init__(self, src): cv.namedWindow(WIN_NAME) cv.moveWindow(WIN_NAME, 0, 0) self.cap = video.create_capture(src, presets['book']) self.frame = None self.auto_output_frame = None self.paused = False self.tracker = PlaneTracker() self.rect_sel = common.RectSelector('plane', self.on_rect) self.user_selected_rect = None self.focal_length = 0.0 self.horizontal_angel = 0.0 self.known_distance = 200 self.KNOWN_WIDTH = 40 self.KNOWN_HEIGHT = 40 self.msg = None self.serial = 0 self.auto_save = False self.auto_serial = 0
def __init__(self, src): self.drone = libardrone.ARDrone(is_ar_drone_2=True) #self.cap = video.create_capture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') cv2.createTrackbar('focal', 'plane', 25, 50, common.nothing) self.rect_sel = common.RectSelector('plane', self.on_rect)
def __init__(self): self.template = None self.paused = False self.recognised = False self.tracker = PlaneTracker() self.character = "" #Add template images to tracker scarlet = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/scarlet.png'))) mustard = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/mustard.png'))) plum = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/plum.png'))) peacock = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/peacock.png'))) scarlet_rect = (0,0,scarlet.shape[1],scarlet.shape[0]) mustard_rect = (0,0,mustard.shape[1],mustard.shape[0]) plum_rect = (0,0,plum.shape[1],plum.shape[0]) peacock_rect = (0,0,peacock.shape[1],peacock.shape[0]) self.tracker.add_target(scarlet.copy(), scarlet_rect,'scarlet') self.tracker.add_target(mustard.copy(), mustard_rect,'mustard') self.tracker.add_target(plum.copy(), plum_rect,'plum') self.tracker.add_target(peacock.copy(), peacock_rect,'peacock')
class characterDetection: def __init__(self): self.template = None self.paused = False self.recognised = False self.tracker = PlaneTracker() self.character = "" #Add template images to tracker scarlet = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/scarlet.png'))) mustard = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/mustard.png'))) plum = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/plum.png'))) peacock = cv2.imread(os.path.abspath(os.path.join(os.path.dirname( __file__ ), '..', 'cluedo_images/peacock.png'))) scarlet_rect = (0,0,scarlet.shape[1],scarlet.shape[0]) mustard_rect = (0,0,mustard.shape[1],mustard.shape[0]) plum_rect = (0,0,plum.shape[1],plum.shape[0]) peacock_rect = (0,0,peacock.shape[1],peacock.shape[0]) self.tracker.add_target(scarlet.copy(), scarlet_rect,'scarlet') self.tracker.add_target(mustard.copy(), mustard_rect,'mustard') self.tracker.add_target(plum.copy(), plum_rect,'plum') self.tracker.add_target(peacock.copy(), peacock_rect,'peacock') def checkPoster(self, cv_image): if not self.recognised: self.frame = cv_image.copy() w, h = getsize(self.frame) vis = np.zeros((h, w, 3), np.uint8) vis[:h,:w] = self.frame tracked = self.tracker.track(self.frame) print(len(tracked)) if len(tracked) > 0: rospy.loginfo("3") for tracked_ob in tracked: rospy.loginfo ('Found ' + tracked_ob.target.data) self.character = tracked_ob.target.data # Calculate Homography h, status = cv2.findHomography(tracked_ob.p0, tracked_ob.p1) self.recognised = True
def __init__(self, src): #self.cap = video.create_capture(src, presets['book']) self.image_pub = rospy.Publisher("image_topic_2",Image, queue_size=10) self.image_sub = rospy.Subscriber("/camera/rgb/image_raw",Image,self.callback) self.bridge = CvBridge() #dtype, n_channels = br.encoding_as_cvtype2('8UC3') #this.im = np.ndarray(shape=(480, 640, n_channels), dtype=dtype) self.cv_image = None self.frame = None #self.count = 1 self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect) self.tracker.clear() rospack = rospkg.RosPack() labPath = rospack.get_path('laboratorio3') files = ['Cercano', 'Medio', 'Lejano','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15'] for f in files: rectanguloFile = os.path.join(labPath, 'detectarCono/rect{}.pkl'.format(f)) frameFile = os.path.join(labPath, 'detectarCono/frame{}.pkl'.format(f)) with open(rectanguloFile, 'rb') as f: rectangulo = pickle.load(f) with open(frameFile, 'rb') as f: frame = pickle.load(f) self.tracker.add_target(frame, rectangulo) self.pubVel = rospy.Publisher('/cmd_vel', Twist , queue_size=10) self.pubNavegacion = rospy.Publisher('/laboratorio3/exploration', String , queue_size=10) self.reiniciar_exploracion_timer = False
class App: def __init__(self, src): self.cap = video.create_capture(src, presets['book']) self.frame = None self.paused = False self.tracker = PlaneTracker() cv.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.clear() self.tracker.add_target(self.frame, rect) def run(self): while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() blue = cv.cvtColor(frame, cv.COLOR_BGR2Luv) # Display the resulting frame cv.imshow('self.frame', blue) w, h = getsize(self.frame) vis = np.zeros((h, w * 2, 3), np.uint8) vis[:h, :w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:, w:] = target.image draw_keypoints(vis[:, w:], target.keypoints) x0, y0, x1, y1 = target.rect #cv.rectangle(vis, (x0+w, y0), (x1+w, y1), (255, 0, 0), 2) center_x = int((x0 + x1 + 2 * w) / 2) center_y = int((y0 + y1) / 2) r_x = int(abs((x0 - x1) / 2)) r_y = int(abs((x0 - x1) / 2)) radius = int(math.sqrt((r_x * r_x) + (r_y * r_y))) cv.circle(vis, (center_x, center_y), radius, (0, 0, 255), 2) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] cv.polylines(vis, [np.int32(tracked.quad)], True, (255, 0, 255), 2) for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): cv.line(vis, (x0 + w, y0), (x1, y1), (255, 0, 0)) draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv.imshow('plane', vis) ch = cv.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == 27: break
class App: def __init__(self, src): self.cap = video.create_capture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.clear() self.tracker.add_target(self.frame, rect) def run(self): def find_line(p0, p1): x0, y0 = p0 x1, y1 = p1 k = (x1 - x0) / (y1 - y0) b = y1 - k * x0 return k, b def cross(l0, l1): k0, b0 = l0 k1, b1 = l1 x = (b1 - b0) / (k0 - k1) y = k0 * x + b0 return x, y while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() w, h = getsize(self.frame) vis = np.zeros((h, w * 2, 3), np.uint8) vis[:h, :w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:, w:] = target.image draw_keypoints(vis[:, w:], target.keypoints) x0, y0, x1, y1 = target.rect cv2.rectangle(vis, (x0 + w, y0), (x1 + w, y1), (0, 255, 0), 2) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] cv2.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2) # print([np.int32(tracked.quad)]) p0, p1, p2, p3 = np.int32(tracked.quad) l0 = find_line(p0, p2) l1 = find_line(p1, p3) x, y = cross(l0, l1) z = 3 * 180 / (p3[1] - p0[1]) * 1 print(x, y, z) draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv2.imshow('plane', vis) ch = cv2.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == 27: break
class App: def __init__(self, src): image = cv.imread(src, 1) small = cv.resize(image, (0,0), fx=0.125, fy=0.125) # resizing the image, as high resolution image taken self.frame = small self.paused = False self.tracker = PlaneTracker() cv.namedWindow('Selected Region') # cv.setMouseCallback('Selected Region', self.draw_circle_corner) self.rect_sel = common.RectSelector('Selected Region', self.on_rect) def on_rect(self, rect): self.tracker.clear() self.tracker.add_target(self.frame, rect) def run_original(self): while True: playing = not self.paused and not self.rect_sel.dragging # flag used to quit imaging, when the size detected. flag = 0 # if playing or self.frame is None: # # ret, frame = self.cap.read() # if not ret: # break # self.frame = frame.copy() # size of the frame (image) - used to draw rectangle w, h = getsize(self.frame) vis = np.zeros((h, w*2, 3), np.uint8) # copy to the image (original) vis[:h,:w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:,w:] = target.image draw_keypoints(vis[:,w:], target.keypoints) x0, y0, x1, y1 = target.rect # rectangle coordinates cv.rectangle(vis, (x0+w, y0), (x1+w, y1), (0, 255, 0), 2) # green line drawn # finding the width of the region width_region = distance(x0, x1, y0, y1) flag = 1 # set flag = 1, quit the program! self.rect_sel.draw(vis) cv.imshow('Selected Region', vis) # show the image ch = cv.waitKey(1) if ch == 27 or flag == 1: print("Quitting") return width_region def run(self, Cover_Dimensions, Actual_Dimensions): ''' Runs the program, of selection of the image's region. Approximates the dimensions of the cover based on given dimensions. ''' while True: # flag used to quit imaging, when the size detected. flag = 0 playing = not self.rect_sel.dragging # get size of the book cover w, h = getsize(self.frame) vis = np.zeros((h, w*2, 3), np.uint8) vis[:h,:w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:,w:] = target.image draw_keypoints(vis[:,w:], target.keypoints) x0, y0, x1, y1 = target.rect # get the selected region coordinates cv.rectangle(vis, (x0+w, y0), (x1+w, y1), (0, 255, 0), 2) Region_Dimensions = [x1 - x0, y1 - y0] print("Region_Dimensions:", Region_Dimensions) # Ratio of the cover dimensions (width) to region dimensions (width) # similarly for height ratio_width = float(Cover_Dimensions)/(Region_Dimensions[0]) # Hard coded the actual width and height of the region. # Actual width (in cm) = 14 # Actual height (in cm) = 1.1 width_of_book = ratio_width * Actual_Dimensions[0] # height_of_book = ratio_height * Actual_Dimensions[1] # Optional (useful in case of video source) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] cv.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2) for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): cv.line(vis, (x0+w, y0), (x1, y1), (0, 255, 0)) print("Detected") # break when the region is detected. flag = 1 break draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv.imshow('Selected Region', vis) cv.waitKey(1) if flag == 1: print("Dimensions of the book : ", width_of_book) return
import numpy as np import cv2 from common import getsize, draw_keypoints from plane_tracker import PlaneTracker face_cascade = cv2.CascadeClassifier( 'haarcascades/haarcascade_frontalface_default.xml') eye_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_eye.xml') searchFor = cv2.imread('myPic.jpg', 0) # Load Search Image #searchForGray = cv2.cvtColor(searchFor, cv2.COLOR_BGR2GRAY) # Change to GRAY searchHeight, searchWidth = searchFor.shape tracker = PlaneTracker() tracker.add_target(searchFor, (0, 0, searchWidth, searchHeight)) cap = cv2.VideoCapture(0) # Init Camera while (True): # Get Frame ret, img = cap.read() gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2) # Draw Faces On img # Crop Face cropped = img[y:y + h, x:x + w] #croppedGray = cv2.cvtColor(cropped, cv2.COLOR_BGR2GRAY)
def track_from_file(input_image_file, check_images_dir, result_dir): print "Tracking", input_image_file tracker = PlaneTracker() # ------------ INPUT IMAGE input_image = cv2.imread(input_image_file) input_image = cv2.resize(input_image, (0,0), fx=SCALE_DOWN_COEF, fy=SCALE_DOWN_COEF) # input_image = rotateImage(input_image, -90) input_image_gray = cv2.cvtColor(input_image, cv2.COLOR_BGR2GRAY) height, width = input_image.shape[:2] # ------------ tracker.clear() tracker.add_target(input_image_gray, (0, 0, width, height)) # ---------------- for fn in os.listdir(check_images_dir): # print os.path.join(imagesDir, fn) filename = os.path.join(check_images_dir, fn) if os.path.isfile(filename): print "Checking", filename fName, fExtension = os.path.splitext(fn) inpfName, _ = os.path.splitext(os.path.split(input_image_file)[1]) # print fn, fName, fExtension inFile = os.path.join(check_images_dir, fn) # print 'inFile =', inFile resFile = os.path.join(result_dir, inpfName + 'r' + fName + fExtension) # print 'resFile =', resFile # DO SMTH HERE inFile and resFile im = cv2.imread(inFile) im = cv2.resize(im, (0,0), fx=SCALE_DOWN_COEF, fy=SCALE_DOWN_COEF) # im = rotateImage(im, -90) imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY) # im = rotateImage(imgray, -90) # draw corners # for i in range(len(corners)): # print i, corners[i][0] # cv2.circle(im, (corners[i][0][0], corners[i][0][1]), 50, (0,255,0), 8) # track & match features tracked = tracker.track(imgray) if tracked: print "Tracked generation started" resImage = np.zeros((height, width * 2, 3), np.uint8) resImage[:height, :width] = input_image resImage[:height, width:width * 2] = im # keypoints = tracked[0].target.keypoints # resImage = cv2.drawKeypoints(resImage, keypoints, color=(0, 255, 0), # flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS) for tr in tracked: for p0, p1 in zip(tr.p0, tr.p1): from_point = (int(p0[0]), int(p0[1])) to_point = (int(p1[0] + width), int(p1[1])) cv2.line(resImage, from_point, to_point, color=(255, 0, 0)) cv2.imwrite(resFile, rotateImage(resImage, -90)) print 'images ', input_image_file, 'and', filename, ' are similar', ' len.p0=', len( tracked[0].p0), ' len.p1=', len(tracked[0].p1) print_apropriate_room(filename) # else: # print 'images are not similar' print "Tracked generation finished"
class App: def __init__(self, src): self.drone = libardrone.ARDrone(is_ar_drone_2=True) #self.cap = video.create_capture(src) self.frame = None self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') cv2.createTrackbar('focal', 'plane', 25, 50, common.nothing) self.rect_sel = common.RectSelector('plane', self.on_rect) def on_rect(self, rect): self.tracker.add_target(self.frame, rect) def run(self): try: while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: #ret, frame = self.cap.read() #if not ret: # break self.frame = cv2.cvtColor(self.drone.get_image(), cv2.COLOR_BGR2RGB) vis = self.frame.copy() if playing: tracked = self.tracker.track(self.frame) for tr in tracked: cv2.polylines(vis, [np.int32(tr.quad)], True, (255, 255, 255), 2) for (x, y) in np.int32(tr.p1): cv2.circle(vis, (x, y), 2, (255, 255, 255)) self.draw_overlay(vis, tr) self.rect_sel.draw(vis) cv2.imshow('plane', vis) ch = cv2.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == ord('c'): self.tracker.clear() if ch == 27: break finally: cv2.destroyAllWindows() self.drone.emergency() self.drone.reset() self.drone.halt() def draw_overlay(self, vis, tracked): x0, y0, x1, y1 = tracked.target.rect quad_3d = np.float32([[x0, y0, 0], [x1, y0, 0], [x1, y1, 0], [x0, y1, 0]]) fx = 0.5 + cv2.getTrackbarPos('focal', 'plane') / 50.0 h, w = vis.shape[:2] K = np.float64([[fx * w, 0, 0.5 * (w - 1)], [0, fx * w, 0.5 * (h - 1)], [0.0, 0.0, 1.0]]) dist_coef = np.zeros(4) ret, rvec, tvec = cv2.solvePnP(quad_3d, tracked.quad, K, dist_coef) verts = ar_verts * [(x1 - x0), (y1 - y0), -(x1 - x0) * 0.3] + (x0, y0, 0) verts = cv2.projectPoints(verts, rvec, tvec, K, dist_coef)[0].reshape(-1, 2) for i, j in ar_edges: (x0, y0), (x1, y1) = verts[i], verts[j] cv2.line(vis, (int(x0), int(y0)), (int(x1), int(y1)), (255, 255, 0), 2)
class App: def __init__(self, src): #self.cap = video.create_capture(src, presets['book']) self.image_pub = rospy.Publisher("image_topic_2",Image, queue_size=10) self.image_sub = rospy.Subscriber("/camera/rgb/image_raw",Image,self.callback) self.bridge = CvBridge() #dtype, n_channels = br.encoding_as_cvtype2('8UC3') #this.im = np.ndarray(shape=(480, 640, n_channels), dtype=dtype) self.cv_image = None self.frame = None #self.count = 1 self.paused = False self.tracker = PlaneTracker() cv2.namedWindow('plane') self.rect_sel = common.RectSelector('plane', self.on_rect) self.tracker.clear() rospack = rospkg.RosPack() labPath = rospack.get_path('laboratorio3') files = ['Cercano', 'Medio', 'Lejano','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15'] for f in files: rectanguloFile = os.path.join(labPath, 'detectarCono/rect{}.pkl'.format(f)) frameFile = os.path.join(labPath, 'detectarCono/frame{}.pkl'.format(f)) with open(rectanguloFile, 'rb') as f: rectangulo = pickle.load(f) with open(frameFile, 'rb') as f: frame = pickle.load(f) self.tracker.add_target(frame, rectangulo) self.pubVel = rospy.Publisher('/cmd_vel', Twist , queue_size=10) self.pubNavegacion = rospy.Publisher('/laboratorio3/exploration', String , queue_size=10) self.reiniciar_exploracion_timer = False #rospy.init_node('talker', anonymous=True) def callback(self,data): try: self.cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8") #print(self.cv_image) except CvBridgeError as e: print(e) #(rows,cols,channels) = self.cv_image.shape #if cols > 60 and rows > 60 : # cv2.circle(self.cv_image, (50,50), 10, 255) #cv2.imshow("Image window", self.cv_image) #cv2.waitKey(3) try: self.image_pub.publish(self.bridge.cv2_to_imgmsg(self.cv_image, "bgr8")) except CvBridgeError as e: print(e) def on_rect(self, rect): #self.tracker.clear() #self.tracker.add_target(self.frame, rect) #print('ON_RECT') #with open('rect'+str(self.count)+'.pkl', 'wb') as f: # pickle.dump(rect, f, pickle.HIGHEST_PROTOCOL) #with open('frame'+str(self.count)+'.pkl', 'wb') as f: # pickle.dump(self.frame, f, pickle.HIGHEST_PROTOCOL) #self.count = self.count + 1 self.tracker.clear() rospack = rospkg.RosPack() labPath = rospack.get_path('laboratorio3') files = ['Cercano', 'Medio', 'Lejano','1','2','3','4','5','6','7','8','9','10','11','12','13','14','15'] for f in files: rectanguloFile = os.path.join(labPath, 'detectarCono/rect{}.pkl'.format(f)) frameFile = os.path.join(labPath, 'detectarCono/frame{}.pkl'.format(f)) with open(rectanguloFile, 'rb') as f: rectangulo = pickle.load(f) with open(frameFile, 'rb') as f: frame = pickle.load(f) self.tracker.add_target(frame, rectangulo) def reiniciar_exploracion(self, event): self.reiniciar_exploracion_timer = False self.pubNavegacion.publish('START') def run(self): direccion = None while not rospy.is_shutdown(): playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: #print(self.cv_image) ret = True frame = self.cv_image #print(self.cv_image) #print("**************************** frame") #print(frame) #ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() w, h = getsize(self.frame) vis = np.zeros((h, w*2, 3), np.uint8) vis[:h,:w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:,w:] = target.image draw_keypoints(vis[:,w:], target.keypoints) x0, y0, x1, y1 = target.rect #print(x0,y0,x1,y1) cv2.rectangle(vis, (x0+w, y0), (x1+w, y1), (0, 255, 0), 2) if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] if not self.reiniciar_exploracion_timer: self.pubNavegacion.publish('STOP') self.reiniciar_exploracion_timer = True rospy.Timer(rospy.Duration(15), self.reiniciar_exploracion) #Aca se imprimen los 4 puntos que genera #print(str(np.int32(tracked.quad[0]))) #print(str(np.int32(tracked.quad[1]))) #print(str(np.int32(tracked.quad[2]))) #print(str(np.int32(tracked.quad[3]))) #Este es el punto medio del poligono que genera. ptoMedio = (np.int32(tracked.quad[0]) + np.int32(tracked.quad[1]) + np.int32(tracked.quad[2]) + np.int32(tracked.quad[3]))/4 direccion = (ptoMedio[0]-320)/-320.0 twist = Twist(Vector3(15,0,0),Vector3(0,0,direccion)) self.pubVel.publish(twist) cv2.polylines(vis, [np.int32(tracked.quad)], True, (255, 255, 255), 2) for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): cv2.line(vis, (x0+w, y0), (x1, y1), (0, 255, 0)) else: if self.reiniciar_exploracion_timer: direccion = direccion or 0.5 twist = Twist(Vector3(0 if direccion > 0.2 else 10,0,0),Vector3(0,0, direccion if direccion > 0.2 else 0)) self.pubVel.publish(twist) draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv2.imshow('plane', vis) ch = cv2.waitKey(1) if ch == ord(' '): self.paused = not self.paused if ch == 27: break
class App(object): def __init__(self, src): cv.namedWindow(WIN_NAME) cv.moveWindow(WIN_NAME, 0, 0) self.cap = video.create_capture(src, presets['book']) self.frame = None self.auto_output_frame = None self.paused = False self.tracker = PlaneTracker() self.rect_sel = common.RectSelector('plane', self.on_rect) self.user_selected_rect = None self.focal_length = 0.0 self.horizontal_angel = 0.0 self.known_distance = 200 self.KNOWN_WIDTH = 40 self.KNOWN_HEIGHT = 40 self.msg = None self.serial = 0 self.auto_save = False self.auto_serial = 0 def on_rect(self, rect): self.tracker.clear() self.tracker.add_target(self.frame, rect) # rasmus hacked { self.user_selected_rect = rect x0, y0, x1, y1 = rect crop_img = self.frame[y0:y1, x0:x1] #print('type: {}, {}, {}'.format(rect, type(rect), type(rect[0]))) fn = FRAME_FN self.write_file(fn, self.frame) fn = 'rect.jpg' self.write_file(fn, crop_img) self.save_config(rect) # rasmus hacked } def save_config(self, rect): fn = FRAME_FN # elements in 'rect' is numpy.int16, convert them into int, # so that json could store rects = list(map(int, rect)) data = {'fn': fn, 'rect': rects} print(data) j = json.dumps(data) # now j is a string to keep json data with open('h**o.json', 'w') as h**o: h**o.write(j) def load_setting(self, fn): data = myutil.read_jsonfile(fn, debug=True) try: tmp = data['auto_save'] self.auto_save = tmp except: pass print('setting loaded, auto_save: {}'.format(self.auto_save)) def load_config(self, fn): data = myutil.read_jsonfile(fn, debug=True) #print(data['fn']) fn = data.get('fn') frame = np.zeros((640, 480, 3), np.uint8) if myutil.isfile(fn): frame = cv.imread(fn) else: print('file not found: {}'.format(fn)) return None rect = data['rect'] self.focal_length = self.calc_focallength(rect) rect = tuple(map(np.int16, rect)) print(rect) self.tracker.clear() self.tracker.add_target(frame, rect) print('preset loaded') return frame def calc_focallength(self, rect): # initialize the known distance from the camera to the object, which # preset distance from samples self.known_distance = 200 # initialize the known object width, which in this case, the piece of # paper, unit mm width = rect[2] - rect[0] focalLength = (width * self.known_distance) / self.KNOWN_WIDTH print('width: {} focal length: {:.2f}'.format(width, focalLength)) return focalLength def distance_to_camera(self, knownWidth, focalLength, perWidth): # compute and return the distance from the maker to the camera if perWidth == 0.0: return 0.0 return (knownWidth * focalLength) / perWidth @staticmethod def get_dist2d(p1, p2): return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) @staticmethod def write_file(fn, frame): cv.imwrite(fn, frame) print('output to %s' % fn) @staticmethod def get_slope(p1, p2): delta_x = float(p2[0] - p1[0]) delta_y = float(p2[1] - p1[1]) if delta_x == 0: return -1.0 return math.fabs(delta_y / delta_x) @staticmethod def get_degree(slope): if slope < 0.0: return 90.0 deg = math.atan(slope) * 180.0 / math.pi return deg def show_wtf(self, wtf): print('wtf: {} -- {}'.format(wtf, self.user_selected_rect)) def check_wtf(self, wtf, debug=False): self.msg = None for ww in wtf: xx, yy = ww if xx > 640 or yy > 480 or xx < 0 or yy < 0: if debug: print('OOB') return False ang1 = self.get_degree(self.get_slope(wtf[0], wtf[1])) ang2 = self.get_degree(self.get_slope(wtf[2], wtf[3])) if ang1 > 30.0 or ang2 > 30: if debug: print('h ang') return False self.horizontal_angel = ang1 dist = self.get_dist2d(wtf[0], wtf[1]) h_dist = dist * math.cos(self.horizontal_angel * math.pi / 180.0) detph = self.distance_to_camera(self.KNOWN_WIDTH, self.focal_length, h_dist) #print('ang{:4.2f} dist{:4.2f}'.format(self.horizontal_angel, dist), end=' ') #print('hdist {:4.2f}'.format(h_dist), end=' ') self.msg = 'depth {:4.2f} mm'.format(detph) s1 = self.get_slope(wtf[1], wtf[2]) s2 = self.get_slope(wtf[0], wtf[3]) if s1 < 0.0 or s2 < 0.0: if debug: print('t slopy') return False ang1 = self.get_degree(s1) ang2 = self.get_degree(s2) if ang1 < 60.0 or ang2 < 60.0: if debug: print('too s') return False return True def draw_result(self, img, wtf): cv.putText(img, self.msg, (50, 50), cv.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), lineType=cv.LINE_AA) cv.polylines(img, [np.int32(wtf)], True, (255, 255, 255), 2) def run(self): setting_fn = 'setting.json' if myutil.isfile(setting_fn): print('setting exists') self.load_setting(setting_fn) # load preset frame and rect if True and myutil.isfile('h**o.json'): print('preset exists') tmp_frame = self.load_config('h**o.json') #self.frame = tmp_frame print('test: {}'.format( self.distance_to_camera(self.KNOWN_WIDTH, self.focal_length, 135))) while True: playing = not self.paused and not self.rect_sel.dragging if playing or self.frame is None: ret, frame = self.cap.read() if not ret: break self.frame = frame.copy() self.auto_output_frame = frame.copy() w, h = getsize(self.frame) vis = np.zeros((h, w * 2, 3), np.uint8) # if tmp_frame: # vis[:,w:] = tmp_frame vis[:h, :w] = self.frame if len(self.tracker.targets) > 0: target = self.tracker.targets[0] vis[:, w:] = target.image draw_keypoints(vis[:, w:], target.keypoints) x0, y0, x1, y1 = target.rect cv.rectangle(vis, (x0 + w, y0), (x1 + w, y1), (0, 255, 0), 2) is_ok_to_export = False if playing: tracked = self.tracker.track(self.frame) if len(tracked) > 0: tracked = tracked[0] wtf = np.int32(tracked.quad) if self.check_wtf(wtf): self.draw_result(vis, wtf) cv.fillPoly(vis, [wtf], (255, 0, 0)) for (x0, y0), (x1, y1) in zip(np.int32(tracked.p0), np.int32(tracked.p1)): cv.line(vis, (x0 + w, y0), (x1, y1), (0, 255, 0)) is_ok_to_export = True if self.auto_save: self.draw_result(self.auto_output_frame, wtf) fn = 'autosave_{:04d}.png'.format(self.auto_serial) self.save_image(fn, self.auto_output_frame) self.auto_serial += 1 draw_keypoints(vis, self.tracker.frame_points) self.rect_sel.draw(vis) cv.imshow(WIN_NAME, vis) ch = cv.waitKey(1) if ch == ord(' '): self.paused = not self.paused elif ch == 27: break elif ch == ord('s'): fn = 'saved_{:04d}.png'.format(self.serial) self.serial += 1 self.save_image(fn, vis) def save_image(self, fn, img): print('save image to {}'.format(fn)) cv.imwrite(fn, img)
def __init__(self, features_detect=1500): self.tracker = PlaneTracker(0.025, 10, max_features_detect=1500) self.__templates = [] # Keep track of templates being tracked