def __add_floor(self):
rotate_transform = Transform.rotate(Vector(-1, 0, 0), 90)
scale_transform = Transform.scale(Vector(100, 100, 100))
translate_transform = Transform.translate(
Vector(0.0, self.floor_height, 0.0))
total_transform = translate_transform * scale_transform\
* rotate_transform
if self.scene.active_view.background == "d":
reflectance = Spectrum(0.05)
elif self.scene.active_view.background == "l":
reflectance = Spectrum(0.5)
else:
reflectance = Spectrum(0.0)
floor = self.plgr.create({
"type": "rectangle",
"toWorld": total_transform,
"bsdf": {
"type": "roughdiffuse",
"diffuseReflectance": reflectance,
"alpha": 0.5
}
})
self.mitsuba_scene.addChild(floor)
def __add_cone(self, shape):
y_dir = np.array([0.0, 1.0, 0.0])
v = shape.end_points[1] - shape.end_points[0]
center = 0.5 * (shape.end_points[0] + shape.end_points[1])
height = norm(v)
scale = Transform.scale(Vector(shape.radius, height, shape.radius))
axis = np.cross(y_dir, v)
axis_len = norm(axis)
angle = degrees(atan2(axis_len, np.dot(y_dir, v)))
if (axis_len > 1e-6):
axis /= axis_len
rotate = Transform.rotate(Vector(*axis), angle)
else:
axis = np.array([1.0, 0.0, 0.0])
rotate = Transform.rotate(Vector(*axis), angle)
translate = Transform.translate(Vector(*center))
cone_file = self.file_resolver.resolve("cone.ply")
cone_transform = translate * rotate * scale
setting = {
"type": "ply",
"filename": cone_file,
"toWorld": cone_transform
}
return setting
def __get_normalize_transform(self, active_view):
centroid = active_view.center
scale = active_view.scale
normalize_transform = Transform.scale(Vector(scale, scale, scale)) *\
Transform.translate(Vector(*(-1 * centroid)))
return normalize_transform
def __init__(self, icp): #icp is initial cranicm pointi
self._cranicm_radius = 3.0
self._neck_radius = 1.5
self._neck_length = 6.0
self._init_cranicm_point = icp
self._init_neck_toWorld = tf.translate(Vector(
icp.x, icp.y - 3, icp.z)) * tf.scale(
Vector(1, self._neck_length, 1)) * tf.rotate(
Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
self.cranicm_prop = {
'type': 'sphere',
'center': self._init_cranicm_point,
'radius': self._cranicm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.neck_prop = {
'type': 'cylinder',
'toWorld': self._init_neck_toWorld,
'radius': self._neck_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
def transform_lookAt(self, origin, target, up, scale=None):
# Blender is Z up but Mitsuba is Y up, convert the lookAt
transform = Transform.lookAt(
Point(origin[0], origin[2], -origin[1]),
Point(target[0], target[2], -target[1]),
Vector(up[0], up[2], -up[1]))
if scale is not None:
transform *= Transform.scale(Vector(scale, scale, 1))
return transform
def transform_lookAt(self, origin, target, up, scale=None):
# Blender is Z up but Mitsuba is Y up, convert the lookAt
transform = Transform.lookAt(
Point(origin[0], origin[2], -origin[1]),
Point(target[0], target[2], -target[1]),
Vector(up[0], up[2], -up[1])
)
if scale is not None:
transform *= Transform.scale(Vector(scale, scale, 1))
return transform
def set_slocal_rotate_angle(self, gpitch, gyaw, groll):
self._slocal_axes_rotate_angle['pitch'] = gpitch
self._slocal_axes_rotate_angle['yaw'] = gyaw
self._slocal_axes_rotate_angle['roll'] = groll
rotation = tf.rotate(Vector(1, 0, 0), gpitch) * tf.rotate(Vector(0, 1, 0), gyaw) * tf.rotate(Vector(0, 0, 1), groll)
self._slocal_axes['x'] = rotation * self._slocal_axes['x']
self._slocal_axes['y'] = rotation * self._slocal_axes['y']
self._slocal_axes['z'] = rotation * self._slocal_axes['z']
self.set_joint_angles(self._shoulder_pitch, self._shoulder_yaw, self._shoulder_yaw, self._elbow_angle)
return self._slocal_axes
def __init__(self, itp): # itp is initial torso point
self._torso_radius = 5.5
self._torso_length = 18.0
self._init_clavile_toWorld = tf.translate(
Vector(itp.x, itp.y + (self._torso_length / 2), itp.z)) * tf.scale(
Vector(self._torso_radius, 1, self._torso_radius)) * tf.rotate(
Vector(1, 0, 0), -90)
self._init_torso_cylinder_toWorld = tf.translate(
Vector(itp.x, itp.y, itp.z)) * tf.scale(
Vector(1, self._torso_length, 1)) * tf.rotate(
Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
self._init_hip_toWorld = tf.translate(
Vector(itp.x, itp.y - (self._torso_length / 2), itp.z)) * tf.scale(
Vector(self._torso_radius, 1, self._torso_radius)) * tf.rotate(
Vector(1, 0, 0), 90)
self._torso_cylinder_point = itp
self.clavile_prop = {
'type': 'disk',
'toWorld': self._init_clavile_toWorld,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.torso_cylinder_prop = {
'type': 'cylinder',
'toWorld': self._init_torso_cylinder_toWorld,
'radius': self._torso_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.hip_prop = {
'type': 'disk',
'toWorld': self._init_hip_toWorld,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
def set_slocal_rotate_angle(self, gpitch, gyaw, groll):
self._slocal_axes_rotate_angle['pitch'] = gpitch
self._slocal_axes_rotate_angle['yaw'] = gyaw
self._slocal_axes_rotate_angle['roll'] = groll
rotation = tf.rotate(Vector(1, 0, 0), gpitch) * tf.rotate(
Vector(0, 1, 0), gyaw) * tf.rotate(Vector(0, 0, 1), groll)
self._slocal_axes['x'] = rotation * self._slocal_axes['x']
self._slocal_axes['y'] = rotation * self._slocal_axes['y']
self._slocal_axes['z'] = rotation * self._slocal_axes['z']
self.set_joint_angles(self._shoulder_pitch, self._shoulder_yaw,
self._shoulder_yaw, self._elbow_angle)
return self._slocal_axes
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(
gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_cranicm_point = movement * self._init_cranicm_point
self._init_neck_toWorld = movement * self._init_neck_toWorld
self.cranicm_prop['center'] = movement * self.cranicm_prop['center']
self.neck_prop['toWorld'] = movement * self.neck_prop['toWorld']
def create_transform_on_bbsphere(bbox,
radius_multiplier: float,
positioning_vector: Vector3,
tilt=None) -> Transform:
"""
Create a camera with origin on the bounding sphere around an object and looking towards the center of that sphere
Camera center is calculated as: bbsphere_center + radius_multiplier * bbsphere_radius * normalized_positioning_vector
:param bbox: The bounding box of the object from which to calculate the bounding sphere
:param radius_multiplier: The value to multiply the bounding sphere's radius with
(= distance of the camera origin to the center of the bounding sphere)
:param positioning_vector: The vector pointing towards the camera center
:param tilt: Transform to apply to camera origin. Usually a small rotation to tilt the camera perspective a little
:return: A transform on the bbsphere
"""
bsphere = bbox.getBSphere()
camera_target = bsphere.center
camera_offset = radius_multiplier * bsphere.radius * normalize(
positioning_vector)
camera_origin = camera_target + camera_offset
camera_transform = Transform.lookAt(
tilt * camera_origin if tilt is not None else camera_origin,
camera_target, Vector3(0., 0., 1.))
return camera_transform
def create_trajectory_on_bbsphere(bbox,
initial_positioning_vector: Vector3,
rotation_around: Vector3,
num_cameras: int,
radius_multiplier: float,
tilt: Transform = None) -> List[Transform]:
"""
Creates an interpolated trajectory on the bounding sphere of a scene/object
:param bbox: The bounding box of the object/scene to render
:param initial_positioning_vector: Controls where to position the camera initially
:param rotation_around: Specify axis to rotate camera around
:param num_cameras: Number of cameras to generate
:param radius_multiplier: Cameras will be placed at distance multiplier * bbsphere radius
:param tilt: Additional transformation meant to tilt the camera a bit
:return: List with generated transforms
"""
transforms = []
step_angle = 360. / float(num_cameras)
for camera_idx in range(num_cameras):
transform = create_transform_on_bbsphere(
bbox, radius_multiplier,
Transform.rotate(rotation_around, step_angle * camera_idx) * tilt *
initial_positioning_vector)
transforms.append(transform)
return transforms
def set_joint_angles(self, hip_pitch, hip_yaw, hip_roll, knee_angle):
self._hip_pitch = hip_pitch
self._hip_yaw = hip_yaw
self._hip_roll = hip_roll
self._knee_angle = knee_angle
# sto is the translate "hip to origin"
sto = tf.translate(Vector(-self.hip_joint_prop['center'][0], -self.hip_joint_prop['center'][1], -self.hip_joint_prop['center'][2]))
# ots is the translate "hip from origin"
ots = tf.translate(Vector(self.hip_joint_prop['center'][0], self.hip_joint_prop['center'][1], self.hip_joint_prop['center'][2]))
self.thigh_prop['toWorld'] = ots * self._create_xyz_rotation(hip_pitch, hip_yaw, hip_roll) * sto * self._init_thigh_toWorld
self.thigh_endcap_prop['center'] = ots * self._create_xyz_rotation(hip_pitch, hip_yaw, hip_roll) * sto * self._init_thigh_end_point
self.knee_joint_prop['center'] = ots * self._create_xyz_rotation(hip_pitch, hip_yaw, hip_roll) * sto * self._init_knee_point
self.calf_endcap_prop['center'] = ots * self._create_xyz_rotation(hip_pitch, hip_yaw, hip_roll) * sto * self._init_calf_start_point
self.calf_prop['toWorld'] = ots * self._create_xyz_rotation(hip_pitch, hip_yaw, hip_roll) * sto * self._init_calf_toWorld
self.foot_prop['center'] = ots * self._create_xyz_rotation(hip_pitch, hip_yaw, hip_roll) * sto * self._init_foot_point
# eto is the translate "knee to origin"
eto = tf.translate(Vector(-self.knee_joint_prop['center'][0], -self.knee_joint_prop['center'][1], -self.knee_joint_prop['center'][2]))
# ots is the translate "origin to hip"
ote = tf.translate(Vector(self.knee_joint_prop['center'][0], self.knee_joint_prop['center'][1], self.knee_joint_prop['center'][2]))
knee_axis = self.thigh_prop['toWorld'] * self._hlocal_axes['x']
self.calf_endcap_prop['center'] = ote * tf.rotate(knee_axis, knee_angle) * eto * self.calf_endcap_prop['center']
self.calf_prop['toWorld'] = ote * tf.rotate(knee_axis, knee_angle) * eto * self.calf_prop['toWorld']
self.foot_prop['center'] = ote * tf.rotate(knee_axis, knee_angle) * eto * self.foot_prop['center']
def set_joint_angles(self, shoulder_pitch, shoulder_yaw, shoulder_roll, elbow_angle):
self._shoulder_pitch = shoulder_pitch
self._shoulder_yaw = shoulder_yaw
self._shoulder_roll = shoulder_roll
self._elbow_angle = elbow_angle
# sto is the translate "shoulder to origin"
sto = tf.translate(Vector(-self.shoulder_joint_prop['center'][0], -self.shoulder_joint_prop['center'][1], -self.shoulder_joint_prop['center'][2]))
# ots is the translate "shoulder from origin"
ots = tf.translate(Vector(self.shoulder_joint_prop['center'][0], self.shoulder_joint_prop['center'][1], self.shoulder_joint_prop['center'][2]))
self.upperarm_prop['toWorld'] = ots * self._create_xyz_rotation(shoulder_pitch, shoulder_yaw, shoulder_roll) * sto * self._init_upperarm_toWorld
self.upperarm_endcap_prop['center'] = ots * self._create_xyz_rotation(shoulder_pitch, shoulder_yaw, shoulder_roll) * sto * self._init_upperarm_end_point
self.elbow_joint_prop['center'] = ots * self._create_xyz_rotation(shoulder_pitch, shoulder_yaw, shoulder_roll) * sto * self._init_elbow_point
self.forearm_endcap_prop['center'] = ots * self._create_xyz_rotation(shoulder_pitch, shoulder_yaw, shoulder_roll) * sto * self._init_forearm_start_point
self.forearm_prop['toWorld'] = ots * self._create_xyz_rotation(shoulder_pitch, shoulder_yaw, shoulder_roll) * sto * self._init_forearm_toWorld
self.hand_prop['center'] = ots * self._create_xyz_rotation(shoulder_pitch, shoulder_yaw, shoulder_roll) * sto * self._init_hand_point
# eto is the translate "elbow to origin"
eto = tf.translate(Vector(-self.elbow_joint_prop['center'][0], -self.elbow_joint_prop['center'][1], -self.elbow_joint_prop['center'][2]))
# ots is the translate "origin to shoulder"
ote = tf.translate(Vector(self.elbow_joint_prop['center'][0], self.elbow_joint_prop['center'][1], self.elbow_joint_prop['center'][2]))
elbow_axis = self.upperarm_prop['toWorld'] * (-self._slocal_axes['x'])
self.forearm_endcap_prop['center'] = ote * tf.rotate(elbow_axis, elbow_angle) * eto * self.forearm_endcap_prop['center']
self.forearm_prop['toWorld'] = ote * tf.rotate(elbow_axis, elbow_angle) * eto * self.forearm_prop['toWorld']
self.hand_prop['center'] = ote * tf.rotate(elbow_axis, elbow_angle) * eto * self.hand_prop['center']
def transform_matrix(self, matrix):
# Blender is Z up but Mitsuba is Y up, convert the matrix
global_matrix = axis_conversion(to_forward="-Z",
to_up="Y").to_4x4()
l = matrix_to_list(global_matrix * matrix)
mat = Matrix4x4(l)
transform = Transform(mat)
return transform
def __init__(self, itp): # itp is initial torso point
self._torso_radius = 5.5
self._torso_length = 18.0
self._init_clavile_toWorld = tf.translate(Vector(itp.x, itp.y+(self._torso_length/2), itp.z)) * tf.scale(Vector(self._torso_radius, 1, self._torso_radius)) * tf.rotate(Vector(1, 0, 0), -90)
self._init_torso_cylinder_toWorld = tf.translate(Vector(itp.x, itp.y, itp.z)) * tf.scale(Vector(1, self._torso_length, 1)) * tf.rotate(Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
self._init_hip_toWorld = tf.translate(Vector(itp.x, itp.y-(self._torso_length/2), itp.z)) * tf.scale(Vector(self._torso_radius, 1, self._torso_radius)) * tf.rotate(Vector(1, 0, 0), 90)
self._torso_cylinder_point = itp
self.clavile_prop = {
'type' : 'disk',
'toWorld': self._init_clavile_toWorld,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.torso_cylinder_prop = {
'type' : 'cylinder',
'toWorld': self._init_torso_cylinder_toWorld,
'radius' : self._torso_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.hip_prop = {
'type' : 'disk',
'toWorld': self._init_hip_toWorld,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_clavile_toWorld = movement * self._init_clavile_toWorld
self._init_torso_cylinder_toWorld = movement * self._init_torso_cylinder_toWorld
self._init_hip_toWorld = movement * self._init_hip_toWorld
self.clavile_prop['toWorld'] = movement * self.clavile_prop['toWorld']
self.torso_cylinder_prop['toWorld'] = movement * self.torso_cylinder_prop['toWorld']
self.hip_prop['toWorld'] = movement * self.hip_prop['toWorld']
self._torso_cylinder_point = movement * self._torso_cylinder_point
def convert_transform2numpy(transform: Transform) -> np.ndarray:
"""
Get a numpy array containing the same transformation matrix values as a Mitsuba Transform object
:param transform: Mitsuba Transform
:return: 4x4 Numpy array representing the transformation matrix
"""
matrix = np.zeros([4, 4], dtype=float)
for i in range(4):
for j in range(4):
matrix[i, j] = transform.getMatrix()[i, j]
return matrix
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(gx, gy, gz)) # Affine matrix for horizontal movement.
self._body_center = movement * self._init_torso_center
self.head.horiz_move(x, y, z)
self.torso.horiz_move(x, y, z)
self.left_arm.horiz_move(x, y, z)
self.right_arm.horiz_move(x, y, z)
if self._lower_body_flag:
self.left_leg.horiz_move(x, y, z)
self.right_leg.horiz_move(x, y, z)
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(
gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_clavile_toWorld = movement * self._init_clavile_toWorld
self._init_torso_cylinder_toWorld = movement * self._init_torso_cylinder_toWorld
self._init_hip_toWorld = movement * self._init_hip_toWorld
self.clavile_prop['toWorld'] = movement * self.clavile_prop['toWorld']
self.torso_cylinder_prop[
'toWorld'] = movement * self.torso_cylinder_prop['toWorld']
self.hip_prop['toWorld'] = movement * self.hip_prop['toWorld']
self._torso_cylinder_point = movement * self._torso_cylinder_point
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(
gx, gy, gz)) # Affine matrix for horizontal movement.
self._body_center = movement * self._init_torso_center
self.head.horiz_move(x, y, z)
self.torso.horiz_move(x, y, z)
self.left_arm.horiz_move(x, y, z)
self.right_arm.horiz_move(x, y, z)
if self._lower_body_flag:
self.left_leg.horiz_move(x, y, z)
self.right_leg.horiz_move(x, y, z)
def set_joint_angles(self, shoulder_pitch, shoulder_yaw, shoulder_roll,
elbow_angle):
self._shoulder_pitch = shoulder_pitch
self._shoulder_yaw = shoulder_yaw
self._shoulder_roll = shoulder_roll
self._elbow_angle = elbow_angle
# sto is the translate "shoulder to origin"
sto = tf.translate(
Vector(-self.shoulder_joint_prop['center'][0],
-self.shoulder_joint_prop['center'][1],
-self.shoulder_joint_prop['center'][2]))
# ots is the translate "shoulder from origin"
ots = tf.translate(
Vector(self.shoulder_joint_prop['center'][0],
self.shoulder_joint_prop['center'][1],
self.shoulder_joint_prop['center'][2]))
self.upperarm_prop['toWorld'] = ots * self._create_xyz_rotation(
shoulder_pitch, shoulder_yaw,
shoulder_roll) * sto * self._init_upperarm_toWorld
self.upperarm_endcap_prop['center'] = ots * self._create_xyz_rotation(
shoulder_pitch, shoulder_yaw,
shoulder_roll) * sto * self._init_upperarm_end_point
self.elbow_joint_prop['center'] = ots * self._create_xyz_rotation(
shoulder_pitch, shoulder_yaw,
shoulder_roll) * sto * self._init_elbow_point
self.forearm_endcap_prop['center'] = ots * self._create_xyz_rotation(
shoulder_pitch, shoulder_yaw,
shoulder_roll) * sto * self._init_forearm_start_point
self.forearm_prop['toWorld'] = ots * self._create_xyz_rotation(
shoulder_pitch, shoulder_yaw,
shoulder_roll) * sto * self._init_forearm_toWorld
self.hand_prop['center'] = ots * self._create_xyz_rotation(
shoulder_pitch, shoulder_yaw,
shoulder_roll) * sto * self._init_hand_point
# eto is the translate "elbow to origin"
eto = tf.translate(
Vector(-self.elbow_joint_prop['center'][0],
-self.elbow_joint_prop['center'][1],
-self.elbow_joint_prop['center'][2]))
# ots is the translate "origin to shoulder"
ote = tf.translate(
Vector(self.elbow_joint_prop['center'][0],
self.elbow_joint_prop['center'][1],
self.elbow_joint_prop['center'][2]))
elbow_axis = self.upperarm_prop['toWorld'] * (-self._slocal_axes['x'])
self.forearm_endcap_prop['center'] = ote * tf.rotate(
elbow_axis, elbow_angle) * eto * self.forearm_endcap_prop['center']
self.forearm_prop['toWorld'] = ote * tf.rotate(
elbow_axis, elbow_angle) * eto * self.forearm_prop['toWorld']
self.hand_prop['center'] = ote * tf.rotate(
elbow_axis, elbow_angle) * eto * self.hand_prop['center']
def __add_active_camera(self):
active_view = self.scene.active_view
camera = self.scene.active_camera
if active_view.transparent_bg:
pixel_format = "rgba"
else:
pixel_format = "rgb"
crop_bbox = np.array(camera.crop_bbox)
if np.amax(crop_bbox) <= 1.0:
# bbox is relative.
crop_bbox[:, 0] *= self.image_width
crop_bbox[:, 1] *= self.image_height
assert (np.all(crop_bbox >= 0))
assert (np.all(crop_bbox[:, 0] <= self.image_width))
assert (np.all(crop_bbox[:, 1] <= self.image_height))
mitsuba_camera = self.plgr.create({
"type":
"perspective",
"fov":
float(camera.fovy),
"fovAxis":
"y",
"toWorld":
Transform.lookAt(Point(*camera.location),
Point(*camera.look_at_point),
Vector(*camera.up_direction)),
"film": {
"type": "ldrfilm",
"width": self.image_width,
"height": self.image_height,
"cropOffsetX": int(crop_bbox[0, 0]),
"cropOffsetY": int(crop_bbox[0, 1]),
"cropWidth": int(crop_bbox[1, 0] - crop_bbox[0, 0]),
"cropHeight": int(crop_bbox[1, 1] - crop_bbox[0, 1]),
"banner": False,
"pixelFormat": pixel_format,
"rfilter": {
"type": "gaussian"
}
},
"sampler": {
"type": "halton",
"sampleCount": 4,
}
})
self.mitsuba_scene.addChild(mitsuba_camera)
def convert_meshlab2mitsuba_camera(camera_def: dict) -> Transform:
"""
Takes a meshlab camera dict (usually loaded from a meshlab xml file) and turns it into a valid mitsuba Transform
which can then be applied to a sensor
:param camera_def: The camera def dict, containing at least keys RotationMatrix and TranslationVector
:return: A mitsuba transform constructed from the given values
"""
# Meshlab camera matrix is transposed
matrix = Matrix4x4([
float(elem) for elem in camera_def['RotationMatrix'].split(' ')[:16]
]).transpose()
# Add translation vector
translation = [
-float(elem) for elem in camera_def['TranslationVector'].split(' ')
]
for i in range(3):
matrix[i, 3] = translation[i]
# Make Mitsuba transform and flip rotation signs (y is not flipped, otherwise resulting image will be flipped vertically)
transform = Transform(matrix)
transform *= transform.scale(Vector3(-1, 1, -1))
return transform
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_shoulder_point = movement * self._init_shoulder_point
self._init_upperarm_toWorld = movement * self._init_upperarm_toWorld
self._init_upperarm_end_point = movement * self._init_upperarm_end_point
self._init_elbow_point = movement * self._init_elbow_point
self._init_forearm_start_point = movement * self._init_forearm_start_point
self._init_hand_point = movement * self._init_hand_point
self._init_forearm_toWorld = movement * self._init_forearm_toWorld
self.shoulder_joint_prop['center'] = movement * self.shoulder_joint_prop['center']
self.upperarm_endcap_prop['center'] = movement * self.upperarm_endcap_prop['center']
self.upperarm_prop['toWorld'] = movement * self.upperarm_prop['toWorld']
self.elbow_joint_prop['center'] = movement * self.elbow_joint_prop['center']
self.forearm_endcap_prop['center'] = movement * self.forearm_endcap_prop['center']
self.forearm_prop['toWorld'] = movement * self.forearm_prop['toWorld']
self.hand_prop['center'] = movement * self.hand_prop['center']
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_hip_point = movement * self._init_hip_point
self._init_thigh_toWorld = movement * self._init_thigh_toWorld
self._init_thigh_end_point = movement * self._init_thigh_end_point
self._init_knee_point = movement * self._init_knee_point
self._init_calf_start_point = movement * self._init_calf_start_point
self._init_foot_point = movement * self._init_foot_point
self._init_calf_toWorld = movement * self._init_calf_toWorld
self.hip_joint_prop['center'] = movement * self.hip_joint_prop['center']
self.thigh_endcap_prop['center'] = movement * self.thigh_endcap_prop['center']
self.thigh_prop['toWorld'] = movement * self.thigh_prop['toWorld']
self.knee_joint_prop['center'] = movement * self.knee_joint_prop['center']
self.calf_endcap_prop['center'] = movement * self.calf_endcap_prop['center']
self.calf_prop['toWorld'] = movement * self.calf_prop['toWorld']
self.foot_prop['center'] = movement * self.foot_prop['center']
def set_joint_angles(self, hip_pitch, hip_yaw, hip_roll, knee_angle):
self._hip_pitch = hip_pitch
self._hip_yaw = hip_yaw
self._hip_roll = hip_roll
self._knee_angle = knee_angle
# sto is the translate "hip to origin"
sto = tf.translate(
Vector(-self.hip_joint_prop['center'][0],
-self.hip_joint_prop['center'][1],
-self.hip_joint_prop['center'][2]))
# ots is the translate "hip from origin"
ots = tf.translate(
Vector(self.hip_joint_prop['center'][0],
self.hip_joint_prop['center'][1],
self.hip_joint_prop['center'][2]))
self.thigh_prop['toWorld'] = ots * self._create_xyz_rotation(
hip_pitch, hip_yaw, hip_roll) * sto * self._init_thigh_toWorld
self.thigh_endcap_prop['center'] = ots * self._create_xyz_rotation(
hip_pitch, hip_yaw, hip_roll) * sto * self._init_thigh_end_point
self.knee_joint_prop['center'] = ots * self._create_xyz_rotation(
hip_pitch, hip_yaw, hip_roll) * sto * self._init_knee_point
self.calf_endcap_prop['center'] = ots * self._create_xyz_rotation(
hip_pitch, hip_yaw, hip_roll) * sto * self._init_calf_start_point
self.calf_prop['toWorld'] = ots * self._create_xyz_rotation(
hip_pitch, hip_yaw, hip_roll) * sto * self._init_calf_toWorld
self.foot_prop['center'] = ots * self._create_xyz_rotation(
hip_pitch, hip_yaw, hip_roll) * sto * self._init_foot_point
# eto is the translate "knee to origin"
eto = tf.translate(
Vector(-self.knee_joint_prop['center'][0],
-self.knee_joint_prop['center'][1],
-self.knee_joint_prop['center'][2]))
# ots is the translate "origin to hip"
ote = tf.translate(
Vector(self.knee_joint_prop['center'][0],
self.knee_joint_prop['center'][1],
self.knee_joint_prop['center'][2]))
knee_axis = self.thigh_prop['toWorld'] * self._hlocal_axes['x']
self.calf_endcap_prop['center'] = ote * tf.rotate(
knee_axis, knee_angle) * eto * self.calf_endcap_prop['center']
self.calf_prop['toWorld'] = ote * tf.rotate(
knee_axis, knee_angle) * eto * self.calf_prop['toWorld']
self.foot_prop['center'] = ote * tf.rotate(
knee_axis, knee_angle) * eto * self.foot_prop['center']
def main(args):
input_filepaths = [Path(elem) for elem in args.input]
output_path = Path(args.output)
assert all([elem.is_file() for elem in input_filepaths])
assert output_path.is_dir()
bbox = get_pointcloud_bbox(load_from_ply(input_filepaths[0]))
sensor_transform = cameras.create_transform_on_bbsphere(
bbox,
radius_multiplier=3.,
positioning_vector=Vector3(0, -1, 1),
tilt=Transform.rotate(util.axis_unit_vector('x'), -25.))
sensor = cameras.create_sensor_from_transform(sensor_transform,
args.width,
args.height,
fov=45.,
num_samples=args.samples)
render_pointclouds(zip(input_filepaths, cycle([output_path])), sensor,
args.radius, args.workers)
def createRenderJob(self):
self.scene = self.pmgr.create({
'type' : 'scene',
'sphere' : {
'type' : 'sphere',
},
'envmap' : {
'type' : 'sky'
},
'sensor' : {
'type' : 'perspective',
'toWorld' : Transform.translate(Vector(0, 0, -5)),
'sampler' : {
'type' : 'halton',
'sampleCount' : 64
}
}
})
return RenderJob('rjob', self.scene, self.queue)
def makeScene():
scene = Scene()
pmgr = PluginManager.getInstance()
# make shapes
for i in range(100):
shapeProps = Properties("sphere")
shapeProps["center"] = Point(i, i, i)
shapeProps["radius"] = 0.1
shape = pmgr.createObject(shapeProps)
shape.configure()
scene.addChild(shape)
# make perspective sensor
sensorProps = Properties("perspective")
sensorProps["toWorld"] = Transform.lookAt(Point(0, 0, 10), Point(0, 0, 0),
Vector(0, 1, 0))
sensorProps["fov"] = 45.0
sensor = pmgr.createObject(sensorProps)
# make film
filmProps = Properties("ldrfilm")
filmProps["width"] = 640
filmProps["height"] = 480
film = pmgr.createObject(filmProps)
film.configure()
sensor.addChild("film", film)
sensor.configure()
scene.addChild(sensor)
scene.configure()
return scene
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(
gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_hip_point = movement * self._init_hip_point
self._init_thigh_toWorld = movement * self._init_thigh_toWorld
self._init_thigh_end_point = movement * self._init_thigh_end_point
self._init_knee_point = movement * self._init_knee_point
self._init_calf_start_point = movement * self._init_calf_start_point
self._init_foot_point = movement * self._init_foot_point
self._init_calf_toWorld = movement * self._init_calf_toWorld
self.hip_joint_prop[
'center'] = movement * self.hip_joint_prop['center']
self.thigh_endcap_prop[
'center'] = movement * self.thigh_endcap_prop['center']
self.thigh_prop['toWorld'] = movement * self.thigh_prop['toWorld']
self.knee_joint_prop[
'center'] = movement * self.knee_joint_prop['center']
self.calf_endcap_prop[
'center'] = movement * self.calf_endcap_prop['center']
self.calf_prop['toWorld'] = movement * self.calf_prop['toWorld']
self.foot_prop['center'] = movement * self.foot_prop['center']
def makeScene():
scene = Scene()
pmgr = PluginManager.getInstance()
# make shapes
for i in range(100):
shapeProps = Properties("sphere")
shapeProps["center"] = Point(i, i, i)
shapeProps["radius"] = 0.1
shape = pmgr.createObject(shapeProps)
shape.configure()
scene.addChild(shape)
# make perspective sensor
sensorProps = Properties("perspective")
sensorProps["toWorld"] = Transform.lookAt(Point(0, 0, 10), Point(0, 0, 0), Vector(0, 1, 0))
sensorProps["fov"] = 45.0
sensor = pmgr.createObject(sensorProps)
# make film
filmProps = Properties("ldrfilm")
filmProps["width"] = 640
filmProps["height"] = 480
film = pmgr.createObject(filmProps)
film.configure()
sensor.addChild("film", film)
sensor.configure()
scene.addChild(sensor)
scene.configure()
return scene
def horiz_move(self, gx, gy, gz):
movement = tf.translate(Vector(
gx, gy, gz)) # Affine matrix for horizontal movement.
self._init_shoulder_point = movement * self._init_shoulder_point
self._init_upperarm_toWorld = movement * self._init_upperarm_toWorld
self._init_upperarm_end_point = movement * self._init_upperarm_end_point
self._init_elbow_point = movement * self._init_elbow_point
self._init_forearm_start_point = movement * self._init_forearm_start_point
self._init_hand_point = movement * self._init_hand_point
self._init_forearm_toWorld = movement * self._init_forearm_toWorld
self.shoulder_joint_prop[
'center'] = movement * self.shoulder_joint_prop['center']
self.upperarm_endcap_prop[
'center'] = movement * self.upperarm_endcap_prop['center']
self.upperarm_prop[
'toWorld'] = movement * self.upperarm_prop['toWorld']
self.elbow_joint_prop[
'center'] = movement * self.elbow_joint_prop['center']
self.forearm_endcap_prop[
'center'] = movement * self.forearm_endcap_prop['center']
self.forearm_prop['toWorld'] = movement * self.forearm_prop['toWorld']
self.hand_prop['center'] = movement * self.hand_prop['center']
def _create_xyz_rotation(self, pitch, yaw, roll):
return tf.rotate(self._slocal_axes['x'], pitch) * tf.rotate(
self._slocal_axes['y'], yaw) * tf.rotate(self._slocal_axes['z'],
roll)
def __get_glob_transform(self):
glob_transform = Transform(
Matrix4x4(self.global_transform.ravel(order="C").tolist()))
return glob_transform
def __get_view_transform(self, active_view):
transform = np.eye(4)
transform[0:3, :] = active_view.transform.reshape((3, 4), order="F")
view_transform = Transform(
Matrix4x4(transform.ravel(order="C").tolist()))
return view_transform
def create_interpolated_trajectory(
cameras: List[Transform],
method: str,
num_cameras_per_m: int = 75,
num_cameras_per_rad: int = 225,
num_total_cameras: int = 1000) -> List[Transform]:
"""
Creates an interpolated camera trajectory using supplied key camera transforms
:param cameras: Camera transformations to use as control points for interpolation
:param method: How to interpolate: *bezier* (used for both camera centers and rotations):
Smooth trajectory, but does not necessarily pass through the control points (except the first and last) or
*catmullrom* (used for camera centers, using quaternion slerp for rotations):
Passes through all control points, but needs more tuning to prevent weird behaviour
:param num_cameras_per_m: catmullrom parameter: Camera centers per meter
:param num_cameras_per_rad: catmullrom parameter: Camera rotations per radiant
:param num_total_cameras: bezier parameter: Number of interpolated cameras between first and last key camera pose
:return: A list of interpolated transforms
"""
all_interpolated = []
camera_pose_matrices = [
util.convert_transform2numpy(camera) for camera in cameras
]
if method == 'bezier':
interpolated_cameras = bezier_curve(camera_pose_matrices,
num_steps=num_total_cameras)
for elem in interpolated_cameras:
position = Point3(*elem[:3, 3].tolist())
look = Vector3(*elem[:3, :3].dot(np.array([0, 0, 1])).tolist())
up = Vector3(*(elem[:3, :3].dot(np.array([0, 1, 0]))).tolist())
all_interpolated.append(
Transform.lookAt(position, position + look, up))
elif method == 'catmullrom':
assert len(cameras) >= 4
camera_groups = [
camera_pose_matrices[idx:idx + 4]
for idx in range(len(cameras) - 3)
]
for camera_group in camera_groups:
key_positions = (camera_group[1][:3, 3], camera_group[2][:3, 3])
key_looks = (camera_group[1][:3, :3] * np.array([0, 0, 1]),
camera_group[2][:3, :3] * np.array([0, 0, 1]))
dist = np.linalg.norm(key_positions[1] - key_positions[0])
angle = math.acos(
np.clip(np.sum(key_looks[1] @ key_looks[0]), -1., 1.))
num_t = int(np.round(dist / 100. * num_cameras_per_m))
num_r = int(np.round(angle * num_cameras_per_rad))
num = max(40, max(num_t, num_r))
interpolated_cameras = catmull_rom_spline(camera_group, num)
for elem in interpolated_cameras:
position = Point3(*elem[:3, 3].tolist())
look = Vector3(*elem[:3, :3].dot(np.array([0, 0, 1])).tolist())
up = Vector3(*(elem[:3, :3].dot(np.array([0, 1, 0]))).tolist())
all_interpolated.append(
Transform.lookAt(position, position + look, up))
else:
raise NotImplementedError(
f'The method you chose ({method}) is not implemented')
return all_interpolated
def __init__(self, ihp): # ihp is initial hip point
self._thigh_radius = 1.5
self._thigh_length = 8.0
self._knee_radius = 1.5
self._calf_radius = 1.5
self._calf_length = 8.0
self._init_hip_point = ihp # == _init_thigh_start_point
self._init_thigh_end_point = Point(ihp.x, ihp.y - self._thigh_length,
ihp.z)
self._init_thigh_toWorld = tf.translate(
Vector(ihp.x, ihp.y - (self._thigh_length / 2), ihp.z)) * tf.scale(
Vector(1, self._thigh_length, 1)) * tf.rotate(
Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
self._init_knee_point = Point(
ihp.x, ihp.y -
(self._thigh_length + self._thigh_radius + self._knee_radius),
ihp.z)
self._init_calf_start_point = Point(
ihp.x, ihp.y - (self._thigh_length + self._thigh_radius +
self._knee_radius * 2 + self._calf_radius), ihp.z)
self._init_foot_point = Point(
ihp.x, ihp.y -
(self._thigh_length + self._thigh_radius + self._knee_radius * 2 +
self._calf_radius + self._calf_length),
ihp.z) # == _init_calf_end_point
self._init_calf_toWorld = tf.translate(
Vector(
ihp.x, ihp.y -
(self._thigh_length + self._thigh_radius + self._knee_radius *
2 + self._calf_radius + self._calf_length / 2), ihp.z)
) * tf.scale(Vector(1, self._calf_length, 1)) * tf.rotate(
Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
# local axes at hip
self._hlocal_axes = {
'x': Vector(1, 0, 0),
'y': Vector(0, 1, 0),
'z': Vector(0, 0, 1)
}
# rotate angle of local axes at hip
self._hlocal_axes_rotate_angle = {'pitch': 0, 'yaw': 0, 'roll': 0}
self._hip_pitch = 0
self._hip_yaw = 0
self._hip_roll = 0
self._knee_angle = 0
self.hip_joint_prop = {
'type': 'sphere',
'center': self._init_hip_point,
'radius': self._thigh_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.thigh_prop = {
'type': 'cylinder',
'toWorld': self._init_thigh_toWorld,
'radius': self._thigh_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.thigh_endcap_prop = {
'type': 'sphere',
'center': self._init_thigh_end_point,
'radius': self._thigh_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.knee_joint_prop = {
'type': 'sphere',
'center': self._init_knee_point,
'radius': self._knee_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.1, 0.1, 0.1])
}
}
self.calf_endcap_prop = {
'type': 'sphere',
'center': self._init_calf_start_point,
'radius': self._calf_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.calf_prop = {
'type': 'cylinder',
'toWorld': self._init_calf_toWorld,
'radius': self._calf_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.foot_prop = {
'type': 'sphere',
'center': self._init_foot_point,
'radius': self._calf_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
def __add_quarter(self):
scale = self.scene.active_view.scale
radius = 12.13 * scale
thickness = 0.875 * scale
face_scale = Transform.scale(Vector(radius))
tail_offset = Transform.translate(Vector(0, 0, thickness))
head_offset = Transform.translate(Vector(0, 0, -thickness)) *\
Transform.scale(Vector(1.0, 1.0, -1.0))
bbox_diag = 0.5 * norm(self.transformed_bbox_max -
self.transformed_bbox_min)
custom_transform = Transform.translate(
Vector(0.5, self.floor_height + radius + 0.01, -bbox_diag - 0.01))
head_texture = self.file_resolver.resolve("head.png")
tail_texture = self.file_resolver.resolve("tail.png")
side_texture = self.file_resolver.resolve("side.png")
quarter_ring = self.plgr.create({
"type": "cylinder",
"p0": Point(0.0, 0.0, thickness),
"p1": Point(0.0, 0.0, -thickness),
"radius": radius,
"toWorld": custom_transform,
"bsdf": {
"type": "bumpmap",
"texture": {
"type": "scale",
"scale": 0.01,
"texture": {
"type": "bitmap",
"filename": side_texture,
"gamma": 1.0,
"uscale": 100.0,
},
},
"bsdf": {
"type": "roughconductor",
"distribution": "ggx",
"alpha": 0.5,
"material": "Ni_palik"
#"diffuseReflectance": Spectrum(0.5)
}
}
})
head = self.plgr.create({
"type": "disk",
"toWorld": custom_transform * head_offset * face_scale,
"bsdf": {
"type": "diffuse",
"reflectance": {
"type": "bitmap",
"filename": head_texture
}
}
})
tail = self.plgr.create({
"type": "disk",
"toWorld": custom_transform * tail_offset * face_scale,
"bsdf": {
"type": "diffuse",
"reflectance": {
"type": "bitmap",
"filename": tail_texture
}
}
})
self.mitsuba_scene.addChild(quarter_ring)
self.mitsuba_scene.addChild(head)
self.mitsuba_scene.addChild(tail)
def __init__(self, isp): # isp is initial shoulder point
self._upperarm_radius = 1.0
self._upperarm_length = 6.0
self._elbow_radius = 1.0
self._forearm_radius = 1.0
self._forearm_length = 6.0
self._init_shoulder_point = isp # == _init_upperarm_start_point
self._init_upperarm_end_point = Point(isp.x,
isp.y - self._upperarm_length,
isp.z)
self._init_upperarm_toWorld = tf.translate(
Vector(isp.x, isp.y -
(self._upperarm_length / 2), isp.z)) * tf.scale(
Vector(1, self._upperarm_length, 1)) * tf.rotate(
Vector(1, 0, 0), -90) * tf.translate(
Vector(0, 0, -0.5))
self._init_elbow_point = Point(
isp.x, isp.y - (self._upperarm_length + self._upperarm_radius +
self._elbow_radius), isp.z)
self._init_forearm_start_point = Point(
isp.x, isp.y - (self._upperarm_length + self._upperarm_radius +
self._elbow_radius * 2 + self._forearm_radius),
isp.z)
self._init_hand_point = Point(
isp.x, isp.y - (self._upperarm_length + self._upperarm_radius +
self._elbow_radius * 2 + self._forearm_radius +
self._forearm_length),
isp.z) # == _init_forearm_end_point
self._init_forearm_toWorld = tf.translate(
Vector(
isp.x, isp.y -
(self._upperarm_length + self._upperarm_radius +
self._elbow_radius * 2 + self._forearm_radius +
self._forearm_length / 2), isp.z)) * tf.scale(
Vector(1, self._forearm_length, 1)) * tf.rotate(
Vector(1, 0, 0), -90) * tf.translate(
Vector(0, 0, -0.5))
# local axes at shoulder
self._slocal_axes = {
'x': Vector(1, 0, 0),
'y': Vector(0, 1, 0),
'z': Vector(0, 0, 1)
}
# rotate angle of local axes at shoulder
self._slocal_axes_rotate_angle = {'pitch': 0, 'yaw': 0, 'roll': 0}
self._shoulder_pitch = 0
self._shoulder_yaw = 0
self._shoulder_roll = 0
self._elbow_angle = 0
self.shoulder_joint_prop = {
'type': 'sphere',
'center': self._init_shoulder_point,
'radius': self._upperarm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.upperarm_prop = {
'type': 'cylinder',
'toWorld': self._init_upperarm_toWorld,
'radius': self._upperarm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.upperarm_endcap_prop = {
'type': 'sphere',
'center': self._init_upperarm_end_point,
'radius': self._upperarm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.elbow_joint_prop = {
'type': 'sphere',
'center': self._init_elbow_point,
'radius': self._elbow_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.1, 0.1, 0.1])
}
}
self.forearm_endcap_prop = {
'type': 'sphere',
'center': self._init_forearm_start_point,
'radius': self._forearm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.forearm_prop = {
'type': 'cylinder',
'toWorld': self._init_forearm_toWorld,
'radius': self._forearm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
self.hand_prop = {
'type': 'sphere',
'center': self._init_hand_point,
'radius': self._forearm_radius,
'bsdf': {
'type': 'ward',
'alphaU': 0.003,
'alphaV': 0.003,
'specularReflectance': Spectrum(0.01),
'diffuseReflectance': Spectrum([0.05, 0.05, 0.05])
}
}
def __init__(self, isp): # isp is initial shoulder point
self._upperarm_radius = 1.0
self._upperarm_length = 6.0
self._elbow_radius = 1.0
self._forearm_radius = 1.0
self._forearm_length = 6.0
self._init_shoulder_point = isp # == _init_upperarm_start_point
self._init_upperarm_end_point = Point(isp.x, isp.y-self._upperarm_length, isp.z)
self._init_upperarm_toWorld = tf.translate(Vector(isp.x, isp.y-(self._upperarm_length/2), isp.z)) * tf.scale(Vector(1, self._upperarm_length, 1)) * tf.rotate(Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
self._init_elbow_point = Point(isp.x, isp.y-(self._upperarm_length+self._upperarm_radius+self._elbow_radius), isp.z)
self._init_forearm_start_point = Point(isp.x, isp.y-(self._upperarm_length+self._upperarm_radius+self._elbow_radius*2+self._forearm_radius), isp.z)
self._init_hand_point = Point(isp.x, isp.y-(self._upperarm_length+self._upperarm_radius+self._elbow_radius*2+self._forearm_radius+self._forearm_length), isp.z) # == _init_forearm_end_point
self._init_forearm_toWorld = tf.translate(Vector(isp.x, isp.y-(self._upperarm_length+self._upperarm_radius+self._elbow_radius*2+self._forearm_radius+self._forearm_length/2), isp.z)) * tf.scale(Vector(1, self._forearm_length, 1)) * tf.rotate(Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
# local axes at shoulder
self._slocal_axes = {
'x' : Vector(1, 0, 0),
'y' : Vector(0, 1, 0),
'z' : Vector(0, 0, 1)
}
# rotate angle of local axes at shoulder
self._slocal_axes_rotate_angle = {
'pitch' : 0,
'yaw' : 0,
'roll' : 0
}
self._shoulder_pitch = 0
self._shoulder_yaw = 0
self._shoulder_roll = 0
self._elbow_angle = 0
self.shoulder_joint_prop = {
'type' : 'sphere',
'center' : self._init_shoulder_point,
'radius' : self._upperarm_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.upperarm_prop = {
'type' : 'cylinder',
'toWorld': self._init_upperarm_toWorld,
'radius' : self._upperarm_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.upperarm_endcap_prop = {
'type' : 'sphere',
'center' : self._init_upperarm_end_point,
'radius' : self._upperarm_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.elbow_joint_prop = {
'type' : 'sphere',
'center' : self._init_elbow_point,
'radius' : self._elbow_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.1, 0.1, 0.1])
}
}
self.forearm_endcap_prop = {
'type' : 'sphere',
'center' : self._init_forearm_start_point,
'radius' : self._forearm_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.forearm_prop = {
'type' : 'cylinder',
'toWorld' : self._init_forearm_toWorld,
'radius' : self._forearm_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.hand_prop = {
'type' : 'sphere',
'center' : self._init_hand_point,
'radius' : self._forearm_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
def do_simulation_multiangle_seq(seqname):
currdir = os.path.split(os.path.realpath(__file__))[0]
sys.path.append(currdir + '/bin/rt/' + current_rt_program + '/python/2.7/')
os.environ['PATH'] = currdir + '/bin/rt/' + current_rt_program + os.pathsep + os.environ['PATH']
import mitsuba
from mitsuba.core import Vector, Point, Ray, Thread, Scheduler, LocalWorker, PluginManager, Transform
from mitsuba.render import SceneHandler
from mitsuba.render import RenderQueue, RenderJob
from mitsuba.render import Scene
import multiprocessing
scheduler = Scheduler.getInstance()
for i in range(0, multiprocessing.cpu_count()):
scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
scene_path = session.get_scenefile_path()
fileResolver = Thread.getThread().getFileResolver()
fileResolver.appendPath(str(scene_path))
scene = SceneHandler.loadScene(fileResolver.resolve(
str(os.path.join(session.get_scenefile_path(), main_scene_xml_file))))
scene.configure()
scene.initialize()
queue = RenderQueue()
sceneResID = scheduler.registerResource(scene)
bsphere = scene.getKDTree().getAABB().getBSphere()
radius = bsphere.radius
targetx, targety, targetz = bsphere.center[0], bsphere.center[1], bsphere.center[2]
f = open(seqname + ".conf", 'r')
params = json.load(f)
obs_azimuth = params['seq1']['obs_azimuth']
obs_zenith = params['seq2']['obs_zenith']
cfgfile = session.get_config_file()
f = open(cfgfile, 'r')
cfg = json.load(f)
viewR = cfg["sensor"]["obs_R"]
mode = cfg["sensor"]["film_type"]
azi_arr = map(lambda x: float(x), obs_azimuth.strip().split(":")[1].split(","))
zeni_arr = map(lambda x: float(x), obs_zenith.strip().split(":")[1].split(","))
seq_header = multi_file_prefix + "_" + seqname
index = 0
for azi in azi_arr:
for zeni in zeni_arr:
distFile = os.path.join(session.get_output_dir(),
seq_header + ("_VA_%.2f" % azi).replace(".", "_") + ("_VZ_%.2f" % zeni).replace(".", "_"))
newScene = Scene(scene)
pmgr = PluginManager.getInstance()
newSensor = pmgr.createObject(scene.getSensor().getProperties())
theta = zeni / 180.0 * math.pi
phi = (azi - 90) / 180.0 * math.pi
scale_x = radius
scale_z = radius
toWorld = Transform.lookAt(
Point(targetx - viewR * math.sin(theta) * math.cos(phi), targety + viewR * math.cos(theta),
targetz - viewR * math.sin(theta) * math.sin(phi)), # original
Point(targetx, targety, targetz), # target
Vector(0, 0, 1) # up
) * Transform.scale(
Vector(scale_x, scale_z, 1) # 视场大小
)
newSensor.setWorldTransform(toWorld)
newFilm = pmgr.createObject(scene.getFilm().getProperties())
newFilm.configure()
newSensor.addChild(newFilm)
newSensor.configure()
newScene.addSensor(newSensor)
newScene.setSensor(newSensor)
newScene.setSampler(scene.getSampler())
newScene.setDestinationFile(str(distFile))
job = RenderJob('Simulation Job' + "VA_"+str(azi)+"_VZ_"+str(zeni), newScene, queue, sceneResID)
job.start()
queue.waitLeft(0)
queue.join()
# handle npy
if mode == "spectrum" and (output_format not in ("npy", "NPY")):
for azi in azi_arr:
for zeni in zeni_arr:
distFile = os.path.join(session.get_output_dir(),
seq_header + ("_VA_%.2f" % azi).replace(".", "_") + ("_VZ_%.2f" % zeni).replace(
".", "_"))
data = np.load(distFile + ".npy")
bandlist = cfg["sensor"]["bands"].split(",")
RasterHelper.saveToHdr_no_transform(data, distFile, bandlist, output_format)
os.remove(distFile + ".npy")
def __init__(self, ihp): # ihp is initial hip point
self._thigh_radius = 1.5
self._thigh_length = 8.0
self._knee_radius = 1.5
self._calf_radius = 1.5
self._calf_length = 8.0
self._init_hip_point = ihp # == _init_thigh_start_point
self._init_thigh_end_point = Point(ihp.x, ihp.y-self._thigh_length, ihp.z)
self._init_thigh_toWorld = tf.translate(Vector(ihp.x, ihp.y-(self._thigh_length/2), ihp.z)) * tf.scale(Vector(1, self._thigh_length, 1)) * tf.rotate(Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
self._init_knee_point = Point(ihp.x, ihp.y-(self._thigh_length+self._thigh_radius+self._knee_radius), ihp.z)
self._init_calf_start_point = Point(ihp.x, ihp.y-(self._thigh_length+self._thigh_radius+self._knee_radius*2+self._calf_radius), ihp.z)
self._init_foot_point = Point(ihp.x, ihp.y-(self._thigh_length+self._thigh_radius+self._knee_radius*2+self._calf_radius+self._calf_length), ihp.z) # == _init_calf_end_point
self._init_calf_toWorld = tf.translate(Vector(ihp.x, ihp.y-(self._thigh_length+self._thigh_radius+self._knee_radius*2+self._calf_radius+self._calf_length/2), ihp.z)) * tf.scale(Vector(1, self._calf_length, 1)) * tf.rotate(Vector(1, 0, 0), -90) * tf.translate(Vector(0, 0, -0.5))
# local axes at hip
self._hlocal_axes = {
'x' : Vector(1, 0, 0),
'y' : Vector(0, 1, 0),
'z' : Vector(0, 0, 1)
}
# rotate angle of local axes at hip
self._hlocal_axes_rotate_angle = {
'pitch' : 0,
'yaw' : 0,
'roll' : 0
}
self._hip_pitch = 0
self._hip_yaw = 0
self._hip_roll = 0
self._knee_angle = 0
self.hip_joint_prop = {
'type' : 'sphere',
'center' : self._init_hip_point,
'radius' : self._thigh_radius ,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.thigh_prop = {
'type' : 'cylinder',
'toWorld': self._init_thigh_toWorld,
'radius' : self._thigh_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.thigh_endcap_prop = {
'type' : 'sphere',
'center' : self._init_thigh_end_point,
'radius' : self._thigh_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.knee_joint_prop = {
'type' : 'sphere',
'center' : self._init_knee_point,
'radius' : self._knee_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.1, 0.1, 0.1])
}
}
self.calf_endcap_prop = {
'type' : 'sphere',
'center' : self._init_calf_start_point,
'radius' : self._calf_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.calf_prop = {
'type' : 'cylinder',
'toWorld' : self._init_calf_toWorld,
'radius' : self._calf_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
self.foot_prop = {
'type' : 'sphere',
'center' : self._init_foot_point,
'radius' : self._calf_radius,
'bsdf' : {
'type' : 'ward',
'alphaU' : 0.003,
'alphaV' : 0.003,
'specularReflectance' : Spectrum(0.01),
'diffuseReflectance' : Spectrum([0.05, 0.05, 0.05])
}
}
def _create_xyz_rotation(self, pitch, yaw, roll):
return tf.rotate(self._slocal_axes['x'], pitch) * tf.rotate(self._slocal_axes['y'], yaw) * tf.rotate(self._slocal_axes['z'], roll)
