Merge pull request #2232 from mikedh/release/pickle

Release: Pickleable

Author: mikedh

examples/prepare.py

@@ -0,0 +1,156 @@
+"""
+An example of a simple way of preparing and analyzing a model
+for properties of interest to 3D printing, implemented using
+dataclasses which can easily be used for API routes.
+
+- Volume
+- Oriented Bounding Box
+- thin regions
+
+The nominal operations flow we're using here is defined by
+easily serialized `dataclass` objects and goes:
+
+RawFile ->           # a raw loadable file
+  PrintCandidate ->  # usable properties about the model
+    PrintJob ->      # after quantities and options are picked
+      PrintRelease   # i.e. what you would send to the machine
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+import trimesh
+
+
+@dataclass
+class RawFile:
+    # the data for the loadable file
+    file_data: bytes
+
+    # the original name of the file
+    # the extension will be used to determine type
+    file_name: str
+
+    # the units of the file if it is in a format
+    # that does not include units (i.e. STL files)
+    units: Optional[str] = None
+
+
+@dataclass
+class Error:
+    # the user-facing message
+    message: str
+
+    # a code that can be used to group problems
+    code: str
+
+    # if faces were colored to indicate the problem
+    color: str
+
+
+@dataclass
+class PrintCandidate:
+    # the repaired model repaired into a GLB file
+    glb: bytes
+
+    # any problems that were encountered
+    errors: list[Error]
+
+    # the volume of the mesh
+    volume: float
+
+    # the size of the axis-aligned bounding box
+    extents: list[float]
+
+
+def load(raw: RawFile) -> trimesh.Trimesh:
+    """
+    Load a raw file for 3D printing, collapsing meshes into a single body.
+    """
+    # coerce scenes and formats with normals into a mesh
+    mesh = trimesh.load(
+        file_obj=trimesh.util.wrap_as_stream(raw.file_data),
+        file_type=raw.file_name,
+        process=True,
+        merge_tex=True,  # ignore UV coordinates
+        merge_norm=True,  # ignore vertex normals
+        force="mesh",  # concatenate into single mesh
+    )
+    mesh.process(merge_tex=True, merge_norm=True)
+
+    # if passed explicitly
+    if mesh.units is None and raw.units is not None:
+        mesh.units = raw.units
+
+    # convert mesh to meters and guess as a fallback
+    mesh.convert_units("meters", guess=True)
+
+    # make sure it is using face colors
+    mesh.visual = trimesh.visual.ColorVisuals(mesh=mesh)
+
+    return mesh
+
+
+def prepare(
+    mesh: trimesh.Trimesh,
+    minimum_thickness: float = 0.0005,
+) -> PrintCandidate:
+    """
+    Take a raw 3D model and process it for 3D printing.
+    """
+
+    # collect issues to report
+    problems = []
+
+    if not mesh.fill_holes():
+        problems.append(
+            Error(message="Mesh is not watertight!", code="watertight", color="#FF0000")
+        )
+        # will apply "red" to broken faces
+        trimesh.repair.broken_faces(mesh=mesh, color=[255, 0, 0, 255])
+
+    thick_bad = (
+        trimesh.proximity.thickness(
+            mesh, mesh.triangles_center - mesh.face_normals * 0.001
+        )
+        < minimum_thickness
+    )
+
+    if thick_bad.any():
+        mesh.visual.face_colors[thick_bad] = [0, 0, 255, 255]
+        problems.append(
+            Error(
+                message="Mesh has regions below minimum thickness!",
+                code="watertight",
+                color="#0000FF",
+            )
+        )
+
+    mesh.show()
+
+    return PrintCandidate(
+        glb=mesh.export(file_type="glb"),
+        errors=problems,
+        volume=mesh.volume,
+        extents=mesh.extents,
+    )
+
+
+if __name__ == "__main__":
+    # current working directory
+    cwd = os.path.abspath(os.path.expanduser(os.path.dirname(__file__)))
+
+    # create a raw "request"
+    file_name = "machinist.3DXML"
+    # file_name = 'ADIS16480.STL'
+    file_path = os.path.join(cwd, "..", "models", file_name)
+    with open(file_path, "rb") as f:
+        loaded = load(raw=RawFile(file_data=f.read(), file_name=file_name, units=None))
+
+    from pyinstrument import Profiler
+
+    with Profiler() as P:
+        report = prepare(loaded)
+
+    P.print()

models/cubevc.glb

@@ -5,7 +5,7 @@ requires = ["setuptools >= 61.0", "wheel"]
 [project]
 name = "trimesh"
 requires-python = ">=3.7"
-version = "4.4.0"
+version = "4.4.1"
 authors = [{name = "Michael Dawson-Haggerty", email = "mikedh@kerfed.com"}]
 license = {file = "LICENSE.md"}
 description = "Import, export, process, analyze and view triangular meshes."
@@ -137,7 +137,8 @@ select = [
     "W", # style warnings
     "YTT", # sys.version
     "ISC002",
-    "NPY201"
+    "NPY201",
+    "TID251"
 ]
 
 ignore = [
@@ -153,6 +154,9 @@ ignore = [
 # don't allow implicit string concatenation
 flake8-implicit-str-concat = {"allow-multiline" = false}
 
+[tool.ruff.lint.flake8-tidy-imports.banned-api]
+"IPython.embed".msg = "you forgot to remove a debug embed ;)"
+
 [tool.codespell]
 skip = "*.js*,./docs/built/*,./docs/generate/*,./models*,*.toml"
 ignore-words-list = "nd,coo,whats,bu,childs,mis,filetests"

pyproject.toml

@@ -98,12 +98,7 @@ def on_repo(repo, commit):
                         a, b = geom.visual.material, ori.visual.material
                         # try our fancy equal
                         assert equal(a.baseColorFactor, b.baseColorFactor)
-                        try:
-                            assert equal(a.baseColorTexture, b.baseColorTexture)
-                        except BaseException:
-                            from IPython import embed
-
-                            embed()
+                        assert equal(a.baseColorTexture, b.baseColorTexture)
 
         except NotImplementedError as E:
             # this is what unsupported formats

tests/corpus.py

@@ -9,6 +9,7 @@
 import json
 import copy
 import time
+import pickle
 import shutil
 import timeit
 import base64

tests/generic.py

@@ -31,7 +31,7 @@ def write_json(template, file_name="../templates/dxf.json"):
 
 def replace_whitespace(text, SAFE_SPACE="|<^>|", insert=True, reformat=False):
     """
