def add_output_entry(output):
""" Registers the given output in the scene's custom properties
:param output: A dict containing key and path of the new output type.
"""
if GlobalStorage.is_in_storage("output"):
if not Utility.output_already_registered(output, GlobalStorage.get("output")): # E.g. multiple camera samplers
GlobalStorage.get("output").append(output)
else:
GlobalStorage.set("output", [output])
def run(self):
label_mapping = LabelIdMapping.from_csv(
Utility.resolve_path(
os.path.join('resources', 'id_mappings', 'nyu_idset.csv')))
# Add label mapping to global storage, s.t. it could be used for naming semantic segmentations.
GlobalStorage.set("label_mapping", label_mapping)
loaded_objects = SuncgLoader.load(self.house_path, label_mapping,
self.suncg_dir)
self._set_properties(loaded_objects)
def run(self):
if len(self._obj_ids) > 0:
bpy.context.scene.world.light_settings.use_ambient_occlusion = True # turn AO on
# bpy.context.scene.world.light_settings.ao_factor = 0.5 # set it to 0.5
used_shapenet_objs = [_ for _ in self._obj_list if _['obj_id'] in self._obj_ids]
else:
used_shapenet_objs = random.choices(self._obj_list, k = self._num_objects)
for i, selected_obj_info in enumerate(used_shapenet_objs):
selected_obj_path = os.path.join(
self._shapenet_path,
selected_obj_info['shapenet_synset_id'],
selected_obj_info['shapenet_obj_id'],
"models", "model_normalized.obj"
)
loaded_obj = Utility.import_objects(selected_obj_path)
obj_id_output = selected_obj_info['obj_id'] + OBJECT_ID_OFFSET
for obj in loaded_obj:
obj_name = "obj_%06d" % obj_id_output
obj.name = obj_name
obj['category_id'] = obj_id_output
obj.scale = (self._object_scale, self._object_scale, self._object_scale)
print("len(obj.material_slots)", len(obj.material_slots))
cc_asset_names = selected_obj_info['cc_asset_names']
for j in range(len(obj.material_slots)):
if j >= len(cc_asset_names):
break
mat = obj.material_slots[j]
mat_folder_name = cc_asset_names[j]
cc_mat = self._load_cc_mat(mat_folder_name)
mat.material = cc_mat
# Remap the object uv coordinates
bpy.context.view_layer.objects.active = obj
bpy.ops.object.editmode_toggle()
bpy.ops.uv.sphere_project()
bpy.ops.object.editmode_toggle()
# # Save the object meshes to .obj file if not already done so.
# save_obj_path = os.path.join(self._output_dir, "objects", "%s.obj" % i)
# if not os.path.exists(os.path.dirname(save_obj_path)):
# if not os.path.exists(os.path.dirname(save_obj_path)):
# os.makedirs(os.path.dirname(save_obj_path))
# bpy.ops.export_scene.obj(filepath=save_obj_path, use_selection=True)
obj_diameter = (obj.dimensions[0]**2 + obj.dimensions[1]**2 + obj.dimensions[2]**2) ** (0.5)
GlobalStorage.set("obj_diamater", obj_diameter)
self._set_properties(loaded_obj)
def run(self):
label_mapping = LabelIdMapping.from_csv(self.mapping_file)
# Add label mapping to global storage, s.t. it could be used for naming semantic segmentations.
GlobalStorage.set("label_mapping", label_mapping)
loaded_objects = Front3DLoader.load(
json_path=self.config.get_string("json_path"),
future_model_path=self.config.get_string("3D_future_model_path"),
front_3D_texture_path=self.config.get_string(
"3D_front_texture_path"),
label_mapping=label_mapping,
ceiling_light_strength=self.config.get_float(
"ceiling_light_strength", 0.8),
lamp_light_strength=self.config.get_float("lamp_light_strength",
7.0))
self._set_properties(loaded_objects)
def run(self):
"""
Run the module, loads all the objects and set the properties correctly (including the category_id)
"""
label_mapping = LabelIdMapping.from_csv(
Utility.resolve_path(
os.path.join('resources', 'id_mappings', 'nyu_idset.csv')))
# Add label mapping to global storage, s.t. it could be used for naming semantic segmentations.
GlobalStorage.set("label_mapping", label_mapping)
# load the objects (Use use_image_search=False as some image names have a "/" prefix which will lead to blender search the whole root directory recursively!
loaded_objects = SceneNetLoader.load(
file_path=self._file_path,
texture_folder=self._texture_folder,
label_mapping=label_mapping,
unknown_texture_folder=self._unknown_texture_folder)
# add custom properties
self._set_properties(loaded_objects)
def run(self):
""" Load BOP data """
datasets_path = os.path.dirname(self.bop_dataset_path)
dataset = os.path.basename(self.bop_dataset_path)
print("bob: {}, dataset_path: {}".format(self.bop_dataset_path,
datasets_path))
print("dataset: {}".format(dataset))
try:
from bop_toolkit_lib import dataset_params, inout
except ImportError as error:
print(
'ERROR: Please download the bop_toolkit package and add it to sys_paths in config!'
)
print('https://github.com/thodan/bop_toolkit')
raise error
model_p = dataset_params.get_model_params(
datasets_path,
dataset,
model_type=self.model_type if self.model_type else None)
cam_p = dataset_params.get_camera_params(
datasets_path,
dataset,
cam_type=self.cam_type if self.cam_type else None)
try:
split_p = dataset_params.get_split_params(datasets_path,
dataset,
split=self.split)
except ValueError:
raise Exception(
"Wrong path or {} split does not exist in {}.".format(
self.split, dataset))
bpy.context.scene.world["category_id"] = 0
bpy.context.scene.render.resolution_x = cam_p['im_size'][0]
bpy.context.scene.render.resolution_y = cam_p['im_size'][1]
loaded_objects = []
# only load all/selected objects here, use other modules for setting poses
# e.g. camera.CameraSampler / object.ObjectPoseSampler
if self.scene_id == -1:
# TLESS exception because images are cropped
if self.bop_dataset_name in ['tless']:
cam_p['K'][0, 2] = split_p['im_size'][0] / 2
cam_p['K'][1, 2] = split_p['im_size'][1] / 2
# set camera intrinsics
CameraUtility.set_intrinsics_from_K_matrix(cam_p['K'],
split_p['im_size'][0],
split_p['im_size'][1])
obj_ids = self.obj_ids if self.obj_ids else model_p['obj_ids']
# if sampling is enabled
if self.sample_objects:
loaded_ids = {}
loaded_amount = 0
if self.obj_instances_limit != -1 and len(
obj_ids
) * self.obj_instances_limit < self.num_of_objs_to_sample:
raise RuntimeError(
"{}'s {} split contains {} objects, {} object where requested to sample with "
"an instances limit of {}. Raise the limit amount or decrease the requested "
"amount of objects.".format(self.bop_dataset_path,
self.split, len(obj_ids),
self.num_of_objs_to_sample,
self.obj_instances_limit))
while loaded_amount != self.num_of_objs_to_sample:
random_id = choice(obj_ids)
if random_id not in loaded_ids.keys():
loaded_ids.update({random_id: 0})
# if there is no limit or if there is one, but it is not reached for this particular object
if self.obj_instances_limit == -1 or loaded_ids[
random_id] < self.obj_instances_limit:
cur_obj = self._load_mesh(random_id,
model_p,
scale=self.scale)
loaded_ids[random_id] += 1
loaded_amount += 1
loaded_objects.append(cur_obj)
else:
print(
"ID {} was loaded {} times with limit of {}. Total loaded amount {} while {} are "
"being requested".format(
random_id, loaded_ids[random_id],
self.obj_instances_limit, loaded_amount,
self.num_of_objs_to_sample))
else:
for obj_id in obj_ids:
cur_obj = self._load_mesh(obj_id,
model_p,
scale=self.scale)
loaded_objects.append(cur_obj)
self._set_properties(loaded_objects)
if self._render_grid:
# Record the object diameter for future use
obj_diameter = (cur_obj.dimensions[0]**2 +
cur_obj.dimensions[1]**2 +
cur_obj.dimensions[2]**2)**(0.5)
GlobalStorage.set("obj_diamater",
obj_diameter * self.scale * 1.2)
bpy.context.scene.world.light_settings.use_ambient_occlusion = True # turn AO on
# replicate scene: load scene objects, object poses, camera intrinsics and camera poses
else:
sc_gt = inout.load_scene_gt(split_p['scene_gt_tpath'].format(
**{'scene_id': self.scene_id}))
sc_camera = inout.load_json(split_p['scene_camera_tpath'].format(
**{'scene_id': self.scene_id}))
for i, (cam_id, insts) in enumerate(sc_gt.items()):
cam_K, cam_H_m2c_ref = self._get_ref_cam_extrinsics_intrinsics(
sc_camera, cam_id, insts, self.scale)
if i == 0:
# define world = first camera
cam_H_m2w_ref = cam_H_m2c_ref.copy()
cur_objs = []
# load scene objects and set their poses
for inst in insts:
cur_objs.append(
self._load_mesh(inst['obj_id'],
model_p,
scale=self.scale))
self.set_object_pose(cur_objs[-1], inst, self.scale)
cam_H_c2w = self._compute_camera_to_world_trafo(
cam_H_m2w_ref, cam_H_m2c_ref)
# set camera intrinsics
CameraUtility.set_intrinsics_from_K_matrix(
cam_K, split_p['im_size'][0], split_p['im_size'][1])
# set camera extrinsics as next frame
frame_id = CameraUtility.add_camera_pose(cam_H_c2w)
# Add key frame for camera shift, as it changes from frame to frame in the tless replication
cam = bpy.context.scene.camera.data
cam.keyframe_insert(data_path='shift_x', frame=frame_id)
cam.keyframe_insert(data_path='shift_y', frame=frame_id)
# Copy object poses to key frame (to be sure)
for cur_obj in cur_objs:
self._insert_key_frames(cur_obj, frame_id)