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()