-    Replace non-strippable whitepace in a string with a safe space
+    Replace non-strippable whitespace in a string with a safe space
     """
     if insert:
         # replace whitespace with safe space chr

tests/helpers/dxfhelp.py

@@ -796,6 +796,23 @@ def test_vertex_attrib(self):
         # make sure the color vertex attributes survived the roundtrip
         assert g.np.allclose(r.visual.vertex_attributes["color"], colors)
 
+    def test_vertex_colors_import(self):
+        # get a mesh with face colors
+        m = g.get_mesh("cubevc.glb")
+        assert len(m.geometry.items()) > 0
+
+        mesh = next(iter(m.geometry.items()))[1]
+        assert mesh is not None
+
+        # Loaded mesh should have vertex colors
+        assert hasattr(mesh.visual, "vertex_colors")
+
+        # Loaded mesh should have all vertex colors filled with magenta color
+        magenta = g.np.array([255, 0, 255, 255])
+        for color in mesh.visual.vertex_colors:
+            is_magenta = g.np.array_equal(color, magenta)
+            assert is_magenta, f"Imported vertex color is not of expected value: got {color}, expected {magenta}"
+
     def test_export_postprocess(self):
         scene = g.trimesh.Scene()
         sphere = g.trimesh.primitives.Sphere()

tests/test_gltf.py

@@ -104,8 +104,33 @@ def test_meshes(self):
             assert len(mesh.vertices) == len(mesh.vertex_defects)
             assert len(mesh.principal_inertia_components) == 3
 
+            # make a ray query which may lead to unpicklable caching
+            dimension = (100, 3)
+            ray_origins = g.random(dimension)
+            ray_directions = g.np.tile([0, 0, 1], (dimension[0], 1))
+            ray_origins[:, 2] = mesh.bounds[0][2] - mesh.scale
+
+            # call additional C objects
+            assert mesh.kdtree is not None
+            assert mesh.triangles_tree is not None
+
+            # force ray object to be created
+            ray = mesh.ray.intersects_location(ray_origins, ray_directions)
+            assert ray is not None
+
             # collect list of cached properties that are writeable
             writeable = []
+
+            # make sure a roundtrip pickle works
+            # if the cache has non-pickleable stuff this will break
+            pickle = g.pickle.dumps(mesh)
+            assert isinstance(pickle, bytes)
+            assert len(pickle) > 0
+
+            r = g.pickle.loads(pickle)
+            assert r.faces.shape == mesh.faces.shape
+            assert g.np.isclose(r.volume, mesh.volume)
+
             # we should have built up a bunch of stuff into
             # our cache, so make sure all numpy arrays cached
             # are read-only and not crazy

tests/test_mesh.py

@@ -252,7 +252,7 @@ def export_scene(scene, file_obj, file_type=None, resolver=None, **kwargs):
         else:
             raise ValueError("file_type not specified!")
 
-    # always remove whitepace and leading characters
+    # always remove whitespace and leading characters
     file_type = file_type.strip().lower().lstrip(".")
 
     # now handle our different scene export types

trimesh/exchange/export.py

@@ -1560,11 +1560,11 @@ def _read_buffers(
                             if len(colors) == len(kwargs["vertices"]):
                                 if visuals is None:
                                     # just pass to mesh as vertex color
-                                    kwargs["vertex_colors"] = colors
+                                    kwargs["vertex_colors"] = colors.copy()
                                 else:
                                     # we ALSO have texture so save as vertex
                                     # attribute
-                                    visuals.vertex_attributes["color"] = colors
+                                    visuals.vertex_attributes["color"] = colors.copy()
                         except BaseException:
                             # survive failed colors
                             log.debug("failed to load colors", exc_info=True)