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):
""" Writes coco annotations in the following steps:
1. Locat the seg images
2. Locat the rgb maps
3. Locat the seg maps
4. Read color mappings
5. For each frame write the coco annotation
"""
if self._avoid_output:
print("Avoid output is on, no output produced!")
return
# Check if a label mapping is registered which could be used for naming the categories.
if GlobalStorage.is_in_storage("label_mapping"):
label_mapping = GlobalStorage.get("label_mapping")
else:
label_mapping = None
CocoWriterUtility.write(self._determine_output_dir(False),
mask_encoding_format=self.mask_encoding_format,
supercategory=self._supercategory,
append_to_existing_output=self._append_to_existing_output,
segmap_output_key=self.segmap_output_key,
segcolormap_output_key=self.segcolormap_output_key,
rgb_output_key=self.rgb_output_key,
label_mapping=label_mapping)
def get_registered_outputs() -> List[Dict[str, Any]]:
""" Returns a list of outputs which were registered.
:return: A list of dicts containing all information registered for the outputs.
"""
outputs = []
if GlobalStorage.is_in_storage("output"):
outputs = GlobalStorage.get("output")
return outputs
def find_registered_output_by_key(key):
""" Returns the output which was registered with the given key.
:param key: The output key to look for.
:return: The dict containing all information registered for that output. If no output with the given key exists, None is returned.
"""
if GlobalStorage.is_in_storage("output"):
for output in GlobalStorage.get("output"):
if output["key"] == key:
return output
return None
def run(self):
"""
:return: Sampled value. Type: Mathutils Vector
"""
# Radius of the sphere.
radius = self.config.get_float(
"radius", GlobalStorage.get("obj_diamater")) * 1.25
position = mathutils.Vector()
current = self._count // self._repeat
# print("UniformSphere current:", current)
for i in range(3):
position[i] = self._total_points[current,
i] * radius + self._center[i]
self._count += 1
return position
def run(self):
if self._avoid_rendering:
print("Avoid rendering is on, no output produced!")
return
if self.config.get_bool("append_to_existing_output", False):
frame_offset = 0
# Look for hdf5 file with highest index
for path in os.listdir(self._determine_output_dir(False)):
if path.endswith(".hdf5"):
index = path[:-len(".hdf5")]
if index.isdigit():
frame_offset = max(frame_offset, int(index) + 1)
else:
frame_offset = 0
# Go through all frames
for frame in range(bpy.context.scene.frame_start,
bpy.context.scene.frame_end):
# Create output hdf5 file
hdf5_path = os.path.join(self._determine_output_dir(False),
str(frame + frame_offset) + ".hdf5")
with h5py.File(hdf5_path, "w") as f:
if not GlobalStorage.is_in_storage("output"):
print("No output was designed in prior models!")
return
# Go through all the output types
print("Merging data for frame " + str(frame) + " into " +
hdf5_path)
for output_type in GlobalStorage.get("output"):
# Build path (path attribute is format string)
file_path = output_type["path"]
if '%' in file_path:
file_path = file_path % frame
# Check if file exists
if not os.path.exists(file_path):
# If not try stereo suffixes
path_l, path_r = self._get_stereo_path_pair(file_path)
if not os.path.exists(path_l) or not os.path.exists(
path_r):
raise Exception("File not found: " + file_path)
else:
use_stereo = True
else:
use_stereo = False
if use_stereo:
path_l, path_r = self._get_stereo_path_pair(file_path)
img_l, new_key, new_version = self._load_and_postprocess(
path_l, output_type["key"], output_type["version"])
img_r, new_key, new_version = self._load_and_postprocess(
path_r, output_type["key"], output_type["version"])
if self.config.get_bool("stereo_separate_keys", False):
self._write_to_hdf_file(f, new_key + "_0", img_l)
self._write_to_hdf_file(f, new_key + "_1", img_r)
else:
data = np.array([img_l, img_r])
self._write_to_hdf_file(f, new_key, data)
else:
data, new_key, new_version = self._load_and_postprocess(
file_path, output_type["key"],
output_type["version"])
self._write_to_hdf_file(f, new_key, data)
self._write_to_hdf_file(f, new_key + "_version",
np.string_([new_version]))
def run(self):
""" Does the stereo global matching in the following steps:
1. Collect camera object and its state,
2. For each frame, load left and right images and call the `sgm()` methode.
3. Write the results to a numpy file.
"""
if self._avoid_output:
print("Avoid output is on, no output produced!")
return
if GlobalStorage.is_in_storage("renderer_distance_end"):
self.depth_max = GlobalStorage.get("renderer_distance_end")
else:
raise RuntimeError(
"A distance rendering has to be executed before this module is executed, "
"else the `renderer_distance_end` is not set!")
self.rgb_output_path = Utility.find_registered_output_by_key(
self.rgb_output_key)["path"]
# Collect camera and camera object
cam_ob = bpy.context.scene.camera
cam = cam_ob.data
self.width = bpy.context.scene.render.resolution_x
self.height = bpy.context.scene.render.resolution_y
print('Resolution: {}, {}'.format(self.width, self.height))
self.baseline = cam.stereo.interocular_distance
if not self.baseline:
raise Exception(
"Stereo parameters are not set. Make sure to enable RGB stereo rendering before this module."
)
if self.config.get_bool("infer_focal_length_from_fov", False):
fov = cam.angle_x if cam.angle_x else cam.angle
if not fov:
raise Exception("Could not obtain field of view angle")
self.focal_length = float(
(1.0 / tan(fov / 2.0)) * (float(self.width) / 2.0))
else:
self.focal_length = self.config.get_float("focal_length", 0.0)
if self.focal_length == 0.0:
raise Exception(
"Focal length set to 0. This is either intentional or because no value was set by the user. Either way, this needs to be corrected by setting a value > 0 or enabling 'infer_focal_length_from_fov'."
)
for frame in range(bpy.context.scene.frame_start,
bpy.context.scene.frame_end):
path_split = self.rgb_output_path.split(".")
path_l = "{}_L.{}".format(path_split[0], path_split[1])
path_r = "{}_R.{}".format(path_split[0], path_split[1])
imgL = load_image(path_l % frame)
imgR = load_image(path_r % frame)
depth, disparity = self.sgm(imgL, imgR)
np.save(
os.path.join(self.output_dir, "stereo-depth_%04d") % frame,
depth)
if self.config.get_bool("output_disparity", False):
np.save(
os.path.join(self.output_dir, "disparity_%04d") % frame,
disparity)
Utility.register_output(self._determine_output_dir(), "stereo-depth_",
"stereo-depth", ".npy", "1.0.0")
if self.config.get_bool("output_disparity", False):
Utility.register_output(self._determine_output_dir(), "disparity_",
"disparity", ".npy", "1.0.0")