Initial commit. Support basic glTF structure and unrolled view

Author: diliash

README.md

@@ -0,0 +1,69 @@
+# pygltftoolkit
+
+## Table of Contents
+
+- [About](#about)
+- [Install](#install)
+- [Usage](#usage)
+- [Limitations and Development](#dev)
+
+## About <a name = "about"></a>
+
+pygltftoolkit aims to provide high-level API for loading and processing glTF 2.0 files. 
+
+### Install <a name = "install"></a>
+
+There are just a couple of dependencies to install:
+
+```
+python>=3.8
+numpy
+pygltflib
+PIL
+```
+
+## Usage <a name = "usage"></a>
+
+Loading a file:
+
+```
+import pygltgtoolkit as pygltk
+gltf = pygltk.load("/path/to/file.glb")
+```
+
+pygltftoolkit provides an "unrolled" view of the scene in addition to basic graph structure
+
+```
+vertices = gltf.vertices
+faces = gltf.faces
+triangles = vertices[faces]
+```
+
+In order to preserve dependencies on graph structure when using "unrolled" view, a number of maps are stored. Note that these maps correspond to the nodes that contain meshes and meshes directly (that is parents are not accounted for). Maps exist for nodes, meshes and primitives (however maps are local for primitives as they don't have global id).
+
+```
+# Obtaining nodes containing meshes
+nodes = np.unique(gltf.node_map)
+
+# Working withs the corresponding triangles
+for node_id in nodes:
+    node_mask = gltf.node_map == node_id
+    node_triangles = vertices[faces[node_mask]]
+    # Process node_triangles ...
+```
+
+## Limitations and Development <a name = "dev"></a>
+
+There is a number of limitations that may or may not be lifted in the future:
+* Only a single scene is supported. Multiple scenes are used rarely and there was even a proposal to remove the support for multiple scenes in a single file. See [discussion](https://github.com/KhronosGroup/glTF/issues/1542). 
+* Skin, animation and sampler part of the glTF graph are not supported (and are not planned currently).
+* Currently only the following attributes are extracted from primitives, if present: ["COLOR_0", "NORMAL", "POSITION", "TEXCOORD_0"]. 
+* Limited number of texture types supported (excluding normalTexture, occlusionTexture, emissiveTexture)
+
+Current TODOs (approximately in order of priority):
+* Support STK annotations 
+* Point cloud sampling (starting with CPU, CUDA implementation may be added in the future) and exporting to hdf5
+* Mesh modification and exporting
+* KDTree and KNN
+* Support transformations (node transformations defined in glTF are already supported)
+* Integrate renderer

__init__.py

@@ -0,0 +1 @@
+from .core import *

__pycache__/__init__.cpython-39.pyc

@@ -0,0 +1,53 @@
+import tempfile
+
+import pygltflib
+
+from .gltfScene import gltfScene
+
+
+def load(
+    path: str,
+    stk_segmentation: str = None,
+    stk_articulation: str = None,
+    stk_precomputed_segmentation: str = None
+) -> gltfScene:
+    """
+    Load the glTF 2.0 file. Allows to load the segmentation and articulation annotations as produced by the STK.
+    Args:
+        path: string, the path to the glTF 2.0 file
+        stk_segmentation: string, the path to the segmentation annotations produced by the STK. Defaults to None.
+        stk_articulation: string, the path to the articulation annotations produced by the STK. Defaults to None.
+    Returns:
+        scene: pygltftoolkit.gltfScene object, the glTF 2.0 scene.
+    """
+    scene = pygltflib.GLTF2().load(path)
+
+    # We support only a single scene in glTF file.
+    # Multiple scenes are rarely used and it was even proposed to remove them from the glTF 2.0 specification.
+    # See https://github.com/KhronosGroup/glTF/issues/1542
+    if len(scene.scenes) > 1:
+        raise ValueError("Only one scene in the glTF file is supported.")
+
+    # Please use .glb, we will handle .gltf with an ugly trick
+    if path.endswith(".gltf"):
+        with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+            scene.save_binary(temp_file.name)
+            temp_file_path = temp_file.name
+        scene = pygltflib.GLTF2().load(temp_file_path)
+
+    gltf = gltfScene(scene)
+
+    # Load the segmentation and articulation annotations
+    if stk_segmentation is not None:
+        # No support yet
+        gltf.load_stk_segmentation(stk_segmentation)
+    if stk_articulation is not None:
+        if stk_segmentation is None:
+            raise ValueError("Please provide the segmentation annotations as well.")
+        # No support yet
+        gltf.load_stk_articulation(stk_articulation)
+    if stk_precomputed_segmentation is not None:
+        # No support yet
+        gltf.load_stk_precomputed_segmentation(stk_precomputed_segmentation)
+
+    return gltf

__pycache__/core.cpython-39.pyc

@@ -0,0 +1 @@
+from .gltfScene import gltfScene

core.py

@@ -0,0 +1,3 @@
+from .mesh import Mesh
+from .node import Node
+from .primitive import Primitive

gltfScene/__init__.py

@@ -0,0 +1,21 @@
+
+class Mesh():
+    def __init__(self, id: int, primitives: list, name: str = None):
+        """
+        Initialize the Mesh object
+        Args:
+            id: int, the id of the mesh
+            name: str, the name of the mesh
+            primitives: list, the primitives of the mesh
+        Properties:
+            id: int, the id of the mesh
+            name: str, the name of the mesh
+            primitives: list, the primitives of the mesh
+        """
+        self.id: int = id
+
+        self.name: str = None
+        if name is not None:
+            self.name: str = name
+
+        self.primitives: list = primitives

gltfScene/__pycache__/__init__.cpython-39.pyc

@@ -0,0 +1,68 @@
+import numpy as np
+
+from .mesh import Mesh
+
+
+class Node():
+    def __init__(self, id: int,
+                 children: list,
+                 mesh: Mesh,
+                 matrix: list = [1, 0, 0, 0, 1, 0, 0, 0, 1],
+                 translation: list = [0, 0, 0],
+                 rotation: list = [0, 0, 0, 1],
+                 scale: list = [1, 1, 1],
+                 name: str = None):
+        """
+        Initialize the Node object, initialize next components recursively
+        Args:
+            id: int, the id of the node
+            children: list, the children of the node
+            mesh: pygltflib.gltfScene.components.Mesh, Mesh object referenced by the current node
+            matrix: list or np.ndarray(np.float32), the matrix of the node
+            translation: list or np.ndarray(np.float32), the translation of the node
+            rotation: list or np.ndarray(np.float32), the rotation of the node
+            scale: list or np.ndarray(np.float32), the scale of the node
+            name: str, the name of the node
+        Properties:
+            id: int, the id of the node
+            children: list, the children of the node
+            mesh: pygltflib.gltfScene.components.Mesh, Mesh object referenced by the current node
+            matrix: np.ndarray(np.float32), the matrix of the node
+            translation: np.ndarray(np.float32), the translation of the node
+            rotation: np.ndarray(np.float32), the rotation of the node
+            scale: np.ndarray(np.float32), the scale of the node
+            cameras: list, the cameras of the node
+            name: str, the name of the node
+        """
+        self.id: int = id
+        self.children: list = children
+        self.mesh = None
+        if mesh is not None:
+            self.mesh = mesh
+
+        if isinstance(matrix, list):
+            matrix = np.asarray(matrix, dtype=np.float32)
+        elif isinstance(matrix, np.ndarray) and matrix.dtype != np.float32:
+            raise ValueError("Matrix must be of type np.float32 or list.")
+        self.matrix: np.ndarray = matrix
+        if isinstance(translation, list):
+            translation = np.asarray(translation, dtype=np.float32)
+        elif isinstance(translation, np.ndarray) and translation.dtype != np.float32:
+            raise ValueError("Translation must be of type np.float32 or list.")
+        self.translation: np.ndarray = translation
+        if isinstance(rotation, list):
+            rotation = np.asarray(rotation, dtype=np.float32)
+        elif isinstance(rotation, np.ndarray) and rotation.dtype != np.float32:
+            raise ValueError("Rotation must be of type np.float32 or list.")
+        self.rotation: np.ndarray = rotation
+        if isinstance(scale, list):
+            scale = np.asarray(scale, dtype=np.float32)
+        elif isinstance(scale, np.ndarray) and scale.dtype != np.float32:
+            raise ValueError("Scale must be of type np.float32 or list.")
+        self.scale: np.ndarray = scale
+
+        self.cameras = []  # TODO initialize and support cameras
+
+        self.name: str = None
+        if name is not None:
+            self.name = name

gltfScene/__pycache__/gltfScene.cpython-39.pyc

@@ -0,0 +1,34 @@
+import numpy as np
+
+from .visual.material import Material
+
+
+class Primitive():
+    def __init__(self, attributes: dict,
+                 vertex_colors: np.ndarray = None,
+                 material: Material = None):
+        """
+        Initialize the Primitive object
+        Args:
+            attributes: dict, the attributes of the primitive
+            material: pygltftoolkit.gltfScene.components.visual.Material, the material of the primitive
+        Properties:
+            attributes: dict, the attributes of the primitive
+            material: pygltftoolkit.gltfScene.components.visual.Material, the material of the primitive
+        """
+        self.attributes: dict = attributes
+        self.has_normals: bool = False
+        if "NORMAL" in self.attributes:
+            self.has_normals = True
+        self.has_texture: bool = False
+        if "TEXCOORD_0" in self.attributes:
+            self.has_texture = True
+        self.has_colors: bool = False
+        if "COLOR_0" in self.attributes:
+            self.has_colors = True
+        self.has_baseColorFactor: bool = False
+        if not self.has_texture and not self.has_colors:
+            self.has_baseColorFactor = True
+        if vertex_colors is not None:
+            self.has_colors = True
+        self.material: Material = material

gltfScene/components/__init__.py

@@ -0,0 +1,2 @@
+from .image import TextureImage
+from .material import PBRMaterial, TextureMaterial

gltfScene/components/__pycache__/__init__.cpython-39.pyc

@@ -0,0 +1,23 @@
+from PIL import Image
+
+
+class TextureImage():
+    def __init__(self, image: Image, mimeType: str, name: str = None) -> None:
+        """
+        Initialize the TextureImage object
+        Args:
+            image: PIL.Image, the image
+            mimeType: str, the mimeType of the image. Either of ["image/jpeg", "image/png"]
+            name: str, the name of the image
+        Properties:
+            image: PIL.Image, the image
+            name: str, the name of the image
+            mimeType: str, the mimeType of the image. Either of ["image/jpeg", "image/png"]
+            width: int, the width of the image
+            height: int, the height of the image
+        """
+        self.image: Image = image
+        self.name: str = name
+        self.mimeType: str = mimeType
+        self.width: int = image.width
+        self.height: int = image.height

gltfScene/components/__pycache__/mesh.cpython-39.pyc

@@ -0,0 +1,42 @@
+import numpy as np
+
+from .image import TextureImage
+
+
+class Material():
+    """
+    Abstract class for Material objects
+    """
+    def __init__(self) -> None:
+        pass
+
+
+class TextureMaterial(Material):
+    def __init__(self, uv: np.ndarray, image: TextureImage) -> None:
+        """
+        Initialize the TextureMaterial object
+        Args:
+            texture: str, the path to the texture
+        Properties:
+            texture: str, the path to the texture
+        """
+        self.texture: str = image
+        self.uv: np.ndarray = uv
+
+
+class PBRMaterial(Material):
+    def __init__(self, baseColorFactor: np.ndarray, metallicFactor: float, roughnessFactor: float) -> None:
+        """
+        Initialize the PBRMaterial object
+        Args:
+            baseColorFactor: np.ndarray(np.float32), the base color factor
+            metallicFactor: float, the metallic factor
+            roughnessFactor: float, the roughness factor
+        Properties:
+            baseColorFactor: np.ndarray(np.float32), the base color factor
+            metallicFactor: float, the metallic factor
+            roughnessFactor: float, the roughness factor
+        """
+        self.baseColorFactor: np.ndarray = baseColorFactor
+        self.metallicFactor: float = metallicFactor
+        self.roughnessFactor: float = roughnessFactor