Merge pull request #2152 from mikedh/release/blender

Release: Scale Fix

Author: mikedh

Dockerfile

@@ -63,7 +63,7 @@ COPY --chown=499 pyproject.toml .
 COPY --chown=499 ./.git ./.git/
 
 USER root
-RUN trimesh-setup --install=test,build,gltf_validator,llvmpipe,binvox
+RUN trimesh-setup --install=test,gltf_validator,llvmpipe,binvox
 USER user
 
 # install things like pytest

pyproject.toml

@@ -5,7 +5,7 @@ requires = ["setuptools >= 61.0", "wheel"]
 [project]
 name = "trimesh"
 requires-python = ">=3.7"
-version = "4.1.3"
+version = "4.1.4"
 authors = [{name = "Michael Dawson-Haggerty", email = "mikedh@kerfed.com"}]
 license = {file = "LICENSE.md"}
 description = "Import, export, process, analyze and view triangular meshes."
@@ -78,6 +78,7 @@ easy = [
     "embreex",
     "pillow",
     "vhacdx",
+    "xatlas",
 ]
 
 recommend = [
@@ -86,7 +87,6 @@ recommend = [
     "meshio",
     "pyglet<2",
     "psutil",
-    "xatlas",
     "scikit-image",
     "python-fcl",
     "manifold3d>=2.3.0"

tests/test_ply.py

@@ -103,24 +103,30 @@ def test_face_attributes(self):
         # Test writing face attributes to a ply, by reading
         # them back and asserting the written attributes array matches
 
-        m = g.get_mesh("box.STL")
-        test_1d_attribute = g.np.copy(m.face_angles[:, 0])
-        test_nd_attribute = g.np.copy(m.face_angles)
-        m.face_attributes["test_1d_attribute"] = test_1d_attribute
-        m.face_attributes["test_nd_attribute"] = test_nd_attribute
-
-        export = m.export(file_type="ply")
-        reconstructed = g.roundtrip(export, file_type="ply")
-
-        face_attributes = reconstructed.metadata["_ply_raw"]["face"]["data"]
-        result_1d = face_attributes["test_1d_attribute"]
-        result_nd = face_attributes["test_nd_attribute"]["f1"]
-
-        g.np.testing.assert_almost_equal(result_1d, test_1d_attribute)
-        g.np.testing.assert_almost_equal(result_nd, test_nd_attribute)
-
-        no_attr = m.export(file_type="ply", include_attributes=False)
-        assert len(no_attr) < len(export)
+        for encoding in ["binary", "ascii"]:
+            for dt in [g.np.float32, g.np.float64]:
+                m = g.get_mesh("box.STL")
+                test_1d_attribute = g.np.copy(m.face_angles[:, 0])
+                test_nd_attribute = g.np.copy(m.face_angles)
+                m.face_attributes["test_1d_attribute"] = test_1d_attribute.astype(dt)
+                m.face_attributes["test_nd_attribute"] = test_nd_attribute.astype(dt)
+
+                export = m.export(file_type="ply", include_attributes=True, encoding=encoding)
+                reconstructed = g.roundtrip(export, file_type="ply", process=False)
+
+                face_attributes = reconstructed.metadata["_ply_raw"]["face"]["data"]
+                result_1d = face_attributes["test_1d_attribute"]
+                if encoding == "binary":
+                    # only binary format allows this
+                    result_nd = face_attributes["test_nd_attribute"]["f1"]
+                else:
+                    result_nd = face_attributes["test_nd_attribute"]
+
+                g.np.testing.assert_almost_equal(result_1d, test_1d_attribute)
+                g.np.testing.assert_almost_equal(result_nd, test_nd_attribute)
+
+                no_attr = m.export(file_type="ply", include_attributes=False)
+                assert len(no_attr) < len(export)
 
     def test_cases(self):
         a = g.get_mesh("featuretype.STL")

trimesh/base.py

@@ -565,24 +565,6 @@ def extents(self) -> Optional[NDArray[float64]]:
 
         return extents
 
-    @caching.cache_decorator
-    def scale(self) -> float:
-        """
-        A metric for the overall scale of the mesh, the length of the
-        diagonal of the axis aligned bounding box of the mesh.
-
-        Returns
-        ----------
-        scale : float
-          The length of the meshes AABB diagonal
-        """
-        # if mesh is empty just return no scale
-        if self.extents is None:
-            return 1.0
-        # make sure we are returning python floats
-        scale = float((self.extents**2).sum() ** 0.5)
-        return scale
-
     @caching.cache_decorator
     def centroid(self) -> NDArray[float64]:
         """

trimesh/boolean.py

@@ -67,6 +67,11 @@ def intersection(meshes, engine=None, **kwargs):
       Meshes to be processed
     engine : str
       Which backend to use, i.e. 'blender' or 'manifold'
+    solver_options: str
+      Fast has some limitations
+      Exact is slow but handles most of the cases
+    use_self: Bool
+      Self Intersection, Do self-union or self-intersection
 
     Returns
     ----------
@@ -100,7 +105,6 @@ def boolean_manifold(meshes, operation, debug=False, **kwargs):
         result_manifold = manifolds[0] - manifolds[1]
     elif operation == "union":
         result_manifold = manifolds[0]
-
         for manifold in manifolds[1:]:
             result_manifold = result_manifold + manifold
     elif operation == "intersection":

trimesh/caching.py

@@ -20,8 +20,10 @@
 ```
 """
 import os
+import sys
 import time
 from functools import wraps
+from hashlib import sha256 as _sha256
 
 import numpy as np
 
@@ -34,22 +36,17 @@
     from collections.abc import Mapping
 
 
-# sha256 is always available
-from hashlib import sha256 as _sha256
-
-
-def sha256(item):
+def sha256(item) -> int:
     return int(_sha256(item).hexdigest(), 16)
 
 
-try:
+if sys.version_info >= (3, 9):
     # blake2b is available on Python 3 and
     from hashlib import blake2b as _blake2b
 
     def hash_fallback(item):
-        return int(_blake2b(item).hexdigest(), 16)
-
-except BaseException:
+        return int(_blake2b(item, usedforsecurity=False).hexdigest(), 16)
+else:
     # fallback to sha256
     hash_fallback = sha256
 

trimesh/exchange/ply.py

@@ -153,8 +153,8 @@ def _add_attributes_to_dtype(dtype, attributes):
             dtype.append((name, data.dtype))
         else:
             attribute_dtype = data.dtype if len(data.dtype) == 0 else data.dtype[0]
-            dtype.append((f"{name}_count", "u1"))
-            dtype.append((name, _numpy_type_to_ply_type(attribute_dtype), data.shape[1]))
+            dtype.append((f"{name}_count", "<u1"))
+            dtype.append((name, attribute_dtype, data.shape[1]))
     return dtype
 
 

trimesh/interfaces/blender.py

@@ -32,19 +32,49 @@
 exists = _blender_executable is not None
 
 
-def boolean(meshes, operation="difference", debug=False):
+def boolean(
+    meshes,
+    operation: str = "difference",
+    use_exact: bool = False,
+    use_self: bool = False,
+    debug: bool = False,
+):
     """
     Run a boolean operation with multiple meshes using Blender.
+
+    Parameters
+    -----------
+    meshes
+      List of mesh objects to be operated on
+    operation
+      Type of boolean operation ("difference", "union", "intersect").
+    use_exact
+      Use the "exact" mode as opposed to the "fast" mode.
+    use_self
+      Whether to consider self-intersections.
+    debug
+      Provide additional output for troubleshooting.
+
+    Returns
+    ----------
+    result
+      The result of the boolean operation on the provided meshes.
     """
     if not exists:
         raise ValueError("No blender available!")
     operation = str.upper(operation)
     if operation == "INTERSECTION":
         operation = "INTERSECT"
 
+    if use_exact:
+        solver_options = "EXACT"
+    else:
+        solver_options = "FAST"
     # get the template from our resources folder
     template = resources.get("templates/blender_boolean.py.tmpl")
     script = template.replace("$OPERATION", operation)
+    script = script.replace("$SOLVER_OPTIONS", solver_options)
+    script = script.replace("$USE_SELF", f"{use_self}")
 
     with MeshScript(meshes=meshes, script=script, debug=debug) as blend:
         result = blend.run(_blender_executable + " --background --python $SCRIPT")

trimesh/parent.py

@@ -10,6 +10,7 @@
 
 from . import bounds, caching
 from . import transformations as tf
+from .caching import cache_decorator
 from .constants import tol
 from .util import ABC
 
@@ -152,6 +153,32 @@ def __radd__(self, other):
         # otherwise just use the regular add function
         return self.__add__(type(self)(other))
 
+    @cache_decorator
+    def scale(self) -> float:
+        """
+        A loosely specified "order of magnitude scale" for the
+        geometry which always returns a value and can be used
+        to make code more robust to large scaling differences.
+
+        It returns the diagonal of the axis aligned bounding box
+        or if anything is invalid or undefined, `1.0`.
+
+        Returns
+        ----------
+        scale : float
+          Approximate order of magnitude scale of the geometry.
+        """
+        # if geometry is empty return 1.0
+        if self.extents is None:
+            return 1.0
+
+        # get the length of the AABB diagonal
+        scale = float((self.extents**2).sum() ** 0.5)
+        if scale < tol.zero:
+            return 1.0
+
+        return scale
+
 
 class Geometry3D(Geometry):
 

trimesh/path/path.py

@@ -267,24 +267,6 @@ def kdtree(self):
         kdtree = cKDTree(self.vertices.view(np.ndarray))
         return kdtree
 
-    @property
-    def scale(self) -> float:
-        """
-        What is a representitive number that reflects the magnitude
-        of the world holding the paths, for numerical comparisons.
-
-        Returns
-        ----------
-        scale : float
-          Approximate size of the world holding this path
-        """
-        # check to see if this path is empty first
-        if len(self.vertices) == 0:
-            return 1.0
-
-        # return the diagonal length of the AABB
-        return np.linalg.norm(self.vertices.ptp(axis=0))
-
     @caching.cache_decorator
     def length(self):
         """