def frames(self):
"""Retrieve the next frame from the image directory and convert it to a ColorImage,
a DepthImage, and an IrImage.
Parameters
----------
skip_registration : bool
If True, the registration step is skipped.
Returns
-------
:obj:`tuple` of :obj:`ColorImage`, :obj:`DepthImage`, :obj:`IrImage`, :obj:`numpy.ndarray`
The ColorImage, DepthImage, and IrImage of the current frame.
Raises
------
RuntimeError
If the Kinect stream is not running or if all images in the
directory have been used.
"""
if not self._running:
raise RuntimeError('Primesense device pointing to %s not runnning. Cannot read frames' %(self._path_to_images))
if self._im_index > self._num_images:
raise RuntimeError('Primesense device is out of images')
# read images
color_filename = os.path.join(self._path_to_images, 'color_%d.png' %(self._im_index))
color_im = ColorImage.open(color_filename, frame=self._frame)
depth_filename = os.path.join(self._path_to_images, 'depth_%d.npy' %(self._im_index))
depth_im = DepthImage.open(depth_filename, frame=self._frame)
self._im_index += 1
return color_im, depth_im, None
def load(save_dir):
if not os.path.exists(save_dir):
raise ValueError('Directory %s does not exist!' % (save_dir))
color_image_filename = os.path.join(save_dir, 'color.png')
depth_image_filename = os.path.join(save_dir, 'depth.npy')
camera_intr_filename = os.path.join(save_dir, 'camera.intr')
segmask_filename = os.path.join(save_dir, 'segmask.npy')
obj_segmask_filename = os.path.join(save_dir, 'obj_segmask.npy')
state_filename = os.path.join(save_dir, 'state.pkl')
camera_intr = CameraIntrinsics.load(camera_intr_filename)
color = ColorImage.open(color_image_filename, frame=camera_intr.frame)
depth = DepthImage.open(depth_image_filename, frame=camera_intr.frame)
segmask = None
if os.path.exists(segmask_filename):
segmask = BinaryImage.open(segmask_filename,
frame=camera_intr.frame)
obj_segmask = None
if os.path.exists(obj_segmask_filename):
obj_segmask = SegmentationImage.open(obj_segmask_filename,
frame=camera_intr.frame)
fully_observed = None
if os.path.exists(state_filename):
fully_observed = pkl.load(open(state_filename, 'rb'))
return RgbdImageState(RgbdImage.from_color_and_depth(color, depth),
camera_intr,
segmask=segmask,
obj_segmask=obj_segmask,
fully_observed=fully_observed)
def load(save_dir):
if not os.path.exists(save_dir):
raise ValueError('Directory %s does not exist!' % (save_dir))
grasp_filename = os.path.join(save_dir, 'grasp.pkl')
q_value_filename = os.path.join(save_dir, 'pred_robustness.pkl')
image_filename = os.path.join(save_dir, 'tf_image.npy')
grasp = pkl.load(open(grasp_filename, 'rb'))
q_value = pkl.load(open(q_value_filename, 'rb'))
image = DepthImage.open(image_filename)
return GraspAction(grasp, q_value, image)
import IPython
from autolab_core import RigidTransform
from visualization import Visualizer2D as vis2d
from visualization import Visualizer3D as vis3d
from perception import DepthImage, CameraIntrinsics
KSIZE = 9
if __name__ == '__main__':
depth_im_filename = sys.argv[1]
camera_intr_filename = sys.argv[2]
camera_intr = CameraIntrinsics.load(camera_intr_filename)
depth_im = DepthImage.open(depth_im_filename, frame=camera_intr.frame)
depth_im = depth_im.inpaint()
point_cloud_im = camera_intr.deproject_to_image(depth_im)
normal_cloud_im = point_cloud_im.normal_cloud_im(ksize=KSIZE)
vis3d.figure()
vis3d.points(point_cloud_im.to_point_cloud(), scale=0.0025)
alpha = 0.025
subsample = 20
for i in range(0, point_cloud_im.height, subsample):
for j in range(0, point_cloud_im.width, subsample):
p = point_cloud_im[i, j]
n = normal_cloud_im[i, j]
def create_dataset(self, datapoints_per_file=100):
""" Compress all known data into a numpy dataset """
# create compressed data dir
if not os.path.exists(self.compressed_data_path):
os.mkdir(self.compressed_data_path)
# write all data
file_num = 0
num_recorded = 0
data_tensors = {}
for row in self._data_csv:
# add all attributes of the current row to the tensor
if not row['completed']:
continue
for name, value in row.iteritems():
# read raw data
data = None
if name == 'input_depth_im':
if os.path.exists(value):
data = DepthImage.open(value).raw_data[np.newaxis, ...]
elif name == 'input_binary_im':
if os.path.exists(value):
data = BinaryImage.open(value).raw_data[np.newaxis,
...]
elif name == 'input_pose':
if os.path.exists(value):
data = np.load(value)[np.newaxis, ...]
elif name == 'lifted_object' or name == 'human_label' \
or name == 'gripper_width' or name == 'found_grasp' \
or name == 'gripper_torque':
data = float(value)
if data is None:
continue
# update tensor
if name not in data_tensors or data_tensors[name] is None:
data_tensors[name] = data
else:
data_tensors[name] = np.r_[data_tensors[name], data]
num_recorded += 1
# write to file if necessary
if num_recorded >= datapoints_per_file:
# save each tensor
for name, tensor in data_tensors.iteritems():
output_name = self.experiment_data_output_names[name]
if output_name is None:
output_name = name
filename = os.path.join(
self.compressed_data_path,
'%s_%05d.npz' % (output_name, file_num))
np.savez_compressed(filename, tensor)
# update for next round
for name in data_tensors.keys():
del data_tensors[name]
data_tensors[name] = None
file_num += 1
num_recorded = 0
# save final tensor
if num_recorded > 0:
for name, tensor in data_tensors.iteritems():
output_name = self.experiment_data_output_names[name]
if output_name is None:
output_name = name
filename = os.path.join(
self.compressed_data_path,
'%s_%05d.npz' % (output_name, file_num))
np.savez_compressed(filename, tensor)
