Source code for fury.gltf

# TODO: Materials, Lights
import base64
import copy
import os
from typing import Dict  # noqa

import numpy as np
import pygltflib as gltflib
from PIL import Image
from pygltflib.utils import glb2gltf, gltf2glb

from fury import actor, io, transform, utils
from fury.animation import Animation
from fury.animation.interpolator import (
    linear_interpolator,
    slerp,
    step_interpolator,
    tan_cubic_spline_interpolator,
)
from fury.lib import Camera, Matrix4x4, Texture, Transform, numpy_support

comp_type = {
    5120: {'size': 1, 'dtype': np.byte},
    5121: {'size': 1, 'dtype': np.ubyte},
    5122: {'size': 2, 'dtype': np.short},
    5123: {'size': 2, 'dtype': np.ushort},
    5125: {'size': 4, 'dtype': np.uint},
    5126: {'size': 4, 'dtype': np.float32},
}

acc_type = {'SCALAR': 1, 'VEC2': 2, 'VEC3': 3, 'VEC4': 4, 'MAT4': 16}


[docs] class glTF:
[docs] def __init__(self, filename, apply_normals=False): """Read and generate actors from glTF files. Parameters ---------- filename : str Path of the gltf file apply_normals : bool, optional If `True` applies normals to the mesh. """ if filename in ['', None]: raise IOError('Filename cannot be empty or None!') name, extension = os.path.splitext(filename) if extension == '.glb': fname_gltf = f'{name}.gltf' if not os.path.exists(fname_gltf): glb2gltf(filename) filename = fname_gltf self.gltf = gltflib.GLTF2().load(filename) self.pwd = os.path.dirname(filename) self.apply_normals = apply_normals self.cameras = {} self.materials = [] self.nodes = [] self.transformations = [] self.polydatas = [] self.init_transform = np.identity(4) self.node_transform = [] self.animation_channels = {} self.sampler_matrices = {} # Skinning Information self.bone_tranforms = {} self.keyframe_transforms = [] self.joints_0 = [] self.weights_0 = [] self.bones = [] self.ibms = {} self._vertices = None self._vcopy = None self._bvertices = {} self._bvert_copy = {} self.show_bones = False # morphing inofrmations self.morph_vertices = [] self.morph_weights = [] self.inspect_scene(0) self._actors = [] self._bactors = {}
[docs] def actors(self): """Generate actors from glTF file. Returns ------- actors : list List of vtkActors with texture. """ for i, polydata in enumerate(self.polydatas): actor = utils.get_actor_from_polydata(polydata) transform_mat = self.transformations[i] _transform = Transform() _matrix = Matrix4x4() _matrix.DeepCopy(transform_mat.ravel()) _transform.SetMatrix(_matrix) actor.SetUserTransform(_transform) if self.materials[i] is not None: base_col_tex = self.materials[i]['baseColorTexture'] actor.SetTexture(base_col_tex) base_color = self.materials[i]['baseColor'] actor.GetProperty().SetColor(tuple(base_color[:3])) self._actors.append(actor) return self._actors
[docs] def inspect_scene(self, scene_id=0): """Loop over nodes in a scene. Parameters ---------- scene_id : int, optional scene index of the glTF. """ scene = self.gltf.scenes[scene_id] nodes = scene.nodes for node_id in nodes: self.transverse_node(node_id, self.init_transform) for i, animation in enumerate(self.gltf.animations): self.transverse_channels(animation, i)
[docs] def transverse_node(self, nextnode_id, matrix, parent=None, is_joint=False): """Load mesh and generates transformation matrix. Parameters ---------- nextnode_id : int Index of the node matrix : ndarray (4, 4) Transformation matrix parent : list, optional List of indices of parent nodes Default: None. is_joint : Bool To determine if the current node is a joint/bone of skins. Default: False """ node = self.gltf.nodes[nextnode_id] if parent is None: parent = [nextnode_id] else: parent.append(nextnode_id) matnode = np.identity(4) if node.matrix is not None: matnode = np.array(node.matrix) matnode = matnode.reshape(-1, 4).T else: if node.translation is not None: trans = node.translation translate = transform.translate(trans) matnode = np.dot(matnode, translate) if node.rotation is not None: rot = node.rotation rotate = transform.rotate(rot) matnode = np.dot(matnode, rotate) if node.scale is not None: scales = node.scale scale = transform.scale(scales) matnode = np.dot(matnode, scale) next_matrix = np.dot(matrix, matnode) if node.skin is not None: if ( nextnode_id in self.gltf.skins[0].joints and nextnode_id not in self.bone_tranforms ): self.bone_tranforms[nextnode_id] = next_matrix[:] if is_joint: if not (nextnode_id in self.bone_tranforms): self.bone_tranforms[nextnode_id] = next_matrix[:] if node.mesh is not None: mesh_id = node.mesh self.load_mesh(mesh_id, next_matrix, parent) if node.skin is not None: skin_id = node.skin joints, ibms = self.get_skin_data(skin_id) for bone, ibm in zip(joints, ibms): self.bones.append(bone) self.ibms[bone] = ibm self.transverse_node(joints[0], np.identity(4), parent, is_joint=True) if node.camera is not None: camera_id = node.camera self.load_camera(camera_id, next_matrix) if node.children: for child_id in node.children: self.transverse_node(child_id, next_matrix, parent, is_joint)
[docs] def load_mesh(self, mesh_id, transform_mat, parent): """Load the mesh data from accessor and applies the transformation. Parameters ---------- mesh_id : int Mesh index to be loaded transform_mat : ndarray (4, 4) Transformation matrix. """ primitives = self.gltf.meshes[mesh_id].primitives for primitive in primitives: attributes = primitive.attributes vertices = self.get_acc_data(attributes.POSITION) self.transformations.append(transform_mat) polydata = utils.PolyData() utils.set_polydata_vertices(polydata, vertices) if attributes.NORMAL is not None and self.apply_normals: normals = self.get_acc_data(attributes.NORMAL) normals = transform.apply_transformation(normals, transform_mat) utils.set_polydata_normals(polydata, normals) if attributes.TEXCOORD_0 is not None: tcoords = self.get_acc_data(attributes.TEXCOORD_0) utils.set_polydata_tcoords(polydata, tcoords) if attributes.COLOR_0 is not None: color = self.get_acc_data(attributes.COLOR_0) color = color[:, :-1] * 255 utils.set_polydata_colors(polydata, color) if primitive.indices is not None: indices = self.get_acc_data(primitive.indices).reshape(-1, 3) else: indices = np.arange(0, len(vertices)).reshape((-1, 3)) utils.set_polydata_triangles(polydata, indices) if attributes.JOINTS_0 is not None: vertex_joints = self.get_acc_data(attributes.JOINTS_0) self.joints_0.append(vertex_joints) vertex_weight = self.get_acc_data(attributes.WEIGHTS_0) self.weights_0.append(vertex_weight) material = None if primitive.material is not None: material = self.get_materials(primitive.material) self.polydatas.append(polydata) self.nodes.append(parent[:]) self.materials.append(material) if primitive.targets is not None: prim_morphdata = [] for target in primitive.targets: prim_morphdata.append(self.get_morph_data(target, mesh_id)) self.morph_vertices.append(prim_morphdata)
[docs] def get_acc_data(self, acc_id): """Get the correct data from buffer using accessors and bufferviews. Parameters ---------- acc_id : int Accessor index Returns ------- buffer_array : ndarray Numpy array extracted from the buffer. """ accessor = self.gltf.accessors[acc_id] buffview_id = accessor.bufferView acc_byte_offset = accessor.byteOffset count = accessor.count d_type = comp_type.get(accessor.componentType) d_size = d_type['size'] a_type = acc_type.get(accessor.type) buffview = self.gltf.bufferViews[buffview_id] buff_id = buffview.buffer byte_offset = buffview.byteOffset byte_stride = buffview.byteStride byte_stride = byte_stride if byte_stride else (a_type * d_size) byte_length = count * byte_stride total_byte_offset = byte_offset + acc_byte_offset buff_array = self.get_buff_array( buff_id, d_type['dtype'], byte_length, total_byte_offset, byte_stride ) return buff_array[:, :a_type]
[docs] def get_buff_array(self, buff_id, d_type, byte_length, byte_offset, byte_stride): """Extract the mesh data from buffer. Parameters ---------- buff_id : int Buffer Index d_type : type Element data type byte_length : int The length of the buffer data byte_offset : int The offset into the buffer in bytes byte_stride : int The stride, in bytes Returns ------- out_arr : ndarray Numpy array of size byte_length from buffer. """ buffer = self.gltf.buffers[buff_id] uri = buffer.uri if d_type == np.short or d_type == np.ushort or d_type == np.uint16: byte_length = int(byte_length / 2) byte_stride = int(byte_stride / 2) elif d_type == np.float32: byte_length = int(byte_length / 4) byte_stride = int(byte_stride / 4) try: if uri.startswith('data:application/octet-stream;base64') or uri.startswith( 'data:application/gltf-buffer;base64' ): buff_data = uri.split(',')[1] buff_data = base64.b64decode(buff_data) elif uri.endswith('.bin'): with open(os.path.join(self.pwd, uri), 'rb') as f: buff_data = f.read(-1) out_arr = np.frombuffer( buff_data, dtype=d_type, count=byte_length, offset=byte_offset ) out_arr = out_arr.reshape(-1, byte_stride) return out_arr except IOError: print('Failed to read ! Error in opening file:')
[docs] def get_materials(self, mat_id): """Get the material data. Parameters ---------- mat_id : int Material index Returns ------- materials : dict Dictionary of all textures. """ material = self.gltf.materials[mat_id] bct = None pbr = material.pbrMetallicRoughness if pbr.baseColorTexture is not None: bct = pbr.baseColorTexture.index bct = self.get_texture(bct) colors = pbr.baseColorFactor return {'baseColorTexture': bct, 'baseColor': colors}
[docs] def get_texture(self, tex_id): """Read and convert image into vtk texture. Parameters ---------- tex_id : int Texture index Returns ------- atexture : Texture Returns flipped vtk texture from image. """ texture = self.gltf.textures[tex_id].source image = self.gltf.images[texture] file = image.uri bv_index = image.bufferView if file is None: mimetype = image.mimeType if file is not None and file.startswith('data:image'): buff_data = file.split(',')[1] buff_data = base64.b64decode(buff_data) extension = '.png' if file.startswith('data:image/png') else '.jpg' image_path = os.path.join(self.pwd, str('b64texture' + extension)) with open(image_path, 'wb') as image_file: image_file.write(buff_data) elif bv_index is not None: bv = self.gltf.bufferViews[bv_index] buffer = bv.buffer bo = bv.byteOffset bl = bv.byteLength uri = self.gltf.buffers[buffer].uri with open(os.path.join(self.pwd, uri), 'rb') as f: f.seek(bo) img_binary = f.read(bl) extension = '.png' if mimetype == 'images/png' else '.jpg' image_path = os.path.join(self.pwd, str('bvtexture' + extension)) with open(image_path, 'wb') as image_file: image_file.write(img_binary) else: image_path = os.path.join(self.pwd, file) rgb = io.load_image(image_path) grid = utils.rgb_to_vtk(np.flipud(rgb)) atexture = Texture() atexture.InterpolateOn() atexture.EdgeClampOn() atexture.SetInputDataObject(grid) return atexture
[docs] def load_camera(self, camera_id, transform_mat): """Load the camera data of a node. Parameters ---------- camera_id : int Camera index of a node. transform_mat : ndarray (4, 4) Transformation matrix of the camera. """ camera = self.gltf.cameras[camera_id] vtk_cam = Camera() position = vtk_cam.GetPosition() position = np.asarray([position]) new_position = transform.apply_transformation(position, transform_mat) vtk_cam.SetPosition(tuple(new_position[0])) if camera.type == 'orthographic': orthographic = camera.orthographic vtk_cam.ParallelProjectionOn() zfar = orthographic.zfar znear = orthographic.znear vtk_cam.SetClippingRange(znear, zfar) else: perspective = camera.perspective vtk_cam.ParallelProjectionOff() zfar = perspective.zfar if perspective.zfar else 1000.0 znear = perspective.znear vtk_cam.SetClippingRange(znear, zfar) angle = perspective.yfov * 180 / np.pi if perspective.yfov else 30.0 vtk_cam.SetViewAngle(angle) if perspective.aspectRatio: vtk_cam.SetExplicitAspectRatio(perspective.aspectRatio) self.cameras[camera_id] = vtk_cam
[docs] def transverse_channels(self, animation: gltflib.Animation, count: int): """Loop over animation channels and sets animation data. Parameters ---------- animation : glTflib.Animation pygltflib animation object. count : int Animation count. """ name = animation.name if name is None: name = str(f'anim_{count}') anim_channel = dict() # type: Dict[int, np.ndarray] for channel in animation.channels: sampler = animation.samplers[channel.sampler] node_id = channel.target.node path = channel.target.path anim_data = self.get_sampler_data(sampler, node_id, path) self.node_transform.append(anim_data) sampler_data = self.get_matrix_from_sampler( path, node_id, anim_channel, sampler ) anim_channel[node_id] = sampler_data self.animation_channels[name] = anim_channel
[docs] def get_sampler_data(self, sampler: gltflib.Sampler, node_id: int, transform_type): """Get the animation and transformation data from sampler. Parameters ---------- sampler : glTFlib.Sampler pygltflib sampler object. node_id : int Node index of the current animation channel. transform_type : str Property of the node to be transformed. Returns ------- sampler_data : dict dictionary of data containing timestamps, node transformations and interpolation type. """ time_array = self.get_acc_data(sampler.input) transform_array = self.get_acc_data(sampler.output) interpolation = sampler.interpolation return { 'node': node_id, 'input': time_array, 'output': transform_array, 'interpolation': interpolation, 'property': transform_type, }
[docs] def get_matrix_from_sampler( self, prop, node, anim_channel, sampler: gltflib.Sampler ): """Return transformation matrix for a given timestamp from Sampler data. Combine matrices for a given common timestamp. Parameters ---------- prop : str Property of the array ('translation', 'rotation' or 'scale') node : int Node index of the sampler data. anim_channel : dict Containing previous animations with node as keys. sampler : gltflib.Sampler Sampler object for an animation channel. """ time_array = self.get_acc_data(sampler.input) tran_array = self.get_acc_data(sampler.output) if prop == 'weights': tran_array = tran_array.reshape( -1, ) tran_matrix = [] if node in anim_channel: prev_arr = anim_channel[node]['matrix'] else: prev_arr = [np.identity(4) for i in range(len(tran_array))] for i, arr in enumerate(tran_array): temp = self.generate_tmatrix(arr, prop) if temp.shape == (4, 4): tran_matrix.append(np.dot(prev_arr[i], temp)) else: tran_matrix.append(temp) data = {'timestamps': time_array, 'matrix': tran_matrix} self.sampler_matrices[node] = data return data
[docs] def get_morph_data(self, target, mesh_id): weights_array = self.gltf.meshes[mesh_id].weights if target.get('POSITION') is not None: morphed_data = self.get_acc_data(target.get('POSITION')) self.morph_weights.append(weights_array) return morphed_data
[docs] def get_skin_data(self, skin_id): """Get the inverse bind matrix for each bone in the skin. Parameters ---------- skin_id : int Index of the skin. Returns ------- joint_nodes : list List of bones in the skin. inv_bind_matrix : ndarray Numpy array containing inverse bind pose for each bone. """ skin = self.gltf.skins[skin_id] inv_bind_matrix = self.get_acc_data(skin.inverseBindMatrices) inv_bind_matrix = inv_bind_matrix.reshape((-1, 4, 4)) joint_nodes = skin.joints return joint_nodes, inv_bind_matrix
[docs] def generate_tmatrix(self, transf, prop): """Create transformation matrix from TRS array. Parameters ---------- transf : ndarray Array containing translation, rotation or scale values. prop : str String that defines the type of array (values: translation, rotation or scale). Returns ------- matrix : ndarray (4, 4) ransformation matrix of shape (4, 4) with respective transforms. """ if prop == 'translation': matrix = transform.translate(transf) elif prop == 'rotation': matrix = transform.rotate(transf) elif prop == 'scale': matrix = transform.scale(transf) else: matrix = transf return matrix
[docs] def transverse_animations( self, animation, bone_id, timestamp, joint_matrices, parent_bone_deform=np.identity(4), ): """Calculate skinning matrix (Joint Matrices) and transform bone for each animation. Parameters ---------- animation : Animation Animation object. bone_id : int Bone index of the current transform. timestamp : float Current timestamp of the animation. joint_matrices : dict Empty dictionary that will contain joint matrices. parent_bone_transform : ndarray (4, 4) Transformation matrix of the parent bone. (default=np.identity(4)) """ deform = animation.get_value('transform', timestamp) new_deform = np.dot(parent_bone_deform, deform) ibm = self.ibms[bone_id].T skin_matrix = np.dot(new_deform, ibm) joint_matrices[bone_id] = skin_matrix node = self.gltf.nodes[bone_id] if self.show_bones: actor_transform = self.transformations[0] bone_transform = np.dot(actor_transform, new_deform) self._bvertices[bone_id][:] = transform.apply_transformation( self._bvert_copy[bone_id], bone_transform ) utils.update_actor(self._bactors[bone_id]) if node.children: c_animations = animation.child_animations c_bones = node.children for c_anim, c_bone in zip(c_animations, c_bones): self.transverse_animations( c_anim, c_bone, timestamp, joint_matrices, new_deform )
[docs] def update_skin(self, animation): """Update the animation and actors with skinning data. Parameters ---------- animation : Animation Animation object. """ animation.update_animation() timestamp = animation.current_timestamp joint_matrices = {} root_bone = self.gltf.skins[0].skeleton root_bone = root_bone if root_bone else self.bones[0] if not root_bone == self.bones[0]: _animation = animation.child_animations[0] parent_transform = self.transformations[root_bone].T else: _animation = animation parent_transform = np.identity(4) for child in _animation.child_animations: self.transverse_animations( child, self.bones[0], timestamp, joint_matrices, parent_transform ) for i, vertex in enumerate(self._vertices): vertex[:] = self.apply_skin_matrix(self._vcopy[i], joint_matrices, i) actor_transf = self.transformations[i] vertex[:] = transform.apply_transformation(vertex, actor_transf) utils.update_actor(self._actors[i]) utils.compute_bounds(self._actors[i])
[docs] def initialize_skin(self, animation, bones=False, length=0.2): """Create bones and add to the animation and initialise `update_skin` Parameters ---------- animation : Animation Skin animation object. bones : bool Switches the visibility of bones in scene. (default=False) length : float Length of the bones. (default=0.2) """ self.show_bones = bones if bones: self.get_joint_actors(length, False) animation.add_actor(list(self._bactors.values())) self.update_skin(animation)
[docs] def apply_skin_matrix(self, vertices, joint_matrices, actor_index=0): """Apply the skinnig matrix, that transform the vertices. Parameters ---------- vertices : ndarray Vertices of an actor. join_matrices : list List of skinning matrix to calculate the weighted transformation. Returns ------- vertices : ndarray Modified vertices. """ clone = np.copy(vertices) weights = self.weights_0[actor_index] joints = self.joints_0[actor_index] for i, xyz in enumerate(clone): a_joint = joints[i] a_joint = [self.bones[i] for i in a_joint] a_weight = weights[i] skin_mat = ( np.multiply(a_weight[0], joint_matrices[a_joint[0]]) + np.multiply(a_weight[1], joint_matrices[a_joint[1]]) + np.multiply(a_weight[2], joint_matrices[a_joint[2]]) + np.multiply(a_weight[3], joint_matrices[a_joint[3]]) ) xyz = np.dot(skin_mat, np.append(xyz, [1.0])) clone[i] = xyz[:3] return clone
[docs] def transverse_bones(self, bone_id, channel_name, parent_animation: Animation): """Loop over the bones and add child bone animation to their parent animation. Parameters ---------- bone_id : int Index of the bone. channel_name : str Animation name. parent_animation : Animation The animation of the parent bone. Should be `root_animation` by default. """ node = self.gltf.nodes[bone_id] animation = Animation() if bone_id in self.bone_tranforms.keys(): orig_transform = self.bone_tranforms[bone_id] else: orig_transform = np.identity(4) if bone_id in self.animation_channels[channel_name]: transforms = self.animation_channels[channel_name][bone_id] timestamps = transforms['timestamps'] metrices = transforms['matrix'] for time, matrix in zip(timestamps, metrices): animation.set_keyframe('transform', time[0], matrix) else: animation.set_keyframe('transform', 0.0, orig_transform) parent_animation.add(animation) if node.children: for child_bone in node.children: self.transverse_bones(child_bone, channel_name, animation)
[docs] def skin_animation(self): """One animation for each bone, contains parent transforms. Returns ------- root_animations : Dict An animation containing all the child animations for bones. """ root_animations = {} self._vertices = [utils.vertices_from_actor(act) for act in self.actors()] self._vcopy = [np.copy(vert) for vert in self._vertices] for name in self.animation_channels.keys(): root_animation = Animation() root_bone = self.gltf.skins[0].skeleton root_bone = root_bone if root_bone else self.bones[0] self.transverse_bones(root_bone, name, root_animation) root_animations[name] = root_animation root_animation.add_actor(self._actors) return root_animations
[docs] def get_joint_actors(self, length=0.5, with_transforms=False): """Create an arrow actor for each bone in a skinned model. Parameters ---------- length : float (default = 0.5) Length of the arrow actor with_transforms : bool (default = False) Applies respective transformations to bone. Bones will be at origin if set to `False`. """ origin = np.zeros((3, 3)) parent_transforms = self.bone_tranforms for bone in self.bones: arrow = actor.arrow(origin, [0, 1, 0], [1, 1, 1], scales=length) verts = utils.vertices_from_actor(arrow) if with_transforms: verts[:] = transform.apply_transformation( verts, parent_transforms[bone] ) utils.update_actor(arrow) self._bactors[bone] = arrow self._bvertices[bone] = verts self._bvert_copy = copy.deepcopy(self._bvertices)
[docs] def update_morph(self, animation): """Update the animation and actors with morphing. Parameters ---------- animation : Animation Animation object. """ animation.update_animation() timestamp = animation.current_timestamp for i, vertex in enumerate(self._vertices): weights = animation.child_animations[0].get_value('morph', timestamp) vertex[:] = self.apply_morph_vertices(self._vcopy[i], weights, i) vertex[:] = transform.apply_transformation(vertex, self.transformations[i]) utils.update_actor(self._actors[i]) utils.compute_bounds(self._actors[i])
[docs] def apply_morph_vertices(self, vertices, weights, cnt): """Calculate weighted vertex from the morph data. Parameters ---------- vertices : ndarray Vertices of a actor. weights : ndarray Morphing weights used to calculate the weighted average of new vertex. cnt : int Count of the actor. """ clone = np.copy(vertices) target_vertices = np.copy(self.morph_vertices[cnt]) for i, weight in enumerate(weights): target_vertices[i][:] = np.multiply(weight, target_vertices[i]) new_verts = sum(target_vertices) for i, vertex in enumerate(clone): clone[i][:] = vertex + new_verts[i] return clone
[docs] def morph_animation(self): """Create animation for each channel in animations. Returns ------- root_animations : Dict A dictionary containing animations as values and animation name as keys. """ animations = {} self._vertices = [utils.vertices_from_actor(act) for act in self.actors()] self._vcopy = [np.copy(vert) for vert in self._vertices] for name, data in self.animation_channels.items(): root_animation = Animation() for i, transforms in enumerate(data.values()): weights = self.morph_weights[i] animation = Animation() timestamps = transforms['timestamps'] metrices = transforms['matrix'] metrices = np.array(metrices).reshape(-1, len(weights)) for time, weights in zip(timestamps, metrices): animation.set_keyframe('morph', time[0], weights) root_animation.add(animation) root_animation.add_actor(self._actors) animations[name] = root_animation return animations
[docs] def get_animations(self): """Return list of animations. Returns ------- animations: List List of animations containing actors. """ actors = self.actors() interpolators = { 'LINEAR': linear_interpolator, 'STEP': step_interpolator, 'CUBICSPLINE': tan_cubic_spline_interpolator, } rotation_interpolators = { 'LINEAR': slerp, 'STEP': step_interpolator, 'CUBICSPLINE': tan_cubic_spline_interpolator, } animations = [] for transforms in self.node_transform: target_node = transforms['node'] for i, nodes in enumerate(self.nodes): animation = Animation() transform_mat = self.transformations[i] position, rot, scale = transform.transform_from_matrix(transform_mat) animation.set_keyframe('position', 0.0, position) if target_node in nodes: animation.add_actor(actors[i]) timestamp = transforms['input'] node_transform = transforms['output'] prop = transforms['property'] interpolation_type = transforms['interpolation'] interpolator = interpolators.get(interpolation_type) rot_interp = rotation_interpolators.get(interpolation_type) timeshape = timestamp.shape transhape = node_transform.shape if transforms['interpolation'] == 'CUBICSPLINE': node_transform = node_transform.reshape( (timeshape[0], -1, transhape[1]) ) for time, trs in zip(timestamp, node_transform): in_tan, out_tan = None, None if trs.ndim == 2: cubicspline = trs in_tan = cubicspline[0] trs = cubicspline[1] out_tan = cubicspline[2] if prop == 'rotation': animation.set_rotation( time[0], trs, in_tangent=in_tan, out_tangent=out_tan ) animation.set_rotation_interpolator(rot_interp) if prop == 'translation': animation.set_position( time[0], trs, in_tangent=in_tan, out_tangent=out_tan ) animation.set_position_interpolator(interpolator) if prop == 'scale': animation.set_scale( time[0], trs, in_tangent=in_tan, out_tangent=out_tan ) animation.set_scale_interpolator(interpolator) else: animation.add_static_actor(actors[i]) animations.append(animation) return animations
[docs] def main_animation(self): """Return main animation with all glTF animations. Returns ------- main_animation : Animation A parent animation containing all child animations for simple animation. """ main_animation = Animation() animations = self.get_animations() for animation in animations: main_animation.add(animation) return main_animation
[docs] def export_scene(scene, filename='default.gltf'): """Generate gltf from FURY scene. Parameters ---------- scene: Scene FURY scene object. filename: str, optional Name of the model to be saved """ gltf_obj = gltflib.GLTF2() name, extension = os.path.splitext(filename) if extension not in ['.gltf', '.glb']: raise IOError('Filename should be .gltf or .glb') buffer_file = open(f'{name}.bin', 'wb') primitives = [] buffer_size = 0 bview_count = 0 for act in scene.GetActors(): prim, size, count = _connect_primitives( gltf_obj, act, buffer_file, buffer_size, bview_count, name ) primitives.append(prim) buffer_size = size bview_count = count buffer_file.close() write_mesh(gltf_obj, primitives) write_buffer(gltf_obj, size, f'{name}.bin') camera = scene.camera() cam_id = None if camera: write_camera(gltf_obj, camera) cam_id = 0 write_node(gltf_obj, mesh_id=0, camera_id=cam_id) write_scene(gltf_obj, [0]) gltf_obj.save(f'{name}.gltf') if extension == '.glb': gltf2glb(f'{name}.gltf', destination=filename)
def _connect_primitives(gltf, actor, buff_file, byteoffset, count, name): """Create Accessor, BufferViews and writes primitive data to a binary file Parameters ---------- gltf: Pygltflib.GLTF2 actor: Actor the fury actor buff_file: file filename.bin opened in `wb` mode byteoffset: int offset of the bufferview count: int BufferView count name: str Prefix of the gltf filename Returns ------- prim: Pygltflib.Primitive byteoffset: int Offset size of a primitive count: int BufferView count after adding the primitive. """ polydata = actor.GetMapper().GetInput() colors = utils.colors_from_actor(actor) if colors is not None: polydata = utils.set_polydata_colors(polydata, colors) vertices = utils.get_polydata_vertices(polydata) colors = utils.get_polydata_colors(polydata) normals = utils.get_polydata_normals(polydata) tcoords = utils.get_polydata_tcoord(polydata) try: indices = utils.get_polydata_triangles(polydata) except AssertionError as error: indices = None print(error) ispoints = polydata.GetNumberOfVerts() islines = polydata.GetNumberOfLines() istraingles = polydata.GetNumberOfPolys() if ispoints: mode = 0 elif islines: mode = 3 elif istraingles: mode = 4 vertex, index, normal, tcoord, color = (None, None, None, None, None) if indices is not None and len(indices) != 0: indices = indices.reshape((-1,)) amax = [np.max(indices)] amin = [np.min(indices)] ctype = comp_type.get(gltflib.UNSIGNED_SHORT) atype = acc_type.get(gltflib.SCALAR) indices = indices.astype(np.ushort) blength = len(indices) * ctype['size'] buff_file.write(indices.tobytes()) write_bufferview(gltf, 0, byteoffset, blength) write_accessor( gltf, count, 0, gltflib.UNSIGNED_SHORT, len(indices), gltflib.SCALAR ) byteoffset += blength index = count count += 1 if vertices is not None: amax = np.max(vertices, 0).tolist() amin = np.min(vertices, 0).tolist() ctype = comp_type.get(gltflib.FLOAT) atype = acc_type.get(gltflib.VEC3) vertices = vertices.reshape((-1,)).astype(ctype['dtype']) blength = len(vertices) * ctype['size'] buff_file.write(vertices.tobytes()) write_bufferview(gltf, 0, byteoffset, blength) write_accessor( gltf, count, 0, gltflib.FLOAT, len(vertices) // atype, gltflib.VEC3, amax, amin, ) byteoffset += blength vertex = count count += 1 if normals is not None: amax = np.max(normals, 0).tolist() amin = np.min(normals, 0).tolist() ctype = comp_type.get(gltflib.FLOAT) atype = acc_type.get(gltflib.VEC3) normals = normals.reshape((-1,)) blength = len(normals) * ctype['size'] buff_file.write(normals.tobytes()) write_bufferview(gltf, 0, byteoffset, blength) write_accessor( gltf, count, 0, gltflib.FLOAT, len(normals) // atype, gltflib.VEC3, amax, amin, ) byteoffset += blength normal = count count += 1 if tcoords is not None: amax = np.max(tcoords, 0).tolist() amin = np.min(tcoords, 0).tolist() ctype = comp_type.get(gltflib.FLOAT) atype = acc_type.get(gltflib.VEC2) tcoords = tcoords.reshape((-1,)).astype(ctype['dtype']) blength = len(tcoords) * ctype['size'] buff_file.write(tcoords.tobytes()) write_bufferview(gltf, 0, byteoffset, blength) write_accessor( gltf, count, 0, gltflib.FLOAT, len(tcoords) // atype, gltflib.VEC2 ) byteoffset += blength tcoord = count count += 1 vtk_image = actor.GetTexture().GetInput() rows, cols, _ = vtk_image.GetDimensions() scalars = vtk_image.GetPointData().GetScalars() np_im = numpy_support.vtk_to_numpy(scalars) np_im = np.reshape(np_im, (rows, cols, -1)) img = Image.fromarray(np_im) image_path = f'{name}BaseColorTexture.png' img.save(image_path) write_material(gltf, 0, image_path) if colors is not None: ctype = comp_type.get(gltflib.FLOAT) atype = acc_type.get(gltflib.VEC3) shape = colors.shape[0] colors = np.concatenate((colors, np.full((shape, 1), 255.0)), axis=1) colors = colors / 255 colors = colors.reshape((-1,)).astype(ctype['dtype']) blength = len(colors) * ctype['size'] buff_file.write(colors.tobytes()) write_bufferview(gltf, 0, byteoffset, blength) write_accessor(gltf, count, 0, gltflib.FLOAT, shape, gltflib.VEC4) byteoffset += blength color = count count += 1 material = None if tcoords is None else 0 prim = get_prim(vertex, index, color, tcoord, normal, material, mode) return prim, byteoffset, count
[docs] def write_scene(gltf, nodes): """Create scene Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object nodes: list List of node indices. """ scene = gltflib.Scene() scene.nodes = nodes gltf.scenes.append(scene)
[docs] def write_node(gltf, mesh_id=None, camera_id=None): """Create node Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object mesh_id: int, optional Mesh index camera_id: int, optional Camera index. """ node = gltflib.Node() if mesh_id is not None: node.mesh = mesh_id if camera_id is not None: node.camera = camera_id gltf.nodes.append(node)
[docs] def write_mesh(gltf, primitives): """Create mesh and add primitive. Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object. primitives: list List of Primitive object. """ mesh = gltflib.Mesh() for prim in primitives: mesh.primitives.append(prim) gltf.meshes.append(mesh)
[docs] def write_camera(gltf, camera): """Create and add camera. Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object. camera: vtkCamera scene camera. """ orthographic = camera.GetParallelProjection() cam = gltflib.Camera() if orthographic: cam.type = 'orthographic' else: clip_range = camera.GetClippingRange() angle = camera.GetViewAngle() ratio = camera.GetExplicitAspectRatio() aspect_ratio = ratio if ratio else 1.0 pers = gltflib.Perspective() pers.aspectRatio = aspect_ratio pers.znear, pers.zfar = clip_range pers.yfov = angle * np.pi / 180 cam.type = 'perspective' cam.perspective = pers gltf.cameras.append(cam)
[docs] def get_prim(vertex, index, color, tcoord, normal, material, mode=4): """Return a Primitive object. Parameters ---------- vertex: int Accessor index for the vertices data. index: int Accessor index for the triangles data. color: int Accessor index for the colors data. tcoord: int Accessor index for the texture coordinates data. normal: int Accessor index for the normals data. material: int Materials index. mode: int, optional The topology type of primitives to render. Default: 4 Returns ------- prim: Primitive pygltflib primitive object. """ prim = gltflib.Primitive() attr = gltflib.Attributes() attr.POSITION = vertex attr.NORMAL = normal attr.TEXCOORD_0 = tcoord attr.COLOR_0 = color prim.attributes = attr prim.indices = index if material is not None: prim.material = material prim.mode = mode return prim
[docs] def write_material(gltf, basecolortexture: int, uri: str): """Write Material, Images and Textures Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object. basecolortexture: int BaseColorTexture index. uri: str BaseColorTexture uri. """ material = gltflib.Material() texture = gltflib.Texture() image = gltflib.Image() pbr = gltflib.PbrMetallicRoughness() tinfo = gltflib.TextureInfo() tinfo.index = basecolortexture pbr.baseColorTexture = tinfo pbr.metallicFactor = 0.0 material.pbrMetallicRoughness = pbr texture.source = basecolortexture image.uri = uri gltf.materials.append(material) gltf.textures.append(texture) gltf.images.append(image)
[docs] def write_accessor( gltf, bufferview, byte_offset, comp_type, count, accssor_type, max=None, min=None ): """Write accessor in the gltf. Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 objecomp_type bufferview: int BufferView Index byte_offset: int ByteOffset of the accessor comp_type: type Type of a single component count: int Elements count of the accessor accssor_type: type Type of the accessor(SCALAR, VEC2, VEC3, VEC4) max: ndarray, optional Maximum elements of an array min: ndarray, optional Minimum elements of an array """ accessor = gltflib.Accessor() accessor.bufferView = bufferview accessor.byteOffset = byte_offset accessor.componentType = comp_type accessor.count = count accessor.type = accssor_type if (max is not None) and (min is not None): accessor.max = max accessor.min = min gltf.accessors.append(accessor)
[docs] def write_bufferview(gltf, buffer, byte_offset, byte_length, byte_stride=None): """Write bufferview in the gltf. Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object buffer: int Buffer index byte_offset: int Byte offset of the bufferview byte_length: int Byte length ie, Length of the data we want to get from the buffer byte_stride: int, optional Byte stride of the bufferview. """ buffer_view = gltflib.BufferView() buffer_view.buffer = buffer buffer_view.byteOffset = byte_offset buffer_view.byteLength = byte_length buffer_view.byteStride = byte_stride gltf.bufferViews.append(buffer_view)
[docs] def write_buffer(gltf, byte_length, uri): """Write buffer int the gltf Parameters ---------- gltf: GLTF2 Pygltflib GLTF2 object byte_length: int Length of the buffer uri: str Path to the external `.bin` file. """ buffer = gltflib.Buffer() buffer.uri = uri buffer.byteLength = byte_length gltf.buffers.append(buffer)