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