Release: Simple endian tests (#2512)

Even if we can't fully support other endian platforms, imports and
exports should explicitly set endian-ness of outputs.

- Adds a `make test-arch` which runs a subset of test on qemu/docker to
catch simple problems on little-endian and 32bit platforms
  - Fixes #2511 
  - Fixes #2510
- Adds fix from #2506 which implemented `Line.closed` setter to
auto-close polylines when passed.
- Audit use of `np.einsum`/`np.dot` from good discussion in #2514. My
conclusion was that `numpy.dot` is probably not the culprit and too core
to avoid. As part of looking into this I benchmarked our other uses of
`np.einsum` against simple numpy operations, it was on average ~2x
slower. I also tried the `np.einsum(... optimize=True) as discussed in
this [interesting
post](https://dev.to/kylepena/investigating-the-performance-of-npeinsum-22ho)
but for the trimesh use cases of very simple expressions this was
substantially slower in every case I measured.

Author: mikedh

.github/workflows/test.yml

@@ -50,6 +50,15 @@ jobs:
     - name: Run Pytest In Docker
       run: make tests
 
+  arch:
+    name: Architecture Tests (s390x + i386)
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: docker/setup-qemu-action@v3
+    - name: Run Tests On s390x and i386
+      run: make test-arch
+
   corpus:
     runs-on: ubuntu-latest
     name: Check Corpus Loading

Makefile

@@ -80,6 +80,27 @@ docs: ## Build trimesh's sphinx docs
 bash: build ## Start a bash terminal in the image.
 	docker run -it $(TAG_LATEST) /bin/bash
 
+.PHONY: test-arch
+test-arch: ## Run tests on big-endian s390x and 32-bit i386 via QEMU emulation.
+	docker run --rm --platform linux/s390x \
+		-v $(CURDIR):/trimesh \
+		-w /trimesh \
+		debian:trixie-slim \
+		bash -c "apt-get update -qq && apt-get install -y -qq \
+	python3-numpy python3-pytest python3-pil python3-shapely python3-scipy python3-lxml \
+	python3-networkx python3-jsonschema python3-httpx python3-collada python3-rtree \
+	 && python3 -m pytest \
+	tests/test_ply.py tests/test_gltf.py tests/test_voxel.py \
+	tests/test_stl.py tests/test_dae.py tests/test_obj.py -v"
+	docker run --rm --platform linux/386 \
+		-v $(CURDIR):/trimesh \
+		-w /trimesh \
+		debian:trixie-slim \
+		bash -c "apt-get update -qq && apt-get install -y -qq \
+	python3-numpy python3-pytest python3-scipy python3-rtree \
+	 && python3 -m pytest \
+	tests/test_voxel.py -v"
+
 .PHONY: publish-docker
 publish-docker: build ## Publish Docker images.
 	docker push $(TAG_LATEST)

docs/requirements.txt

@@ -1,11 +1,11 @@
-pypandoc==1.16.2
+pypandoc==1.17
 recommonmark==0.7.1
 jupyter==1.1.1
 
 # get sphinx version range from furo install
 furo==2025.12.19
 myst-parser==5.0.0
-pyopenssl==25.3.0
+pyopenssl==26.0.0
 autodocsumm==0.2.14
 jinja2==3.1.6
 matplotlib==3.10.8

pyproject.toml

@@ -5,7 +5,7 @@ requires = ["setuptools >= 61.0", "wheel"]
 [project]
 name = "trimesh"
 requires-python = ">=3.8"
-version = "4.11.3"
+version = "4.11.4"
 authors = [{name = "Michael Dawson-Haggerty", email = "mikedh@kerfed.com"}]
 license = {file = "LICENSE.md"}
 description = "Import, export, process, analyze and view triangular meshes."

tests/test_entity.py

@@ -0,0 +1,24 @@
+def test_line_closed():
+    import numpy as np
+
+    from trimesh.path.entities import Line
+
+    e = Line(points=[0, 1, 2], closed=False)
+    assert np.allclose(e.points, [0, 1, 2])
+
+    e = Line(points=[0, 1, 2], closed=True)
+    assert np.allclose(e.points, [0, 1, 2, 0])
+
+    e = Line(points=[0, 1, 2, 0], closed=True)
+    assert np.allclose(e.points, [0, 1, 2, 0])
+
+    # should it really drop the last point... that seems weird
+    e = Line(points=[0, 1, 2, 0], closed=False)
+    assert np.allclose(e.points, [0, 1, 2, 0])
+
+
+if __name__ == "__main__":
+    import trimesh
+
+    trimesh.util.attach_to_log()
+    test_line_closed()

trimesh/curvature.py

@@ -8,6 +8,7 @@
 import numpy as np
 
 from . import util
+from .util import diagonal_dot
 
 try:
     from scipy.sparse import coo_matrix
@@ -153,9 +154,9 @@ def line_ball_intersection(start_points, end_points, center, radius):
     L = end_points - start_points
     oc = start_points - center  # o-c
     r = radius
-    ldotl = np.einsum("ij, ij->i", L, L)  # l.l
-    ldotoc = np.einsum("ij, ij->i", L, oc)  # l.(o-c)
-    ocdotoc = np.einsum("ij, ij->i", oc, oc)  # (o-c).(o-c)
+    ldotl = diagonal_dot(L, L)
+    ldotoc = diagonal_dot(L, oc)
+    ocdotoc = diagonal_dot(oc, oc)
     discrims = ldotoc**2 - ldotl * (ocdotoc - r**2)
 
     # If discriminant is non-positive, then we have zero length

trimesh/exchange/gltf/__init__.py

@@ -963,9 +963,10 @@ def _append_mesh(
         # GLTF has no floating point type larger than 32 bits so clip
         # any float64 or larger to float32
         if attrib.dtype.kind == "f" and attrib.dtype.itemsize > 4:
-            data = attrib.astype(np.float32)
+            data = attrib.astype(float32)
         else:
-            data = attrib
+            # force little-endian to match GLTF binary format
+            data = attrib.astype(attrib.dtype.newbyteorder("<"), copy=False)
 
         if len(data.shape) == 1:
             data = data[:, np.newaxis]
@@ -1206,9 +1207,10 @@ def _append_path(path, name, tree, buffer_items):
         # GLTF has no floating point type larger than 32 bits so clip
         # any float64 or larger to float32
         if attrib.dtype.kind == "f" and attrib.dtype.itemsize > 4:
-            data = attrib.astype(np.float32)
+            data = attrib.astype(float32)
         else:
-            data = attrib
+            # force little-endian to match GLTF binary format
+            data = attrib.astype(attrib.dtype.newbyteorder("<"), copy=False)
 
         if not all(util.is_instance_named(e, "Line") for e in path.entities):
             log.warning(

trimesh/exchange/ply.py

@@ -150,12 +150,12 @@ def _add_attributes_to_dtype(dtype, attributes):
     dtype : list of numpy datatypes
     """
     for name, data in attributes.items():
-        if data.ndim == 1:
-            dtype.append((name, data.dtype))
+        # force little-endian to match PLY binary format
+        field_dtype = data.dtype.newbyteorder("<")
+        if data.ndim > 1:
+            dtype.extend([(f"{name}_count", "<u1"), (name, field_dtype, data.shape[1])])
         else:
-            attribute_dtype = data.dtype if len(data.dtype) == 0 else data.dtype[0]
-            dtype.append((f"{name}_count", "<u1"))
-            dtype.append((name, attribute_dtype, data.shape[1]))
+            dtype.append((name, field_dtype))
     return dtype
 
 

trimesh/intersections.py

@@ -554,7 +554,7 @@ def slice_faces_plane(
     denom[denom == 0.0] = 1e-12  # prevent division by zero
     dist = np.divide(num, denom)
     # intersection points for each segment
-    int_points = np.einsum("ij,ijk->ijk", dist, d) + o
+    int_points = dist[:, :, None] * d + o
 
     # Initialize the array of new vertices with the current vertices
     new_vertices = vertices

trimesh/path/entities.py

@@ -7,6 +7,7 @@
 """
 
 from copy import deepcopy
+from logging import getLogger
 
 import numpy as np
 
@@ -15,6 +16,8 @@
 from .arc import arc_center, discretize_arc
 from .curve import discretize_bezier, discretize_bspline
 
+log = getLogger(__name__)
+
 
 class Entity(ABC):
     def __init__(
@@ -105,8 +108,7 @@ def closed(self):
         closed : bool
           Is the entity closed or not?
         """
-        closed = len(self.points) > 2 and self.points[0] == self.points[-1]
-        return closed
+        return len(self.points) > 2 and self.points[0] == self.points[-1]
 
     @property
     def nodes(self):
@@ -529,6 +531,21 @@ def discrete(self, vertices, scale=1.0):
         """
         return self._orient(vertices[self.points])
 
+    @property
+    def closed(self):
+        return len(self.points) > 2 and self.points[0] == self.points[-1]
+
+    @closed.setter
+    def closed(self, value: bool):
+        current = self.points[0] == self.points[-1]
+        if value and not current:
+            # case where we've been asked to close the line
+            # this seems pretty obvious that we should just append the first pointOB
+            self.points = np.concatenate((self.points, [self.points[0]]))
+        elif not value and current:
+            # case where we've been asked to *disconnect* a closed path
+            log.debug("ignoring `Line.closed = False`")
+
     @property
     def is_valid(self):
         """