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.
observation_dealer = ecto.Dealer(
tendril=db_reader.inputs.at('observation'), iterable=obs_ids)
depthTo3d = calib.DepthTo3d('Depth ~> 3D')
rescale_depth = capture.RescaledRegisteredDepth(
'Depth scaling') #this is for SXGA mode scale handling.
point_cloud_transform = reconstruction.PointCloudTransform(
'Object Space Transform', do_transform=False
) #keeps the points in camera coordinates, but populates the global sensor position and orientatino.
point_cloud_converter = conversion.MatToPointCloudXYZRGB('To Point Cloud')
to_ecto_pcl = ecto_pcl.PointCloudT2PointCloud('converter',
format=ecto_pcl.XYZRGB)
plasm = ecto.Plasm()
plasm.connect(observation_dealer[:] >> db_reader['observation'],
db_reader['K'] >> depthTo3d['K'],
db_reader['image'] >> rescale_depth['image'],
db_reader['depth'] >> rescale_depth['depth'],
rescale_depth[:] >> depthTo3d['depth'],
depthTo3d['points3d'] >> point_cloud_converter['points'],
db_reader['image'] >> point_cloud_converter['image'],
db_reader['mask'] >> point_cloud_converter['mask'],
db_reader['R', 'T'] >> point_cloud_transform['R', 'T'],
point_cloud_converter['point_cloud'] >> to_ecto_pcl[:],
to_ecto_pcl[:] >> point_cloud_transform['cloud'])
ply_writer = ecto_pcl.PLYWriter('PLY Saver',
filename_format='%s/cloud_%%05d.ply' %
(object_name))
pcd_writer = ecto_pcl.PCDWriter('PCD Saver',
filename_format='%s/cloud_%%05d.pcd' %
(object_name))
plasm.connect(point_cloud_transform['view'] >> (ply_writer['input'],
pcd_writer['input']))
if args.visualize:
global cloud_view
plasm.connect(
point_cloud_transform['view'] >> cloud_view,
db_reader['image'] >> imshows['image'],
db_reader['depth'] >> imshows['depth'],
db_reader['mask'] >> imshows['mask'],
)
from ecto.opts import run_plasm
run_plasm(args, plasm, locals=vars())
def __init__(self):
self.regionFilter = hirop_perception.RegionFilters("regionFilter",
maxZ=2)
self.pclFunsion = hirop_perception.PclFusion("pclFusion")
self.rosSource = hirop_perception.PointCloudRos(
'source',
topic_name="/kinect2/qhd/points",
world_frame='base_link')
self.pclViewer = ecto_pcl.CloudViewer("viewer",
window_name="PCD Viewer")
self.saver = ecto_pcl.PCDWriter(
"saver", filename_format="/home/eima/test_%04u.pcd", binary=True)
self.loader = ecto_pcl.PCDReader("Reader",
filename="/home/eima/test_0000.pcd")
self.publisher = hirop_perception.PointCloudPublish(
"publisher", topic_name="/filter_points", frame_id="base_link")
self.objectFilter = hirop_perception.ObjectFilter("objectFilter",
frame_id="base_link",
hight=0.20,
width=0.13,
length=0.15)
self.voxelFilter = hirop_perception.VoxelFilter("voxelFilter")
self.lookPlasm = ecto.Plasm()
self.lookPlasm.connect(self.rosSource["output"] >> self.regionFilter["input"], self.regionFilter["output"] >> self.voxelFilter["input"],\
self.rosSource["R"] >> self.pclFunsion["R"], self.rosSource["T"] >> self.pclFunsion["T"],\
self.voxelFilter["output"] >> self.pclFunsion["input"], self.pclFunsion["output"] >> self.objectFilter["input"], \
self.objectFilter["output"] >> self.publisher["input"])
self.savePlasm = ecto.Plasm()
self.savePlasm.connect(self.rosSource["output"] >> self.pclFunsion["input"],\
self.rosSource["T"] >>self.pclFunsion["T"], self.rosSource["R"] >>self.pclFunsion["R"], \
self.pclFunsion["output"] >> self.saver["input"])
self.loadPlasm = ecto.Plasm()
self.loadPlasm.connect(self.loader["output"] >> self.pclFunsion["input"], \
self.pclFunsion["output"] >> self.pclViewer["input"])
self.testPlasm = ecto.Plasm()
self.testPlasm.connect(self.rosSource["output"] >> self.pclFunsion["input"], self.pclFunsion["output"] >> self.regionFilter["input"],\
self.pclFunsion["output"] >> self.pclViewer["input"])
self.cleanPlasm = ecto.Plasm()
self.cleanPlasm.connect(
self.rosSource["output"] >> self.pclFunsion["input"],
self.pclFunsion["output"] >> self.objectFilter["input"])
self.keepRun = True
import hirop_perecption.hirop_perception as hirop_perception
import ecto, ecto_pcl
import sys
import time
import os
plasm = ecto.Plasm()
pcdfile = os.path.join(os.path.dirname(__file__), 'test.pcd')
if len(sys.argv) > 1:
pcdfile = sys.argv[1]
reader = ecto_pcl.PCDReader("Reader", filename=pcdfile)
filters = hirop_perception.RegionFilters("tester", maxZ=1)
fusion = hirop_perception.PclFusion()
viewer = ecto_pcl.CloudViewer("viewer", window_name="PCD Viewer")
saver = ecto_pcl.PCDWriter("Saver")
plasm.connect(reader["output"] >> fusion["input"],
fusion["output"] >> viewer["input"])
if __name__ == "__main__":
sched = ecto.Scheduler(plasm)
sched.execute(niter=1)
#sleep 10 seconds and exit.
time.sleep(10)
#!/usr/bin/env python
"""
This example shows how to read/write pcd files.
"""
import ecto, ecto_pcl
import sys
import os
plasm = ecto.Plasm()
pcdfile = os.path.join(os.path.dirname(__file__), 'cloud.pcd')
if len(sys.argv) > 1:
pcdfile = sys.argv[1]
reader = ecto_pcl.PCDReader("Reader", filename=pcdfile)
writer = ecto_pcl.PCDWriter("Writer",
filename_format="ascii_%04d.pcd",
binary=False)
plasm.connect(reader[:] >> writer[:])
if __name__ == "__main__":
from ecto.opts import doit
doit(plasm, description='Read/write pcd.', default_niter=1)