pyrender-maintained 1.0.0__py3-none-any.whl

pyrender/mesh.py

@@ -0,0 +1,328 @@
+"""Meshes, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-mesh
+
+Author: Matthew Matl
+"""
+import copy
+
+import numpy as np
+import trimesh
+
+from .primitive import Primitive
+from .constants import GLTF
+from .material import MetallicRoughnessMaterial
+
+
+class Mesh(object):
+    """A set of primitives to be rendered.
+
+    Parameters
+    ----------
+    name : str
+        The user-defined name of this object.
+    primitives : list of :class:`Primitive`
+        The primitives associated with this mesh.
+    weights : (k,) float
+        Array of weights to be applied to the Morph Targets.
+    is_visible : bool
+        If False, the mesh will not be rendered.
+    """
+
+    def __init__(self, primitives, name=None, weights=None, is_visible=True):
+        self.primitives = primitives
+        self.name = name
+        self.weights = weights
+        self.is_visible = is_visible
+
+        self._bounds = None
+
+    @property
+    def name(self):
+        """str : The user-defined name of this object.
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if value is not None:
+            value = str(value)
+        self._name = value
+
+    @property
+    def primitives(self):
+        """list of :class:`Primitive` : The primitives associated
+        with this mesh.
+        """
+        return self._primitives
+
+    @primitives.setter
+    def primitives(self, value):
+        self._primitives = value
+
+    @property
+    def weights(self):
+        """(k,) float : Weights to be applied to morph targets.
+        """
+        return self._weights
+
+    @weights.setter
+    def weights(self, value):
+        self._weights = value
+
+    @property
+    def is_visible(self):
+        """bool : Whether the mesh is visible.
+        """
+        return self._is_visible
+
+    @is_visible.setter
+    def is_visible(self, value):
+        self._is_visible = value
+
+    @property
+    def bounds(self):
+        """(2,3) float : The axis-aligned bounds of the mesh.
+        """
+        if self._bounds is None:
+            bounds = np.array([[np.inf, np.inf, np.inf],
+                               [-np.inf, -np.inf, -np.inf]])
+            for p in self.primitives:
+                bounds[0] = np.minimum(bounds[0], p.bounds[0])
+                bounds[1] = np.maximum(bounds[1], p.bounds[1])
+            self._bounds = bounds
+        return self._bounds
+
+    @property
+    def centroid(self):
+        """(3,) float : The centroid of the mesh's axis-aligned bounding box
+        (AABB).
+        """
+        return np.mean(self.bounds, axis=0)
+
+    @property
+    def extents(self):
+        """(3,) float : The lengths of the axes of the mesh's AABB.
+        """
+        return np.diff(self.bounds, axis=0).reshape(-1)
+
+    @property
+    def scale(self):
+        """(3,) float : The length of the diagonal of the mesh's AABB.
+        """
+        return np.linalg.norm(self.extents)
+
+    @property
+    def is_transparent(self):
+        """bool : If True, the mesh is partially-transparent.
+        """
+        for p in self.primitives:
+            if p.is_transparent:
+                return True
+        return False
+
+    @staticmethod
+    def from_points(points, colors=None, normals=None,
+                    is_visible=True, poses=None):
+        """Create a Mesh from a set of points.
+
+        Parameters
+        ----------
+        points : (n,3) float
+            The point positions.
+        colors : (n,3) or (n,4) float, optional
+            RGB or RGBA colors for each point.
+        normals : (n,3) float, optionals
+            The normal vectors for each point.
+        is_visible : bool
+            If False, the points will not be rendered.
+        poses : (x,4,4)
+            Array of 4x4 transformation matrices for instancing this object.
+
+        Returns
+        -------
+        mesh : :class:`Mesh`
+            The created mesh.
+        """
+        primitive = Primitive(
+            positions=points,
+            normals=normals,
+            color_0=colors,
+            mode=GLTF.POINTS,
+            poses=poses
+        )
+        mesh = Mesh(primitives=[primitive], is_visible=is_visible)
+        return mesh
+
+    @staticmethod
+    def from_trimesh(mesh, material=None, is_visible=True,
+                     poses=None, wireframe=False, smooth=True):
+        """Create a Mesh from a :class:`~trimesh.base.Trimesh`.
+
+        Parameters
+        ----------
+        mesh : :class:`~trimesh.base.Trimesh` or list of them
+            A triangular mesh or a list of meshes.
+        material : :class:`Material`
+            The material of the object. Overrides any mesh material.
+            If not specified and the mesh has no material, a default material
+            will be used.
+        is_visible : bool
+            If False, the mesh will not be rendered.
+        poses : (n,4,4) float
+            Array of 4x4 transformation matrices for instancing this object.
+        wireframe : bool
+            If `True`, the mesh will be rendered as a wireframe object
+        smooth : bool
+            If `True`, the mesh will be rendered with interpolated vertex
+            normals. Otherwise, the mesh edges will stay sharp.
+
+        Returns
+        -------
+        mesh : :class:`Mesh`
+            The created mesh.
+        """
+
+        if isinstance(mesh, (list, tuple, set, np.ndarray)):
+            meshes = list(mesh)
+        elif isinstance(mesh, trimesh.Trimesh):
+            meshes = [mesh]
+        else:
+            raise TypeError('Expected a Trimesh or a list, got a {}'
+                            .format(type(mesh)))
+
+        primitives = []
+        for m in meshes:
+            positions = None
+            normals = None
+            indices = None
+
+            # Compute positions, normals, and indices
+            if smooth:
+                positions = m.vertices.copy()
+                normals = m.vertex_normals.copy()
+                indices = m.faces.copy()
+            else:
+                positions = m.vertices[m.faces].reshape((3 * len(m.faces), 3))
+                normals = np.repeat(m.face_normals, 3, axis=0)
+
+            # Compute colors, texture coords, and material properties
+            color_0, texcoord_0, primitive_material = Mesh._get_trimesh_props(m, smooth=smooth, material=material)
+
+            # Override if material is given.
+            if material is not None:
+                #primitive_material = copy.copy(material)
+                primitive_material = copy.deepcopy(material)  # TODO
+
+            if primitive_material is None:
+                # Replace material with default if needed
+                primitive_material = MetallicRoughnessMaterial(
+                    alphaMode='BLEND',
+                    baseColorFactor=[0.3, 0.3, 0.3, 1.0],
+                    metallicFactor=0.2,
+                    roughnessFactor=0.8
+                )
+
+            primitive_material.wireframe = wireframe
+
+            # Create the primitive
+            primitives.append(Primitive(
+                positions=positions,
+                normals=normals,
+                texcoord_0=texcoord_0,
+                color_0=color_0,
+                indices=indices,
+                material=primitive_material,
+                mode=GLTF.TRIANGLES,
+                poses=poses
+            ))
+
+        return Mesh(primitives=primitives, is_visible=is_visible)
+
+    @staticmethod
+    def _get_trimesh_props(mesh, smooth=False, material=None):
+        """Gets the vertex colors, texture coordinates, and material properties
+        from a :class:`~trimesh.base.Trimesh`.
+        """
+        colors = None
+        texcoords = None
+
+        # If the trimesh visual is undefined, return none for both
+        if not mesh.visual.defined:
+            return colors, texcoords, material
+
+        # Process vertex colors
+        if material is None:
+            if mesh.visual.kind == 'vertex':
+                vc = mesh.visual.vertex_colors.copy()
+                if smooth:
+                    colors = vc
+                else:
+                    colors = vc[mesh.faces].reshape(
+                        (3 * len(mesh.faces), vc.shape[1])
+                    )
+                material = MetallicRoughnessMaterial(
+                    alphaMode='BLEND',
+                    baseColorFactor=[1.0, 1.0, 1.0, 1.0],
+                    metallicFactor=0.2,
+                    roughnessFactor=0.8
+                )
+            # Process face colors
+            elif mesh.visual.kind == 'face':
+                if smooth:
+                    raise ValueError('Cannot use face colors with a smooth mesh')
+                else:
+                    colors = np.repeat(mesh.visual.face_colors, 3, axis=0)
+
+                material = MetallicRoughnessMaterial(
+                    alphaMode='BLEND',
+                    baseColorFactor=[1.0, 1.0, 1.0, 1.0],
+                    metallicFactor=0.2,
+                    roughnessFactor=0.8
+                )
+
+        # Process texture colors
+        if mesh.visual.kind == 'texture':
+            # Configure UV coordinates
+            if mesh.visual.uv is not None and len(mesh.visual.uv) != 0:
+                uv = mesh.visual.uv.copy()
+                if smooth:
+                    texcoords = uv
+                else:
+                    texcoords = uv[mesh.faces].reshape(
+                        (3 * len(mesh.faces), uv.shape[1])
+                    )
+
+            if material is None:
+                # Configure mesh material
+                mat = mesh.visual.material
+
+                if isinstance(mat, trimesh.visual.texture.PBRMaterial):
+                    material = MetallicRoughnessMaterial(
+                        normalTexture=mat.normalTexture,
+                        occlusionTexture=mat.occlusionTexture,
+                        emissiveTexture=mat.emissiveTexture,
+                        emissiveFactor=mat.emissiveFactor,
+                        alphaMode='BLEND',
+                        baseColorFactor=mat.baseColorFactor,
+                        baseColorTexture=mat.baseColorTexture,
+                        metallicFactor=mat.metallicFactor,
+                        roughnessFactor=mat.roughnessFactor,
+                        metallicRoughnessTexture=mat.metallicRoughnessTexture,
+                        doubleSided=mat.doubleSided,
+                        alphaCutoff=mat.alphaCutoff
+                    )
+                elif isinstance(mat, trimesh.visual.texture.SimpleMaterial):
+                    glossiness = mat.kwargs.get('Ns', 1.0)
+                    if isinstance(glossiness, list):
+                        glossiness = float(glossiness[0])
+                    roughness = (2 / (glossiness + 2)) ** (1.0 / 4.0)
+                    material = MetallicRoughnessMaterial(
+                        alphaMode='BLEND',
+                        roughnessFactor=roughness,
+                        baseColorFactor=mat.diffuse,
+                        baseColorTexture=mat.image,
+                    )
+                elif isinstance(mat, MetallicRoughnessMaterial):
+                    material = mat
+
+        return colors, texcoords, material

pyrender/node.py

@@ -0,0 +1,263 @@
+"""Nodes, conforming to the glTF 2.0 standards as specified in
+https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-node
+
+Author: Matthew Matl
+"""
+import numpy as np
+
+import trimesh.transformations as transformations
+
+from .camera import Camera
+from .mesh import Mesh
+from .light import Light
+
+
+class Node(object):
+    """A node in the node hierarchy.
+
+    Parameters
+    ----------
+    name : str, optional
+        The user-defined name of this object.
+    camera : :class:`Camera`, optional
+        The camera in this node.
+    children : list of :class:`Node`
+        The children of this node.
+    skin : int, optional
+        The index of the skin referenced by this node.
+    matrix : (4,4) float, optional
+        A floating-point 4x4 transformation matrix.
+    mesh : :class:`Mesh`, optional
+        The mesh in this node.
+    rotation : (4,) float, optional
+        The node's unit quaternion in the order (x, y, z, w), where
+        w is the scalar.
+    scale : (3,) float, optional
+        The node's non-uniform scale, given as the scaling factors along the x,
+        y, and z axes.
+    translation : (3,) float, optional
+        The node's translation along the x, y, and z axes.
+    weights : (n,) float
+        The weights of the instantiated Morph Target. Number of elements must
+        match number of Morph Targets of used mesh.
+    light : :class:`Light`, optional
+        The light in this node.
+    """
+
+    def __init__(self,
+                 name=None,
+                 camera=None,
+                 children=None,
+                 skin=None,
+                 matrix=None,
+                 mesh=None,
+                 rotation=None,
+                 scale=None,
+                 translation=None,
+                 weights=None,
+                 light=None):
+        # Set defaults
+        if children is None:
+            children = []
+
+        self._matrix = None
+        self._scale = None
+        self._rotation = None
+        self._translation = None
+        if matrix is None:
+            if rotation is None:
+                rotation = np.array([0.0, 0.0, 0.0, 1.0])
+            if translation is None:
+                translation = np.zeros(3)
+            if scale is None:
+                scale = np.ones(3)
+            self.rotation = rotation
+            self.translation = translation
+            self.scale = scale
+        else:
+            self.matrix = matrix
+
+        self.name = name
+        self.camera = camera
+        self.children = children
+        self.skin = skin
+        self.mesh = mesh
+        self.weights = weights
+        self.light = light
+
+    @property
+    def name(self):
+        """str : The user-defined name of this object.
+        """
+        return self._name
+
+    @name.setter
+    def name(self, value):
+        if value is not None:
+            value = str(value)
+        self._name = value
+
+    @property
+    def camera(self):
+        """:class:`Camera` : The camera in this node.
+        """
+        return self._camera
+
+    @camera.setter
+    def camera(self, value):
+        if value is not None and not isinstance(value, Camera):
+            raise TypeError('Value must be a camera')
+        self._camera = value
+
+    @property
+    def children(self):
+        """list of :class:`Node` : The children of this node.
+        """
+        return self._children
+
+    @children.setter
+    def children(self, value):
+        self._children = value
+
+    @property
+    def skin(self):
+        """int : The skin index for this node.
+        """
+        return self._skin
+
+    @skin.setter
+    def skin(self, value):
+        self._skin = value
+
+    @property
+    def mesh(self):
+        """:class:`Mesh` : The mesh in this node.
+        """
+        return self._mesh
+
+    @mesh.setter
+    def mesh(self, value):
+        if value is not None and not isinstance(value, Mesh):
+            raise TypeError('Value must be a mesh')
+        self._mesh = value
+
+    @property
+    def light(self):
+        """:class:`Light` : The light in this node.
+        """
+        return self._light
+
+    @light.setter
+    def light(self, value):
+        if value is not None and not isinstance(value, Light):
+            raise TypeError('Value must be a light')
+        self._light = value
+
+    @property
+    def rotation(self):
+        """(4,) float : The xyzw quaternion for this node.
+        """
+        return self._rotation
+
+    @rotation.setter
+    def rotation(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (4,):
+            raise ValueError('Quaternion must be a (4,) vector')
+        if np.abs(np.linalg.norm(value) - 1.0) > 1e-3:
+            raise ValueError('Quaternion must have norm == 1.0')
+        self._rotation = value
+        self._matrix = None
+
+    @property
+    def translation(self):
+        """(3,) float : The translation for this node.
+        """
+        return self._translation
+
+    @translation.setter
+    def translation(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (3,):
+            raise ValueError('Translation must be a (3,) vector')
+        self._translation = value
+        self._matrix = None
+
+    @property
+    def scale(self):
+        """(3,) float : The scale for this node.
+        """
+        return self._scale
+
+    @scale.setter
+    def scale(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (3,):
+            raise ValueError('Scale must be a (3,) vector')
+        self._scale = value
+        self._matrix = None
+
+    @property
+    def matrix(self):
+        """(4,4) float : The homogenous transform matrix for this node.
+
+        Note that this matrix's elements are not settable,
+        it's just a copy of the internal matrix. You can set the whole
+        matrix, but not an individual element.
+        """
+        if self._matrix is None:
+            self._matrix = self._m_from_tqs(
+                self.translation, self.rotation, self.scale
+            )
+        return self._matrix.copy()
+
+    @matrix.setter
+    def matrix(self, value):
+        value = np.asanyarray(value)
+        if value.shape != (4,4):
+            raise ValueError('Matrix must be a 4x4 numpy ndarray')
+        if not np.allclose(value[3,:], np.array([0.0, 0.0, 0.0, 1.0])):
+            raise ValueError('Bottom row of matrix must be [0,0,0,1]')
+        self.rotation = Node._q_from_m(value)
+        self.scale = Node._s_from_m(value)
+        self.translation = Node._t_from_m(value)
+        self._matrix = value
+
+    @staticmethod
+    def _t_from_m(m):
+        return m[:3,3]
+
+    @staticmethod
+    def _r_from_m(m):
+        U = m[:3,:3]
+        norms = np.linalg.norm(U.T, axis=1)
+        return U / norms
+
+    @staticmethod
+    def _q_from_m(m):
+        M = np.eye(4)
+        M[:3,:3] = Node._r_from_m(m)
+        q_wxyz = transformations.quaternion_from_matrix(M)
+        return np.roll(q_wxyz, -1)
+
+    @staticmethod
+    def _s_from_m(m):
+        return np.linalg.norm(m[:3,:3].T, axis=1)
+
+    @staticmethod
+    def _r_from_q(q):
+        q_wxyz = np.roll(q, 1)
+        return transformations.quaternion_matrix(q_wxyz)[:3,:3]
+
+    @staticmethod
+    def _m_from_tqs(t, q, s):
+        S = np.eye(4)
+        S[:3,:3] = np.diag(s)
+
+        R = np.eye(4)
+        R[:3,:3] = Node._r_from_q(q)
+
+        T = np.eye(4)
+        T[:3,3] = t
+
+        return T.dot(R.dot(S))