def _cam2world_matrix_from_cam_extrinsics(self,
config: Config) -> np.ndarray:
""" Determines camera extrinsics by using the given config and returns them in form of a cam to world frame transformation matrix.
:param config: The configuration object.
:return: The 4x4 cam to world transformation matrix.
"""
if not config.has_param("cam2world_matrix"):
position = MathUtility.change_coordinate_frame_of_point(
config.get_vector3d("location", [0, 0, 0]), self.source_frame)
# position = Vector((-0.01111459918320179, -0.051188092678785324, 0.19301876425743103))
rotation_format = config.get_string("rotation/format", "euler")
value = config.get_vector3d("rotation/value", [0, 0, 0])
# Transform to blender coord frame
value = MathUtility.change_coordinate_frame_of_point(
value, self.source_frame)
if rotation_format == "euler":
# Rotation, specified as euler angles
rotation_matrix = Euler(value, 'XYZ').to_matrix()
elif rotation_format == "forward_vec":
# Convert forward vector to euler angle (Assume Up = Z)
rotation_matrix = CameraUtility.rotation_from_forward_vec(
value)
elif rotation_format == "look_at":
# Convert forward vector to euler angle (Assume Up = Z)
rotation_matrix = CameraUtility.rotation_from_forward_vec(
value - position)
else:
raise Exception("No such rotation format:" +
str(rotation_format))
if rotation_format == "look_at" or rotation_format == "forward_vec":
inplane_rot = config.get_float("rotation/inplane_rot", 0.0)
rotation_matrix = np.matmul(
rotation_matrix,
Euler((0.0, 0.0, inplane_rot)).to_matrix())
extra_rot = config.get_vector("rotation/extra_rot",
mathutils.Vector([0., 0., 0.]))
#extra_rot = Vector([0.3,-0.3,-0.7841])
rotation_matrix = rotation_matrix @ Euler(
extra_rot).to_matrix()
# cam2world_matrix = Matrix.Translation(Vector(position)) @ rotation_matrix.to_4x4()
cam2world_matrix = MathUtility.build_transformation_mat(
position, rotation_matrix)
else:
cam2world_matrix = np.array(
config.get_list("cam2world_matrix")).reshape(4, 4).astype(
np.float32)
cam2world_matrix = MathUtility.change_target_coordinate_frame_of_transformation_matrix(
cam2world_matrix, self.source_frame)
return cam2world_matrix
def _cam2world_matrix_from_cam_extrinsics(self, config):
""" Determines camera extrinsics by using the given config and returns them in form of a cam to world frame transformation matrix.
:param config: The configuration object.
:return: The cam to world transformation matrix.
"""
if not config.has_param("cam2world_matrix"):
position = MathUtility.transform_point_to_blender_coord_frame(
config.get_vector3d("location", [0, 0, 0]), self.source_frame)
# Rotation
rotation_format = config.get_string("rotation/format", "euler")
value = config.get_vector3d("rotation/value", [0, 0, 0])
# Transform to blender coord frame
value = MathUtility.transform_point_to_blender_coord_frame(
Vector(value), self.source_frame)
if rotation_format == "euler":
# Rotation, specified as euler angles
rotation_matrix = Euler(value, 'XYZ').to_matrix()
elif rotation_format == "forward_vec":
# Convert forward vector to euler angle (Assume Up = Z)
rotation_matrix = CameraUtility.rotation_from_forward_vec(
value)
elif rotation_format == "look_at":
# Convert forward vector to euler angle (Assume Up = Z)
rotation_matrix = CameraUtility.rotation_from_forward_vec(
(value - position).normalized())
else:
raise Exception("No such rotation format:" +
str(rotation_format))
if rotation_format == "look_at" or rotation_format == "forward_vec":
inplane_rot = config.get_float("rotation/inplane_rot", 0.0)
rotation_matrix = rotation_matrix @ Euler(
(0.0, 0.0, inplane_rot)).to_matrix()
cam2world_matrix = Matrix.Translation(
Vector(position)) @ rotation_matrix.to_4x4()
else:
cam2world_matrix = Matrix(
np.array(config.get_list("cam2world_matrix")).reshape(
4, 4).astype(np.float32))
cam2world_matrix = Utility.transform_matrix_to_blender_coord_frame(
cam2world_matrix, self.source_frame)
return cam2world_matrix
CameraUtility.set_intrinsics_from_blender_params(1,
512,
512,
pixel_aspect_x=1.333333333,
lens_unit="FOV")
# read the camera positions file and convert into homogeneous camera-world transformation
with open(args.camera, "r") as f:
for line in f.readlines():
line = [float(x) for x in line.split()]
position = MathUtility.change_coordinate_frame_of_point(
line[:3], ["X", "-Z", "Y"])
rotation = MathUtility.change_coordinate_frame_of_point(
line[3:6], ["X", "-Z", "Y"])
matrix_world = MathUtility.build_transformation_mat(
position, CameraUtility.rotation_from_forward_vec(rotation))
CameraUtility.add_camera_pose(matrix_world)
# makes Suncg objects emit light
SuncgLighting.light()
# activate normal and distance rendering
RendererUtility.enable_normals_output()
RendererUtility.enable_distance_output()
MaterialLoaderUtility.add_alpha_channel_to_textures(blurry_edges=True)
# render the whole pipeline
data = RendererUtility.render()
data.update(
SegMapRendererUtility.render(Utility.get_temporary_directory(),
objs = ObjectLoader.load(args.scene)
# define a light and set its location and energy level
light = Light()
light.set_type("POINT")
light.set_location([5, -5, 5])
light.set_energy(1000)
# Find point of interest, all cam poses should look towards it
poi = MeshObject.compute_poi(objs)
# Sample five camera poses
for i in range(5):
# Sample random camera location above objects
location = np.random.uniform([-10, -10, 12], [10, 10, 8])
# Compute rotation based on vector going from location towards poi
rotation_matrix = CameraUtility.rotation_from_forward_vec(poi - location, inplane_rot=np.random.uniform(-0.7854, 0.7854))
# Add homog cam pose based on location an rotation
cam2world_matrix = MathUtility.build_transformation_mat(location, rotation_matrix)
CameraUtility.add_camera_pose(cam2world_matrix)
# activate normal and distance rendering
RendererUtility.enable_normals_output()
RendererUtility.enable_distance_output()
# set the amount of samples, which should be used for the color rendering
RendererUtility.set_samples(350)
# render the whole pipeline
data = RendererUtility.render()
# write the data to a .hdf5 container
WriterUtility.save_to_hdf5(args.output_dir, data)