def do_ecto(): baggers = dict(image=ImageBagger(topic_name='/camera/rgb/image_color'), depth=ImageBagger(topic_name='/camera/depth/image'), ) bagreader = ecto_ros.BagReader('Bag Ripper', baggers=baggers, bag=sys.argv[1], ) im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ bagreader["image"] >> im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show", name="rgb")[:], bagreader["depth"] >> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show", name="depth")[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.Scheduler(plasm) sched.execute()
def do_ecto(): #Set up the ecto_ros subscribers, with a dict of output name -> subscriber cell subs = dict(image=ImageSub(topic_name='image',queue_size=0), depth=ImageSub(topic_name='depth',queue_size=0), ) #The synchronizer expects this dict, and will have an output foreach key:value pair sync = ecto_ros.Synchronizer('Synchronizator', subs=subs) #some rosmsg ~> opencv type converters rgb = ecto_ros.Image2Mat() depth = ecto_ros.Image2Mat() #declare a graph that just shows the images using opencv highgui graph = [ sync["image"] >> rgb["image"], sync["depth"] >> depth["image"], rgb["image"] >> imshow(name="rgb")["image"], depth["image"] >> imshow(name="depth")["image"] ] #add the graph to our ecto plasm plasm = ecto.Plasm() plasm.connect(graph) #We'll use a threadpool based scheduler to execute this one. sched = ecto.schedulers.Singlethreaded(plasm) sched.execute() #execute forever
def do_ecto(): baggers = dict(image=ImageBagger(topic_name='/camera/rgb/image_mono'), depth=ImageBagger(topic_name='/camera/depth/image_raw'), ) bagwriter = ecto_ros.BagWriter('Bag Writer', baggers=baggers, bag=sys.argv[1], ) subs = dict( image=ImageSub(topic_name='/camera/rgb/image_mono',queue_size=0), depth=ImageSub(topic_name='/camera/depth/image_raw',queue_size=0), ) sync = ecto_ros.Synchronizer('Synchronizator', subs=subs ) im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ sync["image"] >> im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show", name="rgb", waitKey=5)[:], sync[:] >> bagwriter[:], sync["depth"] >> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show", name="depth", waitKey= -1)[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute(niter=30)#capture a second.
def do_ecto(): baggers = dict(image=ImageBagger(topic_name='/camera/rgb/image_color'), depth=ImageBagger(topic_name='/camera/depth/image'), ) bagreader = ecto_ros.BagReader('Bag Ripper', baggers=baggers, bag=sys.argv[1], ) im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ bagreader["image"] >> im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show", name="rgb", waitKey=5)[:], bagreader["depth"] >> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show", name="depth", waitKey= -1)[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.schedulers.Singlethreaded(plasm) sched.execute()
def do_ecto(): #Set up the ecto_ros subscribers, with a dict of output name -> subscriber cell subs = dict( image=ImageSub(topic_name='image', queue_size=0), depth=ImageSub(topic_name='depth', queue_size=0), ) #The synchronizer expects this dict, and will have an output foreach key:value pair sync = ecto_ros.Synchronizer('Synchronizator', subs=subs) #some rosmsg ~> opencv type converters rgb = ecto_ros.Image2Mat() depth = ecto_ros.Image2Mat() #declare a graph that just shows the images using opencv highgui graph = [ sync["image"] >> rgb["image"], sync["depth"] >> depth["image"], rgb["image"] >> imshow(name="rgb")["image"], depth["image"] >> imshow(name="depth")["image"] ] #add the graph to our ecto plasm plasm = ecto.Plasm() plasm.connect(graph) #We'll use a threadpool based scheduler to execute this one. sched = ecto.schedulers.Singlethreaded(plasm) sched.execute() #execute forever
def do_ecto(): baggers = dict( image=ImageBagger(topic_name='/camera/rgb/image_mono'), depth=ImageBagger(topic_name='/camera/depth/image_raw'), ) bagwriter = ecto_ros.BagWriter( 'Bag Writer', baggers=baggers, bag=sys.argv[1], ) subs = dict( image=ImageSub(topic_name='/camera/rgb/image_mono', queue_size=0), depth=ImageSub(topic_name='/camera/depth/image_raw', queue_size=0), ) sync = ecto_ros.Synchronizer('Synchronizator', subs=subs) im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ sync["image"] >> im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show", name="rgb")[:], sync[:] >> bagwriter[:], sync["depth"] >> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show", name="depth")[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute(niter=30) #capture a second.
def do_ecto(): subs = dict( image=ImageSub(topic_name='/camera/rgb/image_color',queue_size=0), depth=ImageSub(topic_name='/camera/depth/image',queue_size=0), depth_info=CameraInfoSub(topic_name='/camera/depth/camera_info',queue_size=0), image_info=CameraInfoSub(topic_name='/camera/rgb/camera_info',queue_size=0), ) sync = ecto_ros.Synchronizer('Synchronizator', subs=subs ) drift_printer = ecto_ros.DriftPrinter() im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ sync["image"] >> im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show", name="rgb", waitKey=5)[:], sync[:] >> drift_printer[:], sync["depth"] >> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show", name="depth", waitKey= -1)[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute()
def connections(self): graph = [] # connect the input graph += [ self.source['image'] >> self.feature_descriptor['image'], self.source['image'] >> self.rescale_depth['image'], self.source['mask'] >> self.feature_descriptor['mask'], self.source['depth'] >> self.rescale_depth['depth'], self.source['K'] >> self.depth_to_3d_sparse['K'] ] # Make sure the keypoints are in the mask and with a valid depth graph += [ self.feature_descriptor['keypoints', 'descriptors'] >> self.keypoint_validator['keypoints', 'descriptors'], self.source['K'] >> self.keypoint_validator['K'], self.source['mask'] >> self.keypoint_validator['mask'], self.rescale_depth['depth'] >> self.keypoint_validator['depth'] ] # transform the keypoints/depth into 3d points graph += [ self.keypoint_validator['points'] >> self.depth_to_3d_sparse['points'], self.rescale_depth['depth'] >> self.depth_to_3d_sparse['depth'], self.source['R'] >> self.camera_to_world['R'], self.source['T'] >> self.camera_to_world['T'], self.depth_to_3d_sparse['points3d'] >> self.camera_to_world['points'] ] # store all the info graph += [ self.camera_to_world['points'] >> self.model_stacker['points3d'], self.keypoint_validator['points'] >> self.model_stacker['points'], self.keypoint_validator['descriptors'] >> self.model_stacker['descriptors'], self.source['K', 'R', 'T'] >> self.model_stacker['K', 'R', 'T'], ] if self.visualize: mask_view = highgui.imshow(name="mask") depth_view = highgui.imshow(name="depth") graph += [ self.source['mask'] >> mask_view['image'], self.source['depth'] >> depth_view['image'] ] # draw the keypoints keypoints_view = highgui.imshow(name="Keypoints") draw_keypoints = features2d.DrawKeypoints() graph += [ self.source['image'] >> draw_keypoints['image'], self.feature_descriptor['keypoints'] >> draw_keypoints['keypoints'], draw_keypoints['image'] >> keypoints_view['image'] ] return graph
def mesh_session(session, args): db_reader = capture.ObservationReader('db_reader', session_id=session.id) depthTo3d = calib.DepthTo3d() surfel_reconstruction = reconstruction.SurfelReconstruction(corrDistForUpdate=0.02, maxInterpolationDist=0.04, starvationConfidence=2, timeDiffForRemoval=25, maxNormalAngle=90 * math.pi / 180) if True: plasm = ecto.Plasm() plasm.connect( db_reader['K', 'depth'] >> depthTo3d['K', 'depth'], depthTo3d['points3d'] >> surfel_reconstruction['points3d'], db_reader['K', 'R', 'T', 'image', 'mask'] >> surfel_reconstruction['K', 'R', 'T', 'image', 'mask'], ) if args.visualize: plasm.connect( db_reader['image'] >> highgui.imshow('image', name='image', waitKey=10, autoSize=True)[:], db_reader['depth'] >> highgui.imshow('depth', name='depth', waitKey= -1, autoSize=True)[:], db_reader['mask'] >> highgui.imshow('mask', name='mask', waitKey= -1, autoSize=True)[:], ) sched = ecto.schedulers.Singlethreaded(plasm) sched.execute() if True: location = '/tmp/object_recognition/' mesh_script_txt = '''<!DOCTYPE FilterScript> <FilterScript> <filter name="Surface Reconstruction: Poisson"> <Param type="RichInt" value="8" name="OctDepth"/> <Param type="RichInt" value="8" name="SolverDivide"/> <Param type="RichFloat" value="2" name="SamplesPerNode"/> <Param type="RichFloat" value="1" name="Offset"/> </filter> </FilterScript> ''' mesh_file_name = os.path.join(location, 'meshing.mlx') with open(mesh_file_name, 'w') as mesh_script: mesh_script.write(mesh_script_txt) try: os.makedirs(location) except Exception, e: pass name_base = str(session.id) surfel_ply = os.path.join(location, name_base + '.ply') print "Saving to :", surfel_ply surfel_saver = reconstruction.SurfelToPly(filename=surfel_ply) surfel_saver.inputs.at('model').copy_value(surfel_reconstruction.outputs.at('model')) surfel_saver.inputs.at('params').copy_value(surfel_reconstruction.outputs.at('params')) surfel_saver.inputs.at('camera_params').copy_value(surfel_reconstruction.outputs.at('camera_params')) surfel_saver.configure() surfel_saver.process() #manually thunk the cell's process function
def connections(self, p): # Rescale the depth image and convert to 3d graph = [ self.passthrough['image'] >> self._depth_map['image'], self._depth_map['depth'] >> self._points3d['depth'], self.passthrough['K'] >> self._points3d['K'], self._points3d['points3d'] >> self.guess_generator['points3d'] ] # make sure the inputs reach the right cells if 'depth' in self.feature_descriptor.inputs.keys(): graph += [ self._depth_map['depth'] >> self.feature_descriptor['depth']] graph += [ self.passthrough['image'] >> self.feature_descriptor['image'], self.passthrough['image'] >> self.guess_generator['image'] ] graph += [ self.descriptor_matcher['spans'] >> self.guess_generator['spans'], self.descriptor_matcher['object_ids'] >> self.guess_generator['object_ids'] ] graph += [ self.feature_descriptor['keypoints'] >> self.guess_generator['keypoints'], self.feature_descriptor['descriptors'] >> self.descriptor_matcher['descriptors'], self.descriptor_matcher['matches', 'matches_3d'] >> self.guess_generator['matches', 'matches_3d'] ] cvt_color = imgproc.cvtColor(flag=imgproc.RGB2GRAY) if p.visualize or ECTO_ROS_FOUND: draw_keypoints = features2d.DrawKeypoints() graph += [ self.passthrough['image'] >> cvt_color[:], cvt_color[:] >> draw_keypoints['image'], self.feature_descriptor['keypoints'] >> draw_keypoints['keypoints'] ] if p.visualize: # visualize the found keypoints image_view = highgui.imshow(name="RGB") keypoints_view = highgui.imshow(name="Keypoints") graph += [ self.passthrough['image'] >> image_view['image'], draw_keypoints['image'] >> keypoints_view['image'] ] pose_view = highgui.imshow(name="Pose") pose_drawer = calib.PosesDrawer() # draw the poses graph += [ self.passthrough['image', 'K'] >> pose_drawer['image', 'K'], self.guess_generator['Rs', 'Ts'] >> pose_drawer['Rs', 'Ts'], pose_drawer['output'] >> pose_view['image'] ] if ECTO_ROS_FOUND: ImagePub = ecto_sensor_msgs.Publisher_Image pub_features = ImagePub("Features Pub", topic_name='features') graph += [ draw_keypoints['image'] >> self.message_cvt[:], self.message_cvt[:] >> pub_features[:] ] return graph
def connections(self): graph = [] # connect the input graph += [ self.source["image"] >> self.feature_descriptor["image"], self.source["image"] >> self.rescale_depth["image"], self.source["mask"] >> self.feature_descriptor["mask"], self.source["depth"] >> self.rescale_depth["depth"], self.source["K"] >> self.depth_to_3d_sparse["K"], ] # Make sure the keypoints are in the mask and with a valid depth graph += [ self.feature_descriptor["keypoints", "descriptors"] >> self.keypoint_validator["keypoints", "descriptors"], self.source["K"] >> self.keypoint_validator["K"], self.source["mask"] >> self.keypoint_validator["mask"], self.rescale_depth["depth"] >> self.keypoint_validator["depth"], ] # transform the keypoints/depth into 3d points graph += [ self.keypoint_validator["points"] >> self.depth_to_3d_sparse["points"], self.rescale_depth["depth"] >> self.depth_to_3d_sparse["depth"], self.source["R"] >> self.camera_to_world["R"], self.source["T"] >> self.camera_to_world["T"], self.depth_to_3d_sparse["points3d"] >> self.camera_to_world["points"], ] # store all the info graph += [ self.camera_to_world["points"] >> self.model_stacker["points3d"], self.keypoint_validator["points"] >> self.model_stacker["points"], self.keypoint_validator["descriptors"] >> self.model_stacker["descriptors"], self.source["K", "R", "T"] >> self.model_stacker["K", "R", "T"], ] if self.visualize: mask_view = highgui.imshow(name="mask") depth_view = highgui.imshow(name="depth") graph += [self.source["mask"] >> mask_view["image"], self.source["depth"] >> depth_view["image"]] # draw the keypoints keypoints_view = highgui.imshow(name="Keypoints") draw_keypoints = features2d.DrawKeypoints() graph += [ self.source["image"] >> draw_keypoints["image"], self.feature_descriptor["keypoints"] >> draw_keypoints["keypoints"], draw_keypoints["image"] >> keypoints_view["image"], ] return graph
def calibration(rows, cols, square_size, pattern_type, n_obs, video): plasm = ecto.Plasm() pattern_show = highgui.imshow(name="pattern", waitKey=10, autoSize=True) rgb2gray = imgproc.cvtColor(flag=7) circle_detector = calib.PatternDetector(rows=rows, cols=cols, pattern_type=pattern_type, square_size=square_size) ecto.print_module_doc(circle_detector) circle_drawer = calib.PatternDrawer(rows=rows, cols=cols) camera_calibrator = calib.CameraCalibrator(output_file_name="camera.yml", n_obs=n_obs) plasm.connect(video, "image", rgb2gray, "input") plasm.connect(rgb2gray, "out", circle_detector, "input") plasm.connect(video, "image", circle_drawer, "input") plasm.connect(video, "image", camera_calibrator, "image") plasm.connect(circle_detector, "out", circle_drawer, "points") plasm.connect(circle_detector, "found", circle_drawer, "found") plasm.connect(circle_drawer, "out", pattern_show, "input") plasm.connect(circle_detector, "ideal", camera_calibrator, "ideal") plasm.connect(circle_detector, "out", camera_calibrator, "points") plasm.connect(circle_detector, "found", camera_calibrator, "found") print plasm.viz() ecto.view_plasm(plasm) while (pattern_show.outputs.out != 27 and camera_calibrator.outputs.calibrated == False): plasm.execute(1)
def __init__(self, plasm, rows, cols, pattern_type, square_size, debug=True): ecto.BlackBox.__init__(self, plasm) self.video_cap = ecto.Passthrough('Image Input') self.rgb2gray = imgproc.cvtColor('rgb -> gray', flag=7) self.circle_detector = calib.PatternDetector('Dot Detector', rows=rows, cols=cols, pattern_type=pattern_type, square_size=square_size) self.pose_calc = calib.FiducialPoseFinder('Pose Calc') self.camera_info = calib.CameraIntrinsics('Camera Info', camera_file="camera.yml") self.debug = debug if self.debug: self.fps = highgui.FPSDrawer() self.circle_drawer = calib.PatternDrawer('Circle Draw', rows=rows, cols=cols) self.circle_display = highgui.imshow('Pattern show', name='Pattern', waitKey=2, autoSize=True) self.pose_draw = calib.PoseDrawer('Pose Draw')
def calibration(rows,cols,square_size,pattern_type,n_obs,video): plasm = ecto.Plasm() pattern_show = highgui.imshow(name="pattern", waitKey=10, autoSize=True) rgb2gray = imgproc.cvtColor(flag=7) circle_detector = calib.PatternDetector(rows=rows, cols=cols,pattern_type=pattern_type,square_size=square_size ) ecto.print_module_doc(circle_detector) circle_drawer = calib.PatternDrawer(rows=rows, cols=cols) camera_calibrator = calib.CameraCalibrator(output_file_name="camera.yml",n_obs=n_obs) plasm.connect(video, "image", rgb2gray, "input") plasm.connect(rgb2gray, "out", circle_detector, "input") plasm.connect(video, "image", circle_drawer, "input") plasm.connect(video, "image", camera_calibrator, "image") plasm.connect(circle_detector, "out", circle_drawer, "points") plasm.connect(circle_detector, "found", circle_drawer, "found") plasm.connect(circle_drawer, "out", pattern_show, "input") plasm.connect(circle_detector, "ideal", camera_calibrator,"ideal") plasm.connect(circle_detector, "out", camera_calibrator,"points") plasm.connect(circle_detector, "found", camera_calibrator, "found") print plasm.viz() ecto.view_plasm(plasm) while(pattern_show.outputs.out != 27 and camera_calibrator.outputs.calibrated == False): plasm.execute(1)
def make_calib(images, plasm, calibfname): rgb2gray = imgproc.cvtColor(flag=imgproc.RGB2GRAY) plasm.connect(images["image"] >> rgb2gray[:]) detect = calib.PatternDetector(rows=5, cols=3, pattern_type=calib.ASYMMETRIC_CIRCLES_GRID, square_size=0.04) plasm.connect(rgb2gray["out"] >> detect["input"]) draw = calib.PatternDrawer(rows=5, cols=3) plasm.connect(detect["out"] >> draw["points"], detect["found"] >> draw["found"], images["image"] >> draw["input"]) fps = highgui.FPSDrawer() plasm.connect(draw[:] >> fps[:]) calibcell = calib.CameraCalibrator(output_file_name=calibfname + '.yml', n_obs=75, quit_when_calibrated=False) plasm.connect(detect["ideal"] >> calibcell["ideal"], detect["out"] >> calibcell["points"], detect["found"] >> calibcell["found"], images["image"] >> calibcell["image"]) pattern_show = highgui.imshow(name=calibfname, waitKey=10) plasm.connect(fps[:] >> pattern_show["input"])
def create_capture_plasm(bag_name, angle_thresh, segmentation_cell, n_desired, orb_template='', res=SXGA_RES, fps=FPS_30, orb_matches=False, preview=False, use_turn_table=True): ''' Creates a plasm that will capture openni data into a bag, using a dot pattern to sparsify views. @param bag_name: A filename for the bag, will write to this file. @param angle_thresh: The angle threshhold in radians to sparsify the views with. ''' graph = [] # Create ros node, subscribing to openni topics argv = sys.argv[:] ecto_ros.strip_ros_args(argv) ecto_ros.init(argv, "object_capture_msd_pcl", False) cloud_sub = ecto_ros.ecto_sensor_msgs.Subscriber_PointCloud2("cloud_sub", topic_name='/camera/depth_registered/points') rgb_image_sub = ecto_ros.ecto_sensor_msgs.Subscriber_Image("rgb_image_sub", topic_name='/camera/rgb/image_raw') depth_image_sub = ecto_ros.ecto_sensor_msgs.Subscriber_Image("depth_image_sub", topic_name='/camera/depth_registered/image_raw') rgb_camera_info_sub = ecto_ros.ecto_sensor_msgs.Subscriber_CameraInfo("rgb_camera_info_sub", topic_name='/camera/rgb/camera_info') depth_camera_info_sub = ecto_ros.ecto_sensor_msgs.Subscriber_CameraInfo("depth_camera_info_sub", topic_name='/camera/depth_registered/camera_info') # Converte ros topics to cv types msg2cloud = ecto_pcl_ros.Message2PointCloud("msg2cloud", format=XYZRGB) image2cv = ecto_ros.Image2Mat() depth2cv = ecto_ros.Image2Mat() rgb_info2cv = ecto_ros.CameraInfo2Cv() depth_info2cv = ecto_ros.CameraInfo2Cv() graph += [ cloud_sub['output'] >> msg2cloud[:], rgb_image_sub[:] >> image2cv[:], depth_image_sub[:] >> depth2cv[:], rgb_camera_info_sub[:] >> rgb_info2cv[:], depth_camera_info_sub[:] >> depth_info2cv[:] ] #display the mask display = highgui.imshow(name='Poses') graph += [image2cv[:] >> display[:], ] # convert the image to grayscale # rgb2gray = imgproc.cvtColor('rgb -> gray', flag=imgproc.Conversion.RGB2GRAY) # graph += [image2cv[:] >> rgb2gray[:] ] # get a pose use the dot pattern: there might be a scale ambiguity as this is 3d only poser = OpposingDotPoseEstimator(rows=5, cols=3, pattern_type=calib.ASYMMETRIC_CIRCLES_GRID, square_size=0.04, debug=True) graph += [ image2cv[:] >> poser['color_image'], rgb_info2cv['K'] >> poser['K_image'], image2cv[:] >> poser['image'] ] plasm = ecto.Plasm() plasm.connect(graph) return (plasm, segmentation_cell) # return segmentation for tuning of parameters.
def connections(self, p): graph = [] # connect the input if 'depth' in self.feature_descriptor.inputs.keys(): graph += [self.rescale_depth['depth'] >> self.feature_descriptor['depth']] graph += [self.source['image'] >> self.feature_descriptor['image'], self.source['image'] >> self.rescale_depth['image'], self.source['mask'] >> self.feature_descriptor['mask'], self.source['depth'] >> self.rescale_depth['depth'], self.source['K'] >> self.depth_to_3d_sparse['K']] # Make sure the keypoints are in the mask and with a valid depth graph += [self.feature_descriptor['keypoints', 'descriptors'] >> self.keypoint_validator['keypoints', 'descriptors'], self.source['K'] >> self.keypoint_validator['K'], self.source['mask'] >> self.keypoint_validator['mask'], self.rescale_depth['depth'] >> self.keypoint_validator['depth'] ] # transform the keypoints/depth into 3d points graph += [ self.keypoint_validator['points'] >> self.depth_to_3d_sparse['points'], self.rescale_depth['depth'] >> self.depth_to_3d_sparse['depth'], self.source['R'] >> self.camera_to_world['R'], self.source['T'] >> self.camera_to_world['T'], self.depth_to_3d_sparse['points3d'] >> self.camera_to_world['points']] # store all the info graph += [ self.camera_to_world['points'] >> self.model_stacker['points3d'], self.keypoint_validator['points', 'descriptors', 'disparities'] >> self.model_stacker['points', 'descriptors', 'disparities'], self.source['K', 'R', 'T'] >> self.model_stacker['K', 'R', 'T'], ] if self.visualize: mask_view = highgui.imshow(name="mask") depth_view = highgui.imshow(name="depth") graph += [ self.source['mask'] >> mask_view['image'], self.source['depth'] >> depth_view['image']] # draw the keypoints keypoints_view = highgui.imshow(name="Keypoints") draw_keypoints = features2d.DrawKeypoints() graph += [ self.source['image'] >> draw_keypoints['image'], self.feature_descriptor['keypoints'] >> draw_keypoints['keypoints'], draw_keypoints['image'] >> keypoints_view['image']] return graph
def connections(self): connections = [self._sync["image"] >> self._im2mat_rgb["image"], self._sync["depth"] >> self._im2mat_depth["image"], self._sync["image_info"] >> self._camera_info['camera_info'], self._camera_info['K'] >> self._depth_to_3d['K'], self._im2mat_depth['image'] >> self._depth_to_3d['depth'] ] if self._debug: connections += [self._im2mat_depth[:] >> highgui.imshow(name='kinect depth',waitKey=10)[:]] return connections
def do_ecto(): sub_rgb = ImageSub("image_sub",topic_name='/camera/rgb/image_mono') sub_depth = ImageSub("depth_sub",topic_name='/camera/depth/image') im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ sub_rgb["output"]>>im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show",name="rgb")[:], sub_depth["output"]>> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show",name="depth")[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute()
def do_ecto(): sub_rgb = ImageSub("image_sub", topic_name='/camera/rgb/image_mono') sub_depth = ImageSub("depth_sub", topic_name='/camera/depth/image') im2mat_rgb = ecto_ros.Image2Mat() im2mat_depth = ecto_ros.Image2Mat() graph = [ sub_rgb["output"] >> im2mat_rgb["image"], im2mat_rgb["image"] >> highgui.imshow("rgb show", name="rgb")[:], sub_depth["output"] >> im2mat_depth["image"], im2mat_depth["image"] >> highgui.imshow("depth show", name="depth")[:] ] plasm = ecto.Plasm() plasm.connect(graph) ecto.view_plasm(plasm) sched = ecto.Scheduler(plasm) sched.execute()
def connect_observation_calc(sync, commit, object_id, session_id, debug=False): plasm = ecto.Plasm() depth_ci = ecto_ros.CameraInfo2Cv('camera_info -> cv::Mat') image_ci = ecto_ros.CameraInfo2Cv('camera_info -> cv::Mat') image = ecto_ros.Image2Mat() depth = ecto_ros.Image2Mat() #conversions plasm.connect( sync["image"] >> image["image"], sync["depth"] >> depth['image'], sync['image_ci'] >> image_ci[:], sync['depth_ci'] >> depth_ci[:] ) rgb = imgproc.cvtColor('bgr -> rgb', flag=imgproc.Conversion.BGR2RGB) gray = imgproc.cvtColor('rgb -> gray', flag=imgproc.Conversion.RGB2GRAY) calc_observations = CalcObservations(plasm) rescale_depth = capture.RescaledRegisteredDepth() #this is for SXGA mode scale handling. plasm.connect(image[:] >> (rgb[:], gray[:]), gray[:] >> (calc_observations['image'], rescale_depth['image']), depth[:] >> rescale_depth['depth'], rescale_depth['depth'] >> calc_observations['depth'], image_ci['K'] >> calc_observations['K'], ) if debug: image_display = highgui.imshow('image display', name='image', waitKey=10, autoSize=True) mask_display = highgui.imshow('mask display', name='mask', waitKey= -1, autoSize=True) plasm.connect(rgb[:] >> image_display[:]) plasm.connect(calc_observations['mask'] >> mask_display[:]) if commit: db_inserter = capture.ObservationInserter("db_inserter", object_id=object_id, session_id=session_id) plasm.connect(depth[:] >> db_inserter['depth'], calc_observations['R', 'T', 'mask', 'novel'] >> db_inserter['R', 'T', 'mask', 'found'], rgb[:] >> db_inserter['image'], image_ci['K'] >> db_inserter['K'], ) return plasm
def connections(self, _p): train = self.train orb = self.orb graph = [ self.gray_image[:] >> orb['image'], self.points3d[:] >> orb['points3d'], self.depth_mask[:] >> orb['points3d_mask'] ] matcher = Matcher() # if self.use_lsh: # matcher = self.lsh graph += [ orb['descriptors'] >> matcher['test'], train['descriptors'] >> matcher['train'], ] #3d estimation pose_estimation = self.pose_estimation graph += [ matcher['matches'] >> pose_estimation['matches'], orb['points', 'points3d'] >> pose_estimation['test_2d', 'test_3d'], train['points', 'points3d'] >> pose_estimation['train_2d', 'train_3d'] ] if self.show_matches: #display matches match_drawer = DrawMatches() graph += [ pose_estimation['matches'] >> match_drawer['matches'], pose_estimation['matches_mask'] >> match_drawer['matches_mask'], orb['points'] >> match_drawer['test'], train['points'] >> match_drawer['train'], self.rgb_image[:] >> match_drawer['test_image'], train['image'] >> match_drawer['train_image'], match_drawer['output'] >> imshow(name='Matches')[''] ] tr = self.tr fps = self.fps pose_draw = PoseDrawer() graph += [ train['R', 'T'] >> tr['R1', 'T1'], pose_estimation['R', 'T'] >> tr['R2', 'T2'], tr['R', 'T'] >> pose_draw['R', 'T'], pose_estimation['found'] >> pose_draw['trigger'], self.K_image[:] >> pose_draw['K'], self.rgb_image[:] >> pose_draw['image'], pose_draw['output'] >> fps[:], ] return graph
def connections(self): # make sure the inputs reach the right cells connections = [self.passthrough['image'] >> self.feature_descriptor['image'], self.passthrough['image'] >> self.guess_generator['image'], ] connections += [ self.descriptor_matcher['spans'] >> self.guess_generator['spans'], self.descriptor_matcher['object_ids'] >> self.guess_generator['object_ids'] ] connections += [ self.feature_descriptor['keypoints'] >> self.guess_generator['keypoints'], self.feature_descriptor['descriptors'] >> self.descriptor_matcher['descriptors'], self.descriptor_matcher['matches', 'matches_3d'] >> self.guess_generator['matches', 'matches_3d'] ] pub_features = ImagePub("Features Pub", topic_name='features') cvt_color = imgproc.cvtColor(flag=imgproc.RGB2GRAY) draw_keypoints = features2d.DrawKeypoints() connections += [ self.passthrough['image'] >> cvt_color[:], cvt_color[:] >> draw_keypoints['image'], self.feature_descriptor['keypoints'] >> draw_keypoints['keypoints'], draw_keypoints['image'] >> self.message_cvt[:], self.message_cvt[:] >> pub_features[:] ] if self._visualize: # visualize the found keypoints image_view = highgui.imshow(name="RGB") keypoints_view = highgui.imshow(name="Keypoints") connections += [ self.passthrough['image'] >> image_view['image'], draw_keypoints['image'] >> keypoints_view['image'] ] pose_view = highgui.imshow(name="Pose") pose_drawer = calib.PosesDrawer() # draw the poses connections += [ self.passthrough['image', 'K'] >> pose_drawer['image', 'K'], self.guess_generator['Rs', 'Ts'] >> pose_drawer['Rs', 'Ts'], pose_drawer['output'] >> pose_view['image'] ] return connections
def __init__(self, plasm): ecto.BlackBox.__init__(self, plasm) self.video_cap = highgui.VideoCapture(video_device=0) self.fps = highgui.FPSDrawer() self.rgb2gray = imgproc.cvtColor("rgb -> gray", flag=7) self.circle_detector = calib.PatternDetector( "Dot Detector", rows=7, cols=3, pattern_type="acircles", square_size=0.03 ) self.circle_drawer = calib.PatternDrawer("Circle Draw", rows=7, cols=3) self.circle_display = highgui.imshow("Pattern show", name="Pattern", waitKey=2, maximize=True) self.pose_calc = calib.FiducialPoseFinder("Pose Calc") self.pose_draw = calib.PoseDrawer("Pose Draw") self.camera_info = calib.CameraIntrinsics("Camera Info", camera_file="camera.yml")
def create_capture_plasm(bag_name): ''' Creates a plasm that will capture openni data into a bag. ''' # bag writing baggers = dict(image=ImageBagger(topic_name='/camera/rgb/image_color'), depth=ImageBagger(topic_name='/camera/depth/image'), image_ci=CameraInfoBagger(topic_name='/camera/rgb/camera_info'), depth_ci=CameraInfoBagger(topic_name='/camera/depth/camera_info'), ) #conditional writer bagwriter = ecto.If('Bag Writer if \'s\'', cell=ecto_ros.BagWriter(baggers=baggers, bag=bag_name) ) subs = dict(image=ImageSub(topic_name='/camera/rgb/image_color', queue_size=0), image_ci=CameraInfoSub(topic_name='/camera/rgb/camera_info', queue_size=0), depth=ImageSub(topic_name='/camera/depth_registered/image', queue_size=0), cloud=PointCloudSub(topic_name='/camera/depth_registered/points', queue_size=0), depth_ci=CameraInfoSub(topic_name='/camera/depth_registered/camera_info', queue_size=0), ) sync = ecto_ros.Synchronizer('Synchronizator', subs=subs ) graph = [ sync['image','depth','image_ci','depth_ci'] >> bagwriter['image','depth','image_ci','depth_ci'], ] #point cloud stuff msg2cloud = ecto_pcl_ros.Message2PointCloud("msg2cloud", format=ecto_pcl.XYZRGB) example = easy_capture.ExampleFilter() graph += [ sync['cloud'] >> msg2cloud[:], msg2cloud[:] >> example[:], ] #use opencv highgui to display an image. im2mat_rgb = ecto_ros.Image2Mat('rgb -> cv::Mat') display = highgui.imshow('Image Display', name='/camera/rgb/image_color', waitKey=5, autoSize=True, triggers=dict(save=ord('s'))) bgr2rgb = imgproc.cvtColor('rgb -> bgr', flag=imgproc.Conversion.RGB2BGR) graph += [ sync['image'] >> im2mat_rgb[:], im2mat_rgb[:] >> bgr2rgb[:], bgr2rgb[:] >> display[:], display['save'] >> bagwriter['__test__'] ] plasm = ecto.Plasm() plasm.connect(graph) return plasm
def connections(self): n_features = 1000 orb = ORB(n_features=n_features, n_levels=3, scale_factor=1.1) graph = [ self.gray_image[:] >> orb['image'], self.points3d[:] >> orb['points3d'], ] orb_ref = ORB(n_features=n_features, n_levels=3, scale_factor=1.1) graph = [ self.gray_image_ref[:] >> orb_ref['image'], self.points3d_ref[:] >> orb_ref['points3d'], ] matcher = LSHMatcher('LSH', n_tables=4, multi_probe_level=1, key_size=10, radius=70) # matcher = Matcher() graph += [ orb['descriptors'] >> matcher['test'], orb_ref['descriptors'] >> matcher['train'], ] #3d estimation pose_estimation = self.pose_estimation graph += [matcher['matches'] >> pose_estimation['matches'], orb['points'] >> pose_estimation['test_2d'], orb_ref['points'] >> pose_estimation['train_2d'], orb['points3d'] >> pose_estimation['test_3d'], orb_ref['points3d'] >> pose_estimation['train_3d'], ] if self.show_matches: #display matches match_drawer = DrawMatches() graph += [pose_estimation['matches'] >> match_drawer['matches'], pose_estimation['matches_mask'] >> match_drawer['matches_mask'], orb['points'] >> match_drawer['test'], orb_ref['points'] >> match_drawer['train'], self.rgb_image[:] >> match_drawer['test_image'], orb_ref['image'] >> match_drawer['train_image'], match_drawer['output'] >> imshow(name='Matches')[''] ] tr = self.tr fps = self.fps # pose_draw = PoseDrawer() # graph += [train['R', 'T'] >> tr['R1', 'T1'], # pose_estimation['R', 'T'] >> tr['R2', 'T2'], # tr['R', 'T'] >> pose_draw['R', 'T'], # pose_estimation['found'] >> pose_draw['trigger'], # self.K[:] >> pose_draw['K'], # self.rgb_image[:] >> pose_draw['image'], # pose_draw['output'] >> fps[:], # ] return graph
def connect_background_source(self): json_db_str = '{"type": "CouchDB", "root": "http://localhost:5984", "collection": "object_recognition"}' self.json_db = ecto.Constant(value=json_db_str) object_id_str = '4680aac58c1d263b9449d57bd2000f27' self.object_id = ecto.Constant(value=object_id_str) self.image_ci = ecto_ros.CameraInfo2Cv('camera_info -> cv::Mat') self.image = ecto_ros.Image2Mat() self.depth = ecto_ros.Image2Mat() bag = "/home/sam/rosbags/sigverse/no_objects.bag" ImageBagger = ecto_sensor_msgs.Bagger_Image CameraInfoBagger = ecto_sensor_msgs.Bagger_CameraInfo baggers = dict( image=ImageBagger( topic_name='/hsrb/head_rgbd_sensor/rgb/image_raw'), image_ci=CameraInfoBagger( topic_name='/hsrb/head_rgbd_sensor/rgb/camera_info'), depth=ImageBagger( topic_name='/hsrb/head_rgbd_sensor/depth/image_raw'), ) # this will read all images in the path path = '/home/sam/Code/vision/VOCdevkit/VOC2012/JPEGImages' self.file_source = ImageReader(path=os.path.expanduser(path)) self.bag_reader = ecto_ros.BagReader('Bag Reader', baggers=baggers, bag=bag, random_access=True, ) self.rgb = imgproc.cvtColor( 'bgr -> rgb', flag=imgproc.Conversion.BGR2RGB) self.display = highgui.imshow(name='Training Data', waitKey=10000) self.image_mux = ecto_yolo.ImageMux() self.graph += [ self.bag_reader['image'] >> self.image['image'], self.bag_reader['depth'] >> self.depth['image'], self.image[:] >> self.rgb[:], self.bag_reader['image_ci'] >> self.image_ci['camera_info'], self.image_ci['K'] >> self.image_mux['K1'], self.rgb['image'] >> self.image_mux['image1'], self.depth['image'] >> self.image_mux['depth1'], self.file_source['image'] >> self.image_mux['image2'], ]
def __init__(self, plasm): ecto.BlackBox.__init__(self, plasm) self.video_cap = highgui.VideoCapture(video_device=0) self.fps = highgui.FPSDrawer() self.rgb2gray = imgproc.cvtColor('rgb -> gray', flag=7) self.circle_detector = calib.PatternDetector('Dot Detector', rows=7, cols=3, pattern_type="acircles", square_size=0.03) self.circle_drawer = calib.PatternDrawer('Circle Draw', rows=7, cols=3) self.circle_display = highgui.imshow('Pattern show', name='Pattern', waitKey=2, maximize=True) self.pose_calc = calib.FiducialPoseFinder('Pose Calc') self.pose_draw = calib.PoseDrawer('Pose Draw') self.camera_info = calib.CameraIntrinsics('Camera Info', camera_file="camera.yml")
def connections(self): n_features = 4000 train = self.train orb = FeatureFinder('ORB test', n_features=n_features, n_levels=3, scale_factor=1.1, thresh=100, use_fast=False) graph = [ self.gray_image[:] >> orb['image'], self.points3d[:] >> orb['points3d'], self.depth_mask[:] >> orb['mask'] ] matcher = LSHMatcher('LSH', n_tables=4, multi_probe_level=1, key_size=10, radius=70) #matcher = Matcher() graph += [ orb['descriptors'] >> matcher['test'], train['descriptors'] >> matcher['train'], ] #3d estimation pose_estimation = self.pose_estimation graph += [matcher['matches'] >> pose_estimation['matches'], orb['points'] >> pose_estimation['test_2d'], train['points'] >> pose_estimation['train_2d'], orb['points3d'] >> pose_estimation['test_3d'], train['points3d'] >> pose_estimation['train_3d'], ] if self.show_matches: #display matches match_drawer = DrawMatches() graph += [pose_estimation['matches'] >> match_drawer['matches'], pose_estimation['matches_mask'] >> match_drawer['matches_mask'], orb['points'] >> match_drawer['test'], train['points'] >> match_drawer['train'], self.rgb_image[:] >> match_drawer['test_image'], train['image'] >> match_drawer['train_image'], match_drawer['output'] >> imshow(name='Matches')[''] ] tr = self.tr fps = self.fps pose_draw = PoseDrawer() graph += [train['R', 'T'] >> tr['R1', 'T1'], pose_estimation['R', 'T'] >> tr['R2', 'T2'], tr['R', 'T'] >> pose_draw['R', 'T'], pose_estimation['found'] >> pose_draw['trigger'], self.K[:] >> pose_draw['K'], self.rgb_image[:] >> pose_draw['image'], pose_draw['output'] >> fps[:], ] return graph
def connections(self, _p): train = self.train orb = self.orb graph = [ self.gray_image[:] >> orb['image'], self.points3d[:] >> orb['points3d'], self.depth_mask[:] >> orb['mask'] ] matcher = Matcher() # if self.use_lsh: # matcher = self.lsh graph += [ orb['descriptors'] >> matcher['test'], train['descriptors'] >> matcher['train'], ] #3d estimation pose_estimation = self.pose_estimation graph += [matcher['matches'] >> pose_estimation['matches'], orb['points'] >> pose_estimation['test_2d'], train['points'] >> pose_estimation['train_2d'], orb['points3d'] >> pose_estimation['test_3d'], train['points3d'] >> pose_estimation['train_3d'], ] if self.show_matches: #display matches match_drawer = DrawMatches() graph += [pose_estimation['matches'] >> match_drawer['matches'], pose_estimation['matches_mask'] >> match_drawer['matches_mask'], orb['points'] >> match_drawer['test'], train['points'] >> match_drawer['train'], self.rgb_image[:] >> match_drawer['test_image'], train['image'] >> match_drawer['train_image'], match_drawer['output'] >> imshow(name='Matches')[''] ] tr = self.tr fps = self.fps pose_draw = PoseDrawer() graph += [train['R', 'T'] >> tr['R1', 'T1'], pose_estimation['R', 'T'] >> tr['R2', 'T2'], tr['R', 'T'] >> pose_draw['R', 'T'], pose_estimation['found'] >> pose_draw['trigger'], self.K[:] >> pose_draw['K'], self.rgb_image[:] >> pose_draw['image'], pose_draw['output'] >> fps[:], ] return graph
def make_graph(k, sigma, debug): video = highgui.VideoCapture(video_device=0) g = imgproc.GaussianBlur(sigma=sigma) graph = [] graph += [video['image'] >> g['input']] for x in range(k): nextg = imgproc.GaussianBlur(sigma=sigma) graph += [g['out'] >> nextg['input']] g = nextg fps = highgui.FPSDrawer() graph += [ g['out'] >> fps[:], fps[:] >> highgui.imshow("megagauss", name="megagauss", waitKey=10)[:] ] return graph
def connections(self): # LSH matcher, somewhat sensitive to parameters # matcher = LSHMatcher('LSH', n_tables=4, multi_probe_level=1, key_size=6, radius=55) # this is a brute force matcher matcher = Matcher() graph = [ self.desc[:] >> matcher['test'], self.desc_ref[:] >> matcher['train'], ] #3d estimation pose_estimation = self.pose_estimation graph += [ matcher['matches'] >> pose_estimation['matches'], self.points[:] >> pose_estimation['test_2d'], self.points_ref[:] >> pose_estimation['train_2d'], self.points3d[:] >> pose_estimation['test_3d'], self.points3d_ref[:] >> pose_estimation['train_3d'], self.K[:] >> pose_estimation['K'] ] if self.show_matches: #display matches match_drawer = DrawMatches() graph += [ pose_estimation['matches'] >> match_drawer['matches'], pose_estimation['matches_mask'] >> match_drawer['matches_mask'], self.points[:] >> match_drawer['test'], self.points_ref[:] >> match_drawer['train'], self.image[:] >> match_drawer['test_image'], self.image_ref[:] >> match_drawer['train_image'], match_drawer['output'] >> imshow(name='Matches')[''] ] tr = self.tr fps = self.fps # pose_draw = PoseDrawer() # graph += [train['R', 'T'] >> tr['R1', 'T1'], # pose_estimation['R', 'T'] >> tr['R2', 'T2'], # tr['R', 'T'] >> pose_draw['R', 'T'], # pose_estimation['found'] >> pose_draw['trigger'], # self.K[:] >> pose_draw['K'], # self.rgb_image[:] >> pose_draw['image'], # pose_draw['output'] >> fps[:], # ] return graph
def connections(self): # LSH matcher, somewhat sensitive to parameters # matcher = LSHMatcher('LSH', n_tables=4, multi_probe_level=1, key_size=6, radius=55) # this is a brute force matcher matcher = Matcher() graph = [ self.desc[:] >> matcher['test'], self.desc_ref[:] >> matcher['train'], ] #3d estimation pose_estimation = self.pose_estimation graph += [matcher['matches'] >> pose_estimation['matches'], self.points[:] >> pose_estimation['test_2d'], self.points_ref[:] >> pose_estimation['train_2d'], self.points3d[:] >> pose_estimation['test_3d'], self.points3d_ref[:] >> pose_estimation['train_3d'], self.K[:] >> pose_estimation['K'] ] if self.show_matches: #display matches match_drawer = DrawMatches() graph += [pose_estimation['matches'] >> match_drawer['matches'], pose_estimation['matches_mask'] >> match_drawer['matches_mask'], self.points[:] >> match_drawer['test'], self.points_ref[:] >> match_drawer['train'], self.image[:] >> match_drawer['test_image'], self.image_ref[:] >> match_drawer['train_image'], match_drawer['output'] >> imshow(name='Matches')[''] ] tr = self.tr fps = self.fps # pose_draw = PoseDrawer() # graph += [train['R', 'T'] >> tr['R1', 'T1'], # pose_estimation['R', 'T'] >> tr['R2', 'T2'], # tr['R', 'T'] >> pose_draw['R', 'T'], # pose_estimation['found'] >> pose_draw['trigger'], # self.K[:] >> pose_draw['K'], # self.rgb_image[:] >> pose_draw['image'], # pose_draw['output'] >> fps[:], # ] return graph
def __init__(self, plasm,rows,cols,pattern_type,square_size,debug=True): ecto.BlackBox.__init__(self, plasm) self.video_cap = ecto.Passthrough('Image Input') self.rgb2gray = imgproc.cvtColor('rgb -> gray', flag=7) self.circle_detector = calib.PatternDetector('Dot Detector', rows=rows, cols=cols, pattern_type=pattern_type, square_size=square_size) self.pose_calc = calib.FiducialPoseFinder('Pose Calc') self.camera_info = calib.CameraIntrinsics('Camera Info', camera_file="camera.yml") self.debug = debug if self.debug: self.fps = highgui.FPSDrawer() self.circle_drawer = calib.PatternDrawer('Circle Draw', rows=rows, cols=cols) self.circle_display = highgui.imshow('Pattern show', name='Pattern', waitKey=2, autoSize=True) self.pose_draw = calib.PoseDrawer('Pose Draw')
def do_ecto(): # ecto options parser = argparse.ArgumentParser( description='Publish images from directory.') scheduler_options(parser) args = parser.parse_args() #this will read all images in the path path = '/home/sam/Code/vision/VOCdevkit/VOC2012/JPEGImages' images = ImageReader(path=os.path.expanduser(path)) mat2image = ecto_ros.Mat2Image(encoding='rgb8') pub_rgb = ImagePub("image_pub", topic_name='/camera/rgb/image_raw') display = imshow(name='image', waitKey=5000) plasm = ecto.Plasm() plasm.connect( images['image'] >> mat2image['image'], images['image'] >> display['image'], mat2image['image'] >> pub_rgb['input'], ) ecto.view_plasm(plasm) run_plasm(args, plasm, locals=vars())
#debug = True plasm = ecto.Plasm() video = highgui.VideoCapture(video_device=0) rgb2gray = imgproc.cvtColor(flag=7) gaussian = imgproc.GaussianBlur(sigma=2.0) circle_drawer = calib.CircleDrawer() circle_drawer2 = calib.CircleDrawer() pong = calib.PingPongDetector(dp=2, maxRadius=500, minRadius=1, param1=200, param2=100, minDist=20) print pong.__doc__ show_circles = highgui.imshow("show circles", name="Circles", waitKey=10) plasm.connect(video["image"] >> (rgb2gray["input"], circle_drawer["image"]), rgb2gray["out"] >> gaussian["input"], gaussian["out"] >> pong["image"], pong["circles"] >> circle_drawer["circles"], circle_drawer["image"] >> show_circles["input"]) if debug: print plasm.viz() ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute(nthreads=8)
#!/bin/python import ecto #import ecto_opencv.cv_bp as opencv from ecto_opencv import highgui, calib, imgproc, line_mod, cv_bp as cv import os debug = True plasm = ecto.Plasm() #Constructor for Plasm raw_image = highgui.imshow(name="raw image", waitKey=-1, autoSize=True) highgui_db_color = highgui.imshow(name="db_color", waitKey=-1, autoSize=True) bin_color = line_mod.ColorMod(gsize=5, gsig=2.0) db_color = line_mod.ColorDebug() coded_color = highgui.imshow(name="coded_color", waitKey=-1, autoSize=True) #templ_calc = line_mod.ColorTemplCalc(skipx = 5,skipy=5,hist_type=1) #train = line_mod.TrainColorTempl(acceptance_threshold=0.999,threshold=0.95) #test = line_mod.TestColorTempl(filename="test_tree.txt") testimage = line_mod.TestColorImage(filename="test_tree.txt", template_size=cv.Size(45, 120), sample_skipx=5, sample_skipy=5, match_thresh=0.985, search_skipx=5, search_skipy=5, hist_type=1, overlap_thresh=.75) #IdGen = line_mod.IdGenerator(object_id="Odwalla"); DrawDetections = line_mod.DrawDetections()
#!/usr/bin/env python import ecto from ecto_opencv.highgui import VideoCapture, imshow, FPSDrawer video_cap = VideoCapture(video_device=0, width=640, height=480) fps = FPSDrawer() plasm = ecto.Plasm() plasm.connect(video_cap['image'] >> fps['image'], fps['image'] >> imshow(name='video_cap')['image'], ) if __name__ == '__main__': from ecto.opts import doit doit(plasm, description='Capture a video from the device and display it.')
#!/usr/bin/env python import ecto from ecto_opencv.highgui import imshow, NiConverter, FPSDrawer from ecto_opencv.imgproc import ConvertTo from ecto_opencv.cv_bp import CV_8UC1 from ecto_openni import OpenNICapture, DEPTH_RGB, DEPTH_IR device = 0 capture = OpenNICapture(stream_mode=DEPTH_RGB, registration=False) next_mode = DEPTH_IR fps = FPSDrawer('fps') conversion = ConvertTo(cv_type=CV_8UC1, alpha=0.5) # scale the IR so that we can visualize it. plasm = ecto.Plasm() plasm.insert(capture) plasm.connect(capture['image'] >> fps[:], fps[:] >> imshow('image display', name='image')[:], capture['depth'] >> imshow('depth display', name='depth')[:], capture['ir'] >> conversion[:], conversion[:] >> imshow('IR display', name='IR')[:], ) sched = ecto.schedulers.Singlethreaded(plasm) while True: sched.execute(niter=100) #swap it modes next_mode, capture.params.stream_mode = capture.params.stream_mode, next_mode
video_cap = highgui.VideoCapture(video_device=0) fps = highgui.FPSDrawer() rgb2gray = imgproc.cvtColor('rgb -> gray', flag=imgproc.RGB2GRAY) detect = calib.PatternDetector(rows=5, cols=3, pattern_type=calib.ASYMMETRIC_CIRCLES_GRID, square_size=0.04) draw = calib.PatternDrawer(rows=5, cols=3) pose_calc = calib.FiducialPoseFinder('Pose Calc') pose_draw = calib.PoseDrawer('Pose Draw') camera_info = calib.CameraIntrinsics('Camera Info', camera_file="camera.yml") imshow = highgui.imshow(name='Pattern', waitKey=2) plasm.connect( video_cap['image'] >> rgb2gray['input'], rgb2gray['out'] >> detect['input'], detect['out', 'found'] >> draw['points', 'found'], video_cap['image'] >> draw['input'], camera_info['K'] >> (pose_calc['K'], pose_draw['K']), detect['out', 'ideal', 'found'] >> pose_calc['points', 'ideal', 'found'], pose_calc['R', 'T'] >> pose_draw['R', 'T'], draw['out'] >> pose_draw['image'], pose_draw['output'] >> fps['image'], fps['image'] >> imshow['input'] ) if __name__ == "__main__":
#!/usr/bin/env python # # Simple vid cap # import ecto from ecto_opencv import highgui, calib, imgproc plasm = ecto.Plasm() video_cap = highgui.VideoCapture(video_device=0) fps = highgui.FPSDrawer() video_display = highgui.imshow('imshow', name='video_cap', waitKey=2) saver = highgui.VideoWriter("saver", video_file='ecto.avi', fps=15) plasm.connect(video_cap['image'] >> fps['image'], fps['image'] >> video_display['input'], fps['image'] >> saver['image'], ) if __name__ == '__main__': ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute()
#!/bin/python import ecto #import ecto_opencv.cv_bp as opencv from ecto_opencv import highgui, calib, imgproc, line_mod debug = True plasm = ecto.Plasm() #Constructor for Plasm video = highgui.VideoCapture(video_device=1) bin_color = line_mod.ColorMod(thresh_bw=20) db_color = line_mod.ColorMod(); coded_color = highgui.imshow(name="coded_color", waitKey=10, autoSize=True) raw_image = highgui.imshow(name="raw image", waitKey= -1, autoSize=True) highgui_db_color = highgui.imshow(name="db_color", waitKey= -1, autoSize=True) if debug: ecto.print_module_doc(video) ecto.print_module_doc(coded_color) plasm.connect(video, "image", bin_color, "image") plasm.connect(video, "image", raw_image, "input") plasm.connect(bin_color, "output", coded_color, "input") plasm.connect(bin_color, "output", db_color, "input") plasm.connect(db_color, "output", highgui_db_color, "input") if debug: ecto.view_plasm(plasm) thresh_gt = 10 bin_color.params.thresh_gt = thresh_gt;
#ecto options scheduler_options(parser.add_argument_group('Scheduler Options')) args = parser.parse_args() if not os.path.exists(args.output): os.makedirs(args.output) source = create_source( package_name='image_pipeline', source_type='OpenNISource') #optionally pass keyword args here... depth_saver = ecto.If( 'depth saver', cell=ImageSaver( filename_format=os.path.join(args.output, 'depth%04d.png'))) image_saver = ecto.If( 'rgb saver', cell=ImageSaver( filename_format=os.path.join(args.output, 'image%04d.png'))) display = imshow(name='RGB', triggers=dict(save=ord('s'))) plasm = ecto.Plasm() plasm.connect( source['image'] >> (display['image'], image_saver['image']), source['depth'] >> (imshow(name='Depth')['image'], depth_saver['image']), display['save'] >> (image_saver['__test__'], depth_saver['__test__'])) run_plasm(args, plasm, locals=vars())
def create_capture_plasm(bag_name, angle_thresh, segmentation_cell, n_desired=72, orb_template='', res=SXGA_RES, fps=FPS_30, orb_matches=False, preview=False, use_turn_table=True): ''' Creates a plasm that will capture openni data into a bag, using a dot pattern to sparsify views. @param bag_name: A filename for the bag, will write to this file. @param angle_thresh: The angle threshhold in radians to sparsify the views with. ''' graph = [] # try several parameter combinations source = create_source('image_pipeline', 'OpenNISource', outputs_list=['K', 'K', 'camera', 'image', 'depth', 'points3d', 'mask_depth'], res=res, fps=fps) # convert the image to grayscale rgb2gray = imgproc.cvtColor('rgb -> gray', flag=imgproc.Conversion.RGB2GRAY) graph += [source['image'] >> rgb2gray[:] ] # Find planes plane_est = PlaneFinder(min_size=10000) compute_normals = ComputeNormals() graph += [ # find the normals source['K', 'points3d'] >> compute_normals['K', 'points3d'], # find the planes compute_normals['normals'] >> plane_est['normals'], source['K', 'points3d'] >> plane_est['K', 'points3d'] ] if orb_template: # find the pose using ORB poser = OrbPoseEstimator(directory=orb_template, show_matches=orb_matches) graph += [ source['image', 'K', 'mask_depth', 'points3d'] >> poser['color_image', 'K', 'mask', 'points3d'], rgb2gray[:] >> poser['image'] ] else: # get a pose use the dot pattern: there might be a scale ambiguity as this is 3d only poser = OpposingDotPoseEstimator(rows=5, cols=3, pattern_type=calib.ASYMMETRIC_CIRCLES_GRID, square_size=0.04, debug=True) graph += [ source['image', 'K'] >> poser['color_image', 'K'], rgb2gray[:] >> poser['image'] ] # filter the previous pose and resolve the scale ambiguity using 3d pose_filter = object_recognition_capture.ecto_cells.capture.PlaneFilter(); # make sure the pose is centered at the origin of the plane graph += [ source['K'] >> pose_filter['K'], poser['R', 'T'] >> pose_filter['R', 'T'], plane_est['planes', 'masks'] >> pose_filter['planes', 'masks'] ] # draw the found pose pose_drawer = calib.PoseDrawer('Pose Draw') display = highgui.imshow(name='Poses') graph += [ pose_filter['found'] >> pose_drawer['trigger'], poser['debug_image'] >> pose_drawer['image'], source['K'] >> pose_drawer['K'], pose_filter['R', 'T'] >> pose_drawer['R', 'T'], pose_drawer['output'] >> display[:] ] delta_pose = ecto.If('delta R|T', cell=object_recognition_capture.DeltaRT(angle_thresh=angle_thresh, n_desired=n_desired)) poseMsg = RT2PoseStamped(frame_id='/camera_rgb_optical_frame') graph += [ pose_filter['R', 'T', 'found'] >> delta_pose['R', 'T', 'found'], pose_filter['R', 'T'] >> poseMsg['R', 'T'] ] # publish the source data rgbMsg = Mat2Image(frame_id='/camera_rgb_optical_frame', swap_rgb=True) depthMsg = Mat2Image(frame_id='/camera_rgb_optical_frame') graph += [ source['depth'] >> depthMsg[:], source['image'] >> rgbMsg[:] ] # mask out the object masker = segmentation_cell graph += [ source['points3d'] >> masker['points3d'], plane_est['masks', 'planes'] >> masker['masks', 'planes'], pose_filter['T'] >> masker['T'] ] # publish the mask maskMsg = Mat2Image(frame_id='/camera_rgb_optical_frame') graph += [ masker['mask'] >> maskMsg[:] ] camera2cv = CameraModelToCv() cameraMsg = Cv2CameraInfo(frame_id='/camera_rgb_optical_frame') graph += [source['camera'] >> camera2cv['camera'], camera2cv['K', 'D', 'image_size'] >> cameraMsg['K', 'D', 'image_size'] ] #display the mask mask_display = object_recognition_capture.MaskDisplay() mask_display_highgui = highgui.imshow(name='mask') graph += [ masker['mask'] >> mask_display['mask'], source['image'] >> mask_display['image'], mask_display['image'] >> mask_display_highgui['image'], ] if not preview: baggers = dict(image=ImageBagger(topic_name='/camera/rgb/image_color'), depth=ImageBagger(topic_name='/camera/depth/image'), mask=ImageBagger(topic_name='/camera/mask'), pose=PoseBagger(topic_name='/camera/pose'), image_ci=CameraInfoBagger(topic_name='/camera/rgb/camera_info'), depth_ci=CameraInfoBagger(topic_name='/camera/depth/camera_info'), ) bagwriter = ecto.If('Bag Writer if R|T', cell=ecto_ros.BagWriter(baggers=baggers, bag=bag_name) ) graph += [ rgbMsg[:] >> bagwriter['image'], depthMsg[:] >> bagwriter['depth'], cameraMsg[:] >> (bagwriter['image_ci'], bagwriter['depth_ci']), poseMsg['pose'] >> bagwriter['pose'], maskMsg[:] >> bagwriter['mask'], ] novel = delta_pose['novel'] if use_turn_table: table = TurnTable(angle_thresh=angle_thresh) ander = ecto.And() graph += [ table['trigger'] >> (delta_pose['__test__'], ander['in2']), delta_pose['novel'] >> ander['in1'], ] novel = ander['out'] else: delta_pose.inputs.__test__ = True graph += [novel >> (bagwriter['__test__'])] plasm = ecto.Plasm() plasm.connect(graph) return (plasm, segmentation_cell) # return segmentation for tuning of parameters.
info2cv = ecto_ros.CameraInfo2Cv("Info to CV") to_pose_stamped = ecto_ros.RT2PoseStamped("To Pose Stamped",frame_id="openni_rgb_optical_frame") #pose estimation rows = 5; cols = 3; square_size=0.04; pattern_type=calib.ASYMMETRIC_CIRCLES_GRID circle_detector = calib.PatternDetector(rows=rows, cols=cols, pattern_type=pattern_type, square_size=square_size) poser = calib.FiducialPoseFinder() offset = ecto_corrector.TranslationOffset("Offset",tx=-0.079,ty=0.120,tz=0.000) #visualization circle_drawer = calib.PatternDrawer(rows=rows, cols=cols) pose_drawer = calib.PoseDrawer() show_triggers = {'c_key':ord('c')} show = highgui.imshow("imshow",waitKey=10,triggers=show_triggers) #bagging baggers = dict(image=ecto_sensor_msgs.Bagger_Image(topic_name='image_color'), info=ecto_sensor_msgs.Bagger_CameraInfo(topic_name='camera_info'), cloud=ecto_sensor_msgs.Bagger_PointCloud2(topic_name="points"), pose=ecto_geometry_msgs.Bagger_PoseStamped(topic_name="pose"), ) bagwriterif = ecto.If('Bag Writer if key', cell=ecto_ros.BagWriter(baggers=baggers, bag=bag_name) ) plasm = ecto.Plasm() plasm.connect( #conversions sync["image"] >> img2mat[:],
import os import math import subprocess import couchdb import ecto from ecto_opencv import calib, highgui, imgproc import object_recognition from object_recognition import tools as dbtools, models, capture from ecto_object_recognition import reconstruction, conversion import ecto_pcl from tempfile import NamedTemporaryFile cloud_view = ecto_pcl.CloudViewer("Cloud Display", window_name="PCD Viewer")[:] imshows = dict(image=highgui.imshow('Image Display', name='image')[:], mask=highgui.imshow('Mask Display', name='mask')[:], depth=highgui.imshow('Depth Display', name='depth')[:]) def generate_pointclouds_in_object_space(dbs, session, args): object_name = dbs[session.object_id]['object_name'] if not os.path.exists(object_name): os.mkdir(object_name) obs_ids = models.find_all_observations_for_session(dbs, session.id) if len(obs_ids) == 0: raise RuntimeError("There are no observations available.") db_reader = capture.ObservationReader( 'Database Source', db_params=dbtools.args_to_db_params(args)) #observation dealer will deal out each observation id.
#!/usr/bin/env python import ecto from ecto_opencv.highgui import VideoCapture, imshow, FPSDrawer from ecto_opencv.imgproc import Canny, RGB2GRAY, cvtColor video_cap = VideoCapture(video_device=0, width=640, height=480) fps = FPSDrawer() canny = Canny() gray = cvtColor(flag=RGB2GRAY) plasm = ecto.Plasm() plasm.connect( video_cap['image'] >> gray[:], gray[:] >> canny['image'], canny['image'] >> fps['image'], fps['image'] >> imshow(name='Canny Image')['image'], video_cap['image'] >> imshow(name='Original Image')['image'], ) if __name__ == '__main__': from ecto.opts import doit doit(plasm, description='Capture a video from the device and display it.')
square_size = 0.025 #2.5 cm pattern_type = CHESSBOARD rgb2gray = cvtColor(flag=Conversion.RGB2GRAY) detector = PatternDetector(rows=rows, cols=cols, pattern_type=pattern_type, square_size=square_size) pattern_drawer = PatternDrawer(rows=rows, cols=cols) camera_intrinsics = CameraIntrinsics(camera_file=args.camera) poser = FiducialPoseFinder() pose_drawer = PoseDrawer() plasm = ecto.Plasm() plasm.connect( image_reader['image'] >> (pattern_drawer['input'], rgb2gray['image']), rgb2gray['image'] >> detector['input'], detector['ideal', 'out', 'found'] >> poser['ideal', 'points', 'found'], camera_intrinsics['K'] >> poser['K'], detector['out', 'found'] >> pattern_drawer['points', 'found'], poser['R', 'T'] >> pose_drawer['R', 'T'], poser['R'] >> MatPrinter(name='R')['mat'], poser['T'] >> MatPrinter(name='T')['mat'], pattern_drawer['out'] >> pose_drawer['image'], camera_intrinsics['K'] >> pose_drawer['K'], pose_drawer['output'] >> imshow(name='Pose', waitKey=0)['image'], ) sched = ecto.schedulers.Singlethreaded(plasm) sched.execute()
plasm = ecto.Plasm() sched = ecto.schedulers.Singlethreaded(plasm) video_cap = highgui.VideoCapture(video_device=0) fps = highgui.FPSDrawer() rgb2gray = imgproc.cvtColor('rgb -> gray', flag=7) circle_detector = calib.PatternDetector(rows=7, cols=3, pattern_type="acircles", square_size=0.03) circle_drawer = calib.PatternDrawer(rows=7, cols=3) circle_display = highgui.imshow('Pattern show', name='Pattern', waitKey=2, maximize=True) pose_calc = calib.FiducialPoseFinder('Pose Calc') pose_draw = calib.PoseDrawer('Pose Draw') camera_info = calib.CameraIntrinsics('Camera Info', camera_file="camera.yml") plasm.connect( video_cap['image'] >> circle_drawer['input'], circle_drawer['out'] >> pose_draw['image'], pose_draw['output'] >> fps['image'], fps['image'] >> circle_display['input'], video_cap['image'] >> rgb2gray['input'], rgb2gray['out'] >> circle_detector['input'],
#!/bin/python import ecto from ecto_opencv import imgproc, highgui, features2d import time #import orb as imgproc debug = False #debug = True plasm = ecto.Plasm() video = highgui.VideoCapture(video_device=0) orb_m = features2d.ORB(n_features=2500) draw_kpts = features2d.DrawKeypoints() imshow = highgui.imshow(name="ORB", waitKey=2, autoSize=True) rgb2gray = imgproc.cvtColor(flag=7) plasm.connect(video, "image", rgb2gray, "input") plasm.connect(rgb2gray, "out", orb_m, "image") plasm.connect(orb_m, "kpts", draw_kpts, "kpts") plasm.connect(video, "image", draw_kpts, "input") plasm.connect(draw_kpts, "output", imshow, "input") if debug: print plasm.viz() ecto.view_plasm(plasm) prev = time.time() count = 0 while (imshow.outputs.out != 27):
from ecto_openni import OpenNICapture, DEPTH_RGB, DEPTH_IR, RGB, IR, IRGamma from image_pipeline import StereoCalibration, Points2DAccumulator, Points3DAccumulator from pattern_helpers import * create_detector_drawer = create_detector_drawer_chessboard ir_reader = ImageReader(path='ir') rgb_reader = ImageReader(path='rgb') plasm = ecto.Plasm() ir_detector, ir_drawer = create_detector_drawer() rgb_detector, rgb_drawer = create_detector_drawer() rgb_display = imshow(name="RGB Points") plasm.connect(ir_reader['image'] >> (ir_detector[:], ir_drawer['input']), rgb_reader['image'] >> (rgb_detector[:], rgb_drawer['input']), ir_detector['found', 'out'] >> ir_drawer['found', 'points'], rgb_detector['found', 'out'] >> rgb_drawer['found', 'points'], rgb_drawer[:] >> rgb_display[:], ir_drawer[:] >> imshow(name='Depth points')[:]) #triggers ander = ecto.And(ninput=2) plasm.connect( rgb_detector['found'] >> ander['in1'], ir_detector['found'] >> ander['in2'], )
scheduler_options(parser.add_argument_group('Scheduler Options')) args = parser.parse_args() if not os.path.exists(args.output): os.makedirs(args.output) #camera = VideoCapture(video_device=1,width=int(args.width),height=int(args.height)) source = create_source( package_name='image_pipeline', source_type='OpenNISource') #optionally pass keyword args here... depth_saver = ImageSaver( filename_format=os.path.join(args.output, 'frame_%010d_depth.png')) image_saver = ImageSaver( filename_format=os.path.join(args.output, 'frame_%010d_image.png')) #mono_saver = ImageSaver(filename_format=os.path.join(args.output, 'frame_%010d_mono.png')) plasm = ecto.Plasm() plasm.connect( # camera['image'] >> imshow(name='Mono')['image'], source['depth'] >> imshow(name='Depth')['image'], source['image'] >> imshow(name='RGB')['image']) if not args.preview: plasm.connect( source['image'] >> image_saver['image'], source['depth'] >> depth_saver['image'], # camera['image'] >> mono_saver['image'], ) run_plasm(args, plasm, locals=vars())
#!/usr/bin/env python import ecto from ecto_opencv.highgui import VideoCapture, imshow, FPSDrawer from ecto_opencv.imgproc import Scale, Interpolation video_cap = VideoCapture(video_device=0, width=640, height=480) fps = FPSDrawer() factor = 0.1 scale_down = Scale(factor=factor, interpolation=Interpolation.AREA) scale_up = Scale(factor=1 / factor, interpolation=Interpolation.LANCZOS4) plasm = ecto.Plasm() plasm.connect( video_cap["image"] >> scale_down["image"], scale_down["image"] >> scale_up["image"], scale_up["image"] >> fps["image"], fps["image"] >> imshow(name="Rescaled")["image"], ) if __name__ == "__main__": from ecto.opts import doit doit(plasm, description="Capture a video from the device and display it.", locals=vars())
def parse_args(): import argparse parser = argparse.ArgumentParser( description='Computes the odometry between frames.') scheduler_options(parser.add_argument_group('Scheduler')) options = parser.parse_args() return options if __name__ == '__main__': options = parse_args() video = VideoCapture(video_device=0) lucid = LUCID() draw_kpts = DrawKeypoints() rgb2gray = cvtColor(flag=Conversion.RGB2GRAY) fps = FPSDrawer() plasm = ecto.Plasm() plasm.connect( video['image'] >> rgb2gray['image'], rgb2gray['image'] >> lucid['image'], lucid['keypoints'] >> draw_kpts['keypoints'], video['image'] >> draw_kpts['image'], draw_kpts['image'] >> fps[:], fps[:] >> imshow('eLUCID display', name='LUCID')['image'], ) run_plasm(options, plasm, locals=vars())
device = Capture('ni device', rgb_resolution=ResolutionMode.VGA_RES, depth_resolution=ResolutionMode.VGA_RES, rgb_fps=30, depth_fps=30, device_number=0, registration=True, synchronize=False, device=Device.KINECT ) cloud_generator = NiConverter('cloud_generator') graph = [ device[:] >> cloud_generator[:], ] #detection edge_detector = DepthEdgeDetector("Edge Detector",depth_threshold=0.02, \ erode_size=3,open_size=3) graph += [cloud_generator[:] >> edge_detector["input"], ] #drawing im_drawer = imshow("Drawer",name="depth edges", waitKey=10) graph += [edge_detector[:] >> im_drawer[:]] plasm = ecto.Plasm() plasm.connect(graph) if __name__ == "__main__": if(debug): ecto.view_plasm(plasm) sched = ecto.schedulers.Threadpool(plasm) sched.execute()
from image_pipeline import Rectifier, StereoModelLoader, DepthRegister, CameraModelToCv, CV_INTER_NN from ecto_openni import OpenNICapture, DEPTH_RGB, DEPTH_IR, RGB, IR, IRGamma, enumerate_devices from ecto_object_recognition.conversion import MatToPointCloudXYZRGB from ecto_pcl import PointCloudT2PointCloud, CloudViewer, XYZRGB openni_reg = True print enumerate_devices() capture = OpenNICapture('Camera', stream_mode=DEPTH_RGB, registration=openni_reg, latched=False) depthTo3d = DepthTo3d('Depth ~> 3d') to_xyzrgb = MatToPointCloudXYZRGB('OpenCV ~> PCL') pcl_cloud = PointCloudT2PointCloud('conversion', format=XYZRGB) cloud_viewer = CloudViewer('Cloud Display') plasm = ecto.Plasm() plasm.connect(capture['K'] >> depthTo3d['K'], capture['image'] >> imshow('Image Display')[:], capture['depth'] >> depthTo3d['depth'], depthTo3d['points3d'] >> to_xyzrgb['points'], capture['image'] >> to_xyzrgb['image'], to_xyzrgb[:] >> pcl_cloud[:], pcl_cloud[:] >> cloud_viewer[:]) if __name__ == '__main__': from ecto.opts import doit doit(plasm, description='Capture Kinect depth and RGB and register them.', locals=vars())
depth_ci=CameraInfoSub(topic_name='/camera/depth_registered/camera_info', queue_size=0), ) sync = ecto_ros.Synchronizer('Synchronizator', subs=subs ) im2mat_rgb = ecto_ros.Image2Mat('rgb -> cv::Mat') camera_info = ecto_ros.CameraInfo2Cv('camera_info -> cv::Mat') poser = OpposingDotPoseEstimator(plasm, rows=5, cols=3, pattern_type=calib.ASYMMETRIC_CIRCLES_GRID, square_size=0.04, debug=True) bgr2rgb = imgproc.cvtColor('rgb -> bgr', flag=imgproc.Conversion.RGB2BGR) rgb2gray = imgproc.cvtColor('rgb -> gray', flag=imgproc.Conversion.RGB2GRAY) display = highgui.imshow('Poses', name='Poses', waitKey=5, autoSize=True) graph = [sync['image'] >> im2mat_rgb[:], im2mat_rgb[:] >> (rgb2gray[:], bgr2rgb[:]), bgr2rgb[:] >> poser['color_image'], rgb2gray[:] >> poser['image'], poser['debug_image'] >> display['input'], sync['image_ci'] >> camera_info['camera_info'], camera_info['K'] >> poser['K'], ] plasm.connect(graph) if __name__ == '__main__': import sys ecto_ros.init(sys.argv, "opposing_dots_pose", False) from ecto.opts import doit
debug=debug) camera_info = calib.CameraIntrinsics('Camera Info', camera_file="camera.yml") subs = dict( image=ImageSub(topic_name='camera/rgb/image_color', queue_size=0), depth=ImageSub(topic_name='camera/depth/image', queue_size=0), ) sync = ecto_ros.Synchronizer('Synchronizator', subs=subs) brg2rgb = imgproc.cvtColor('bgr -> rgb', flag=4) rgb2gray = imgproc.cvtColor('rgb -> gray', flag=7) gray2rgb = imgproc.cvtColor('gray -> rgb', flag=8) print gray2rgb.__doc__ display = highgui.imshow('Poses', name='Poses', waitKey=2, autoSize=True) mask_display = highgui.imshow('Masks', name='Masks', waitKey=-1, autoSize=True) object_display = highgui.imshow('Object', name='Object', waitKey=-1, autoSize=True) imsaver = highgui.ImageSaver('pose image saver', filename='image_pose_') rawsaver = highgui.ImageSaver('raw image saver', filename='image_raw_') masker = calib.PlanarSegmentation(z_min=0.015, y_crop=0.15, x_crop=0.15) bitwise_and = imgproc.BitwiseAnd() im2mat_rgb = ecto_ros.Image2Mat()
# # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE # ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. # import ecto from ecto_X import Sink from ecto_opencv.highgui import imshow, FPSDrawer video = Sink(url='localhost', port=2932) fps = FPSDrawer() video_display = imshow(name='video_cap', waitKey=0) plasm = ecto.Plasm() plasm.connect(video[:] >> fps['image'], fps['image'] >> video_display['input'], ) if __name__ == '__main__': from ecto.opts import doit doit(plasm, description='Capture a video from the device and display it.')