def _load_datasets(self):
database = Hdf5Database(self.config['database_name'],
access_level=READ_ONLY_ACCESS)
target_object_keys = self.config['target_objects']
dataset_names = target_object_keys.keys()
datasets = [database.dataset(dn) for dn in dataset_names]
return datasets, target_object_keys
def test_illegal_create(self):
caught_illegal_db = False
try:
database = Hdf5Database(ILLEGAL_DB_NAME, access_level=READ_WRITE_ACCESS)
database.close()
except:
caught_illegal_db = True
self.assertTrue(caught_illegal_db)
def _load_datasets(self):
database = Hdf5Database(self.config['database_name'],
access_level=READ_ONLY_ACCESS)
target_object_keys = self.config['target_objects']
dataset_names = target_object_keys.keys()
datasets = [database.dataset(dn) for dn in dataset_names]
if self.NUM_OBJECTS is not None:
datasets = [
dataset.subset(0, self.NUM_OBJECTS) for dataset in datasets
]
return datasets, target_object_keys
def _load_datasets(self):
""" Load the datasets in the Hdf5 database given through the config file.
Returns
-------
datasets (list): list of datasets
"""
database = Hdf5Database(self.config['database_name'], access_level=READ_ONLY_ACCESS)
target_object_keys = self.config['target_objects']
dataset_names = target_object_keys.keys()
datasets = [database.dataset(dn) for dn in dataset_names]
if self.NUM_OBJECTS is not None:
datasets = [dataset.subset(0, self.NUM_OBJECTS) for dataset in datasets]
return datasets
os.path.dirname(os.path.realpath(__file__)), '..',
'cfg/tools/generate_gqcnn_dataset.yaml')
# turn relative paths absolute
if not os.path.isabs(dataset_path):
dataset_path = os.path.join(os.getcwd(), dataset_path)
if not os.path.isabs(config_filename):
config_filename = os.path.join(os.getcwd(), config_filename)
# parse config
config = YamlConfig(config_filename)
# set seed
debug = config['debug']
if debug:
random.seed(SEED)
np.random.seed(SEED)
# open database
database = Hdf5Database(config['database_name'],
access_level=READ_ONLY_ACCESS)
# read params
target_object_keys = config['target_objects']
env_rv_params = config['env_rv_params']
gripper_name = config['gripper']
# generate the dataset
generate_gqcnn_dataset(dataset_path, database, target_object_keys,
env_rv_params, gripper_name, config)
def test_new_database_and_graspable(self):
# new database
database = Hdf5Database(TEST_DB_NAME, access_level=READ_WRITE_ACCESS)
database.close()
self.assertTrue(database is not None)
# new dataset
database = Hdf5Database(TEST_DB_NAME, access_level=READ_WRITE_ACCESS)
database.create_dataset(TEST_DS_NAME)
database.close()
self.assertTrue(database is not None)
# read existing dataset
database = Hdf5Database(TEST_DB_NAME, access_level=READ_WRITE_ACCESS)
dataset = database.dataset(TEST_DS_NAME)
self.assertTrue(database is not None and dataset is not None)
# create graspable
mass = 1.0
CONFIG['obj_rescaling_type'] = RescalingType.RELATIVE
mesh_processor = MeshProcessor(OBJ_FILENAME, CONFIG['cache_dir'])
mesh_processor.generate_graspable(CONFIG)
dataset.create_graspable(mesh_processor.key, mesh_processor.mesh,
mesh_processor.sdf,
mesh_processor.stable_poses,
mass=mass)
# read graspable and ensure data integrity
obj = dataset[mesh_processor.key]
self.assertTrue(obj.key == mesh_processor.key)
write_vertices = mesh_processor.mesh.vertices
write_triangles = mesh_processor.mesh.triangles
write_sdf_data = mesh_processor.sdf.data
write_stable_poses = mesh_processor.stable_poses
load_vertices = obj.mesh.vertices
load_triangles = obj.mesh.triangles
load_sdf_data = obj.sdf.data
load_stable_poses = dataset.stable_poses(obj.key)
self.assertTrue(np.allclose(write_vertices, load_vertices))
self.assertTrue(np.allclose(write_triangles, load_triangles))
self.assertTrue(np.allclose(write_sdf_data, load_sdf_data))
self.assertTrue(obj.mass == mass)
for wsp, lsp in zip(write_stable_poses, load_stable_poses):
self.assertTrue(np.allclose(wsp.r, lsp.r))
self.assertTrue(np.allclose(wsp.p, lsp.p))
self.assertTrue(database is not None and dataset is not None)
# test loop access
for obj in dataset:
key = obj.key
# test direct access
obj = dataset[key]
self.assertTrue(obj.key == key)
# read / write meshing
obj = dataset[dataset.object_keys[0]]
mesh_filename = dataset.obj_mesh_filename(obj.key, overwrite=True)
f = ObjFile(mesh_filename)
load_mesh = f.read()
write_vertices = np.array(obj.mesh.vertices)
write_triangles = np.array(obj.mesh.triangles)
load_vertices = np.array(load_mesh.vertices)
load_triangles = np.array(load_mesh.triangles)
self.assertTrue(np.allclose(write_vertices, load_vertices, atol=1e-5))
self.assertTrue(np.allclose(write_triangles, load_triangles, atol=1e-5))
# test rendering images
stable_poses = dataset.stable_poses(obj.key)
stable_pose = stable_poses[0]
# setup virtual camera
width = CONFIG['width']
height = CONFIG['height']
f = CONFIG['focal']
cx = float(width) / 2
cy = float(height) / 2
ci = CameraIntrinsics('camera', fx=f, fy=f, cx=cx, cy=cy,
height=height, width=width)
vp = ViewsphereDiscretizer(min_radius=CONFIG['min_radius'],
max_radius=CONFIG['max_radius'],
num_radii=CONFIG['num_radii'],
min_elev=CONFIG['min_elev']*np.pi,
max_elev=CONFIG['max_elev']*np.pi,
num_elev=CONFIG['num_elev'],
num_az=CONFIG['num_az'],
num_roll=CONFIG['num_roll'])
vc = VirtualCamera(ci)
# render segmasks and depth
render_modes = [RenderMode.SEGMASK, RenderMode.DEPTH, RenderMode.SCALED_DEPTH]
for render_mode in render_modes:
rendered_images = vc.wrapped_images_viewsphere(obj.mesh, vp,
render_mode,
stable_pose)
pre_store_num_images = len(rendered_images)
dataset.store_rendered_images(obj.key, rendered_images,
stable_pose_id=stable_pose.id,
render_mode=render_mode)
rendered_images = dataset.rendered_images(obj.key,
stable_pose_id=stable_pose.id,
render_mode=render_mode)
post_store_num_images = len(rendered_images)
self.assertTrue(pre_store_num_images == post_store_num_images)
# test read / write grasp metrics
metric_name = CONFIG['metrics'].keys()[0]
metric_config = CONFIG['metrics'][metric_name]
dataset.create_metric(metric_name, metric_config)
load_metric_config = dataset.metric(metric_name)
self.assertTrue(dataset.has_metric(metric_name))
for key, value in metric_config.iteritems():
if isinstance(value, dict):
for k, v in value.iteritems():
self.assertTrue(load_metric_config[key][k] == v)
else:
self.assertTrue(load_metric_config[key] == value)
dataset.delete_metric(metric_name)
self.assertFalse(dataset.has_metric(metric_name))
# test read / write grasps
num_grasps = NUM_DB_GRASPS
database = Hdf5Database(TEST_DB_NAME, access_level=READ_WRITE_ACCESS)
dataset = database.dataset(TEST_DS_NAME)
key = dataset.object_keys[0]
grasps = []
grasp_metrics = {}
for i in range(num_grasps):
configuration = np.random.rand(9)
configuration[3:6] = configuration[3:6] / np.linalg.norm(configuration[3:6])
random_grasp = ParallelJawPtGrasp3D(configuration)
grasps.append(random_grasp)
dataset.store_grasps(key, grasps)
loaded_grasps = dataset.grasps(key)
for g in loaded_grasps:
grasp_metrics[g.id] = {}
grasp_metrics[g.id]['force_closure'] = 1 * (np.random.rand() > 0.5)
for g1, g2 in zip(grasps, loaded_grasps):
self.assertTrue(np.allclose(g1.configuration, g2.configuration))
self.assertTrue(dataset.has_grasps(key))
dataset.store_grasp_metrics(key, grasp_metrics)
loaded_grasp_metrics = dataset.grasp_metrics(key, loaded_grasps)
for i, metrics in loaded_grasp_metrics.iteritems():
self.assertTrue(metrics['force_closure'] == grasp_metrics[i]['force_closure'])
# remove grasps
dataset.delete_grasps(key)
self.assertFalse(dataset.has_grasps(key))
# remove rendered images
render_modes = [RenderMode.SEGMASK, RenderMode.DEPTH, RenderMode.SCALED_DEPTH]
for render_mode in render_modes:
dataset.delete_rendered_images(key, stable_pose_id=stable_pose.id,
render_mode=render_mode)
rendered_images = dataset.rendered_images(key,
stable_pose_id=stable_pose.id,
render_mode=render_mode)
self.assertTrue(len(rendered_images) == 0)
# remove graspable
database = Hdf5Database(TEST_DB_NAME, access_level=READ_WRITE_ACCESS)
dataset = database.dataset(TEST_DS_NAME)
key = dataset.object_keys[0]
dataset.delete_graspable(key)
obj_deleted = False
try:
obj = dataset[key]
except:
obj_deleted = True
self.assertTrue(obj_deleted)
database.close()