def getTransform(scene, obj, matrix, xml_format='matrix'):
ws = get_worldscale(scene)
mat = matrix.transposed() * ws
xform = {
'pos': [str(co) for co in mat.row[3][0:3]],
}
if xml_format=='quat':
rmq = mat.to_quaternion()
xform['rotation_quaternion'] = {
'axis': list(rmq.axis),
'angle': [-rmq.angle]
}
elif xml_format=='matrix':
# convert the matrix to list of strings
rmr = []
for row in mat.col:
rmr.extend(row[0:3])
xform['rotation'] = { 'matrix': rmr }
return xform
'''#------------------------------------------------------------------------------
def build_xml_element(self, scene, matrix_list):
xml = self.Element('camera')
xml_format = {
'aperture_radius': [aperture_radius(scene, self)],
'sensor_width': [scene.camera.data.sensor_width / 1000.0],
'lens_sensor_dist': [lens_sensor_dist(scene, self)],
'aspect_ratio': [aspect_ratio(scene, self)],
'exposure_duration': 'exposure',
}
if self.whitebalance == 'Custom':
xml_format['white_point'] = {
'chromaticity_coordinates': {
'x': [self.whitebalanceX],
'y': [self.whitebalanceY],
}
}
else:
xml_format['white_balance'] = 'whitebalance',
ws = get_worldscale(scene)
if(scene.camera.data.type == 'ORTHO'):
xml_format['camera_type'] = ['orthographic']
xml_format['sensor_width'] = [scene.camera.data.ortho_scale * ws] # Blender seems to use 'ortho_scale' for the sensor width.
mat = matrix_list[0][1].transposed()
xml_format['pos'] = [ i*ws for i in mat[3][0:3]]
xml_format['forwards'] = [-i*ws for i in mat[2][0:3]]
xml_format['up'] = [ i*ws for i in mat[1][0:3]]
if len(matrix_list) > 1:
# Remove pos, conflicts with keyframes.
del(xml_format['pos'])
keyframes = exportutil.matrixListToKeyframes(scene, scene.camera, matrix_list)
xml_format['keyframe'] = tuple(keyframes)
if self.autofocus:
xml_format['autofocus'] = '' # is empty element
xml_format['focus_distance'] = [10.0] # any non-zero value will do
else:
if scene.camera.data.dof_object is not None:
xml_format['focus_distance'] = [((scene.camera.location - scene.camera.data.dof_object.location).length*ws)]
elif scene.camera.data.dof_distance > 0:
xml_format['focus_distance'] = [scene.camera.data.dof_distance*ws]
else: #autofocus
xml_format['autofocus'] = '' # is empty element
xml_format['focus_distance'] = [10.0] # any non-zero value will do
if self.ad:
xml_format.update({
'aperture_shape': {}
})
if self.ad_obstacle != '':
ad_obstacle = efutil.filesystem_path(self.ad_obstacle)
if os.path.exists(ad_obstacle):
xml_format.update({
'obstacle_map': {
'path': [efutil.path_relative_to_export(ad_obstacle)]
}
})
else:
indigo_log('WARNING: Camera Obstacle Map specified, but image path is not valid')
if self.ad_type == 'image':
ad_image = efutil.filesystem_path(self.ad_image)
if os.path.exists(ad_image):
xml_format['aperture_shape'].update({
'image': {
'path': [efutil.path_relative_to_export(ad_image)]
}
})
else:
indigo_log('WARNING: Camera Aperture Diffraction type "Image" selected, but image path is not valid')
elif self.ad_type == 'generated':
xml_format['aperture_shape'].update({
'generated': {
'num_blades': [self.ad_blades],
'start_angle': [self.ad_angle],
'blade_offset': [self.ad_offset],
'blade_curvature_radius': [self.ad_curvature]
}
})
elif self.ad_type == 'circular':
xml_format['aperture_shape'][self.ad_type] = {}
aspect = aspect_ratio(scene, self)
if scene.camera.data.shift_x != 0:
sx = scene.camera.data.shift_x * 0.001*scene.camera.data.sensor_width
if aspect < 1.0:
sx /= aspect
xml_format['lens_shift_right_distance'] = [sx]
if scene.camera.data.shift_y != 0:
sy = scene.camera.data.shift_y * 0.001*scene.camera.data.sensor_width
if aspect < 1.0:
sy /= aspect
xml_format['lens_shift_up_distance'] = [sy]
self.build_subelements(scene, xml_format, xml)
return xml