backup 04_physworld 2026-11-08 10:11:26 (part 20)

.gitattributes

@@ -3777,3 +3777,12 @@ physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/setuptools/_vendor/mo
 physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/__pycache__/base.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/__pycache__/transformations.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/vhacdx.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/yaml/_yaml.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/test/support/__pycache__/__init__.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/__init__.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/tkinter/__pycache__/tix.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/unittest/__pycache__/mock.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/urllib/__pycache__/request.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/sqlite3.40.0/libsqlite3.40.0.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/tk8.6/demos/images/teapot.ppm filter=lfs diff=lfs merge=lfs -text

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/METADATA

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: trimesh
+Version: 5.1.1
+Summary: Import, export, process, analyze and view triangular meshes.
+Author-email: Michael Dawson-Haggerty <mikedh@kerfed.com>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2023 Michael Dawson-Haggerty
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://github.com/mikedh/trimesh
+Project-URL: documentation, https://trimesh.org
+Keywords: graphics,mesh,geometry,3D
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy>=1.21
+Provides-Extra: easy
+Requires-Dist: colorlog; extra == "easy"
+Requires-Dist: manifold3d>=2.3.0; extra == "easy"
+Requires-Dist: charset-normalizer; extra == "easy"
+Requires-Dist: lxml; extra == "easy"
+Requires-Dist: jsonschema; extra == "easy"
+Requires-Dist: networkx; extra == "easy"
+Requires-Dist: svg.path; extra == "easy"
+Requires-Dist: pycollada; extra == "easy"
+Requires-Dist: shapely; extra == "easy"
+Requires-Dist: xxhash; extra == "easy"
+Requires-Dist: rtree; extra == "easy"
+Requires-Dist: httpx; extra == "easy"
+Requires-Dist: scipy; extra == "easy"
+Requires-Dist: embreex; platform_machine != "aarch64" and extra == "easy"
+Requires-Dist: pillow; extra == "easy"
+Requires-Dist: vhacdx; extra == "easy"
+Requires-Dist: mapbox_earcut>=1.0.2; extra == "easy"
+Provides-Extra: recommend
+Requires-Dist: sympy; extra == "recommend"
+Requires-Dist: pyglet<2; extra == "recommend"
+Requires-Dist: scikit-image; extra == "recommend"
+Requires-Dist: fast-simplification; extra == "recommend"
+Requires-Dist: python-fcl; extra == "recommend"
+Requires-Dist: cascadio; extra == "recommend"
+Provides-Extra: test
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pyinstrument; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Provides-Extra: test-more
+Requires-Dist: ezdxf; extra == "test-more"
+Requires-Dist: meshio; extra == "test-more"
+Requires-Dist: xatlas; extra == "test-more"
+Requires-Dist: pytest-beartype; extra == "test-more"
+Requires-Dist: matplotlib; extra == "test-more"
+Requires-Dist: pymeshlab; python_version < "3.14" and extra == "test-more"
+Requires-Dist: triangle; python_version < "3.14" and extra == "test-more"
+Requires-Dist: ipython; extra == "test-more"
+Requires-Dist: marimo; extra == "test-more"
+Requires-Dist: requests; extra == "test-more"
+Requires-Dist: aiohttp; extra == "test-more"
+Requires-Dist: DracoPy>=1.7.0; extra == "test-more"
+Provides-Extra: deprecated
+Provides-Extra: all
+Requires-Dist: trimesh[deprecated,easy,recommend,test,test_more]; extra == "all"
+Dynamic: license-file
+
+[![trimesh](https://trimesh.org/_static/images/logotype-a.svg)](http://trimesh.org)
+
+-----------
+[![Github Actions](https://github.com/mikedh/trimesh/workflows/Release%20Trimesh/badge.svg)](https://github.com/mikedh/trimesh/actions) [![coverage](https://trimesh.org/coverage/badge.svg)](https://trimesh.org/coverage/)  [![Docker Image Version (latest by date)](https://img.shields.io/docker/v/trimesh/trimesh?label=docker&sort=semver)](https://hub.docker.com/r/trimesh/trimesh/tags) [![PyPI version](https://badge.fury.io/py/trimesh.svg)](https://badge.fury.io/py/trimesh)
+
+
+Trimesh is a pure Python 3.10+ library for loading and using [triangular meshes](https://en.wikipedia.org/wiki/Triangle_mesh) with an emphasis on watertight surfaces. The goal of the library is to provide a full featured and well tested Trimesh object which allows for easy manipulation and analysis, in the style of the Polygon object in the [Shapely library](https://github.com/Toblerity/Shapely).
+
+The API is mostly stable, but this should not be relied on and is not guaranteed: install a specific version if you plan on deploying something using `trimesh`.
+
+Pull requests are appreciated and responded to promptly! If you'd like to contribute, here a quick [development and contributing guide.](https://trimesh.org/contributing.html)
+
+
+## Basic Installation
+
+Keeping `trimesh` easy to install is a core goal, thus the *only* hard dependency is [`numpy`](http://www.numpy.org/). Installing other packages adds functionality but is not required. For the easiest install with just `numpy`:
+
+```bash
+pip install trimesh
+```
+
+The minimal install can load many supported formats (STL, PLY, OBJ, GLTF/GLB) into `numpy.ndarray` values. More functionality is available when [soft dependencies are installed](https://trimesh.org/install#dependency-overview), including convex hulls (`scipy`), graph operations (`networkx`), fast ray queries (`embreex`), vector path handling (`shapely` and `rtree`), XML formats like 3DXML/XAML/3MF (`lxml`), preview windows (`pyglet`), faster cache checks (`xxhash`), etc.
+
+To install `trimesh` with the soft dependencies that generally install cleanly from binaries on Linux x86_64, MacOS ARM, and Windows x86_64 using `pip`:
+```bash
+pip install trimesh[easy]
+```
+
+If you are supporting a different platform or are freezing dependencies for an application we recommend you do not use extras, i.e. depend on `trimesh scipy` versus `trimesh[easy]`. Further information is available in the [advanced installation documentation](https://trimesh.org/install.html).
+
+## Quick Start
+
+Here is an example of loading a mesh from file and colorizing its faces ([nicely formatted notebook version](https://trimesh.org/quick_start.html) of this example.
+
+```python
+import numpy as np
+import trimesh
+
+# attach to logger so trimesh messages will be printed to console
+trimesh.util.attach_to_log()
+
+# mesh objects can be created from existing faces and vertex data
+mesh = trimesh.Trimesh(vertices=[[0, 0, 0], [0, 0, 1], [0, 1, 0]], faces=[[0, 1, 2]])
+
+# by default, Trimesh will do a light processing, which will
+# remove any NaN values and merge vertices that share position
+# if you want to not do this on load, you can pass `process=False`
+mesh = trimesh.Trimesh(
+    vertices=[[0, 0, 0], [0, 0, 1], [0, 1, 0]], faces=[[0, 1, 2]], process=False
+)
+
+# some formats like `glb` represent multiple meshes with multiple instances
+# and `load_mesh` will concatenate irreversibly, load it as a Scene
+# if you need instance information:
+#   `scene = trimesh.load_scene('models/CesiumMilkTruck.glb')`
+mesh = trimesh.load_mesh("models/CesiumMilkTruck.glb")
+
+# is the current mesh watertight?
+mesh.is_watertight
+
+# what's the euler number for the mesh?
+mesh.euler_number
+
+# the convex hull is another Trimesh object that is available as a property
+# lets compare the volume of our mesh with the volume of its convex hull
+print(mesh.volume / mesh.convex_hull.volume)
+
+# since the mesh is watertight it means there is a volume
+# with a center of mass calculated from a surface integral approach
+# which we can set as the origin for our mesh. It's perfectly fine to
+# alter the vertices directly:
+#   mesh.vertices -= mesh.center_mass
+# although this will completely clear the cache including face normals
+# as we don't know that they're still valid. Using the translation
+# method will try to save cached values that are still valid:
+mesh.apply_translation(-mesh.center_mass)
+
+
+# what's the (3, 3) moment of inertia for the mesh?
+mesh.moment_inertia
+
+# if there are multiple bodies in the mesh we can split the mesh by
+# connected components of face adjacency
+# since this example mesh is a single watertight body we get a list of one mesh
+mesh.split()
+
+# facets are groups of coplanar adjacent faces
+# set each facet to a random color
+# colors are 8 bit RGBA by default (n, 4) np.uint8
+for facet in mesh.facets:
+    mesh.visual.face_colors[facet] = trimesh.visual.random_color()
+
+# preview mesh in an opengl window if you installed pyglet and scipy with pip
+mesh.show()
+
+# transform method can be passed a (4, 4) matrix and will cleanly apply the transform
+mesh.apply_transform(trimesh.transformations.random_rotation_matrix())
+
+# axis aligned bounding box is available
+mesh.bounding_box.extents
+
+# a minimum volume oriented bounding box also available
+# primitives are subclasses of Trimesh objects which automatically generate
+# faces and vertices from data stored in the 'primitive' attribute
+mesh.bounding_box_oriented.primitive.extents
+mesh.bounding_box_oriented.primitive.transform
+
+# show the mesh appended with its oriented bounding box
+# the bounding box is a trimesh.primitives.Box object, which subclasses
+# Trimesh and lazily evaluates to fill in vertices and faces when requested
+# (press w in viewer to see triangles)
+(mesh + mesh.bounding_box_oriented).show()
+
+# bounding spheres and bounding cylinders of meshes are also
+# available, and will be the minimum volume version of each
+# except in certain degenerate cases, where they will be no worse
+# than a least squares fit version of the primitive.
+print(
+    mesh.bounding_box_oriented.volume,
+    mesh.bounding_cylinder.volume,
+    mesh.bounding_sphere.volume,
+)
+```
+
+## Features
+
+* Import meshes from binary/ASCII STL, Wavefront OBJ, ASCII OFF, binary/ASCII PLY, GLTF/GLB 2.0, 3MF, XAML, 3DXML, etc.
+* Export meshes as GLB/GLTF, binary STL, binary PLY, ASCII OFF, OBJ, COLLADA, etc.
+* Import and export 2D or 3D vector paths with DXF or SVG files
+* Preview meshes using an OpenGL `pyglet` window, or in-line in jupyter or marimo notebooks using `three.js`
+* Automatic hashing from a subclassed numpy array for change tracking using MD5, zlib CRC, or xxhash, and internal caching of expensive values.
+* Calculate face adjacencies, face angles, vertex defects, convex hulls, etc.
+* Calculate cross sections for a 2D outline, or slice a mesh for a 3D remainder mesh, i.e. slicing for 3D-printing.
+* Split mesh based on face connectivity using networkx, or scipy.sparse
+* Calculate mass properties, including volume, center of mass, moment of inertia, principal components of inertia, etc.
+* Repair simple problems with triangle winding, normals, and quad/triangle holes
+* Compute rotation/translation/tessellation invariant identifier and find duplicate meshes
+* Check if a mesh is watertight, convex, etc.
+* Sample the surface of a mesh
+* Ray-mesh queries including location, triangle index, etc.
+* Boolean operations on meshes (intersection, union, difference) using Manifold3D or Blender.
+* Voxelize watertight meshes
+* Smooth watertight meshes using Laplacian smoothing algorithms (Classic, Taubin, Humphrey)
+* Subdivide faces of a mesh
+* Approximate minimum volume oriented bounding boxes and spheres for meshes.
+* Calculate nearest point on mesh surface and signed distance
+* Primitive objects (Box, Cylinder, Sphere, Extrusion) which are subclassed Trimesh objects and have all the same features (inertia, viewers, etc)
+* Simple scene graph and transform tree which can be rendered (pyglet window, three.js in a jupyter/marimo notebook or exported.
+* Many utility functions, like transforming points, unitizing vectors, aligning vectors, tracking numpy arrays for changes, grouping rows, etc.
+
+## Additional Notes
+
+- Check out some cool stuff people have done in the [GitHub network](https://github.com/mikedh/trimesh/network/dependents).
+- Generally `trimesh` API changes should have a one-year period of [printing a `warnings.DeprecationWarning`](https://trimesh.org/contributing.html#deprecations) although that's not always possible (i.e. the pyglet2 viewer rewrite that's been back-burnered for several years.)
+- Docker containers are available on Docker Hub as [`trimesh/trimesh`](https://hub.docker.com/r/trimesh/trimesh/tags) and there's a [container guide](https://trimesh.org/docker.html) in the docs.
+- If you're choosing which format to use, you may want to try [GLB](https://trimesh.org/formats.html) as a fast modern option.

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/RECORD

@@ -0,0 +1,261 @@
+../../../bin/trimesh,sha256=6WWrPPhYHZQyedABrLWPV3Rqxv6J19eQ_CcTD9OsoMk,255
+trimesh-5.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+trimesh-5.1.1.dist-info/METADATA,sha256=g_9dq972Sj7oLlYPQZwGx9XUBwTjzv4YB-oTbbebAbc,13280
+trimesh-5.1.1.dist-info/RECORD,,
+trimesh-5.1.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+trimesh-5.1.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+trimesh-5.1.1.dist-info/entry_points.txt,sha256=E8JnT07gjUrdCQjuWPKNykjis4Aa2QWCFN6gVFWNNh0,50
+trimesh-5.1.1.dist-info/licenses/LICENSE.md,sha256=_ie174cQZ2zIUlXaKKMvOU4u8_TORwdaHHMqnqHXvQM,1090
+trimesh-5.1.1.dist-info/top_level.txt,sha256=bHXSeALt9l4__maYNLp93GRZSOJ5iApS2fe3jibIV1U,8
+trimesh/__init__.py,sha256=pQ2KnENG-gxfbKDCNO_9EsVIsb7lgZeruBBsteedM2A,2429
+trimesh/__main__.py,sha256=1QP7e1idyhXpLIj_8BAgJ6wCXGgWh7-HobJxdJ_EdDs,1461
+trimesh/__pycache__/__init__.cpython-311.pyc,,
+trimesh/__pycache__/__main__.cpython-311.pyc,,
+trimesh/__pycache__/base.cpython-311.pyc,,
+trimesh/__pycache__/boolean.cpython-311.pyc,,
+trimesh/__pycache__/bounds.cpython-311.pyc,,
+trimesh/__pycache__/caching.cpython-311.pyc,,
+trimesh/__pycache__/collision.cpython-311.pyc,,
+trimesh/__pycache__/comparison.cpython-311.pyc,,
+trimesh/__pycache__/constants.cpython-311.pyc,,
+trimesh/__pycache__/convex.cpython-311.pyc,,
+trimesh/__pycache__/creation.cpython-311.pyc,,
+trimesh/__pycache__/curvature.cpython-311.pyc,,
+trimesh/__pycache__/decomposition.cpython-311.pyc,,
+trimesh/__pycache__/exceptions.cpython-311.pyc,,
+trimesh/__pycache__/geometry.cpython-311.pyc,,
+trimesh/__pycache__/graph.cpython-311.pyc,,
+trimesh/__pycache__/grouping.cpython-311.pyc,,
+trimesh/__pycache__/inertia.cpython-311.pyc,,
+trimesh/__pycache__/intersections.cpython-311.pyc,,
+trimesh/__pycache__/interval.cpython-311.pyc,,
+trimesh/__pycache__/iteration.cpython-311.pyc,,
+trimesh/__pycache__/nsphere.cpython-311.pyc,,
+trimesh/__pycache__/parent.cpython-311.pyc,,
+trimesh/__pycache__/permutate.cpython-311.pyc,,
+trimesh/__pycache__/points.cpython-311.pyc,,
+trimesh/__pycache__/poses.cpython-311.pyc,,
+trimesh/__pycache__/primitives.cpython-311.pyc,,
+trimesh/__pycache__/proximity.cpython-311.pyc,,
+trimesh/__pycache__/registration.cpython-311.pyc,,
+trimesh/__pycache__/remesh.cpython-311.pyc,,
+trimesh/__pycache__/rendering.cpython-311.pyc,,
+trimesh/__pycache__/repair.cpython-311.pyc,,
+trimesh/__pycache__/resolvers.cpython-311.pyc,,
+trimesh/__pycache__/sample.cpython-311.pyc,,
+trimesh/__pycache__/schemas.cpython-311.pyc,,
+trimesh/__pycache__/smoothing.cpython-311.pyc,,
+trimesh/__pycache__/transformations.cpython-311.pyc,,
+trimesh/__pycache__/triangles.cpython-311.pyc,,
+trimesh/__pycache__/typed.cpython-311.pyc,,
+trimesh/__pycache__/units.cpython-311.pyc,,
+trimesh/__pycache__/util.cpython-311.pyc,,
+trimesh/__pycache__/version.cpython-311.pyc,,
+trimesh/base.py,sha256=tNFkLFqFsdgDhcjCVT_JM3tpJh4UxfUSiOm2wW6rwJg,110248
+trimesh/boolean.py,sha256=cMcnOPcdCxIGnjTDvcUd__RK-BioWbaxTQV82XTYwUU,5898
+trimesh/bounds.py,sha256=e6FJj3AhbGb6baXMyLJkHekdvZGFpjacTNeVrp1NZhk,20977
+trimesh/caching.py,sha256=SqI5pyXpep3JRAjmzlTLhQ1GECa5lAkqjyV6Qz7aEAc,19966
+trimesh/collision.py,sha256=JTfGM-VK6VvLmZuygnXUz8V4L_KGLwUxieKe_uQzTCY,24034
+trimesh/comparison.py,sha256=mQM24IEeq6lFdarFRtGSWzcDnadgK2KUFFA_TAxUQUE,5233
+trimesh/constants.py,sha256=xJ1ln2A1outZwxiniEgY7eaKheZCsJGvn6S-ro36y3g,4937
+trimesh/convex.py,sha256=0BtRUcKQs9rfqESUXg4LtJuiZTBLrrs1o2ZC0m2Jqmo,11644
+trimesh/creation.py,sha256=5DqE1zHk9kqN-15JvqtOaR06Wv9wfrva9LBTYFzMMuo,49403
+trimesh/curvature.py,sha256=W84yWS37-SJIXbxDpPnAm6ir2qJwTLnwCpBwwxooczs,6643
+trimesh/decomposition.py,sha256=TEIQITE_dMBV7yZcQomHYyxB17fIuPhMBpKOtfOqGLs,1472
+trimesh/exceptions.py,sha256=GzU9xHcbuTuMMw1_AmcgPaSB8Q7FmCUfKa3x1Xvxb3A,1464
+trimesh/exchange/__init__.py,sha256=mM-22o0bUVOJdj3EMUGdN3d1cvRI1JD_2TQs57jugIw,297
+trimesh/exchange/__pycache__/__init__.cpython-311.pyc,,
+trimesh/exchange/__pycache__/binvox.cpython-311.pyc,,
+trimesh/exchange/__pycache__/cascade.cpython-311.pyc,,
+trimesh/exchange/__pycache__/common.cpython-311.pyc,,
+trimesh/exchange/__pycache__/dae.cpython-311.pyc,,
+trimesh/exchange/__pycache__/export.cpython-311.pyc,,
+trimesh/exchange/__pycache__/load.cpython-311.pyc,,
+trimesh/exchange/__pycache__/misc.cpython-311.pyc,,
+trimesh/exchange/__pycache__/obj.cpython-311.pyc,,
+trimesh/exchange/__pycache__/off.cpython-311.pyc,,
+trimesh/exchange/__pycache__/ply.cpython-311.pyc,,
+trimesh/exchange/__pycache__/stl.cpython-311.pyc,,
+trimesh/exchange/__pycache__/threedxml.cpython-311.pyc,,
+trimesh/exchange/__pycache__/threemf.cpython-311.pyc,,
+trimesh/exchange/__pycache__/urdf.cpython-311.pyc,,
+trimesh/exchange/__pycache__/xaml.cpython-311.pyc,,
+trimesh/exchange/__pycache__/xyz.cpython-311.pyc,,
+trimesh/exchange/binvox.py,sha256=h8ITHHDE0Pd6kEdMavhk0h61pNQON-UqBxQJJKKyx88,18602
+trimesh/exchange/cascade.py,sha256=kOApQAk6pqH_Uyd9F9_PJGv6bZ06329A73IadvfSBfM,2097
+trimesh/exchange/common.py,sha256=WKm7MsW1Rgt_4-yMsLF2REm0YyxIIs_JHaZkL0C_viA,457
+trimesh/exchange/dae.py,sha256=jYDDo4NcjHrKlMFJYk8bTQ_L7CgAy074V8yIXOh8pFM,14910
+trimesh/exchange/export.py,sha256=9zgkbp05jsK-PLi4kVb6ldVG4tJWFgsf8_pN-zU0874,10460
+trimesh/exchange/gltf/__init__.py,sha256=C-urs6KKnnV3Pd9BNaURmNwQetYbu89N4oAZFBfiFZw,79987
+trimesh/exchange/gltf/__pycache__/__init__.cpython-311.pyc,,
+trimesh/exchange/gltf/__pycache__/extensions.cpython-311.pyc,,
+trimesh/exchange/gltf/extensions.py,sha256=Jc9E7vRAoRNOq9XOEOzixAJUuk3nYeWdkzNpFVITpyo,15074
+trimesh/exchange/load.py,sha256=azE8Hw_5KV4c32pVZ1iPXffVwC7qEjU_ydFXQNGank4,21516
+trimesh/exchange/misc.py,sha256=nMNJCchtfRCr6UtOYyIolwxwc1nWoB2ANUvHPPGDNvw,4762
+trimesh/exchange/obj.py,sha256=KFo4CYCnW3T76FhdtrmGlnorm-ZoDiNast0rRqK8tO0,37496
+trimesh/exchange/off.py,sha256=56CDVdrHo5nf1oaF_gYDNMVSSy6dfQtXi40PmYkVdmU,2958
+trimesh/exchange/ply.py,sha256=gTWeQ4ENC_lGZcDvn1bqGr4gy8pNs2mCn6yY5VPvz9Y,37760
+trimesh/exchange/stl.py,sha256=DsnDQGEXLJ_f1Lfp-_pb3qsWqd_QADSN6t524YOOfyg,9957
+trimesh/exchange/threedxml.py,sha256=zV2yftXAS5CdBdJ49qYsaSu04R7bH8FWrBoiOj-zNoo,15995
+trimesh/exchange/threemf.py,sha256=xj13A04L3RKCUy9oqx0nlhA4gcRGRdxC-bX4aPTg-vQ,19650
+trimesh/exchange/urdf.py,sha256=3Uz9TvL3k9e3mdOlZAF50EfAEcSqsjr_MG0inBScchw,5361
+trimesh/exchange/xaml.py,sha256=HgfS_zrHckm0588PtvWM2HsmLXotqdXOGV-m82luwLY,5436
+trimesh/exchange/xyz.py,sha256=p8ilPbWhuwy7kLMHXWABT5BqrzwdwJzDKGAQmNIeIwI,2961
+trimesh/geometry.py,sha256=NTAibuYEGSKHxtgQtpUysLJSKTtdfmpDWV8K60pUNsE,14805
+trimesh/graph.py,sha256=JjQSL5WnfEo6dfN3mIvzCRc5_iZFwYSMDhPapfJdtoU,31460
+trimesh/grouping.py,sha256=9-pbqtMh9wTQfzfcmbj98SulMW-14JotT9VEh-kblXk,27131
+trimesh/inertia.py,sha256=rg9uT0VQC31NnrczngvwsqjP3_2uJjhWJidId5jJMr4,10931
+trimesh/interfaces/__init__.py,sha256=17dhVVvYQG-0ynilMhw2HX1X8vTByVksjwASnNtwoN4,45
+trimesh/interfaces/__pycache__/__init__.cpython-311.pyc,,
+trimesh/interfaces/__pycache__/blender.cpython-311.pyc,,
+trimesh/interfaces/__pycache__/generic.cpython-311.pyc,,
+trimesh/interfaces/blender.py,sha256=6jMWjAjc54eq5hj6IFxvlvxMYn6sWtdpCmn_XfwoFCU,4704
+trimesh/interfaces/generic.py,sha256=7jCalpc1KfTi9ws-BmwMW1wAXQp9N2PGmepDZWNsRRs,3670
+trimesh/intersections.py,sha256=E2T-SxiPCEOqVm63ExfxAUS2zNgQ0rDx4-boliBcfvg,28536
+trimesh/interval.py,sha256=mi0Gny6nfzSZBVBQVSowIMhntlXj0FTdv4V5BAF4iuA,2746
+trimesh/iteration.py,sha256=wQ9V1IAaldh7AvTm02m_c2jhG8-lDrhQXWsaRx5I4B0,5550
+trimesh/nsphere.py,sha256=EVcDMIkUT9lzNpIvZ1JID_ib9b14lN9BJoqhcvDlX2I,5882
+trimesh/parent.py,sha256=7ZJU6D0Pj7KoX4X6JnGaTfRtEw64-FSKPnP7HBe8PFU,12028
+trimesh/path/__init__.py,sha256=Sfnb4j9VssDXhC45phbrFtcR5lw4k3MXQJg0UDz1y58,378
+trimesh/path/__pycache__/__init__.cpython-311.pyc,,
+trimesh/path/__pycache__/arc.cpython-311.pyc,,
+trimesh/path/__pycache__/creation.cpython-311.pyc,,
+trimesh/path/__pycache__/curve.cpython-311.pyc,,
+trimesh/path/__pycache__/entities.cpython-311.pyc,,
+trimesh/path/__pycache__/intersections.cpython-311.pyc,,
+trimesh/path/__pycache__/packing.cpython-311.pyc,,
+trimesh/path/__pycache__/path.cpython-311.pyc,,
+trimesh/path/__pycache__/polygons.cpython-311.pyc,,
+trimesh/path/__pycache__/raster.cpython-311.pyc,,
+trimesh/path/__pycache__/repair.cpython-311.pyc,,
+trimesh/path/__pycache__/segments.cpython-311.pyc,,
+trimesh/path/__pycache__/simplify.cpython-311.pyc,,
+trimesh/path/__pycache__/traversal.cpython-311.pyc,,
+trimesh/path/__pycache__/util.cpython-311.pyc,,
+trimesh/path/arc.py,sha256=9PxotC2p98OXTmYquHNy1eG2ipnrWhKaQQzPTwKyCLg,7689
+trimesh/path/creation.py,sha256=bP5_piTXXdEWwlBod7tKXs-anAgVwsqanNR8JsoJE_c,8553
+trimesh/path/curve.py,sha256=VER431Q72eFiX7ClyYtUDwGpx6Vc-T2XDpdgZjbL47g,3881
+trimesh/path/entities.py,sha256=yFL2M1tjO6gxh-lBojwydYBuh-AOUiY4bUgshV9dgWk,22568
+trimesh/path/exchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+trimesh/path/exchange/__pycache__/__init__.cpython-311.pyc,,
+trimesh/path/exchange/__pycache__/dxf.cpython-311.pyc,,
+trimesh/path/exchange/__pycache__/export.cpython-311.pyc,,
+trimesh/path/exchange/__pycache__/load.cpython-311.pyc,,
+trimesh/path/exchange/__pycache__/misc.cpython-311.pyc,,
+trimesh/path/exchange/__pycache__/svg_io.cpython-311.pyc,,
+trimesh/path/exchange/dxf.py,sha256=0_VFx8RZ786WewD4KHNMma8iIb8cT3o-1VtdqmiWS80,33130
+trimesh/path/exchange/export.py,sha256=i0hHHk87-xzJo-aftc7O6yp57zN6yppr-eGIh4-hT54,2004
+trimesh/path/exchange/load.py,sha256=pDeXLbGnjeVFHZs_UyPqxBxPscsISBwrNP8OHyzgRG4,2881
+trimesh/path/exchange/misc.py,sha256=6zAm5HxX1uu8Qhm6HASF0l0ow8FNtRwFBWtJYhuABtQ,6540
+trimesh/path/exchange/svg_io.py,sha256=duQIVwfvBMBx1P6NiB5aKgM5-q4EdzTQYgw3sgUZTBs,26446
+trimesh/path/intersections.py,sha256=G5AGVQxKxmpgHO4JQg44D-Ldfg6IkxtgzEePee_WGC4,2238
+trimesh/path/packing.py,sha256=_cthqydIedFJe6tFcxZ5u_phGcI8HhNuhIV_1v9v_1E,26347
+trimesh/path/path.py,sha256=lP6vHhYoUMAzTpOWgtDQChIFbw3LFfY821IujbWoR_s,48469
+trimesh/path/polygons.py,sha256=dvDi3rUr7aQvEC4qKjWgsuJF5D-laxrL3g-VTg5Flzo,32695
+trimesh/path/raster.py,sha256=V4oucSE0kx1o8UV9kZuLw28AgLyCvGcr8mIf2zRp2dc,3175
+trimesh/path/repair.py,sha256=nxreZyvWvRB3v1LimbgNEAww-ZoNkr5A-CaklyBFrk8,3237
+trimesh/path/segments.py,sha256=KkgbavWND24Z6tg0HAR4Rp2Hc8HIoBjHzoMo-1Kbs1o,16604
+trimesh/path/simplify.py,sha256=zJfUxCRbCnsetjHsltp-bHr8SnhhSo2StK_AsIAXzSw,12553
+trimesh/path/traversal.py,sha256=OHDqMq5nEusvlF049NP1mVdt2cU6GjJyJY6Wnm8BuNo,16259
+trimesh/path/util.py,sha256=aoHsefWw6TFfNCfbjTNLJc4V5ePTL1JTziu2-3MPJwI,1767
+trimesh/permutate.py,sha256=1nNfIzwuIcgYWXktPiGCuXqsDaxSoiGViqc2r13CGPQ,5141
+trimesh/points.py,sha256=zd4m96sCktwElejFisT7JRZzku9yJ3n_s8jQkVJ6WwQ,22283
+trimesh/poses.py,sha256=FX5nBJswYM1Wq-m3zAPClop0JnVdk_XOZjZwnZYJFh8,10437
+trimesh/primitives.py,sha256=qYYZq1Z4VW4RgGxS5-n3a5-wYwVSygxxNqJGzh-_PG8,35345
+trimesh/proximity.py,sha256=6cLcx2jWnSJvlE7p6xLRsgNR9G4IBufvuLR8Kvf7e3o,19445
+trimesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+trimesh/ray/__init__.py,sha256=5lNzMoKlQygP28tnIQgXNuoB9sjWdO92ZSdE44l_EI0,346
+trimesh/ray/__pycache__/__init__.cpython-311.pyc,,
+trimesh/ray/__pycache__/ray_pyembree.cpython-311.pyc,,
+trimesh/ray/__pycache__/ray_triangle.cpython-311.pyc,,
+trimesh/ray/__pycache__/ray_util.cpython-311.pyc,,
+trimesh/ray/ray_pyembree.py,sha256=ikR-4VB09DvQTVvw81ZXxBbl6vukbBPJkYjE5KoqSng,11555
+trimesh/ray/ray_triangle.py,sha256=Dz5qOH7FXGKsmULoGZ3LpHDQ90P-y-M1-urNC4UjIQE,12741
+trimesh/ray/ray_util.py,sha256=vAJgDSI7q25YK7Geqrh1UJwAwP_RVH6AN4bECMdge7Q,4438
+trimesh/registration.py,sha256=h6e6yea8JKW61yVBY13ipkKYMWEWwEB27DMgLwW8Q2I,41820
+trimesh/remesh.py,sha256=I5BlDSlsE_T4w1No81H-GJEOQb4qx65P0mXkk8e5b1w,16950
+trimesh/rendering.py,sha256=gww6NqyK9tE5o4VKUcqStief6sOYLfgip9I-uCIgyuM,12296
+trimesh/repair.py,sha256=q9uMeEfnL-vEwGRB4EYlAqysN85pjWV2TXrmtgliTdo,12321
+trimesh/resolvers.py,sha256=cuujk5MMvnLVLzSSYDOYO1yBZKHhhPLVvaT2Tu0efiU,21119
+trimesh/resources/__init__.py,sha256=gNYXMa6f-GDU3RFnBl-d0LH4pItbvrfTn0lgrQWAnjU,2597
+trimesh/resources/__pycache__/__init__.cpython-311.pyc,,
+trimesh/resources/color_map.json.gzip,sha256=0Edta1aXREyLNZ_ZM-fv_eEAIzKa7dvr8TLYA-wDFzU,16762
+trimesh/resources/creation.json,sha256=i72dHuxNOk2gbnSjYhWGTEL-WzeWdWR1e3t_3iDP0Ys,1084
+trimesh/resources/schema/README.md,sha256=ZwcnLfRg6Qd1eRMm3Kt9S-oi2yYh2RZT8pllnbYe0J0,443
+trimesh/resources/schema/gltf2.schema.zip,sha256=y9Fpkpfke71DmIXJO2gH5X4_gws7LXBvw6lEiOswjKg,24785
+trimesh/resources/schema/primitive/box.schema.json,sha256=STE93MwWVDyIbBTltXkVTXh6RmcALWO3JKAPrW5BpGQ,814
+trimesh/resources/schema/primitive/capsule.schema.json,sha256=347KHrkcRoGmwbTRxmOTDOTNFuf0pGRlOwGMGxOAeJc,774
+trimesh/resources/schema/primitive/cylinder.schema.json,sha256=Qvc2GhCsFDPLLx0PpD_zZE3I09lAjRbK7ZMDvyY7S34,785
+trimesh/resources/schema/primitive/extrusion.schema.json,sha256=HtKJPxN8DYFXDzVocthjZazbyx94TZlumVu_eRSKm0U,688
+trimesh/resources/schema/primitive/primitive.schema.json,sha256=GlsChe96ci2ptVzAn4_VU52xrvNdBewq77qzQQVWtEg,479
+trimesh/resources/schema/primitive/scenegraph.schema.json,sha256=Gn8inknthqkoXDyWjtVZdgO0nvC6aqWP58ESttGPDAU,791
+trimesh/resources/schema/primitive/sphere.schema.json,sha256=VvCqHrhVMSSyTBowtjBnUkeh6SX-pAK66_t6XfMLLvk,522
+trimesh/resources/schema/primitive/transform.schema.json,sha256=y4UBFIkUQ56ZUHcezFKLLnr68-ZQbWRtAGPKQsxSAlw,469
+trimesh/resources/schema/primitive/trimesh.schema.json,sha256=ioYYpvcrxKQirkbyHxKxh2plBtRXaV9fQU0Oq3WYt8U,859
+trimesh/resources/schema/primitive/wkt.polygon.schema.json,sha256=ryizpoS5vuRWC1YA_LrfFgE4D-32wjUu4X_7_opottM,413
+trimesh/resources/schema/urdf.xsd,sha256=qiA_TEiCkEc8JOL91auwwSpa8xPy49OF0eWAtn1BEkE,11705
+trimesh/resources/templates/base.svg,sha256=MYfPqEHyr5ik4RVyHhludqVaPFJ5Wxjd_Pd32XK6y8c,190
+trimesh/resources/templates/blender_boolean.py.tmpl,sha256=uJ8W5QN-Alq-sRpA7MaJ1Xm3BxiIsEWbsUmTlHRPwIg,2012
+trimesh/resources/templates/blender_unwrap.py.template,sha256=GJOEzRKEtskHwD9PfyvNdEgA3umFeKlURrS0m0kp1As,1147
+trimesh/resources/templates/dxf.json,sha256=E3CfXHa_S5NIyt3FPd4WhLBrhJCQqFSdq9LCUtmLxlo,15667
+trimesh/resources/templates/path.svg,sha256=JPEKKh2lPcwuM0JrOl6iCUIjci-yrlUqq8T-AWUYyX0,36
+trimesh/resources/templates/ply.json,sha256=MxeHS5AqDqw4eQb_frkAoywxpkJxjSdcHu9DyPXpNkA,559
+trimesh/resources/templates/viewer.zip,sha256=chvLtgz_KYjO3-VHWSmU3tdAo0W6QJDhft3jgZMHScU,173435
+trimesh/resources/units_to_inches.json,sha256=rq_7NUdr-xptFoMX9ahCu4OLPGLxccKragKi5PdbT2w,1265
+trimesh/sample.py,sha256=jf7T9gbqMUbzOGTbGYkbOTk164JT0tpXaZVKxjfBkFE,8629
+trimesh/scene/__init__.py,sha256=vLW7-tLswsCiiANiRFeZ8LZpCyiEbeBXw9ZzDC64bTg,141
+trimesh/scene/__pycache__/__init__.cpython-311.pyc,,
+trimesh/scene/__pycache__/cameras.cpython-311.pyc,,
+trimesh/scene/__pycache__/lighting.cpython-311.pyc,,
+trimesh/scene/__pycache__/scene.cpython-311.pyc,,
+trimesh/scene/__pycache__/transforms.cpython-311.pyc,,
+trimesh/scene/cameras.py,sha256=NpkKA6lc5feW8RvO6QvdEjro3ZZ3ScVNx-lsOeaCmi0,12166
+trimesh/scene/lighting.py,sha256=PbjxN_yUxFHIWKzrvTyD2Mnq2nJhiK7kkn97VSExjQE,8723
+trimesh/scene/scene.py,sha256=bdAe_Qntrlj502Q9c_nKlDkEyzU6UvnY9mMyE7aE4Vs,54380
+trimesh/scene/transforms.py,sha256=84vrEYl0FyxCJw0DXzu3frXTdN6MJRqre84aM6--jqI,28938
+trimesh/schemas.py,sha256=EKTwX16mVeQ5IPRQhXCoiDIIet_9DaYVNKnUx0MoMKo,1287
+trimesh/smoothing.py,sha256=5uret7Yp6MGTnwxIspVQDHJuaoDxrtctuAJ6bpTy6h0,12231
+trimesh/transformations.py,sha256=ZEsRJzYSS3gDwCiiSCeZJtEPdIZJY0AG1JOpByLq42A,74801
+trimesh/triangles.py,sha256=uBXNJOqeLAJSzd5ulgJsxH6MfzfUYpbbp-TvD5jORyc,22828
+trimesh/typed.py,sha256=ljmWfdx978-PW8GVmPicqM58Bk-ptSipqcT7aNndWOs,4572
+trimesh/units.py,sha256=B_n8Gp2DC2wvjOM8xQZFtswfoMGmAKaXgUfJVVepyXA,4600
+trimesh/util.py,sha256=JR8stHxeNUfTQUGqWDmwJjjUtJIfhXEIpe1oWvYhP3Y,75569
+trimesh/version.py,sha256=een2lq8n1QFi2zucBxUkfirUmKB7jhHyCDSumq5UeEM,1352
+trimesh/viewer/__init__.py,sha256=GexDehAA_EQNOHrD9v7D50UHzjRb-x6-8YrPCcx87GM,842
+trimesh/viewer/__pycache__/__init__.cpython-311.pyc,,
+trimesh/viewer/__pycache__/notebook.cpython-311.pyc,,
+trimesh/viewer/__pycache__/trackball.cpython-311.pyc,,
+trimesh/viewer/__pycache__/windowed.cpython-311.pyc,,
+trimesh/viewer/notebook.py,sha256=yQieeH6aP0T2VrfxhZXUxJfZwmR8PThTJWaY43KU-Xk,4652
+trimesh/viewer/trackball.py,sha256=Ac223FA8TuI5NqtylRjsbwIrKOvohy5k2m3FyFSOXW4,8233
+trimesh/viewer/windowed.py,sha256=N2R8o5S05_Ni4CEtvTLdxlQa2fHHcww2_grm3ReMTas,33883
+trimesh/visual/__init__.py,sha256=dGTdTpHWt66Rt7IvzqQivdlWNgH-ofHUD9iTfRm78_E,828
+trimesh/visual/__pycache__/__init__.cpython-311.pyc,,
+trimesh/visual/__pycache__/base.cpython-311.pyc,,
+trimesh/visual/__pycache__/color.cpython-311.pyc,,
+trimesh/visual/__pycache__/gloss.cpython-311.pyc,,
+trimesh/visual/__pycache__/material.cpython-311.pyc,,
+trimesh/visual/__pycache__/objects.cpython-311.pyc,,
+trimesh/visual/__pycache__/texture.cpython-311.pyc,,
+trimesh/visual/base.py,sha256=rLBIbRocEqx_NNgh-YK1Hgd5tY1V5PIEOTLKrd4Bajk,1014
+trimesh/visual/color.py,sha256=Lrbu0Qpe9iZtl_qJL_mvMKAcQ5wif9XnSuoEFVjHWC4,36652
+trimesh/visual/gloss.py,sha256=_jlKRmscbrmuJ_EKdIvMrMXh2GxI25PfWU5ASR0F6Pg,14576
+trimesh/visual/material.py,sha256=6P9cED6GXE6PkD6yG9SIJoBzfXYwtdHOyOjrqUnIilE,36062
+trimesh/visual/objects.py,sha256=zqoB_BEBoMM06_8IlcEZmJCudN7-I6oIYelO2fXZNzs,2554
+trimesh/visual/texture.py,sha256=SiNtJFo_nW3YohFwDqTo14tkT6vx_BK5u5ZyF3BwnFU,10677
+trimesh/voxel/__init__.py,sha256=cRHtVx79ffVWI7GDV9YURMYzuRYqgcGQ4MKBXTFiLjk,88
+trimesh/voxel/__pycache__/__init__.cpython-311.pyc,,
+trimesh/voxel/__pycache__/base.cpython-311.pyc,,
+trimesh/voxel/__pycache__/creation.cpython-311.pyc,,
+trimesh/voxel/__pycache__/encoding.cpython-311.pyc,,
+trimesh/voxel/__pycache__/morphology.cpython-311.pyc,,
+trimesh/voxel/__pycache__/ops.cpython-311.pyc,,
+trimesh/voxel/__pycache__/runlength.cpython-311.pyc,,
+trimesh/voxel/__pycache__/transforms.cpython-311.pyc,,
+trimesh/voxel/base.py,sha256=XXvxPQ9bFEsCfyQobpiXfg1omJoMdprGfPRSo6VOW0s,12663
+trimesh/voxel/creation.py,sha256=lkFLzbeHzZnrdzu_j1Tu7MnlP__V3o9gyTyHz_ASE8U,9653
+trimesh/voxel/encoding.py,sha256=6pvX8fAHmWtKC6HyHdEOoxLkJqIXmL3qjDnHb2Dm4Is,27740
+trimesh/voxel/morphology.py,sha256=Pv1uqH3NVfGi1oUtt8alywmiAsqVOBGJDlvYpS5qj20,5455
+trimesh/voxel/ops.py,sha256=nrTvlwntHvV1LHHGjckLDxFIVREw-HOojaeJfT9Lo3c,13619
+trimesh/voxel/runlength.py,sha256=hVNppnBruSCQsnTJ7Au9WtHaW0YUKsWg7OiZf_OOwZs,20386
+trimesh/voxel/transforms.py,sha256=EoyMBMIF1F6f5hGf0sgcTKKEh4dR8YbdzntUrHl5ejw,5259

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trimesh = trimesh:__main__.main

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Michael Dawson-Haggerty
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh-5.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+trimesh

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/geometry.py

@@ -0,0 +1,470 @@
+import numpy as np
+
+from . import util
+from .constants import log
+from .typed import NDArray
+
+try:
+    import scipy.sparse
+except BaseException as E:
+    from . import exceptions
+
+    # raise E again if anyone tries to use sparse
+    scipy = exceptions.ExceptionWrapper(E)
+
+
+def plane_transform(origin, normal):
+    """
+    Given the origin and normal of a plane find the transform
+    that will move that plane to be coplanar with the XY plane.
+
+    Parameters
+    ----------
+    origin : (3,) float
+        Point that lies on the plane
+    normal : (3,) float
+        Vector that points along normal of plane
+
+    Returns
+    ---------
+    transform: (4,4) float
+        Transformation matrix to move points onto XY plane
+    """
+    transform = align_vectors(normal, [0, 0, 1])
+    if origin is not None:
+        transform[:3, 3] = -np.dot(transform, np.append(origin, 1))[:3]
+    return transform
+
+
+def align_vectors(a, b, return_angle=False):
+    """
+    Find the rotation matrix that transforms one 3D vector
+    to another.
+
+    Parameters
+    ------------
+    a : (3,) float
+      Unit vector
+    b : (3,) float
+      Unit vector
+    return_angle : bool
+      Return the angle between vectors or not
+
+    Returns
+    -------------
+    matrix : (4, 4) float
+      Homogeneous transform to rotate from `a` to `b`
+    angle : float
+      If `return_angle` angle in radians between `a` and `b`
+
+    """
+    a = np.array(a, dtype=np.float64)
+    b = np.array(b, dtype=np.float64)
+    if a.shape != (3,) or b.shape != (3,):
+        raise ValueError("vectors must be (3,)!")
+
+    # find the SVD of the two vectors
+    au = np.linalg.svd(a.reshape((-1, 1)))[0]
+    bu = np.linalg.svd(b.reshape((-1, 1)))[0]
+
+    if np.linalg.det(au) < 0:
+        au[:, -1] *= -1.0
+    if np.linalg.det(bu) < 0:
+        bu[:, -1] *= -1.0
+
+    # put rotation into homogeneous transformation
+    matrix = np.eye(4)
+    matrix[:3, :3] = bu.dot(au.T)
+
+    if return_angle:
+        # projection of a onto b
+        # first column of SVD result is normalized source vector
+        dot = np.dot(au[:, 0], bu[:, 0])
+        # clip to avoid floating point error
+        angle = np.arccos(np.clip(dot, -1.0, 1.0))
+        return matrix, angle
+
+    return matrix
+
+
+def faces_to_edges(faces, return_index=False):
+    """
+    Given a list of faces (n,3), return a list of edges (n*3,2)
+
+    Parameters
+    -----------
+    faces : (n, 3) int
+      Vertex indices representing faces
+
+    Returns
+    -----------
+    edges : (n*3, 2) int
+      Vertex indices representing edges
+    """
+    faces = np.asanyarray(faces, np.int64)
+
+    # each face has three edges
+    edges = faces[:, [0, 1, 1, 2, 2, 0]].reshape((-1, 2))
+
+    if return_index:
+        # edges are in order of faces due to reshape
+        face_index = np.tile(np.arange(len(faces)), (3, 1)).T.reshape(-1)
+        return edges, face_index
+    return edges
+
+
+def vector_angle(pairs):
+    """
+    Find the angles between pairs of unit vectors.
+
+    Parameters
+    ----------
+    pairs : (n, 2, 3) float
+      Unit vector pairs
+
+    Returns
+    ----------
+    angles : (n,) float
+      Angles between vectors in radians
+    """
+    pairs = np.asanyarray(pairs, dtype=np.float64)
+    if len(pairs) == 0:
+        return np.array([])
+    elif util.is_shape(pairs, (2, 3)):
+        pairs = pairs.reshape((-1, 2, 3))
+    elif not util.is_shape(pairs, (-1, 2, (2, 3))):
+        raise ValueError("pairs must be (n,2,(2|3))!")
+
+    # do the dot product between vectors
+    dots = util.diagonal_dot(pairs[:, 0], pairs[:, 1])
+    # clip for floating point error
+    dots = np.clip(dots, -1.0, 1.0)
+    # do cos and remove arbitrary sign
+    angles = np.abs(np.arccos(dots))
+
+    return angles
+
+
+def triangulate_quads(quads, dtype=np.int64, use_fan: bool = True) -> NDArray:
+    """
+    Given an array of quad faces return them as triangle faces,
+    also handles pure triangles and mixed triangles and quads.
+
+    Parameters
+    -----------
+    quads: (n, 4) int
+      Vertex indices of quad faces.
+    dtype
+      Data type requested for the return
+    use_fan
+      Triangulate holes larger than quads with fans,
+      which may be wrong if the holes are non-convex
+
+    Returns
+    -----------
+    faces : (m, 3) int
+      Vertex indices of triangular faces.
+    """
+
+    if len(quads) == 0:
+        return np.zeros(0, dtype=dtype)
+
+    try:
+        # this will fail in newer versions of numpy
+        # if there are mixed quads and tris
+        quads = np.array(quads, dtype=dtype)
+
+        if len(quads.shape) == 2 and quads.shape[1] == 3:
+            # if they are just triangles return immediately
+            return quads.astype(dtype)
+
+        if len(quads.shape) == 2 and quads.shape[1] == 4:
+            # if they are just quads stack and return
+            return np.vstack((quads[:, [0, 1, 2]], quads[:, [2, 3, 0]])).astype(dtype)
+    except ValueError:
+        # new numpy raises an error for sequences
+        pass
+
+    # we made it here so we have mixed tris/quads/polygons
+    # do one pass to get the lengths
+    lengths = np.array([len(i) for i in quads], dtype=np.int64)
+
+    # get triangles and quads as clean constant-row numpy arrays
+    tri = np.array([quads[i] for i in np.nonzero(lengths == 3)[0]], dtype=np.int64)
+    quad = np.array([quads[i] for i in np.nonzero(lengths == 4)[0]], dtype=np.int64)
+
+    if use_fan:
+        # get arbitrary polygons as a ragged sequence
+        poly = [quads[i] for i in np.nonzero(lengths > 4)[0]]
+    else:
+        # skip any hole larger than a quad
+        poly = []
+
+    if len(quad) == 0 and len(poly) == 0:
+        # only triangles, return triangles
+        return tri.astype(dtype)
+    if len(poly) > 0:
+        # use numpy slicing to triangulate ragged-sequence polygons
+        poly = util.triangle_fans_to_faces(poly)
+    if len(quad) > 0:
+        # trivially tessellate quads
+        quad = np.vstack((quad[:, [0, 1, 2]], quad[:, [2, 3, 0]]))
+    # stack triangles from all three cases
+    return util.vstack_empty([tri, quad, poly]).astype(dtype)
+
+
+def vertex_face_indices(vertex_count, faces, faces_sparse):
+    """
+    Find vertex face indices from the faces array of vertices
+
+    Parameters
+    -----------
+    vertex_count : int
+      The number of vertices faces refer to
+    faces : (n, 3) int
+      List of vertex indices
+    faces_sparse : scipy.sparse.COO
+      Sparse matrix
+
+    Returns
+    -----------
+    vertex_faces : (vertex_count, ) int
+      Face indices for every vertex
+      Array padded with -1 in each row for all vertices with fewer
+      face indices than the max number of face indices.
+    """
+    # Create 2D array with row for each vertex and
+    # length of max number of faces for a vertex
+    try:
+        counts = np.bincount(faces.flatten(), minlength=vertex_count)
+    except TypeError:
+        # casting failed on 32 bit Windows
+        log.warning("casting failed, falling back!")
+        # fall back to np.unique (usually ~35x slower than bincount)
+        counts = np.unique(faces.flatten(), return_counts=True)[1]
+    assert len(counts) == vertex_count
+    assert faces.max() < vertex_count
+
+    # start cumulative sum at zero and clip off the last value
+    starts = np.append(0, np.cumsum(counts)[:-1])
+    # pack incrementing array into final shape
+    pack = np.arange(counts.max()) + starts[:, None]
+    # pad each row with -1 to pad to the max length
+    padded = -(pack >= (starts + counts)[:, None]).astype(np.int64)
+
+    try:
+        # do most of the work with a sparse dot product
+        identity = scipy.sparse.identity(len(faces), dtype=int)
+        sorted_faces = faces_sparse.dot(identity).nonzero()[1]
+        # this will fail if any face was degenerate
+        # TODO
+        # figure out how to filter out degenerate faces from sparse
+        # result if sorted_faces.size != faces.size
+        padded[padded == 0] = sorted_faces
+    except BaseException:
+        # fall back to a slow loop
+        log.warning(
+            "vertex_faces falling back to slow loop! "
+            + "mesh probably has degenerate faces",
+            exc_info=True,
+        )
+        sort = np.zeros(faces.size, dtype=np.int64)
+        flat = faces.flatten()
+        for v in range(vertex_count):
+            # assign the data in order
+            sort[starts[v] : starts[v] + counts[v]] = (np.where(flat == v)[0] // 3)[::-1]
+        padded[padded == 0] = sort
+    return padded
+
+
+def mean_vertex_normals(vertex_count, faces, face_normals, sparse=None, **kwargs):
+    """
+    Find vertex normals from the mean of the faces that contain
+    that vertex.
+
+    Parameters
+    -----------
+    vertex_count : int
+      The number of vertices faces refer to
+    faces : (n, 3) int
+      List of vertex indices
+    face_normals : (n, 3) float
+      Normal vector for each face
+
+    Returns
+    -----------
+    vertex_normals : (vertex_count, 3) float
+      Normals for every vertex
+      Vertices unreferenced by faces will be zero.
+    """
+
+    def summed_sparse():
+        # use a sparse matrix of which face contains each vertex to
+        # figure out the summed normal at each vertex
+        # allow cached sparse matrix to be passed
+        if sparse is None:
+            matrix = index_sparse(vertex_count, faces)
+        else:
+            matrix = sparse
+        summed = matrix.dot(face_normals)
+        return summed
+
+    def summed_loop():
+        # loop through every face, in tests was ~50x slower than
+        # doing this with a sparse matrix
+        summed = np.zeros((vertex_count, 3))
+        for face, normal in zip(faces, face_normals):
+            summed[face] += normal
+        return summed
+
+    try:
+        summed = summed_sparse()
+    except BaseException:
+        log.warning("unable to use sparse matrix, falling back!", exc_info=True)
+        summed = summed_loop()
+
+    # invalid normals will be returned as zero
+    vertex_normals = util.unitize(summed)
+
+    return vertex_normals
+
+
+def weighted_vertex_normals(
+    vertex_count, faces, face_normals, face_angles, use_loop=False
+):
+    """
+    Compute vertex normals from the faces that contain that vertex.
+    The contribution of a face's normal to a vertex normal is the
+    ratio of the corner-angle in which the vertex is, with respect
+    to the sum of all corner-angles surrounding the vertex.
+
+    Grit Thuerrner & Charles A. Wuethrich (1998)
+    Computing Vertex Normals from Polygonal Facets,
+    Journal of Graphics Tools, 3:1, 43-46
+
+    Parameters
+    -----------
+    vertex_count : int
+      The number of vertices faces refer to
+    faces : (n, 3) int
+      List of vertex indices
+    face_normals : (n, 3) float
+      Normal vector for each face
+    face_angles : (n, 3) float
+      Angles at each vertex in the face
+
+    Returns
+    -----------
+    vertex_normals : (vertex_count, 3) float
+      Normals for every vertex
+      Vertices unreferenced by faces will be zero.
+    """
+
+    def summed_sparse():
+        # use a sparse matrix of which face contains each vertex to
+        # figure out the summed normal at each vertex
+        # allow cached sparse matrix to be passed
+        # fill the matrix with vertex-corner angles as weights
+        matrix = index_sparse(vertex_count, faces, data=face_angles.ravel())
+        return matrix.dot(face_normals)
+
+    def summed_loop():
+        summed = np.zeros((vertex_count, 3), np.float64)
+        for vertex_idx in np.arange(vertex_count):
+            # loop over all vertices
+            # compute normal contributions from surrounding faces
+            # obviously slower than with the sparse matrix
+            face_idxs, inface_idxs = np.where(faces == vertex_idx)
+            surrounding_angles = face_angles[face_idxs, inface_idxs]
+            summed[vertex_idx] = np.dot(
+                surrounding_angles / surrounding_angles.sum(), face_normals[face_idxs]
+            )
+
+        return summed
+
+    # normals should be unit vectors
+    face_ok = (face_normals**2).sum(axis=1) > 0.5
+    # don't consider faces with invalid normals
+    faces = faces[face_ok]
+    face_normals = face_normals[face_ok]
+    face_angles = face_angles[face_ok]
+
+    if not use_loop:
+        try:
+            return util.unitize(summed_sparse())
+        except BaseException:
+            log.warning("unable to use sparse matrix, falling back!", exc_info=True)
+    # we either crashed or were asked to loop
+    return util.unitize(summed_loop())
+
+
+def index_sparse(columns, indices, data=None, dtype=None):
+    """
+    Return a sparse matrix for which vertices are contained in which faces.
+    A data vector can be passed which is then used instead of booleans
+
+    Parameters
+    ------------
+    columns : int
+      Number of columns, usually number of vertices
+    indices : (m, d) int
+      Usually mesh.faces
+
+    Returns
+    ---------
+    sparse: scipy.sparse.coo_matrix of shape (columns, len(faces))
+            dtype is boolean
+
+    Examples
+     ----------
+    In [1]: sparse = faces_sparse(len(mesh.vertices), mesh.faces)
+
+    In [2]: sparse.shape
+    Out[2]: (12, 20)
+
+    In [3]: mesh.faces.shape
+    Out[3]: (20, 3)
+
+    In [4]: mesh.vertices.shape
+    Out[4]: (12, 3)
+
+    In [5]: dense = sparse.toarray().astype(int)
+
+    In [6]: dense
+    Out[6]:
+    array([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+           [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0],
+           [0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0],
+           [0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1],
+           [1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0],
+           [0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0],
+           [0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1],
+           [0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1]])
+
+    In [7]: dense.sum(axis=0)
+    Out[7]: array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3])
+    """
+    indices = np.asanyarray(indices)
+    columns = int(columns)
+
+    # flattened list
+    row = indices.reshape(-1)
+    col = np.tile(
+        np.arange(len(indices)).reshape((-1, 1)), (1, indices.shape[1])
+    ).reshape(-1)
+
+    shape = (columns, len(indices))
+    if data is None:
+        data = np.ones(len(col), dtype=bool)
+    elif len(data) != len(col):
+        raise ValueError("data incorrect length")
+
+    if dtype is not None:
+        data = data.astype(dtype)
+
+    # assemble into sparse matrix
+    return scipy.sparse.coo_matrix((data, (row, col)), shape=shape, dtype=data.dtype)

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/graph.py

@@ -0,0 +1,1017 @@
+"""
+graph.py
+-------------
+
+Deal with graph operations. Primarily deal with graphs in (n, 2)
+edge list form, and abstract the backend graph library being used.
+
+Currently uses networkx or scipy.sparse.csgraph backend.
+"""
+
+import collections
+
+import numpy as np
+
+from . import exceptions, grouping, util
+from .constants import log, tol
+from .geometry import faces_to_edges
+from .typed import (
+    ArrayLike,
+    GraphEngineType,
+    Integer,
+    NDArray,
+    Number,
+    Sequence,
+    int64,
+)
+
+try:
+    from scipy.sparse import coo_matrix, csgraph
+    from scipy.spatial import cKDTree
+except BaseException as E:
+    # re-raise exception when used
+    cKDTree = exceptions.ExceptionWrapper(E)
+    csgraph = exceptions.ExceptionWrapper(E)
+    coo_matrix = exceptions.ExceptionWrapper(E)
+
+try:
+    import networkx as nx
+except BaseException as E:
+    # create a dummy module which will raise the ImportError
+    # or other exception only when someone tries to use networkx
+    nx = exceptions.ExceptionWrapper(E)
+
+
+def face_adjacency(faces=None, mesh=None, return_edges=False):
+    """
+    Returns an (n, 2) list of face indices.
+    Each pair of faces in the list shares an edge, making them adjacent.
+
+
+    Parameters
+    -----------
+    faces : (n, 3) int, or None
+        Vertex indices representing triangles
+    mesh : Trimesh object
+        If passed will used cached edges
+        instead of generating from faces
+    return_edges : bool
+        Return the edges shared by adjacent faces
+
+    Returns
+    ----------
+    adjacency : (m, 2) int
+        Indexes of faces that are adjacent
+    edges: (m, 2) int
+        Only returned if return_edges is True
+        Indexes of vertices which make up the
+        edges shared by the adjacent faces
+
+    Examples
+    ----------
+    This is useful for lots of things such as finding
+    face- connected components:
+    ```python
+    >>> graph = nx.Graph()
+    >>> graph.add_edges_from(mesh.face_adjacency)
+    >>> groups = nx.connected_components(graph_connected)
+    ```
+    """
+
+    if mesh is None:
+        # first generate the list of edges for the current faces
+        # also return the index for which face the edge is from
+        edges, edges_face = faces_to_edges(faces, return_index=True)
+        # make sure edge rows are sorted
+        edges.sort(axis=1)
+    else:
+        # if passed a mesh, used the cached values
+        edges = mesh.edges_sorted
+        edges_face = mesh.edges_face
+
+    # this will return the indices for duplicate edges
+    # every edge appears twice in a well constructed mesh
+    # so for every row in edge_idx:
+    # edges[edge_idx[*][0]] == edges[edge_idx[*][1]]
+    # in this call to group rows we discard edges which
+    # don't occur twice
+    edge_groups = grouping.group_rows(edges, require_count=2)
+
+    if len(edge_groups) == 0:
+        log.debug("No adjacent faces detected! Did you merge vertices?")
+
+    # the pairs of all adjacent faces
+    # so for every row in face_idx, self.faces[face_idx[*][0]] and
+    # self.faces[face_idx[*][1]] will share an edge
+    adjacency = edges_face[edge_groups]
+
+    # degenerate faces may appear in adjacency as the same value
+    nondegenerate = adjacency[:, 0] != adjacency[:, 1]
+    adjacency = adjacency[nondegenerate]
+
+    # sort pairs in-place so we can search for indexes with ordered pairs
+    adjacency.sort(axis=1)
+
+    if return_edges:
+        adjacency_edges = edges[edge_groups[:, 0][nondegenerate]]
+        assert len(adjacency_edges) == len(adjacency)
+        return adjacency, adjacency_edges
+
+    return adjacency
+
+
+def face_neighborhood(mesh) -> NDArray[int64]:
+    """
+    Find faces that share a vertex i.e. 'neighbors' faces.
+    Relies on the fact that an adjacency matrix at a power p
+    contains the number of paths of length p connecting two nodes.
+    Here we take the bipartite graph from mesh.faces_sparse to the power 2.
+    The non-zeros are the faces connected by one vertex.
+
+    Returns
+    ----------
+    neighborhood : (n, 2) int
+        Pairs of faces which share a vertex
+    """
+
+    VT = mesh.faces_sparse
+    TT = VT.T * VT
+    TT.setdiag(0)
+    TT.eliminate_zeros()
+    TT = TT.tocoo()
+    neighborhood = np.concatenate(
+        (TT.row[:, None], TT.col[:, None]), axis=-1, dtype=np.int64
+    )
+    return neighborhood
+
+
+def face_adjacency_unshared(mesh):
+    """
+    Return the vertex index of the two vertices not in the shared
+    edge between two adjacent faces
+
+    Parameters
+    ----------
+    mesh : Trimesh object
+      Input mesh
+
+    Returns
+    -----------
+    vid_unshared : (len(mesh.face_adjacency), 2) int
+      Indexes of mesh.vertices
+      for degenerate faces without exactly
+      one unshared vertex per face it will be -1
+    """
+
+    # the non- shared vertex index is the same shape
+    # as face_adjacency holding vertex indices vs face indices
+    vid_unshared = np.zeros_like(mesh.face_adjacency, dtype=np.int64) - 1
+    # get the shared edges between adjacent faces
+    edges = mesh.face_adjacency_edges
+
+    # loop through the two columns of face adjacency
+    for i, fid in enumerate(mesh.face_adjacency.T):
+        # faces from the current column of face adjacency
+        faces = mesh.faces[fid]
+        # should have one True per row of (3,)
+        # index of vertex not included in shared edge
+        unshared = np.logical_not(
+            np.logical_or(
+                faces == edges[:, 0].reshape((-1, 1)),
+                faces == edges[:, 1].reshape((-1, 1)),
+            )
+        )
+        # each row should have exactly one uncontained verted
+        row_ok = unshared.sum(axis=1) == 1
+        # any degenerate row should be ignored
+        unshared[~row_ok, :] = False
+        # set the
+        vid_unshared[row_ok, i] = faces[unshared]
+
+    return vid_unshared
+
+
+def face_adjacency_radius(mesh):
+    """
+    Compute an approximate radius between adjacent faces.
+
+    Parameters
+    --------------
+    mesh : trimesh.Trimesh
+
+    Returns
+    -------------
+    radii : (len(self.face_adjacency),) float
+      Approximate radius between faces
+      Parallel faces will have a value of np.inf
+    span :  (len(self.face_adjacency),) float
+      Perpendicular projection distance of two
+      unshared vertices onto the shared edge
+    """
+
+    # solve for the radius of the adjacent faces
+    #       distance
+    # R = ---------------
+    #     2 * sin(theta)
+    nonzero = mesh.face_adjacency_angles > np.radians(0.01)
+    denominator = np.abs(2.0 * np.sin(mesh.face_adjacency_angles[nonzero]))
+
+    # consider the distance between the non- shared vertices of the
+    # face adjacency pair as the key distance
+    point_pairs = mesh.vertices[mesh.face_adjacency_unshared]
+    vectors = np.diff(point_pairs, axis=1).reshape((-1, 3))
+
+    # the vertex indices of the shared edge for the adjacency pairx
+    edges = mesh.face_adjacency_edges
+    # unit vector along shared the edge
+    edges_vec = util.unitize(np.diff(mesh.vertices[edges], axis=1).reshape((-1, 3)))
+
+    # the vector of the perpendicular projection to the shared edge
+    perp = np.subtract(
+        vectors, (util.diagonal_dot(vectors, edges_vec).reshape((-1, 1)) * edges_vec)
+    )
+    # the length of the perpendicular projection
+    span = util.row_norm(perp)
+
+    # complete the values for non- infinite radii
+    radii = np.ones(len(mesh.face_adjacency)) * np.inf
+    radii[nonzero] = span[nonzero] / denominator
+
+    return radii, span
+
+
+def vertex_adjacency_graph(mesh):
+    """
+    Returns a networkx graph representing the vertices and
+    their connections in the mesh.
+
+    Parameters
+    ----------
+    mesh : Trimesh object
+
+    Returns
+    ---------
+    graph : networkx.Graph
+        Graph representing vertices and edges between
+        them where vertices are nodes and edges are edges
+
+    Examples
+    ----------
+    This is useful for getting nearby vertices for a given vertex,
+    potentially for some simple smoothing techniques.
+    >>> graph = mesh.vertex_adjacency_graph
+    >>> graph.neighbors(0)
+    > [1, 3, 4]
+    """
+    g = nx.Graph()
+    g.add_edges_from(mesh.edges_unique)
+    return g
+
+
+def shared_edges(faces_a, faces_b):
+    """
+    Given two sets of faces, find the edges which are in both sets.
+
+    Parameters
+    ---------
+    faces_a : (n, 3) int
+      Array of faces
+    faces_b : (m, 3) int
+      Array of faces
+
+    Returns
+    ---------
+    shared : (p, 2) int
+      Edges shared between faces
+    """
+    e_a = np.sort(faces_to_edges(faces_a), axis=1)
+    e_b = np.sort(faces_to_edges(faces_b), axis=1)
+    shared = grouping.boolean_rows(e_a, e_b, operation=np.intersect1d)
+    return shared
+
+
+def facets(mesh, engine: GraphEngineType = None, facet_threshold: Number | None = None):
+    """
+    Find the list of parallel adjacent faces.
+
+    Parameters
+    -----------
+    mesh : trimesh.Trimesh
+    engine
+      Which graph engine to use
+    facet_threshold : float
+      Threshold for two facets to be considered coplanar
+
+    Returns
+    ---------
+    facets : sequence of (n,) int
+        Groups of face indexes of
+        parallel adjacent faces.
+    """
+    if facet_threshold is None:
+        facet_threshold = tol.facet_threshold
+    # what is the radius of a circle that passes through the perpendicular
+    # projection of the vector between the two non- shared vertices
+    # onto the shared edge, with the face normal from the two adjacent faces
+    radii = mesh.face_adjacency_radius
+    # what is the span perpendicular to the shared edge
+    span = mesh.face_adjacency_span
+    # a very arbitrary formula for declaring two adjacent faces
+    # parallel in a way that is hopefully (and anecdotally) robust
+    # to numeric error
+    # a common failure mode is two faces that are very narrow with a slight
+    # angle between them, so here we divide by the perpendicular span
+    # to penalize very narrow faces, and then square it just for fun
+    parallel = np.ones(len(radii), dtype=bool)
+    # if span is zero we know faces are small/parallel
+    nonzero = np.abs(span) > tol.zero
+    # faces with a radii/span ratio larger than a threshold pass
+    parallel[nonzero] = (radii[nonzero] / span[nonzero]) ** 2 > facet_threshold
+
+    # run connected components on the parallel faces to group them
+    components = connected_components(
+        mesh.face_adjacency[parallel],
+        nodes=np.arange(len(mesh.faces)),
+        min_len=2,
+        engine=engine,
+    )
+
+    return components
+
+
+def split(
+    mesh,
+    only_watertight: bool = True,
+    repair: bool = True,
+    adjacency: ArrayLike | None = None,
+    engine: GraphEngineType = None,
+    **kwargs,
+) -> list:
+    """
+    Split a mesh into multiple meshes from face
+    connectivity.
+
+    If only_watertight is true it will only return
+    watertight meshes and will attempt to repair
+    single triangle or quad holes.
+
+    Parameters
+    ----------
+    mesh : trimesh.Trimesh
+      The source multibody mesh to split
+    only_watertight
+      Only return watertight components and discard
+      any connected component that isn't fully watertight.
+    repair
+      If set try to fill small holes in a mesh, before the
+      discard step in `only_watertight.
+    adjacency : (n, 2) int
+      If passed will be used instead of `mesh.face_adjacency`
+    engine
+      Which graph engine to use for the connected components.
+
+    Returns
+    ----------
+    meshes : (m,) trimesh.Trimesh
+      Results of splitting based on parameters.
+    """
+    if adjacency is None:
+        adjacency = mesh.face_adjacency
+
+    if only_watertight:
+        # the smallest watertight mesh has 4 faces
+        min_len = 4
+    else:
+        # allow any size of connected component
+        min_len = 1
+
+    components = connected_components(
+        edges=adjacency, nodes=np.arange(len(mesh.faces)), min_len=min_len, engine=engine
+    )
+    return mesh.submesh(
+        components, only_watertight=only_watertight, repair=repair, **kwargs
+    )
+
+
+def connected_components(
+    edges, min_len: Integer = 1, nodes=None, engine: GraphEngineType = None
+):
+    """
+    Find groups of connected nodes from an edge list.
+
+    Parameters
+    -----------
+    edges : (n, 2) int
+      Edges between nodes
+    nodes : (m, ) int or None
+      List of nodes that exist
+    min_len : int
+      Minimum length of a component group to return
+    engine :  str or None
+      Which graph engine to use (None for automatic):
+      (None, 'networkx', 'scipy')
+
+
+    Returns
+    -----------
+    components : (n,) sequence of (*,) int
+      Nodes which are connected
+    """
+
+    def components_networkx():
+        """
+        Find connected components using networkx
+        """
+        graph = nx.from_edgelist(edges)
+        # make sure every face has a node, so single triangles
+        # aren't discarded (as they aren't adjacent to anything)
+        if min_len <= 1:
+            graph.add_nodes_from(nodes)
+        return [list(i) for i in nx.connected_components(graph)]
+
+    def components_csgraph():
+        """
+        Find connected components using scipy.sparse.csgraph
+        """
+        # label each node
+        labels = connected_component_labels(edges, node_count=node_count)
+
+        # we have to remove results that contain nodes outside
+        # of the specified node set and reindex
+        contained = np.zeros(node_count, dtype=bool)
+        contained[nodes] = True
+        index = np.arange(node_count, dtype=np.int64)[contained]
+        components = grouping.group(labels[contained], min_len=min_len)
+        return [index[c] for c in components]
+
+        return components
+
+    # check input edges
+    edges = np.asanyarray(edges, dtype=np.int64)
+    # if no nodes were specified just use unique
+    if nodes is None:
+        nodes = np.unique(edges)
+
+    # exit early if we have no nodes
+    if len(nodes) == 0:
+        return []
+    elif len(edges) == 0:
+        if min_len <= 1:
+            return np.reshape(nodes, (-1, 1)).tolist()
+        else:
+            return []
+
+    if not util.is_shape(edges, (-1, 2)):
+        raise ValueError("edges must be (n, 2)!")
+
+    # find the maximum index referenced in either nodes or edges
+    counts = [0]
+    if len(edges) > 0:
+        counts.append(edges.max())
+    if len(nodes) > 0:
+        counts.append(nodes.max())
+    node_count = np.max(counts) + 1
+
+    # remove edges that don't have both nodes in the node set
+    mask = np.zeros(node_count, dtype=bool)
+    mask[nodes] = True
+    edges_ok = mask[edges].all(axis=1)
+    edges = edges[edges_ok]
+
+    # networkx is pure python and is usually 5-10x slower than scipy
+    engines = collections.OrderedDict(
+        (("scipy", components_csgraph), ("networkx", components_networkx))
+    )
+
+    # if a graph engine has explicitly been requested use it
+    if engine in engines:
+        return engines[engine]()
+
+    # otherwise, go through our ordered list of graph engines
+    # until we get to one that has actually been installed
+    for function in engines.values():
+        try:
+            return function()
+        # will be raised if the library didn't import correctly above
+        except BaseException:
+            continue
+    raise ImportError("no graph engines available!")
+
+
+def connected_component_labels(edges, node_count=None):
+    """
+    Label graph nodes from an edge list, using scipy.sparse.csgraph
+
+    Parameters
+    -----------
+    edges : (n, 2) int
+       Edges of a graph
+    node_count : int, or None
+        The largest node in the graph.
+
+    Returns
+    ----------
+    labels : (node_count,) int
+        Component labels for each node
+    """
+    matrix = edges_to_coo(edges, node_count)
+    _body_count, labels = csgraph.connected_components(matrix, directed=False)
+
+    if node_count is not None:
+        assert len(labels) == node_count
+
+    return labels
+
+
+def _split_traversal(traversal: NDArray, edges_tree) -> list[NDArray]:
+    """
+    Given a traversal as a list of nodes split the traversal
+    if a sequential index pair is not in the given edges.
+    Useful since the implementation of DFS we're using will
+    happily return disconnected values in a flat traversal.
+
+    Parameters
+    --------------
+    traversal : (m,) int
+       Traversal through edges
+    edges_tree : cKDTree
+      A way to reconstruct original edge indices from
+      sorted (n, 2) edge values. This is a slight misuse of a
+      kdtree since one could just hash the tuples of the integer
+      edges, but that isn't possible with numpy arrays easily
+      and this allows a vectorized reconstruction.
+
+    Returns
+    ---------------
+    split : sequence of (p,) int
+      Traversals split into only connected paths.
+    """
+    # turn the (n,) traversal into (n-1, 2) edges
+    # save the original order of the edges for reconstruction
+    trav_edge = np.column_stack((traversal[:-1], traversal[1:]))
+
+    # check to see if the traversal edges exists in the original edges
+    # the tree is holding the sorted edges so query after sorting
+    exists = edges_tree.query(np.sort(trav_edge, axis=1))[0] < 1e-10
+
+    if exists.all():
+        split = [traversal]
+    else:
+        # contiguous groups of edges
+        blocks = grouping.blocks(exists, min_len=1, only_nonzero=True)
+        split = [
+            np.concatenate([trav_edge[:, 0][b], trav_edge[b[-1]][1:]]) for b in blocks
+        ]
+
+    # a traversal may be effectively closed so check
+    # to see if we need to add on the first index to the end
+    needs_close = np.array(
+        [
+            len(s) > 2
+            and s[0] != s[-1]
+            and edges_tree.query(sorted([s[0], s[-1]]))[0] < 1e-10
+            for s in split
+        ]
+    )
+
+    if needs_close.any():
+        for i in np.nonzero(needs_close)[0]:
+            split[i] = np.concatenate([split[i], split[i][:1]])
+
+    if tol.strict:
+        for s in split:
+            check_edge = np.sort(np.column_stack((s[:-1], s[1:])), axis=1)
+            assert (edges_tree.query(check_edge)[0] < 1e-10).all()
+
+    return split
+
+
+def fill_traversals(traversals: Sequence, edges: ArrayLike) -> Sequence | NDArray:
+    """
+    Convert a traversal of a list of edges into a sequence of
+    traversals where every pair of consecutive node indexes
+    is an edge in a passed edge list
+
+    Parameters
+    -------------
+    traversals : sequence of (m,) int
+       Node indexes of traversals of a graph
+    edges : (n, 2) int
+       Pairs of connected node indexes
+
+    Returns
+    --------------
+    splits : sequence of (p,) int
+       Node indexes of connected traversals
+    """
+    # make sure edges are correct type
+    edges = np.sort(edges, axis=1)
+    edges_tree = cKDTree(edges)
+
+    # if there are no traversals just return edges
+    if len(traversals) == 0:
+        return edges.copy()
+
+    splits = []
+    for nodes in traversals:
+        # split traversals to remove edges that don't actually exist
+        splits.extend(_split_traversal(traversal=nodes, edges_tree=edges_tree))
+
+    # turn the split traversals back into (n, 2) edges
+    included = util.vstack_empty([np.column_stack((i[:-1], i[1:])) for i in splits])
+    if len(included) > 0:
+        # sort included edges in place
+        included.sort(axis=1)
+        # make sure any edges not included in split traversals
+        # are just added as a length 2 traversal
+        splits.extend(grouping.boolean_rows(edges, included, operation=np.setdiff1d))
+    else:
+        # no edges were included, so our filled traversal
+        # is just the original edges copied over
+        splits = edges.copy()
+
+    return splits
+
+
+def traversals(edges, mode="bfs"):
+    """
+    Given an edge list generate a sequence of ordered depth
+    first search traversals using scipy.csgraph routines.
+
+    Parameters
+    ------------
+    edges : (n, 2) int
+      Undirected edges of a graph
+    mode :  str
+      Traversal type, 'bfs' or 'dfs'
+
+    Returns
+    -----------
+    traversals : (m,) sequence of (p,) int
+      Ordered DFS or BFS traversals of the graph.
+    """
+    edges = np.array(edges, dtype=np.int64)
+    if len(edges) == 0:
+        return []
+    elif not util.is_shape(edges, (-1, 2)):
+        raise ValueError("edges are not (n, 2)!")
+
+    # pick the traversal method
+    mode = str(mode).lower().strip()
+    if mode == "bfs":
+        func = csgraph.breadth_first_order
+    elif mode == "dfs":
+        func = csgraph.depth_first_order
+    else:
+        raise ValueError("traversal mode must be either dfs or bfs")
+
+    # make sure edges are sorted so we can query
+    # an ordered pair later
+    edges.sort(axis=1)
+    # coo_matrix for csgraph routines
+    graph = edges_to_coo(edges)
+
+    # get unique nodes AND leaf node info from bincount
+    bincount = np.bincount(edges.ravel())
+
+    # a leaf node occurs exactly once
+    nodes_leaf = np.nonzero(bincount == 1)[0]
+    # a non-leaf node occurs more than once
+    nodes = np.nonzero(bincount > 1)[0]
+
+    # collect traversals
+    traversals = []
+    # keep track of which nodes have been visited
+    visited = np.zeros(len(bincount) + 1, dtype=np.bool_)
+
+    # process leaf nodes first to avoid DFS backtracking
+    # starting DFS from an interior node of an open path causes
+    # backtracking, which produces non-edge consecutive pairs that
+    # fill_traversals then splits a single path into pieces
+    for start in np.concatenate((nodes_leaf, nodes)):
+        if visited[start]:
+            continue
+
+        # get an (n,) ordered traversal from this start
+        ordered = func(
+            graph, i_start=start, return_predecessors=False, directed=False
+        ).astype(np.int64)
+
+        # store the traversal and mark all nodes as visited
+        traversals.append(ordered)
+        visited[ordered] = True
+
+    return traversals
+
+
+def edges_to_coo(edges, count=None, data=None):
+    """
+    Given an edge list, return a boolean scipy.sparse.coo_matrix
+    representing the edges in matrix form.
+
+    Parameters
+    ------------
+    edges : (n, 2) int
+      Edges of a graph
+    count : int
+      The total number of nodes in the graph
+      if None: count = edges.max() + 1
+    data : (n,) any
+      Assign data to each edge, if None will
+      be bool True for each specified edge
+
+    Returns
+    ------------
+    matrix: (count, count) scipy.sparse.coo_matrix
+      Sparse COO
+    """
+    edges = np.asanyarray(edges, dtype=np.int64)
+    if not (len(edges) == 0 or util.is_shape(edges, (-1, 2))):
+        raise ValueError("edges must be (n, 2)!")
+
+    # if count isn't specified just set it to largest
+    # value referenced in edges
+    if count is None:
+        count = edges.max() + 1
+    count = int(count)
+
+    # if no data is specified set every specified edge
+    # to True
+    if data is None:
+        data = np.ones(len(edges), dtype=bool)
+
+    return coo_matrix((data, edges.T), dtype=data.dtype, shape=(count, count))
+
+
+def neighbors(edges, max_index=None, directed=False):
+    """
+    Find the neighbors for each node in an edgelist graph.
+
+    TODO : re-write this with sparse matrix operations
+
+    Parameters
+    ------------
+    edges : (n, 2) int
+      Connected nodes
+    directed : bool
+      If True, only connect edges in one direction
+
+    Returns
+    ---------
+    neighbors : sequence
+      Vertex index corresponds to set of other vertex indices
+    """
+    neighbors = collections.defaultdict(set)
+    if directed:
+        [neighbors[edge[0]].add(edge[1]) for edge in edges]
+    else:
+        [
+            (neighbors[edge[0]].add(edge[1]), neighbors[edge[1]].add(edge[0]))
+            for edge in edges
+        ]
+
+    if max_index is None:
+        max_index = edges.max() + 1
+    array = [list(neighbors[i]) for i in range(max_index)]
+
+    return array
+
+
+def smooth_shade(mesh, angle: Number | None = None, facet_minarea: Number | None = 10.0):
+    """
+    Return a non-watertight version of the mesh which
+    will render nicely with smooth shading by
+    disconnecting faces at sharp angles to each other.
+
+    Parameters
+    -----------
+    mesh : trimesh.Trimesh
+      Source geometry
+    angle : float or None
+      Angle in radians face pairs with angles
+      smaller than this will appear smoothed
+    facet_minarea : float or None
+      Minimum area fraction to consider
+      IE for `facets_minarea=25` only facets larger
+      than `mesh.area / 25` will be considered.
+
+    Returns
+    ---------
+    smooth : trimesh.Trimesh
+      Geometry with disconnected face patches
+    """
+    if angle is None:
+        angle = np.radians(20)
+
+    # if the mesh has no adjacent faces return a copy
+    if len(mesh.face_adjacency) == 0:
+        return mesh.copy()
+
+    # face pairs below angle threshold
+    angle_ok = mesh.face_adjacency_angles < angle
+    # subset of face adjacency
+    adjacency = mesh.face_adjacency[angle_ok]
+
+    # coplanar groups of faces
+    facets = []
+    nodes = None
+    # collect coplanar regions for smoothing
+    if facet_minarea is not None:
+        areas = mesh.area_faces
+        min_area = mesh.area / facet_minarea
+        try:
+            # we can survive not knowing facets
+            # exclude facets with few faces
+            facets = [f for f in mesh.facets if areas[f].sum() > min_area]
+            if len(facets) > 0:
+                # mask for removing adjacency pairs where
+                # one of the faces is contained in a facet
+                mask = np.ones(len(mesh.faces), dtype=bool)
+                mask[np.hstack(facets)] = False
+                # apply the mask to adjacency
+                adjacency = adjacency[mask[adjacency].all(axis=1)]
+                # nodes are no longer every faces
+                nodes = np.unique(adjacency)
+        except BaseException:
+            log.warning("failed to calculate facets", exc_info=True)
+    # run connected components on facet adjacency
+    components = connected_components(adjacency, min_len=2, nodes=nodes)
+
+    # add back coplanar groups if any exist
+    if len(facets) > 0:
+        components.extend(facets)
+
+    if len(components) == 0:
+        # if no components for some reason
+        # just return a copy of the original mesh
+        return mesh.copy()
+
+    # add back any faces that were missed
+    unique = np.unique(np.hstack(components))
+    if len(unique) != len(mesh.faces):
+        # things like single loose faces
+        # or groups below facet_minlen
+        broke = np.setdiff1d(np.arange(len(mesh.faces)), unique)
+        components.extend(broke.reshape((-1, 1)))
+
+    # get a submesh as a single appended Trimesh
+    smooth = mesh.submesh(components, only_watertight=False, append=True)
+    # store face indices from original mesh
+    smooth.metadata["original_components"] = components
+    # smoothed should have exactly the same number of faces
+    if len(smooth.faces) != len(mesh.faces):
+        log.warning("face count in smooth wrong!")
+    return smooth
+
+
+def is_watertight(
+    edges: ArrayLike, edges_sorted: ArrayLike | None = None
+) -> tuple[bool, bool]:
+    """
+    Parameters
+    -----------
+    edges : (n, 2) int
+      List of vertex indices
+    edges_sorted : (n, 2) int
+      Pass vertex indices sorted on axis 1 as a speedup
+
+    Returns
+    ---------
+    watertight : boolean
+      Whether every edge is shared by an even
+      number of faces
+    winding : boolean
+      Whether every shared edge is reversed
+    """
+    # passing edges_sorted is a speedup only
+    if edges_sorted is None:
+        edges_sorted = np.sort(edges, axis=1)
+
+    # group sorted edges throwing away any edge
+    # that doesn't appear exactly twice
+    groups = grouping.group_rows(edges_sorted, require_count=2)
+    # if we didn't throw away any edges that means
+    # every edge shows up exactly twice
+    watertight = bool((len(groups) * 2) == len(edges))
+
+    # check that the un-sorted duplicate edges are reversed
+    opposing = edges[groups].reshape((-1, 4))[:, 1:3].T
+    winding = bool(np.equal(*opposing).all())
+
+    return watertight, winding
+
+
+def graph_to_svg(graph):
+    """
+    Turn a networkx graph into an SVG string
+    using graphviz `dot`.
+
+    Parameters
+    ----------
+    graph: networkx graph
+
+    Returns
+    ---------
+    svg: string, pictoral layout in SVG format
+    """
+
+    import subprocess
+    import tempfile
+
+    with tempfile.NamedTemporaryFile() as dot_file:
+        nx.drawing.nx_agraph.write_dot(graph, dot_file.name)
+        svg = subprocess.check_output(["dot", dot_file.name, "-Tsvg"])
+    return svg
+
+
+def multigraph_paths(G, source, cutoff=None):
+    """
+    For a networkx MultiDiGraph, find all paths from a source node
+    to leaf nodes. This function returns edge instance numbers
+    in addition to nodes, unlike networkx.all_simple_paths.
+
+    Parameters
+    ---------------
+    G : networkx.MultiDiGraph
+      Graph to evaluate
+    source : hashable
+      Node to start traversal at
+    cutoff : int
+      Number of nodes to visit
+      If None will visit all nodes
+
+    Returns
+    ----------
+    traversals : (n,) list of [(node, edge instance index), ] paths
+      Traversals of the multigraph
+    """
+    if cutoff is None:
+        cutoff = (len(G.edges()) * len(G.nodes())) + 1
+
+    # the path starts at the node specified
+    current = [(source, 0)]
+    # traversals we need to go back and do
+    queue = []
+    # completed paths
+    traversals = []
+
+    for _ in range(cutoff):
+        # paths are stored as (node, instance) so
+        # get the node of the last place visited
+        current_node = current[-1][0]
+        # get all the children of the current node
+        child = G[current_node]
+
+        if len(child) == 0:
+            # we have no children, so we are at the end of this path
+            # save the path as a completed traversal
+            traversals.append(current)
+            # if there is nothing on the queue, we are done
+            if len(queue) == 0:
+                break
+            # otherwise continue traversing with the next path
+            # on the queue
+            current = queue.pop()
+        else:
+            # oh no, we have multiple edges from current -> child
+            start = True
+            # iterate through child nodes and edge instances
+            for node in child.keys():
+                for instance in child[node].keys():
+                    if start:
+                        # if this is the first edge, keep it on the
+                        # current traversal and save the others for later
+                        current.append((node, instance))
+                        start = False
+                    else:
+                        # this child has multiple instances
+                        # so we will need to traverse them multiple times
+                        # we appended a node to current, so only take the
+                        # first n-1 visits
+                        queue.append(current[:-1] + [(node, instance)])
+    return traversals
+
+
+def multigraph_collect(G, traversal, attrib=None):
+    """
+    Given a MultiDiGraph traversal, collect attributes along it.
+
+    Parameters
+    -------------
+    G:          networkx.MultiDiGraph
+    traversal:  (n) list of (node, instance) tuples
+    attrib:     dict key, name to collect. If None, will return all
+
+    Returns
+    -------------
+    collected: (len(traversal) - 1) list of attributes
+    """
+
+    collected = []
+    for u, v in util.pairwise(traversal):
+        attribs = G[u[0]][v[0]][v[1]]
+        if attrib is None:
+            collected.append(attribs)
+        else:
+            collected.append(attribs[attrib])
+    return collected

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/grouping.py

@@ -0,0 +1,877 @@
+"""
+grouping.py
+-------------
+
+Functions for grouping values and rows.
+"""
+
+import numpy as np
+
+from . import util
+from .constants import log, tol
+from .typed import ArrayLike, Integer, NDArray, Number, Sequence
+
+try:
+    from scipy.spatial import cKDTree
+except BaseException as E:
+    # wrapping just ImportError fails in some cases
+    # will raise the error when someone tries to use KDtree
+    from . import exceptions
+
+    cKDTree = exceptions.ExceptionWrapper(E)
+
+
+def merge_vertices(
+    mesh,
+    merge_tex: bool | None = None,
+    merge_norm: bool | None = None,
+    digits_vertex: Integer | None = None,
+    digits_norm: Integer | None = None,
+    digits_uv: Integer | None = None,
+):
+    """
+    Removes duplicate vertices, grouped by position and
+    optionally texture coordinate and normal.
+
+    Parameters
+    -------------
+    mesh : Trimesh object
+      Mesh to merge vertices on
+    merge_tex : bool
+      If True textured meshes with UV coordinates will
+      have vertices merged regardless of UV coordinates
+    merge_norm : bool
+      If True, meshes with vertex normals will have
+      vertices merged ignoring different normals
+    digits_vertex : None or int
+      Number of digits to consider for vertex position
+    digits_norm : int
+      Number of digits to consider for unit normals
+    digits_uv : int
+      Number of digits to consider for UV coordinates
+    """
+    # no vertices so exit early
+    if len(mesh.vertices) == 0:
+        return
+    if merge_tex is None:
+        merge_tex = False
+    if merge_norm is None:
+        merge_norm = False
+    if digits_norm is None:
+        digits_norm = 2
+    if digits_uv is None:
+        digits_uv = 4
+    if digits_vertex is None:
+        # use tol.merge if digit precision not passed
+        digits_vertex = util.decimal_to_digits(tol.merge)
+
+    # if we have a ton of unreferenced vertices it will
+    # make the unique_rows call super slow so cull first
+    if hasattr(mesh, "faces") and len(mesh.faces) > 0:
+        referenced = np.zeros(len(mesh.vertices), dtype=bool)
+        referenced[mesh.faces] = True
+    else:
+        # this is used for geometry without faces
+        referenced = np.ones(len(mesh.vertices), dtype=bool)
+
+    # collect vertex attributes into sequence we can stack
+    stacked = [mesh.vertices * (10**digits_vertex)]
+
+    # UV texture visuals require us to update the
+    # vertices and normals differently
+    if (
+        not merge_tex
+        and mesh.visual.defined
+        and mesh.visual.kind == "texture"
+        and mesh.visual.uv is not None
+        and len(mesh.visual.uv) == len(mesh.vertices)
+    ):
+        # get an array with vertices and UV coordinates
+        # converted to integers at requested precision
+        stacked.append(mesh.visual.uv * (10**digits_uv))
+
+    # check to see if we have vertex normals
+    normals = mesh._cache["vertex_normals"]
+    if not merge_norm and np.shape(normals) == mesh.vertices.shape:
+        stacked.append(normals * (10**digits_norm))
+
+    # stack collected vertex properties and round to integer
+    stacked = np.column_stack(stacked).round().astype(np.int64)
+
+    # check unique rows of referenced vertices
+    u, i = unique_rows(stacked[referenced], keep_order=True)
+
+    # construct an inverse using the subset
+    inverse = np.zeros(len(mesh.vertices), dtype=np.int64)
+    inverse[referenced] = i
+    # get the vertex mask
+    mask = np.nonzero(referenced)[0][u]
+    # run the update including normals and UV coordinates
+    mesh.update_vertices(mask=mask, inverse=inverse)
+
+
+def group(values, min_len: Integer | None = None, max_len: Integer | None = None):
+    """
+    Return the indices of values that are identical
+
+    Parameters
+    ----------
+    values : (n,) int
+      Values to group
+    min_len : int
+      The shortest group allowed
+      All groups will have len >= min_length
+    max_len : int
+      The longest group allowed
+      All groups will have len <= max_length
+
+    Returns
+    ----------
+    groups : sequence
+      Contains indices to form groups
+      IE [0,1,0,1] returns [[0,2], [1,3]]
+    """
+    original = np.asanyarray(values)
+
+    # save the sorted order and then apply it
+    order = original.argsort()
+    values = original[order]
+
+    # find the indexes which are duplicates
+    if values.dtype.kind == "f":
+        # for floats in a sorted array, neighbors are not duplicates
+        # if the difference between them is greater than approximate zero
+        nondupe = np.greater(np.abs(np.diff(values)), tol.zero)
+    else:
+        # for ints and strings we can check exact non- equality
+        # for all other types this will only work if they defined
+        # an __eq__
+        nondupe = values[1:] != values[:-1]
+
+    dupe_idx = np.append(0, np.nonzero(nondupe)[0] + 1)
+
+    # start with a mask that marks everything as ok
+    dupe_ok = np.ones(len(dupe_idx), dtype=bool)
+
+    # calculate the length of each group from their index
+    dupe_len = np.diff(np.concatenate((dupe_idx, [len(values)])))
+
+    # cull by length if requested
+    if min_len is not None or max_len is not None:
+        if min_len is not None:
+            dupe_ok &= dupe_len >= min_len
+        if max_len is not None:
+            dupe_ok &= dupe_len <= max_len
+
+    groups = [order[i : (i + j)] for i, j in zip(dupe_idx[dupe_ok], dupe_len[dupe_ok])]
+    return groups
+
+
+def hashable_rows(
+    data: ArrayLike, digits: Integer | None = None, allow_int: bool = True
+) -> NDArray:
+    """
+    We turn our array into integers based on the precision
+    given by digits and then put them in a hashable format.
+
+    Parameters
+    ---------
+    data : (n, m) array
+      Input data
+    digits : int or None
+      How many digits to add to hash if data is floating point
+      If None, tol.merge will be used
+
+    Returns
+    ---------
+    hashable : (n,)
+      May return as a `np.void` or a `np.uint64`
+    """
+    # if there is no data return immediately
+    if len(data) == 0:
+        return np.array([], dtype=np.uint64)
+
+    # get array as integer to precision we care about
+    as_int = float_to_int(data, digits=digits)
+
+    # if it is flat integers already return
+    if len(as_int.shape) == 1:
+        return as_int
+
+    # rows without any columns are all identical: return a constant per row
+    # rather than dividing by the column count below
+    if as_int.shape[1] == 0:
+        return np.zeros(len(as_int), dtype=np.uint64)
+
+    # if array is 2D and smallish, we can try bitbanging
+    # this is significantly faster than the custom dtype
+    if allow_int and len(as_int.shape) == 2 and as_int.shape[1] <= 4:
+        # can we pack the whole row into a single 64 bit integer
+        precision = int(np.floor(64 / as_int.shape[1]))
+
+        # get the extreme values of the data set
+        d_min, d_max = as_int.min(), as_int.max()
+        # since we are quantizing the data down we need every value
+        # to fit in a partial integer so we have to check against extrema
+        threshold = (2 ** (precision - 1)) - 1
+
+        # if the data is within the range of our precision threshold
+        if d_max < threshold and d_min > -threshold:
+            # the resulting package
+            hashable = np.zeros(len(as_int), dtype=np.uint64)
+            # offset to the middle of the unsigned integer range
+            # this array should contain only positive values
+            bitbang = (as_int.T + (threshold + 1)).astype(np.uint64)
+            # loop through each column and bitwise xor to combine
+            # make sure as_int is int64 otherwise bit offset won't work
+            for offset, column in enumerate(bitbang):
+                # will modify hashable in place
+                np.bitwise_xor(hashable, column << (offset * precision), out=hashable)
+            return hashable
+
+    # reshape array into magical data type that is weird but works with unique
+    dtype = np.dtype((np.void, as_int.dtype.itemsize * as_int.shape[1]))
+    # make sure result is contiguous and flat
+    result = np.ascontiguousarray(as_int).view(dtype).reshape(-1)
+    result.flags["WRITEABLE"] = False
+
+    return result
+
+
+def float_to_int(data, digits: Integer | None = None) -> NDArray[np.int64]:
+    """
+    Given a numpy array of float/bool/int, return as integers.
+
+    Parameters
+    -------------
+    data :  (n, d) float, int, or bool
+      Input data
+    digits : float or int
+      Precision for float conversion
+
+    Returns
+    -------------
+    as_int : (n, d) int
+      Data as integers
+    """
+    # convert to any numpy array
+    data = np.asanyarray(data)
+
+    # we can early-exit if we've been passed data that is already
+    # an integer, unsigned integer, boolean, or empty
+    if data.dtype == np.int64:
+        return data
+    elif data.dtype.kind in "iub" or data.size == 0:
+        return data.astype(np.int64)
+    elif data.dtype.kind != "f":
+        # if it's not a floating point try to make it one
+        data = data.astype(np.float64)
+
+    if digits is None:
+        # get digits from `tol.merge`
+        digits = util.decimal_to_digits(tol.merge)
+    elif not isinstance(digits, (int, np.integer)):
+        raise TypeError(f"Digits must be `None` or `int`, not `{type(digits)}`")
+
+    # multiply by requested power of ten
+    # then subtract small epsilon to avoid "go either way" rounding
+    # then do the rounding and convert to integer
+    return np.round((data * 10**digits) - 1e-6).astype(np.int64)
+
+
+def unique_ordered(
+    data: ArrayLike, return_index: bool = False, return_inverse: bool = False
+):
+    """
+    Returns the same as np.unique, but ordered as per the
+    first occurrence of the unique value in data.
+
+    Examples
+    ---------
+    In [1]: a = [0, 3, 3, 4, 1, 3, 0, 3, 2, 1]
+
+    In [2]: np.unique(a)
+    Out[2]: array([0, 1, 2, 3, 4])
+
+    In [3]: trimesh.grouping.unique_ordered(a)
+    Out[3]: array([0, 3, 4, 1, 2])
+    """
+    # uniques are the values, sorted
+    # index is the value in the original `data`
+    # i.e. `data[index] == unique`
+    # inverse is how to re-construct `data` from `unique`
+    # i.e. `unique[inverse] == data`
+    unique, index, inverse = np.unique(data, return_index=True, return_inverse=True)
+
+    # we want to maintain the original index order
+    order = index.argsort()
+
+    if not return_index and not return_inverse:
+        return unique[order]
+
+    # collect return values
+    # start with the unique values in original order
+    result = [unique[order]]
+    # the new index values
+    if return_index:
+        # re-order the index in the original array
+        result.append(index[order])
+    if return_inverse:
+        # create the new inverse from the order of the order
+        result.append(order.argsort()[inverse])
+
+    return result
+
+
+def unique_bincount(
+    values: ArrayLike,
+    minlength: Integer = 0,
+    return_inverse: bool = False,
+    return_counts: bool = False,
+):
+    """
+    For arrays of integers find unique values using bin counting.
+    Roughly 10x faster for correct input than np.unique
+
+    Parameters
+    --------------
+    values : (n,) int
+      Values to find unique members of
+    minlength : int
+      Maximum value that will occur in values (values.max())
+    return_inverse : bool
+      If True, return an inverse such that unique[inverse] == values
+    return_counts : bool
+      If True, also return the number of times each
+      unique item appears in values
+
+    Returns
+    ------------
+    unique : (m,) int
+      Unique values in original array
+    inverse : (n,) int, optional
+      An array such that unique[inverse] == values
+      Only returned if return_inverse is True
+    counts : (m,) int, optional
+      An array holding the counts of each unique item in values
+      Only returned if return_counts is True
+    """
+    values = np.asanyarray(values)
+    if len(values.shape) != 1 or values.dtype.kind != "i":
+        raise ValueError("input must be 1D integers!")
+
+    try:
+        # count the number of occurrences of each value
+        counts = np.bincount(values, minlength=minlength)
+    except TypeError:
+        # casting failed on 32 bit windows
+        log.warning("casting failed, falling back!")
+        # fall back to numpy unique
+        return np.unique(
+            values, return_inverse=return_inverse, return_counts=return_counts
+        )
+
+    # which bins are occupied at all
+    # counts are integers so this works
+    unique_bin = counts.astype(bool)
+
+    # which values are unique
+    # indexes correspond to original values
+    unique = np.where(unique_bin)[0]
+    ret = (unique,)
+
+    if return_inverse:
+        # find the inverse to reconstruct original
+        inverse = (np.cumsum(unique_bin) - 1)[values]
+        ret += (inverse,)
+
+    if return_counts:
+        unique_counts = counts[unique]
+        ret += (unique_counts,)
+
+    if len(ret) == 1:
+        return ret[0]
+    return ret
+
+
+def merge_runs(data: ArrayLike, digits: Integer | None = None):
+    """
+    Merge duplicate sequential values. This differs from unique_ordered
+    in that values can occur in multiple places in the sequence, but
+    only consecutive repeats are removed
+
+    Parameters
+    -----------
+    data: (n,) float or int
+
+    Returns
+    --------
+    merged: (m,) float or int
+
+    Examples
+    ---------
+    In [1]: a
+    Out[1]:
+    array([-1, -1, -1,  0,  0,  1,  1,  2,  0,
+            3,  3,  4,  4,  5,  5,  6,  6,  7,
+            7,  8,  8,  9,  9,  9])
+
+    In [2]: trimesh.grouping.merge_runs(a)
+    Out[2]: array([-1,  0,  1,  2,  0,  3,  4,  5,  6,  7,  8,  9])
+    """
+    if digits is None:
+        epsilon = tol.merge
+    else:
+        epsilon = 10 ** (-digits)
+
+    data = np.asanyarray(data)
+    mask = np.zeros(len(data), dtype=bool)
+    mask[0] = True
+    mask[1:] = np.abs(data[1:] - data[:-1]) > epsilon
+
+    return data[mask]
+
+
+def unique_float(
+    data,
+    return_index: bool = False,
+    return_inverse: bool = False,
+    digits: Integer | None = None,
+):
+    """
+    Identical to the numpy.unique command, except evaluates floating point
+    numbers, using a specified number of digits.
+
+    If digits isn't specified, the library default TOL_MERGE will be used.
+    """
+    data = np.asanyarray(data)
+    as_int = float_to_int(data, digits)
+    _junk, unique, inverse = np.unique(as_int, return_index=True, return_inverse=True)
+
+    if (not return_index) and (not return_inverse):
+        return data[unique]
+
+    result = [data[unique]]
+
+    if return_index:
+        result.append(unique)
+    if return_inverse:
+        result.append(inverse)
+    return tuple(result)
+
+
+def unique_rows(data, digits=None, keep_order=False):
+    """
+    Returns indices of unique rows. It will return the
+    first occurrence of a row that is duplicated:
+    [[1,2], [3,4], [1,2]] will return [0,1]
+
+    Parameters
+    ---------
+    data : (n, m) array
+      Floating point data
+    digits : int or None
+      How many digits to consider
+
+    Returns
+    --------
+    unique :  (j,) int
+      Index in data which is a unique row
+    inverse : (n,) int
+      Array to reconstruct original
+      Example: data[unique][inverse] == data
+    """
+    # get rows hashable so we can run unique function on it
+    rows = hashable_rows(data, digits=digits)
+
+    # we are throwing away the first value which is the
+    # garbage row-hash and only returning index and inverse
+    if keep_order:
+        # keeps order of original occurrence
+        return unique_ordered(rows, return_index=True, return_inverse=True)[1:]
+    # returns values sorted by row-hash but since our row-hash
+    # were pretty much garbage the sort order isn't meaningful
+    return np.unique(rows, return_index=True, return_inverse=True)[1:]
+
+
+def unique_value_in_row(data, unique=None):
+    """
+    For a 2D array of integers find the position of a
+    value in each row which only occurs once.
+
+    If there are more than one value per row which
+    occur once, the last one is returned.
+
+    Parameters
+    ----------
+    data :   (n, d) int
+      Data to check values
+    unique : (m,) int
+      List of unique values contained in data.
+      Generated from np.unique if not passed
+
+    Returns
+    ---------
+    result : (n, d) bool
+      With one or zero True values per row.
+
+
+    Examples
+    -------------------------------------
+    In [0]: r = np.array([[-1,  1,  1],
+                          [-1,  1, -1],
+                          [-1,  1,  1],
+                          [-1,  1, -1],
+                          [-1,  1, -1]], dtype=np.int8)
+
+    In [1]: unique_value_in_row(r)
+    Out[1]:
+           array([[ True, False, False],
+                  [False,  True, False],
+                  [ True, False, False],
+                  [False,  True, False],
+                  [False,  True, False]], dtype=bool)
+
+    In [2]: unique_value_in_row(r).sum(axis=1)
+    Out[2]: array([1, 1, 1, 1, 1])
+
+    In [3]: r[unique_value_in_row(r)]
+    Out[3]: array([-1,  1, -1,  1,  1], dtype=int8)
+    """
+    if unique is None:
+        unique = np.unique(data)
+    data = np.asanyarray(data)
+    result = np.zeros_like(data, dtype=bool, subok=False)
+    for value in unique:
+        test = np.equal(data, value)
+        test_ok = test.sum(axis=1) == 1
+        result[test_ok] = test[test_ok]
+    return result
+
+
+def group_rows(data, require_count=None, digits=None):
+    """
+    Returns index groups of duplicate rows, for example:
+    [[1,2], [3,4], [1,2]] will return [[0,2], [1]]
+
+
+    Note that using require_count allows numpy advanced
+    indexing to be used in place of looping and
+    checking hashes and is ~10x faster.
+
+
+    Parameters
+    ----------
+    data : (n, m) array
+      Data to group
+    require_count : None or int
+      Only return groups of a specified length, eg:
+      require_count =  2
+      [[1,2], [3,4], [1,2]] will return [[0,2]]
+    digits : None or int
+    If data is floating point how many decimals
+    to consider, or calculated from tol.merge
+
+    Returns
+    ----------
+    groups : sequence (*,) int
+      Indices from in indicating identical rows.
+    """
+
+    # start with getting a sortable format
+    hashable = hashable_rows(data, digits=digits)
+
+    # if there isn't a constant column size use more complex logic
+    if require_count is None:
+        return group(hashable)
+
+    # record the order of the rows so we can get the original indices back
+    order = hashable.argsort()
+    # but for now, we want our hashes sorted
+    hashable = hashable[order]
+    # this is checking each neighbour for equality, example:
+    # example: hashable = [1, 1, 1]; dupe = [0, 0]
+    dupe = hashable[1:] != hashable[:-1]
+    # we want the first index of a group, so we can slice from that location
+    # example: hashable = [0 1 1]; dupe = [1,0]; dupe_idx = [0,1]
+    dupe_idx = np.append(0, np.nonzero(dupe)[0] + 1)
+    # if you wanted to use this one function to deal with non- regular groups
+    # you could use: np.array_split(dupe_idx)
+    # this is roughly 3x slower than using the group_dict method above.
+    start_ok = np.diff(np.concatenate((dupe_idx, [len(hashable)]))) == require_count
+    groups = np.tile(dupe_idx[start_ok].reshape((-1, 1)), require_count) + np.arange(
+        require_count
+    )
+    groups_idx = order[groups]
+
+    if require_count == 1:
+        return groups_idx.reshape(-1)
+    return groups_idx
+
+
+def boolean_rows(
+    a: ArrayLike, b: ArrayLike, operation=np.intersect1d
+) -> NDArray[np.int64]:
+    """
+    Find the rows in two arrays which occur in both rows.
+
+    Parameters
+    ---------
+    a: (n, d) int
+        Array with row vectors
+    b: (m, d) int
+        Array with row vectors
+    operation : function
+        Numpy boolean set operation function:
+          -np.intersect1d
+          -np.setdiff1d
+
+    Returns
+    --------
+    shared : (p, d) int64
+       Array containing requested rows in both a and b
+    """
+    a = np.asanyarray(a, dtype=np.int64)
+    b = np.asanyarray(b, dtype=np.int64)
+
+    av = a.view([("", a.dtype)] * a.shape[1]).ravel()
+    bv = b.view([("", b.dtype)] * b.shape[1]).ravel()
+    return operation(av, bv).view(a.dtype).reshape(-1, a.shape[1])
+
+
+def group_vectors(vectors, angle=1e-4, include_negative=False):
+    """
+    Group vectors based on an angle tolerance, with the option to
+    include negative vectors.
+
+    Parameters
+    -----------
+    vectors : (n,3) float
+        Direction vector
+    angle : float
+        Group vectors closer than this angle in radians
+    include_negative : bool
+        If True consider the same:
+        [0,0,1] and [0,0,-1]
+
+    Returns
+    ------------
+    new_vectors : (m,3) float
+        Direction vector
+    groups : (m,) sequence of int
+        Indices of source vectors
+    """
+
+    vectors = np.asanyarray(vectors, dtype=np.float64)
+    angle = float(angle)
+
+    if include_negative:
+        vectors = util.vector_hemisphere(vectors)
+
+    spherical = util.vector_to_spherical(vectors)
+    angles, groups = group_distance(spherical, angle)
+    new_vectors = util.spherical_to_vector(angles)
+    return new_vectors, groups
+
+
+def group_distance(
+    values: ArrayLike, distance: Number
+) -> tuple[NDArray[np.float64], Sequence]:
+    """
+    Find non-overlapping groups of points where no two points in a
+    group are farther than 2*distance apart.
+
+    Parameters
+    ---------
+    values : (n, d) float
+        Points of dimension d
+    distance : float
+        Max distance between points in a cluster
+
+    Returns
+    ----------
+    unique : (m, d) float
+        Median value of each group
+    groups : (m) sequence of int
+        Indexes of points that make up a group
+
+    """
+    values = np.asanyarray(values, dtype=np.float64)
+
+    consumed = np.zeros(len(values), dtype=bool)
+    tree = cKDTree(values)
+
+    # (n, d) set of values that are unique
+    unique = []
+    # (n) sequence of indices in values
+    groups = []
+
+    for index, value in enumerate(values):
+        if consumed[index]:
+            continue
+        group = np.array(tree.query_ball_point(value, distance), dtype=np.int64)
+        group = group[~consumed[group]]
+        consumed[group] = True
+        unique.append(np.median(values[group], axis=0))
+        groups.append(group)
+    return np.array(unique), groups
+
+
+def clusters(points, radius):
+    """
+    Find clusters of points which have neighbours closer than radius
+
+    Parameters
+    ---------
+    points : (n, d) float
+        Points of dimension d
+    radius : float
+        Max distance between points in a cluster
+
+    Returns
+    ----------
+    groups : (m,) sequence of int
+        Indices of points in a cluster
+
+    """
+    from . import graph
+
+    tree = cKDTree(points)
+
+    # some versions return pairs as a set of tuples
+    pairs = tree.query_pairs(r=radius, output_type="ndarray")
+    # group connected components
+    groups = graph.connected_components(pairs)
+
+    return groups
+
+
+def blocks(data, min_len=2, max_len=np.inf, wrap=False, digits=None, only_nonzero=False):
+    """
+    Find the indices in an array of contiguous blocks
+    of equal values.
+
+    Parameters
+    ------------
+    data : (n,) array
+      Data to find blocks on
+    min_len : int
+      The minimum length group to be returned
+    max_len : int
+      The maximum length group to be retuurned
+    wrap : bool
+      Combine blocks on both ends of 1D array
+    digits : None or int
+      If dealing with floats how many digits to consider
+    only_nonzero : bool
+      Only return blocks of non- zero values
+
+    Returns
+    ---------
+    blocks : (m) sequence of (*,) int
+      Indices referencing data
+    """
+    data = float_to_int(data, digits=digits)
+
+    # keep an integer range around so we can slice
+    arange = np.arange(len(data))
+    arange.flags["WRITEABLE"] = False
+
+    nonzero = arange[1:][data[1:] != data[:-1]]
+    infl = np.zeros(len(nonzero) + 2, dtype=int)
+    infl[-1] = len(data)
+    infl[1:-1] = nonzero
+
+    # the length of each chunk
+    infl_len = infl[1:] - infl[:-1]
+
+    # check the length of each group
+    infl_ok = np.logical_and(infl_len >= min_len, infl_len <= max_len)
+
+    if only_nonzero:
+        # check to make sure the values of each contiguous block
+        # are True by checking the first value of each block
+        infl_ok = np.logical_and(infl_ok, data[infl[:-1]])
+
+    # inflate start/end indexes into full ranges of values
+    blocks = [arange[infl[i] : infl[i + 1]] for i, ok in enumerate(infl_ok) if ok]
+
+    if wrap:
+        # wrap only matters if first and last points are the same
+        if data[0] != data[-1]:
+            return blocks
+        # if we are only grouping nonzero things and
+        # the first and last point are zero we can exit
+        if only_nonzero and not bool(data[0]):
+            return blocks
+
+        # if all values are True or False we can exit
+        if len(blocks) == 1 and len(blocks[0]) == len(data):
+            return blocks
+
+        # so now first point equals last point, so the cases are:
+        # - first and last point are in a block: combine two blocks
+        # - first OR last point are in block: add other point to block
+        # - neither are in a block: check if combined is eligible block
+
+        # first point is in a block
+        first = len(blocks) > 0 and blocks[0][0] == 0
+        # last point is in a block
+        last = len(blocks) > 0 and blocks[-1][-1] == (len(data) - 1)
+
+        # CASE: first and last point are BOTH in block: combine blocks
+        if first and last:
+            blocks[0] = np.append(blocks[-1], blocks[0])
+            blocks.pop()
+        else:
+            # combined length
+            combined = infl_len[0] + infl_len[-1]
+            # exit if lengths aren't OK
+            if combined < min_len or combined > max_len:
+                return blocks
+            # new block combines both ends
+            new_block = np.append(
+                np.arange(infl[-2], infl[-1]), np.arange(infl[0], infl[1])
+            )
+            # we are in a first OR last situation now
+            if first:
+                # first was already in a block so replace it with combined
+                blocks[0] = new_block
+            elif last:
+                # last was already in a block so replace with superset
+                blocks[-1] = new_block
+            else:
+                # both are false
+                # combined length generated new block
+                blocks.append(new_block)
+
+    return blocks
+
+
+def group_min(groups, data):
+    """
+    Given a list of groups find the minimum element of data
+    within each group
+
+    Parameters
+    -----------
+    groups : (n,) sequence of (q,) int
+        Indexes of each group corresponding to each element in data
+    data : (m,)
+        The data that groups indexes reference
+
+    Returns
+    -----------
+    minimums : (n,)
+        Minimum value of data per group
+
+    """
+    # sort with major key groups, minor key data
+    order = np.lexsort((data, groups))
+    groups = groups[order]  # this is only needed if groups is unsorted
+    data = data[order]
+    # construct an index which marks borders between groups
+    index = np.zeros(len(groups), "bool")
+    index[0] = True
+    index[1:] = groups[1:] != groups[:-1]
+    return data[index]

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/inertia.py

@@ -0,0 +1,363 @@
+"""
+inertia.py
+-------------
+
+Functions for dealing with inertia tensors.
+
+Results validated against known geometries and checked for
+internal consistency.
+"""
+
+import numpy as np
+
+from .typed import ArrayLike, NDArray, Number, float64
+from .util import multi_dot
+
+
+def cylinder_inertia(
+    mass: Number, radius: Number, height: Number, transform: ArrayLike | None = None
+) -> NDArray[float64]:
+    """
+    Return the inertia tensor of a cylinder.
+
+    Parameters
+    ------------
+    mass : float
+      Mass of cylinder
+    radius : float
+      Radius of cylinder
+    height : float
+      Height of cylinder
+    transform : (4, 4) float
+      Transformation of cylinder
+
+    Returns
+    ------------
+    inertia : (3, 3) float
+      Inertia tensor
+    """
+    h2, r2 = height**2, radius**2
+    diagonal = np.array(
+        [
+            ((mass * h2) / 12) + ((mass * r2) / 4),
+            ((mass * h2) / 12) + ((mass * r2) / 4),
+            (mass * r2) / 2,
+        ]
+    )
+    inertia = diagonal * np.eye(3)
+
+    if transform is not None:
+        inertia = transform_inertia(transform, inertia)
+
+    return inertia
+
+
+def sphere_inertia(mass: Number, radius: Number) -> NDArray[float64]:
+    """
+    Return the inertia tensor of a sphere.
+
+    Parameters
+    ------------
+    mass : float
+      Mass of sphere
+    radius : float
+      Radius of sphere
+
+    Returns
+    ------------
+    inertia : (3, 3) float
+      Inertia tensor
+    """
+    return (2.0 / 5.0) * (radius**2) * mass * np.eye(3)
+
+
+def points_inertia(
+    points: ArrayLike,
+    weights: ArrayLike | Number | None = None,
+    at_center_mass: bool = True,
+) -> NDArray[float64]:
+    """
+    Calculate an inertia tensor for an array of point masses
+    at the center of mass.
+
+    Parameters
+    ----------
+    points : (n, 3)
+      Points in space.
+    weights : (n,) or number
+      Per-point weight to use.
+    at_center_mass
+      Calculate at the center of mass of the points, or if False
+      at the original origin.
+
+    Returns
+    -----------
+    tensor : (3, 3)
+      Inertia tensor for point masses.
+    """
+    if weights is None:
+        # by default make the total weight 1.0 to match
+        # the default mass in other functions, and so that
+        # if a user didn't specify anything it doesn't blow
+        # up the scale depending on the number of points
+        weights = np.full(len(points), 1.0 / float(len(points)), dtype=np.float64)
+    elif isinstance(weights, (float, np.integer, int)):
+        # "is it a number" check
+        weights = np.full(len(points), float(weights), dtype=np.float64)
+    else:
+        weights = np.array(weights)
+        if len(weights) != len(points):
+            raise ValueError(
+                f"Weights must correspond to points! {len(weights)} != {len(points)}"
+            )
+
+    # make sure the points are an array of correct shape
+    points = np.asanyarray(points, dtype=np.float64)
+    if len(points.shape) != 2 or points.shape[1] != 3:
+        raise ValueError(f"Points must be `(n, 3)` not {points.shape}")
+
+    if at_center_mass:
+        # get the center of mass of the points
+        center_mass = np.average(points, weights=weights, axis=0)
+        # get the points with the origin at their center of mass
+        points_com = points - center_mass
+    else:
+        # calculate at original origin
+        points_com = points
+
+    # expand into shorthand for the expressions
+    x, y, z = points_com.T
+    x2, y2, z2 = (points_com**2).T
+
+    # calculate tensors per-point in a flattened (9, n) array
+    # from physics.stackexchange.com/questions/614094
+    tensors = np.array(
+        [y2 + z2, -x * y, -x * z, -x * y, x2 + z2, -y * z, -x * z, -y * z, x2 + y2],
+        dtype=np.float64,
+    )
+
+    # combine the weighted tensors and reshape
+    tensor = (tensors * weights).sum(axis=1).reshape((3, 3))
+
+    return tensor
+
+
+def principal_axis(inertia: ArrayLike):
+    """
+    Find the principal components and principal axis
+    of inertia from the inertia tensor.
+
+    Parameters
+    ------------
+    inertia : (3, 3) float
+      Inertia tensor
+
+    Returns
+    ------------
+    components : (3,) float
+      Principal components of inertia
+    vectors : (3, 3) float
+      Row vectors pointing along the
+      principal axes of inertia
+    """
+    inertia = np.asanyarray(inertia, dtype=np.float64)
+    if inertia.shape != (3, 3):
+        raise ValueError("inertia tensor must be (3, 3)!")
+
+    # you could any of the following to calculate this:
+    # np.linalg.svd, np.linalg.eig, np.linalg.eigh
+    # moment of inertia is square symmetric matrix
+    # eigh has the best precision in tests
+    components, vectors = np.linalg.eigh(inertia)
+
+    # eigh returns them as column vectors, change them to row vectors
+    vectors = vectors.T
+
+    return components, vectors
+
+
+def transform_inertia(
+    transform: ArrayLike,
+    inertia_tensor: ArrayLike,
+    parallel_axis: bool = False,
+    mass: Number | None = None,
+):
+    """
+     Transform an inertia tensor to a new frame.
+
+     Note that in trimesh `mesh.moment_inertia` is *axis aligned*
+     and at `mesh.center_mass`.
+
+     So to transform to a new frame and get the moment of inertia at
+     the center of mass the translation should be ignored and only
+     rotation applied.
+
+     If parallel axis is enabled it will compute the inertia
+     about a new location.
+
+     More details in the MIT OpenCourseWare PDF:
+    ` MIT16_07F09_Lec26.pdf`
+
+
+     Parameters
+     ------------
+     transform : (3, 3) or (4, 4) float
+       Transformation matrix
+     inertia_tensor : (3, 3) float
+       Inertia tensor.
+     parallel_axis : bool
+       Apply the parallel axis theorum or not.
+       If the passed inertia tensor is at the center of mass
+       and you want the new post-transform tensor also at the
+       center of mass you DON'T want this enabled as you *only*
+       want to apply the rotation. Use this to get moment of
+       inertia at an arbitrary frame that isn't the center of mass.
+
+     Returns
+     ------------
+     transformed : (3, 3) float
+       Inertia tensor in new frame.
+    """
+    # check inputs and extract rotation
+    transform = np.asanyarray(transform, dtype=np.float64)
+    if transform.shape == (4, 4):
+        rotation = transform[:3, :3]
+    elif transform.shape == (3, 3):
+        rotation = transform
+    else:
+        raise ValueError("transform must be (3, 3) or (4, 4)!")
+
+    inertia_tensor = np.asanyarray(inertia_tensor, dtype=np.float64)
+    if inertia_tensor.shape != (3, 3):
+        raise ValueError("inertia_tensor must be (3, 3)!")
+
+    if parallel_axis:
+        if transform.shape == (3, 3):
+            # shorthand for "translation"
+            a = np.zeros(3, dtype=np.float64)
+        else:
+            # get the translation
+            a = transform[:3, 3]
+        # First the changed origin of the new transform is taken into
+        # account. To calculate the inertia tensor
+        # the parallel axis theorem is used
+        M = np.array(
+            [
+                [a[1] ** 2 + a[2] ** 2, -a[0] * a[1], -a[0] * a[2]],
+                [-a[0] * a[1], a[0] ** 2 + a[2] ** 2, -a[1] * a[2]],
+                [-a[0] * a[2], -a[1] * a[2], a[0] ** 2 + a[1] ** 2],
+            ]
+        )
+        aligned_inertia = inertia_tensor + mass * M
+
+        return multi_dot([rotation.T, aligned_inertia, rotation])
+
+    return multi_dot([rotation, inertia_tensor, rotation.T])
+
+
+def radial_symmetry(mesh):
+    """
+    Check whether a mesh has radial symmetry.
+
+    Returns
+    -----------
+    symmetry : None or str
+         None         No rotational symmetry
+         'radial'     Symmetric around an axis
+         'spherical'  Symmetric around a point
+    axis : None or (3,) float
+      Rotation axis or point
+    section : None or (3, 2) float
+      If radial symmetry provide vectors
+      to get cross section
+    """
+
+    # shortcuts to avoid typing and hitting cache
+    scalar = mesh.principal_inertia_components.copy()
+
+    # exit early if inertia components are all zero
+    if (scalar < 1e-30).any():
+        return None, None, None
+
+    # normalize the PCI so we can compare them
+    scalar = scalar / np.linalg.norm(scalar)
+    vector = mesh.principal_inertia_vectors
+    # the sorted order of the principal components
+    order = scalar.argsort()
+
+    # we are checking if a geometry has radial symmetry
+    # if 2 of the PCI are equal, it is a revolved 2D profile
+    # if 3 of the PCI (all of them) are equal it is a sphere
+    diff = np.abs(np.diff(scalar[order]))
+    # diffs that are within tol of zero
+    diff_zero = diff < 1e-4
+
+    if diff_zero.all():
+        # this is the case where all 3 PCI are identical
+        # this means that the geometry is symmetric about a point
+        # examples of this are a sphere, icosahedron, etc
+        axis = vector[0]
+        section = vector[1:]
+
+        return "spherical", axis, section
+
+    elif diff_zero.any():
+        # this is the case for 2/3 PCI are identical
+        # this means the geometry is symmetric about an axis
+        # probably a revolved 2D profile
+
+        # we know that only 1/2 of the diff values are True
+        # if the first diff is 0, it means if we take the first element
+        # in the ordered PCI we will have one of the non- revolve axis
+        # if the second diff is 0, we take the last element of
+        # the ordered PCI for the section axis
+        # if we wanted the revolve axis we would just switch [0,-1] to
+        # [-1,0]
+
+        # since two vectors are the same, we know the middle
+        # one is one of those two
+        section_index = order[np.array([[0, 1], [1, -1]])[diff_zero]].flatten()
+        section = vector[section_index]
+
+        # we know the rotation axis is the sole unique value
+        # and is either first or last of the sorted values
+        axis_index = order[np.array([-1, 0])[diff_zero]][0]
+        axis = vector[axis_index]
+        return "radial", axis, section
+
+    return None, None, None
+
+
+def scene_inertia(scene, transform: ArrayLike | None = None) -> NDArray[float64]:
+    """
+    Calculate the inertia of a scene about a specific frame.
+
+    Parameters
+    ------------
+    scene : trimesh.Scene
+      Scene with geometry.
+    transform : None or (4, 4) float
+      Homogeneous transform to compute inertia at.
+
+    Returns
+    ----------
+    moment : (3, 3)
+      Inertia tensor about requested frame
+    """
+    # shortcuts for tight loop
+    graph = scene.graph
+    geoms = scene.geometry
+
+    # get the matrix ang geometry name for
+    nodes = [graph[n] for n in graph.nodes_geometry]
+    # get the moment of inertia with the mesh moved to a location
+    moments = np.array(
+        [
+            geoms[g].moment_inertia_frame(np.dot(np.linalg.inv(mat), transform))
+            for mat, g in nodes
+            if hasattr(geoms[g], "moment_inertia_frame")
+        ],
+        dtype=np.float64,
+    )
+
+    return moments.sum(axis=0)

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/__init__.py

@@ -0,0 +1,3 @@
+from . import blender
+
+__all__ = ["blender"]

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/blender.py

@@ -0,0 +1,142 @@
+import os
+import platform
+
+from .. import util
+from ..constants import log
+from ..resources import get_string
+from ..typed import BooleanOperationType, Iterable
+from .generic import MeshScript
+
+if platform.system() == "Windows":
+    # try to find Blender install on Windows
+    # split existing path by delimiter
+    _search_path = [i for i in os.environ.get("PATH", "").split(";") if len(i) > 0]
+    for pf in [r"C:\Program Files", r"C:\Program Files (x86)"]:
+        pf = os.path.join(pf, "Blender Foundation")
+        if os.path.exists(pf):
+            for p in os.listdir(pf):
+                if "Blender" in p:
+                    _search_path.append(os.path.join(pf, p))
+    _search_path = ";".join(set(_search_path))
+    log.debug("searching for blender in: %s", _search_path)
+elif platform.system() == "Darwin":
+    # try to find Blender on Mac OSX
+    _search_path = [i for i in os.environ.get("PATH", "").split(":") if len(i) > 0]
+    _search_path.extend(
+        [
+            "/Applications/blender.app/Contents/MacOS",
+            "/Applications/Blender.app/Contents/MacOS",
+            "/Applications/Blender/blender.app/Contents/MacOS",
+        ]
+    )
+    _search_path = ":".join(set(_search_path))
+    log.debug("searching for blender in: %s", _search_path)
+else:
+    _search_path = os.environ.get("PATH", "")
+
+_blender_executable = util.which("blender", path=_search_path)
+exists = _blender_executable is not None
+
+# a map that translates:
+# `trimesh.BooleanOperationType` -> blender value
+_blender_bool = {
+    "union": "UNION",
+    "difference": "DIFFERENCE",
+    "intersection": "INTERSECT",
+}
+
+
+def boolean(
+    meshes: Iterable,
+    operation: BooleanOperationType = "difference",
+    use_exact: bool = True,
+    use_self: bool = False,
+    debug: bool = False,
+    check_volume: bool = True,
+):
+    """
+    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.
+    check_volume
+      Raise an error if not all meshes are watertight
+      positive volumes. Advanced users may want to ignore
+      this check as it is expensive.
+
+    Returns
+    ----------
+    result
+      The result of the boolean operation on the provided meshes.
+    """
+    if not exists:
+        raise ValueError("No blender available!")
+    if check_volume and not all(m.is_volume for m in meshes):
+        raise ValueError("Not all meshes are volumes!")
+
+    # conversions from the trimesh `BooleanOperationType` to the blender option
+    key = operation.lower().strip()
+    if key not in _blender_bool:
+        raise ValueError(
+            f"`{operation}` is not a valid boolean: `{_blender_bool.keys()}`"
+        )
+
+    if use_exact:
+        solver_options = "EXACT"
+    else:
+        solver_options = "FAST"
+
+    # get the template from our resources folder
+    template = get_string("templates/blender_boolean.py.tmpl")
+    # use string substitutions rather than `string.Template` as we aren't going
+    # to be filling in all the values here, `MeshScript` is going to be
+    # the source of `$MESH_PRE`, etc.
+    script = (
+        template.replace("$OPERATION", _blender_bool[key])
+        .replace("$SOLVER_OPTIONS", solver_options)
+        .replace("$USE_SELF", f"{use_self}")
+    )
+    with MeshScript(meshes=meshes, script=script, debug=debug) as blend:
+        result = blend.run(_blender_executable + " --background --python $SCRIPT")
+
+    result = util.make_sequence(result)
+    for m in result:
+        # blender returns actively incorrect face normals
+        m.face_normals = None
+
+    return util.concatenate(result)
+
+
+def unwrap(
+    mesh, angle_limit: float = 66.0, island_margin: float = 0.0, debug: bool = False
+):
+    """
+    Run an unwrap operation using blender.
+    """
+    if not exists:
+        raise ValueError("No blender available!")
+
+    # get the template from our resources folder
+    template = get_string("templates/blender_unwrap.py.template")
+    script = template.replace("$ANGLE_LIMIT", f"{angle_limit:.6f}").replace(
+        "$ISLAND_MARGIN", f"{island_margin:.6f}"
+    )
+
+    with MeshScript(meshes=[mesh], script=script, exchange="obj", debug=debug) as blend:
+        result = blend.run(_blender_executable + " --background --python $SCRIPT")
+
+    for m in util.make_sequence(result):
+        # blender returns actively incorrect face normals
+        m.face_normals = None
+
+    return result

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interfaces/generic.py

@@ -0,0 +1,101 @@
+import os
+import platform
+import subprocess
+from string import Template
+from subprocess import CalledProcessError, check_output
+from tempfile import NamedTemporaryFile
+
+from .. import exchange
+from ..util import log
+
+
+class MeshScript:
+    def __init__(self, meshes, script, exchange="stl", debug=False, **kwargs):
+        self.debug = debug
+        self.kwargs = kwargs
+        self.meshes = meshes
+        self.script = script
+        self.exchange = exchange
+
+    def __enter__(self):
+        # windows has problems with multiple programs using open files so we close
+        # them at the end of the enter call, and delete them ourselves at exit
+        # Blender sorts its objects alphabetically
+        # so prefix the mesh number on the file name
+        digit_count = len(str(len(self.meshes)))
+        self.mesh_pre = [
+            NamedTemporaryFile(
+                suffix=f".{self.exchange}",
+                prefix=f"{str(i).zfill(digit_count)}_",
+                mode="wb",
+                delete=False,
+            )
+            for i in range(len(self.meshes))
+        ]
+        self.mesh_post = NamedTemporaryFile(
+            suffix=f".{self.exchange}", mode="rb", delete=False
+        )
+        self.script_out = NamedTemporaryFile(mode="wb", delete=False)
+
+        # export the meshes to a temporary STL container
+        for mesh, file_obj in zip(self.meshes, self.mesh_pre):
+            mesh.export(file_obj=file_obj.name)
+
+        self.replacement = {"MESH_" + str(i): m.name for i, m in enumerate(self.mesh_pre)}
+        self.replacement["MESH_PRE"] = str([i.name for i in self.mesh_pre])
+        self.replacement["MESH_POST"] = self.mesh_post.name
+        self.replacement["SCRIPT"] = self.script_out.name
+
+        script_text = Template(self.script).substitute(self.replacement)
+        if platform.system() == "Windows":
+            script_text = script_text.replace("\\", "\\\\")
+        self.script_out.write(script_text.encode("utf-8"))
+
+        # close all temporary files
+        self.script_out.close()
+        self.mesh_post.close()
+        for file_obj in self.mesh_pre:
+            file_obj.close()
+        return self
+
+    def run(self, command):
+        # substitute per-token so a replacement containing whitespace
+        # stays a single argv entry
+        command_run = [
+            Template(part).substitute(self.replacement) for part in command.split()
+        ]
+        # run the binary
+        startupinfo = None
+        if platform.system() == "Windows":
+            startupinfo = subprocess.STARTUPINFO()
+            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+
+        if self.debug:
+            log.info("executing: {}".format(" ".join(command_run)))
+
+        try:
+            output = check_output(
+                command_run, stderr=subprocess.STDOUT, startupinfo=startupinfo
+            )
+        except CalledProcessError as E:
+            # raise with the output from the process
+            raise RuntimeError(E.output.decode())
+
+        if self.debug:
+            log.info(output.decode())
+
+        # bring the binaries result back as a set of Trimesh kwargs
+        mesh_results = exchange.load.load_mesh(self.mesh_post.name, **self.kwargs)
+
+        return mesh_results
+
+    def __exit__(self, *args, **kwargs):
+        if self.debug:
+            log.info(f"MeshScript.debug: not deleting {self.script_out.name}")
+            return
+        # delete all the temporary files by name
+        # they are closed but their names are still available
+        os.remove(self.script_out.name)
+        for file_obj in self.mesh_pre:
+            os.remove(file_obj.name)
+        os.remove(self.mesh_post.name)

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/intersections.py

@@ -0,0 +1,805 @@
+"""
+intersections.py
+------------------
+
+Primarily mesh-plane intersections (slicing).
+"""
+
+import numpy as np
+
+from . import geometry, grouping, util
+from . import transformations as tf
+from . import triangles as tm
+from .constants import tol
+from .triangles import points_to_barycentric
+
+
+def mesh_plane(
+    mesh,
+    plane_normal,
+    plane_origin,
+    return_faces=False,
+    local_faces=None,
+    cached_dots=None,
+):
+    """
+    Find a the intersections between a mesh and a plane,
+    returning a set of line segments on that plane.
+
+    Parameters
+    ---------
+    mesh : Trimesh object
+      Source mesh to slice
+    plane_normal : (3,) float
+      Normal vector of plane to intersect with mesh
+    plane_origin : (3,) float
+      Point on plane to intersect with mesh
+    return_faces : bool
+      If True return face index each line is from
+    local_faces : None or (m,) int
+      Limit section to just these faces.
+    cached_dots : (n, 3) float
+      If an external function has stored dot
+      products pass them here to avoid recomputing.
+
+    Returns
+    ----------
+    lines :  (m, 2, 3) float
+      List of 3D line segments in space.
+    face_index : (m,) int
+      Index of mesh.faces for each line
+      Only returned if return_faces was True
+    """
+
+    def triangle_cases(signs):
+        """
+        Figure out which faces correspond to which intersection
+        case from the signs of the dot product of each vertex.
+        Does this by bitbang each row of signs into an 8 bit
+        integer.
+
+        code : signs      : intersects
+        0    : [-1 -1 -1] : No
+        2    : [-1 -1  0] : No
+        4    : [-1 -1  1] : Yes; 2 on one side, 1 on the other
+        6    : [-1  0  0] : Yes; one edge fully on plane
+        8    : [-1  0  1] : Yes; one vertex on plane 2 on different sides
+        12   : [-1  1  1] : Yes; 2 on one side, 1 on the other
+        14   : [0 0 0]    : No (on plane fully)
+        16   : [0 0 1]    : Yes; one edge fully on plane
+        20   : [0 1 1]    : No
+        28   : [1 1 1]    : No
+
+        Parameters
+        ----------
+        signs: (n,3) int, all values are -1,0, or 1
+          Each row contains the dot product of all three vertices
+          in a face with respect to the plane
+
+        Returns
+        ---------
+        basic : (n,) bool
+          Which faces are in the basic intersection case
+        one_vertex : (n,) bool
+          Which faces are in the one vertex case
+        one_edge : (n,) bool
+          Which faces are in the one edge case
+        """
+
+        signs_sorted = np.sort(signs, axis=1)
+        coded = np.zeros(len(signs_sorted), dtype=np.int8) + 14
+        for i in range(3):
+            coded += signs_sorted[:, i] << 3 - i
+
+        # one edge fully on the plane
+        # note that we are only accepting *one* of the on- edge cases,
+        # where the other vertex has a positive dot product (16) instead
+        # of both on- edge cases ([6, 16])
+        # this is so that for regions that are co-planar with the the section plane
+        # we don't end up with an invalid boundary
+        key = np.zeros(29, dtype=bool)
+        key[16] = True
+        one_edge = key[coded]
+
+        # one vertex on plane, other two on different sides
+        key[:] = False
+        key[8] = True
+        one_vertex = key[coded]
+
+        # one vertex on one side of the plane, two on the other
+        key[:] = False
+        key[[4, 12]] = True
+        basic = key[coded]
+
+        return basic, one_vertex, one_edge
+
+    def handle_on_vertex(signs, faces, vertices):
+        # case where one vertex is on plane
+        # and two are on different sides
+        vertex_plane = faces[signs == 0]
+        edge_thru = faces[signs != 0].reshape((-1, 2))
+        point_intersect, valid = plane_lines(
+            plane_origin, plane_normal, vertices[edge_thru.T], line_segments=False
+        )
+        lines = np.column_stack((vertices[vertex_plane[valid]], point_intersect)).reshape(
+            (-1, 2, 3)
+        )
+        return lines
+
+    def handle_on_edge(signs, faces, vertices):
+        # case where two vertices are on the plane and one is off
+        edges = faces[signs == 0].reshape((-1, 2))
+        points = vertices[edges]
+        return points
+
+    def handle_basic(signs, faces, vertices):
+        # case where one vertex is on one side and two are on the other
+        unique_element = grouping.unique_value_in_row(signs, unique=[-1, 1])
+        edges = np.column_stack(
+            (
+                faces[unique_element],
+                faces[np.roll(unique_element, 1, axis=1)],
+                faces[unique_element],
+                faces[np.roll(unique_element, 2, axis=1)],
+            )
+        ).reshape((-1, 2))
+        intersections, valid = plane_lines(
+            plane_origin, plane_normal, vertices[edges.T], line_segments=False
+        )
+        # since the data has been pre- culled, any invalid intersections at all
+        # means the culling was done incorrectly and thus things are broken
+        assert valid.all()
+        return intersections.reshape((-1, 2, 3))
+
+    # check input plane
+    plane_normal = np.asanyarray(plane_normal, dtype=np.float64)
+    plane_origin = np.asanyarray(plane_origin, dtype=np.float64)
+    if plane_origin.shape != (3,) or plane_normal.shape != (3,):
+        raise ValueError("Plane origin and normal must be (3,)!")
+
+    if local_faces is None:
+        # do a cross section against all faces
+        faces = mesh.faces
+    else:
+        local_faces = np.asanyarray(local_faces, dtype=np.int64)
+        # only take the subset of faces if passed
+        faces = mesh.faces[local_faces]
+
+    if cached_dots is not None:
+        dots = cached_dots
+    else:
+        # dot product of each vertex with the plane normal indexed by face
+        # so for each face the dot product of each vertex is a row
+        # shape is the same as mesh.faces (n,3)
+        dots = np.dot(mesh.vertices - plane_origin, plane_normal)
+
+    # sign of the dot product is -1, 0, or 1
+    # shape is the same as mesh.faces (n,3)
+    signs = np.zeros(len(mesh.vertices), dtype=np.int8)
+    signs[dots < -tol.merge] = -1
+    signs[dots > tol.merge] = 1
+    signs = signs[faces]
+
+    # figure out which triangles are in the cross section,
+    # and which of the three intersection cases they are in
+    cases = triangle_cases(signs)
+    # handlers for each case
+    handlers = (handle_basic, handle_on_vertex, handle_on_edge)
+
+    # the (m, 2, 3) line segments
+    lines = np.vstack(
+        [h(signs[c], faces[c], mesh.vertices) for c, h in zip(cases, handlers)]
+    )
+
+    if return_faces:
+        # everything that hit something
+        index = np.hstack([np.nonzero(c)[0] for c in cases])
+        assert index.dtype.kind == "i"
+        if local_faces is None:
+            return lines, index
+        # we are considering a subset of faces
+        # so we need to take the indexes from original
+        return lines, local_faces[index]
+    return lines
+
+
+def mesh_multiplane(mesh, plane_origin, plane_normal, heights):
+    """
+    A utility function for slicing a mesh by multiple
+    parallel planes which caches the dot product operation.
+
+    Parameters
+    -------------
+    mesh : trimesh.Trimesh
+        Geometry to be sliced by planes
+    plane_origin : (3,) float
+        Point on a plane
+    plane_normal : (3,) float
+        Normal vector of plane
+    heights : (m,) float
+      Offset distances from plane to slice at:
+      at `height=0` it will be exactly on the passed plane.
+
+    Returns
+    --------------
+    lines : (m,) sequence of (n, 2, 2) float
+        Lines in space for m planes
+    to_3D : (m, 4, 4) float
+        Transform to move each section back to 3D
+    face_index : (m,) sequence of (n,) int
+        Indexes of mesh.faces for each segment
+    """
+    # check input plane
+    plane_normal = util.unitize(plane_normal)
+    plane_origin = np.asanyarray(plane_origin, dtype=np.float64)
+    heights = np.asanyarray(heights, dtype=np.float64)
+
+    # dot product of every vertex with plane
+    vertex_dots = np.dot(plane_normal, (mesh.vertices - plane_origin).T)
+
+    # reconstruct transforms for each 2D section
+    base_transform = geometry.plane_transform(origin=plane_origin, normal=plane_normal)
+    base_transform = np.linalg.inv(base_transform)
+
+    # alter translation Z inside loop
+    translation = np.eye(4)
+
+    # store results
+    transforms = []
+    face_index = []
+    segments = []
+
+    # loop through user specified heights
+    for height in heights:
+        # offset the origin by the height
+        new_origin = plane_origin + (plane_normal * height)
+        # offset the dot products by height and index by faces
+        new_dots = vertex_dots - height
+        # run the intersection with the cached dot products
+        lines, index = mesh_plane(
+            mesh=mesh,
+            plane_origin=new_origin,
+            plane_normal=plane_normal,
+            return_faces=True,
+            cached_dots=new_dots,
+        )
+
+        # get the transforms to 3D space and back
+        translation[2, 3] = height
+        to_3D = np.dot(base_transform, translation)
+        to_2D = np.linalg.inv(to_3D)
+        transforms.append(to_3D)
+
+        # transform points to 2D frame
+        lines_2D = tf.transform_points(lines.reshape((-1, 3)), to_2D)
+
+        # if we didn't screw up the transform all
+        # of the Z values should be zero
+        # assert np.allclose(lines_2D[:, 2], 0.0)
+
+        # reshape back in to lines and discard Z
+        lines_2D = lines_2D[:, :2].reshape((-1, 2, 2))
+        # store (n, 2, 2) float lines
+        segments.append(lines_2D)
+        # store (n,) int indexes of mesh.faces
+        face_index.append(index)
+
+    # (n, 4, 4) transforms from 2D to 3D
+    transforms = np.array(transforms, dtype=np.float64)
+
+    return segments, transforms, face_index
+
+
+def plane_lines(plane_origin, plane_normal, endpoints, line_segments=True):
+    """
+    Calculate plane-line intersections
+
+    Parameters
+    ---------
+    plane_origin : (3,) float
+        Point on plane
+    plane_normal : (3,) float
+        Plane normal vector
+    endpoints : (2, n, 3) float
+        Points defining lines to be tested
+    line_segments : bool
+        If True, only returns intersections as valid if
+        vertices from endpoints are on different sides
+        of the plane.
+
+    Returns
+    ---------
+    intersections : (m, 3) float
+        Cartesian intersection points
+    valid : (n, 3) bool
+        Indicate whether a valid intersection exists
+        for each input line segment
+    """
+    endpoints = np.asanyarray(endpoints)
+    plane_origin = np.asanyarray(plane_origin).reshape(3)
+    line_dir = util.unitize(endpoints[1] - endpoints[0])
+    plane_normal = util.unitize(np.asanyarray(plane_normal).reshape(3))
+
+    t = np.dot(plane_normal, (plane_origin - endpoints[0]).T)
+    b = np.dot(plane_normal, line_dir.T)
+
+    # If the plane normal and line direction are perpendicular, it means
+    # the vector is 'on plane', and there isn't a valid intersection.
+    # We discard on-plane vectors by checking that the dot product is nonzero
+    valid = np.abs(b) > tol.zero
+    if line_segments:
+        test = np.dot(plane_normal, np.transpose(plane_origin - endpoints[1]))
+        different_sides = np.sign(t) != np.sign(test)
+        nonzero = np.logical_or(np.abs(t) > tol.zero, np.abs(test) > tol.zero)
+        valid = np.logical_and(valid, different_sides)
+        valid = np.logical_and(valid, nonzero)
+
+    d = np.divide(t[valid], b[valid])
+    intersection = endpoints[0][valid]
+    intersection = intersection + np.reshape(d, (-1, 1)) * line_dir[valid]
+
+    return intersection, valid
+
+
+def planes_lines(
+    plane_origins,
+    plane_normals,
+    line_origins,
+    line_directions,
+    return_distance=False,
+    return_denom=False,
+):
+    """
+    Given one line per plane find the intersection points.
+
+    Parameters
+    -----------
+    plane_origins : (n,3) float
+        Point on each plane
+    plane_normals : (n,3) float
+        Normal vector of each plane
+    line_origins : (n,3) float
+        Point at origin of each line
+    line_directions : (n,3) float
+        Direction vector of each line
+    return_distance : bool
+      Return distance from origin to point also
+    return_denom : bool
+      Return denominator, so you can check for small values
+
+    Returns
+    ----------
+    on_plane : (n,3) float
+      Points on specified planes
+    valid : (n,) bool
+      Did plane intersect line or not
+    distance : (n,) float
+      [OPTIONAL] Distance from point
+    denom : (n,) float
+      [OPTIONAL] Denominator
+    """
+
+    # check input types
+    plane_origins = np.asanyarray(plane_origins, dtype=np.float64)
+    plane_normals = np.asanyarray(plane_normals, dtype=np.float64)
+    line_origins = np.asanyarray(line_origins, dtype=np.float64)
+    line_directions = np.asanyarray(line_directions, dtype=np.float64)
+
+    # vector from line to plane
+    origin_vectors = plane_origins - line_origins
+
+    projection_ori = util.diagonal_dot(origin_vectors, plane_normals)
+    projection_dir = util.diagonal_dot(line_directions, plane_normals)
+
+    valid = np.abs(projection_dir) > 1e-5
+
+    distance = np.divide(projection_ori[valid], projection_dir[valid])
+
+    on_plane = line_directions[valid] * distance.reshape((-1, 1))
+    on_plane += line_origins[valid]
+
+    result = [on_plane, valid]
+
+    if return_distance:
+        result.append(distance)
+    if return_denom:
+        result.append(projection_dir)
+
+    return result
+
+
+def slice_faces_plane(
+    vertices,
+    faces,
+    plane_normal,
+    plane_origin,
+    uv=None,
+    face_index=None,
+    cached_dots=None,
+):
+    """
+    Slice a mesh (given as a set of faces and vertices) with a plane, returning a
+    new mesh (again as a set of faces and vertices) that is the
+    portion of the original mesh to the positive normal side of the plane.
+
+    Parameters
+    ---------
+    vertices : (n, 3) float
+        Vertices of source mesh to slice
+    faces : (n, 3) int
+        Faces of source mesh to slice
+    plane_normal : (3,) float
+        Normal vector of plane to intersect with mesh
+    plane_origin :  (3,) float
+        Point on plane to intersect with mesh
+    uv : (n, 2) float, optional
+        UV coordinates of source mesh to slice
+    face_index : ((m,) int)
+        Indexes of faces to slice. When no mask is provided, the
+        default is to slice all faces.
+    cached_dots : (n, 3) float
+        If an external function has stored dot
+        products pass them here to avoid recomputing
+
+    Returns
+    ----------
+    new_vertices : (n, 3) float
+        Vertices of sliced mesh
+    new_faces : (n, 3) int
+        Faces of sliced mesh
+    new_uv : (n, 2) int or None
+        UV coordinates of sliced mesh
+    """
+
+    if len(vertices) == 0:
+        return vertices, faces, uv
+
+    have_uv = uv is not None
+
+    # Construct a mask for the faces to slice.
+    if face_index is not None:
+        faces = faces[face_index]
+
+    if cached_dots is not None:
+        dots = cached_dots
+    else:
+        # dot product of each vertex with the plane normal indexed by face
+        # so for each face the dot product of each vertex is a row
+        # shape is the same as faces (n,3)
+        dots = np.dot(vertices - plane_origin, plane_normal)
+
+    # Find vertex orientations w.r.t. faces for all triangles:
+    #  -1 -> vertex "inside" plane (positive normal direction)
+    #   0 -> vertex on plane
+    #   1 -> vertex "outside" plane (negative normal direction)
+    signs = np.zeros(len(vertices), dtype=np.int8)
+    signs[dots < -tol.merge] = 1
+    signs[dots > tol.merge] = -1
+    signs = signs[faces]
+
+    # Find all triangles that intersect this plane
+    # onedge <- indices of all triangles intersecting the plane
+    # inside <- indices of all triangles "inside" the plane (positive normal)
+    signs_sum = signs.sum(axis=1, dtype=np.int8)
+    signs_asum = np.abs(signs).sum(axis=1, dtype=np.int8)
+
+    # Cases:
+    # (0,0,0),  (-1,0,0),  (-1,-1,0), (-1,-1,-1) <- inside
+    # (1,0,0),  (1,1,0),   (1,1,1)               <- outside
+    # (1,0,-1), (1,-1,-1), (1,1,-1)              <- onedge
+    onedge = np.logical_and(signs_asum >= 2, np.abs(signs_sum) <= 1)
+
+    inside = signs_sum == -signs_asum
+
+    # for any faces that lie exactly on-the-plane
+    # we want to only include them if their normal
+    # is backwards from the slicing normal
+    on_plane = signs_asum == 0
+    if on_plane.any():
+        # compute the normals and whether
+        # face is degenerate here
+        check, valid = tm.normals(vertices[faces[on_plane]])
+        # only include faces back from normal
+        dot_check = np.dot(check, plane_normal)
+        # exclude any degenerate faces from the result
+        inside[on_plane] = valid
+        # exclude the degenerate face from our mask
+        on_plane[on_plane] = valid
+        # apply results for this subset
+        inside[on_plane] = dot_check < 0.0
+
+    # Automatically include all faces that are "inside"
+    new_faces = faces[inside]
+
+    # Separate faces on the edge into two cases: those which will become
+    # quads (two vertices inside plane) and those which will become triangles
+    # (one vertex inside plane)
+    triangles = vertices[faces]
+    cut_triangles = triangles[onedge]
+    cut_faces_quad = faces[np.logical_and(onedge, signs_sum < 0)]
+    cut_faces_tri = faces[np.logical_and(onedge, signs_sum >= 0)]
+    cut_signs_quad = signs[np.logical_and(onedge, signs_sum < 0)]
+    cut_signs_tri = signs[np.logical_and(onedge, signs_sum >= 0)]
+
+    # If no faces to cut, the surface is not in contact with this plane.
+    # Thus, return a mesh with only the inside faces
+    if len(cut_faces_quad) + len(cut_faces_tri) == 0:
+        if len(new_faces) == 0:
+            # if no new faces at all return empty arrays
+            empty = (
+                np.zeros((0, 3), dtype=np.float64),
+                np.zeros((0, 3), dtype=np.int64),
+                np.zeros((0, 2), dtype=np.float64) if have_uv else None,
+            )
+            return empty
+
+        # find the unique indices in the new faces
+        # using an integer-only unique function
+        unique, inverse = grouping.unique_bincount(
+            new_faces.reshape(-1), minlength=len(vertices), return_inverse=True
+        )
+
+        # use the unique indices for our final vertices and faces
+        final_vert = vertices[unique]
+        final_face = inverse.reshape((-1, 3))
+        final_uv = uv[unique] if have_uv else None
+
+        return final_vert, final_face, final_uv
+
+    # Extract the intersections of each triangle's edges with the plane
+    o = cut_triangles  # origins
+    d = np.roll(o, -1, axis=1) - o  # directions
+    num = (plane_origin - o).dot(plane_normal)  # compute num/denom
+    denom = np.dot(d, plane_normal)
+    denom[denom == 0.0] = 1e-12  # prevent division by zero
+    dist = np.divide(num, denom)
+    # intersection points for each segment
+    int_points = dist[:, :, None] * d + o
+
+    # Initialize the array of new vertices with the current vertices
+    new_vertices = vertices
+    new_quad_vertices = np.zeros((0, 3))
+    new_tri_vertices = np.zeros((0, 3))
+
+    # Handle the case where a new quad is formed by the intersection
+    # First, extract the intersection points belonging to a new quad
+    quad_int_points = int_points[(signs_sum < 0)[onedge], :, :]
+    num_quads = len(quad_int_points)
+    if num_quads > 0:
+        # Extract the vertex on the outside of the plane, then get the vertices
+        # (in CCW order of the inside vertices)
+        quad_int_inds = np.where(cut_signs_quad == 1)[1]
+        quad_int_verts = cut_faces_quad[
+            np.stack((range(num_quads), range(num_quads)), axis=1),
+            np.stack(((quad_int_inds + 1) % 3, (quad_int_inds + 2) % 3), axis=1),
+        ]
+
+        # Fill out new quad faces with the intersection points as vertices
+        new_quad_faces = np.append(
+            quad_int_verts,
+            np.arange(len(new_vertices), len(new_vertices) + 2 * num_quads).reshape(
+                num_quads, 2
+            ),
+            axis=1,
+        )
+
+        # Extract correct intersection points from int_points and order them in
+        # the same way as they were added to faces
+        new_quad_vertices = quad_int_points[
+            np.stack((range(num_quads), range(num_quads)), axis=1),
+            np.stack((((quad_int_inds + 2) % 3).T, quad_int_inds.T), axis=1),
+            :,
+        ].reshape(2 * num_quads, 3)
+
+        # Add new vertices to existing vertices, triangulate quads, and add the
+        # resulting triangles to the new faces
+        new_vertices = np.append(new_vertices, new_quad_vertices, axis=0)
+        new_tri_faces_from_quads = geometry.triangulate_quads(new_quad_faces)
+        new_faces = np.append(new_faces, new_tri_faces_from_quads, axis=0)
+
+    # Handle the case where a new triangle is formed by the intersection
+    # First, extract the intersection points belonging to a new triangle
+    tri_int_points = int_points[(signs_sum >= 0)[onedge], :, :]
+    num_tris = len(tri_int_points)
+    if num_tris > 0:
+        # Extract the single vertex for each triangle inside the plane and get the
+        # inside vertices (CCW order)
+        tri_int_inds = np.where(cut_signs_tri == -1)[1]
+        tri_int_verts = cut_faces_tri[range(num_tris), tri_int_inds].reshape(num_tris, 1)
+
+        # Fill out new triangles with the intersection points as vertices
+        new_tri_faces = np.append(
+            tri_int_verts,
+            np.arange(len(new_vertices), len(new_vertices) + 2 * num_tris).reshape(
+                num_tris, 2
+            ),
+            axis=1,
+        )
+
+        # Extract correct intersection points and order them in the same way as
+        # the vertices were added to the faces
+        new_tri_vertices = tri_int_points[
+            np.stack((range(num_tris), range(num_tris)), axis=1),
+            np.stack((tri_int_inds.T, ((tri_int_inds + 2) % 3).T), axis=1),
+            :,
+        ].reshape(2 * num_tris, 3)
+
+        # Append new vertices and new faces
+        new_vertices = np.append(new_vertices, new_tri_vertices, axis=0)
+        new_faces = np.append(new_faces, new_tri_faces, axis=0)
+
+    # find the unique indices in the new faces
+    # using an integer-only unique function
+    unique, inverse = grouping.unique_bincount(
+        new_faces.reshape(-1), minlength=len(new_vertices), return_inverse=True
+    )
+
+    # use the unique indexes for our final vertex and faces
+    final_vert = new_vertices[unique]
+    final_face = inverse.reshape((-1, 3))
+
+    final_uv = None
+    if have_uv:
+        # Generate barycentric coordinates for intersection vertices
+        quad_barycentrics = points_to_barycentric(
+            np.repeat(vertices[cut_faces_quad], 2, axis=0), new_quad_vertices
+        )
+        tri_barycentrics = points_to_barycentric(
+            np.repeat(vertices[cut_faces_tri], 2, axis=0), new_tri_vertices
+        )
+        all_barycentrics = np.concatenate([quad_barycentrics, tri_barycentrics])
+
+        # Interpolate UVs
+        cut_uv = np.concatenate([uv[cut_faces_quad], uv[cut_faces_tri]])
+        new_uv = np.einsum("ijk,ij->ik", np.repeat(cut_uv, 2, axis=0), all_barycentrics)
+        final_uv = np.concatenate([uv, new_uv])[unique]
+
+    return final_vert, final_face, final_uv
+
+
+def slice_mesh_plane(
+    mesh,
+    plane_normal,
+    plane_origin,
+    face_index=None,
+    cap=False,
+    engine=None,
+    **kwargs,
+):
+    """
+    Slice a mesh with a plane returning a new mesh that is the
+    portion of the original mesh to the positive normal side
+    of the plane.
+
+    Parameters
+    ---------
+    mesh : Trimesh object
+      Source mesh to slice
+    plane_normal : (3,) float
+      Normal vector of plane to intersect with mesh
+    plane_origin :  (3,) float
+      Point on plane to intersect with mesh
+    cap : bool
+      If True, cap the result with a triangulated polygon
+    face_index : ((m,) int)
+      Indexes of mesh.faces to slice. When no mask is provided, the
+      default is to slice all faces.
+    cached_dots : (n, 3) float
+      If an external function has stored dot
+      products pass them here to avoid recomputing
+    engine : None or str
+      Triangulation engine passed to `triangulate_polygon`
+    kwargs : dict
+      Passed to the newly created sliced mesh
+
+    Returns
+    ----------
+    new_mesh : Trimesh object
+      Sliced mesh
+    """
+    # check input for none
+    if mesh is None:
+        return None
+
+    # avoid circular import
+    from scipy.spatial import cKDTree
+
+    from .base import Trimesh
+    from .creation import triangulate_polygon
+    from .path import polygons
+    from .visual import TextureVisuals
+
+    # check input plane
+    plane_normal = np.asanyarray(plane_normal, dtype=np.float64)
+    plane_origin = np.asanyarray(plane_origin, dtype=np.float64)
+
+    # check to make sure origins and normals have acceptable shape
+    shape_ok = (
+        (plane_origin.shape == (3,) or util.is_shape(plane_origin, (-1, 3)))
+        and (plane_normal.shape == (3,) or util.is_shape(plane_normal, (-1, 3)))
+        and plane_origin.shape == plane_normal.shape
+    )
+    if not shape_ok:
+        raise ValueError("plane origins and normals must be (n, 3)!")
+
+    # start with copy of original mesh, faces, and vertices
+    vertices = mesh.vertices.copy()
+    faces = mesh.faces.copy()
+
+    # We copy the UV coordinates if available
+    has_uv = (
+        hasattr(mesh.visual, "uv") and np.shape(mesh.visual.uv) == (len(mesh.vertices), 2)
+    ) and not cap
+    uv = mesh.visual.uv.copy() if has_uv else None
+
+    if "process" not in kwargs:
+        kwargs["process"] = False
+
+    # slice away specified planes
+    for origin, normal in zip(
+        plane_origin.reshape((-1, 3)), plane_normal.reshape((-1, 3))
+    ):
+        # save the new vertices and faces
+        vertices, faces, uv = slice_faces_plane(
+            vertices=vertices,
+            faces=faces,
+            uv=uv,
+            plane_normal=normal,
+            plane_origin=origin,
+            face_index=face_index,
+        )
+        # check if cap arg specified
+        if cap:
+            if face_index:
+                # This hasn't been implemented yet.
+                raise NotImplementedError("face_index and cap can't be used together")
+
+            # start by deduplicating vertices again
+            unique, inverse = grouping.unique_rows(vertices)
+            vertices = vertices[unique]
+            # will collect additional faces
+            f = inverse[faces]
+            # remove degenerate faces by checking to make sure
+            # that each face has three unique indices
+            f = f[(f[:, :1] != f[:, 1:]).all(axis=1)]
+            # transform to the cap plane
+            to_2D = geometry.plane_transform(origin=origin, normal=-normal)
+            to_3D = np.linalg.inv(to_2D)
+
+            vertices_2D = tf.transform_points(vertices, to_2D)
+            edges = geometry.faces_to_edges(f)
+            edges.sort(axis=1)
+
+            on_plane = np.abs(vertices_2D[:, 2]) < 1e-8
+            edges = edges[on_plane[edges].all(axis=1)]
+            edges = edges[edges[:, 0] != edges[:, 1]]
+
+            unique_edge = grouping.group_rows(edges, require_count=1)
+            if len(unique) < 3:
+                continue
+
+            tree = cKDTree(vertices)
+            # collect new faces
+            faces = [f]
+            for p in polygons.edges_to_polygons(edges[unique_edge], vertices_2D[:, :2]):
+                # triangulate cap and raise an error if any new vertices were inserted
+                vn, fn = triangulate_polygon(p, engine=engine, force_vertices=True)
+                # collect the original index for the new vertices
+                vn3 = tf.transform_points(util.stack_3D(vn), to_3D)
+                distance, vid = tree.query(vn3)
+                if distance.max() > 1e-8:
+                    util.log.debug("triangulate may have inserted vertex!")
+                # triangulation should not have inserted vertices
+                nf = vid[fn]
+                # hmm but it may have returned faces that are now degenerate
+                nf_ok = (nf[:, 1:] != nf[:, :1]).all(axis=1) & (nf[:, 1] != nf[:, 2])
+                faces.append(nf[nf_ok])
+
+            faces = np.vstack(faces)
+
+    visual = (
+        TextureVisuals(uv=uv, material=mesh.visual.material.copy()) if has_uv else None
+    )
+
+    # return the sliced mesh
+    return Trimesh(vertices=vertices, faces=faces, visual=visual, **kwargs)

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/interval.py

@@ -0,0 +1,106 @@
+"""
+interval.py
+--------------
+
+Deal with 1D intervals which are defined by:
+  [start position, end position]
+"""
+
+import numpy as np
+
+from .typed import ArrayLike, NDArray, float64
+
+
+def intersection(a: ArrayLike, b: NDArray[float64]) -> NDArray[float64]:
+    """
+    Given pairs of ranges merge them in to
+    one range if they overlap.
+
+    Parameters
+    --------------
+    a : (2, ) or (n, 2)
+      Start and end of a 1D interval
+    b : (2, ) float
+      Start and end of a 1D interval
+
+    Returns
+    --------------
+    inter : (2, ) or (2, 2) float
+      The unioned range from the two inputs,
+      if not np.ptp(`inter, axis=1)` will be zero.
+    """
+    a = np.array(a, dtype=np.float64)
+    b = np.array(b, dtype=np.float64)
+
+    # convert to vectorized form
+    is_1D = a.shape == (2,)
+    a = a.reshape((-1, 2))
+    b = b.reshape((-1, 2))
+
+    # make sure they're min-max
+    a.sort(axis=1)
+    b.sort(axis=1)
+    a_low, a_high = a.T
+    b_low, b_high = b.T
+
+    # do the checks
+    check = np.logical_not(np.logical_or(b_low >= a_high, a_low >= b_high))
+    overlap = np.zeros(a.shape, dtype=np.float64)
+    overlap[check] = np.column_stack(
+        (
+            np.array([a_low[check], b_low[check]]).max(axis=0),
+            np.array([a_high[check], b_high[check]]).min(axis=0),
+        )
+    )
+
+    if is_1D:
+        return overlap[0]
+
+    return overlap
+
+
+def union(intervals: ArrayLike, sort: bool = True) -> NDArray[float64]:
+    """
+    For array of multiple intervals union them all into
+    the subset of intervals.
+
+    For example:
+    `intervals = [[1,2], [2,3]] -> [[1, 3]]`
+    `intervals = [[1,2], [2.5,3]] -> [[1, 2], [2.5, 3]]`
+
+
+    Parameters
+    ------------
+    intervals : (n, 2)
+      Pairs of `(min, max)` values.
+    sort
+      If the array is already ordered into (min, max) pairs
+      and then pairs sorted by minimum value you can skip the
+      sorting in this function.
+
+    Returns
+    ----------
+    unioned : (m, 2)
+      New intervals where `m <= n`
+    """
+    if len(intervals) == 0:
+        return np.zeros(0)
+
+    # if the intervals have not been pre-sorted we should apply our sorting logic
+    # you would only skip this if you are subsetting a larger list elsewhere.
+    if sort:
+        # copy inputs and make sure they are (min, max) pairs
+        intervals = np.sort(intervals, axis=1)
+        # order them by lowest starting point
+        intervals = intervals[intervals[:, 0].argsort()]
+
+    # we know we will have at least one interval
+    unions = [intervals[0].tolist()]
+
+    for begin, end in intervals[1:]:
+        if unions[-1][1] >= begin:
+            unions[-1][1] = max(unions[-1][1], end)
+        else:
+            unions.append([begin, end])
+
+    return np.array(unions)

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/iteration.py

@@ -0,0 +1,187 @@
+from collections import OrderedDict
+from math import log2
+from typing import Any
+
+from .typed import Callable, Iterable, NDArray, Sequence
+
+
+def reduce_cascade(operation: Callable, items: Sequence | NDArray):
+    """
+    Call an operation function in a cascaded pairwise way against a
+    flat list of items.
+
+    This should produce the same result as `functools.reduce`
+    if `operation` is commutable like addition or multiplication.
+    This may be faster for an `operation` that runs with a speed
+    proportional to its largest input, which mesh booleans appear to.
+
+    The union of a large number of small meshes appears to be
+    "much faster" using this method.
+
+    This only differs from `functools.reduce` for commutative `operation`
+    in that it returns `None` on empty inputs rather than `functools.reduce`
+    which raises a `TypeError`.
+
+    For example on `a b c d e f g` this function would run and return:
+        a b
+        c d
+        e f
+        ab cd
+        ef g
+        abcd efg
+     -> abcdefg
+
+    Where `functools.reduce` would run and return:
+        a b
+        ab c
+        abc d
+        abcd e
+        abcde f
+        abcdef g
+     -> abcdefg
+
+    Parameters
+    ----------
+    operation
+      The function to call on pairs of items.
+    items
+      The flat list of items to apply operation against.
+    """
+    if len(items) == 0:
+        return None
+    elif len(items) == 1:
+        # skip the loop overhead for a single item
+        return items[0]
+    elif len(items) == 2:
+        # skip the loop overhead for a single pair
+        return operation(items[0], items[1])
+
+    for _ in range(int(1 + log2(len(items)))):
+        results = []
+
+        # loop over pairs of items.
+        items_mod = len(items) % 2
+        for i in range(0, len(items) - items_mod, 2):
+            results.append(operation(items[i], items[i + 1]))
+
+        # if we had a non-even number of items it will have been
+        # skipped by the loop so append it to our list
+        if items_mod != 0:
+            results.append(items[-1])
+
+        items = results
+
+    # logic should have reduced to a single item
+    assert len(results) == 1
+
+    return results[0]
+
+
+def chain(*args: Iterable[Any] | Any | None) -> list[Any]:
+    """
+    A less principled version of `list(itertools.chain(*args))` that
+    accepts non-iterable values, filters `None`, and returns a list
+    rather than yielding values.
+
+    If all passed values are iterables this will return identical
+    results to `list(itertools.chain(*args))`.
+
+
+    Examples
+    ----------
+
+    In [1]: list(itertools.chain([1,2], [3]))
+    Out[1]: [1, 2, 3]
+
+    In [2]: trimesh.util.chain([1,2], [3])
+    Out[2]: [1, 2, 3]
+
+    In [3]: trimesh.util.chain([1,2], [3], 4)
+    Out[3]: [1, 2, 3, 4]
+
+    In [4]: list(itertools.chain([1,2], [3], 4))
+      ----> 1 list(itertools.chain([1,2], [3], 4))
+      TypeError: 'int' object is not iterable
+
+    In [5]: trimesh.util.chain([1,2], None, 3, None, [4], [], [], 5, [])
+    Out[5]: [1, 2, 3, 4, 5]
+
+
+    Parameters
+    -----------
+    args
+      Will be individually checked to see if they're iterable
+      before either being appended or extended to a flat list.
+
+
+    Returns
+    ----------
+    chained
+      The values in a flat list.
+    """
+    # collect values to a flat list
+    chained = []
+    # extend if it's a sequence, otherwise append
+    [
+        chained.extend(a)
+        if (hasattr(a, "__iter__") and not isinstance(a, (str, bytes)))
+        else chained.append(a)
+        for a in args
+        if a is not None
+    ]
+    return chained
+
+
+class IndexedDict(OrderedDict):
+    """
+    An append-only `OrderedDict` which knows what position a key was inserted at.
+
+    Useful anywhere values are referenced by *position* but keyed by content so
+    duplicates are only stored once: the only other spelling is
+    `list(d.keys()).index(key)`, which allocates every key and scans it, i.e.
+    quadratic. Looking up the position of all `n` keys once each:
+
+        n       list(keys()).index()      this class
+        2000          0.061s                0.00007s
+        4000          0.262s                0.00012s
+        8000          1.135s                0.00026s
+
+    Removing or reordering a key would shift the position of every key after it,
+    so `__delitem__`, `pop`, `popitem`, and `move_to_end` raise: the supported
+    way to remove is `clear` followed by `update`.
+
+    Examples
+    ----------
+
+    In [1]: IndexedDict({"a": 1, "b": 2, "c": 3}).index("c")
+    Out[1]: 2
+    """
+
+    # subclasses `OrderedDict` rather than `dict` as it routes `__init__`, `update`,
+    # `setdefault`, `|=`, and `copy` through `__setitem__`: one place records a position
+
+    def __init__(self, *args, **kwargs):
+        # must exist before `super` starts routing through `__setitem__`
+        self._position = {}
+        super().__init__(*args, **kwargs)
+
+    def __setitem__(self, key, value):
+        if key not in self:
+            self._position[key] = len(self)
+        super().__setitem__(key, value)
+
+    def _forbidden(self, *args, **kwargs):
+        raise TypeError("`IndexedDict` is append-only: use `clear` and `update`")
+
+    # removing or reordering a key shifts the position of every key after it
+    __delitem__ = pop = popitem = move_to_end = _forbidden
+
+    def clear(self) -> None:
+        super().clear()
+        self._position.clear()
+
+    def index(self, key) -> int:
+        """
+        Which position in insertion order was `key` inserted at.
+        """
+        return self._position[key]

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/nsphere.py

@@ -0,0 +1,181 @@
+"""
+nsphere.py
+--------------
+
+Functions for fitting and minimizing nspheres:
+circles, spheres, hyperspheres, etc.
+"""
+
+import numpy as np
+
+from . import convex, util
+from .constants import log, tol
+
+try:
+    # scipy is a soft dependency
+    from scipy import spatial
+    from scipy.optimize import leastsq
+except BaseException as E:
+    # raise the exception when someone tries to use it
+    from . import exceptions
+
+    leastsq = exceptions.ExceptionWrapper(E)
+    spatial = exceptions.ExceptionWrapper(E)
+
+
+def minimum_nsphere(obj):
+    """
+    Compute the minimum n- sphere for a mesh or a set of points.
+
+    Uses the fact that the minimum n- sphere will be centered at one of
+    the vertices of the furthest site voronoi diagram, which is n*log(n)
+    but should be pretty fast due to using the scipy/qhull implementations
+    of convex hulls and voronoi diagrams.
+
+    Parameters
+    ----------
+    obj : (n, d) float or trimesh.Trimesh
+      Points or mesh to find minimum bounding nsphere
+
+    Returns
+    ----------
+    center : (d,) float
+      Center of fitted n- sphere
+    radius : float
+      Radius of fitted n-sphere
+    """
+
+    # reduce the input points or mesh to the vertices of the convex hull
+    # since we are computing the furthest site voronoi diagram this reduces
+    # the input complexity substantially and returns the same value
+    points = convex.hull_points(obj)
+
+    # we are scaling the mesh to a unit cube
+    # this used to pass qhull_options 'QbB' to Voronoi however this had a bug somewhere
+    # to avoid this we scale to a unit cube ourselves inside this function
+    points_origin = points.min(axis=0)
+    points_scale = np.ptp(points, axis=0).min()
+    points = (points - points_origin) / points_scale
+
+    # if all of the points are on an n-sphere already the voronoi
+    # method will fail so we check a least squares fit before
+    # bothering to compute the voronoi diagram
+    fit_C, fit_R, fit_E = fit_nsphere(points)
+    # return fit radius and center to global scale
+    fit_R = (((points - fit_C) ** 2).sum(axis=1).max() ** 0.5) * points_scale
+    fit_C = (fit_C * points_scale) + points_origin
+
+    if fit_E < 1e-6:
+        # points were on an n-sphere so just return fit
+        return fit_C, fit_R
+
+    # calculate a furthest site voronoi diagram
+    # this will fail if the points are ALL on the surface of
+    # the n-sphere but hopefully the least squares check caught those cases
+    # , qhull_options='QbB Pp')
+    voronoi = spatial.Voronoi(points, furthest_site=True)
+
+    # find the maximum radius^2 point for each of the voronoi vertices
+    # this is worst case quite expensive but we have taken
+    # convex hull to reduce n for this operation
+    # we are doing comparisons on the radius squared then rooting once
+    try:
+        # cdist is massivly faster than looping or tiling methods
+        # although it does create an extremely large intermediate array
+        # first, get an order of magnitude memory size estimate
+        # a float64 would be 8 bytes per entry plus overhead
+        memory_estimate = len(voronoi.vertices) * len(points) * 9
+        # if this `cdist` would require more than 4gb of memory fall
+        # back to the more memory-efficent but much slower loop
+        if memory_estimate > 4e9:
+            raise MemoryError
+        radii_2 = spatial.distance.cdist(
+            voronoi.vertices, points, metric="sqeuclidean"
+        ).max(axis=1)
+    except MemoryError:
+        # log the MemoryError
+        log.warning("MemoryError: falling back to slower check!")
+        # fall back to a potentially very slow list comprehension
+        radii_2 = np.array(
+            [((points - v) ** 2).sum(axis=1).max() for v in voronoi.vertices]
+        )
+
+    # we want the smallest sphere so take the min of the radii
+    radii_idx = radii_2.argmin()
+
+    # return voronoi radius and center to global scale
+    radius_v = np.sqrt(radii_2[radii_idx]) * points_scale
+    center_v = (voronoi.vertices[radii_idx] * points_scale) + points_origin
+
+    if radius_v > fit_R:
+        return fit_C, fit_R
+
+    return center_v, radius_v
+
+
+def fit_nsphere(points, prior=None):
+    """
+    Fit an n-sphere to a set of points using least squares.
+
+    Parameters
+    ------------
+    points : (n, d) float
+      Points in space
+    prior : (d,) float
+      Best guess for center of nsphere
+
+    Returns
+    ---------
+    center : (d,) float
+      Location of center
+    radius : float
+      Mean radius across circle
+    error : float
+      Peak to peak value of deviation from mean radius
+    """
+    # make sure points are numpy array
+    points = np.asanyarray(points, dtype=np.float64)
+    # create ones so we can dot instead of using slower sum
+    ones = np.ones(points.shape[1])
+
+    def residuals(center):
+        # do the axis sum with a dot
+        # this gets called a LOT so worth optimizing
+        radii_sq = np.dot((points - center) ** 2, ones)
+        # residuals are difference between mean
+        # use our sum mean vs .mean() as it is slightly faster
+        return radii_sq - (radii_sq.sum() / len(radii_sq))
+
+    if prior is None:
+        guess = points.mean(axis=0)
+    else:
+        guess = np.asanyarray(prior)
+
+    center_result, return_code = leastsq(residuals, guess, xtol=1e-8)
+
+    if return_code not in [1, 2, 3, 4]:
+        raise ValueError("Least square fit failed!")
+
+    radii = util.row_norm(points - center_result)
+    radius = radii.mean()
+    error = np.ptp(radii)
+    return center_result, radius, error
+
+
+def is_nsphere(points):
+    """
+    Check if a list of points is an nsphere.
+
+    Parameters
+    -----------
+    points : (n, dimension) float
+      Points in space
+
+    Returns
+    -----------
+    check : bool
+      True if input points are on an nsphere
+    """
+    _center, _radius, error = fit_nsphere(points)
+    check = error < tol.merge
+    return check

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/parent.py

@@ -0,0 +1,419 @@
+"""
+parent.py
+-------------
+
+The base class for Trimesh, PointCloud, and Scene objects
+"""
+
+import abc
+import os
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from . import bounds, caching
+from . import transformations as tf
+from .caching import cache_decorator
+from .constants import tol
+from .resolvers import ResolverLike
+from .typed import ArrayLike, NDArray, float64
+from .util import ABC
+
+
+@dataclass
+class LoadSource:
+    """
+    Save information about where a particular object was loaded from.
+    """
+
+    # a file-like object that can be accessed
+    file_obj: Any | None = None
+
+    # a cleaned file type string, i.e. "stl"
+    file_type: str | None = None
+
+    # if this was originally loaded from a file path
+    # save it here so we can check it later.
+    file_path: str | None = None
+
+    # did we open `file_obj` ourselves?
+    was_opened: bool = False
+
+    # a resolver for loading assets next to the file
+    resolver: ResolverLike | None = None
+
+    @property
+    def file_name(self) -> str | None:
+        """
+        Get just the file name from the path if available.
+
+        Returns
+        ---------
+        file_name
+          Just the file name, i.e. for file_path="/a/b/c.stl" -> "c.stl"
+        """
+        if self.file_path is None:
+            return None
+        return os.path.basename(self.file_path)
+
+    def __getstate__(self) -> dict[str, Any]:
+        # this overrides the `pickle.dump` behavior for this class
+        # we cannot pickle a file object so return `file_obj: None` for pickles
+        return {k: v if k != "file_obj" else None for k, v in self.__dict__.items()}
+
+    def __deepcopy__(self, *args):
+        return LoadSource(**self.__getstate__())
+
+
+class Geometry(ABC):
+    """
+    `Geometry` is the parent class for all geometry.
+
+    By decorating a method with `abc.abstractmethod` it means
+    the objects that inherit from `Geometry` MUST implement
+    those methods.
+    """
+
+    # geometry should have a dict to store loose metadata
+    metadata: dict[str, Any]
+
+    @property
+    def source(self) -> LoadSource:
+        """
+        Where and what was this current geometry loaded from?
+
+        Returns
+        --------
+        source
+          If loaded from a file, has the path, type, etc.
+        """
+        # this should have been tacked on by the loader
+        # but we want to *always* be able to access
+        # a value like `mesh.source.file_type` so add a default
+        current = getattr(self, "_source", None)
+        if current is not None:
+            return current
+        self._source = LoadSource()
+        return self._source
+
+    @property
+    @abc.abstractmethod
+    def identifier_hash(self) -> str:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def bounds(self) -> NDArray[np.float64]:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def extents(self) -> NDArray[np.float64]:
+        pass
+
+    @abc.abstractmethod
+    def apply_transform(self, matrix: ArrayLike) -> Any:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def is_empty(self) -> bool:
+        pass
+
+    def __hash__(self):
+        """
+        Get a hash of the current geometry.
+
+        Returns
+        ---------
+        hash
+          Hash of current graph and geometry.
+        """
+        return self._data.__hash__()  # type: ignore
+
+    @abc.abstractmethod
+    def copy(self):
+        pass
+
+    @abc.abstractmethod
+    def show(self):
+        pass
+
+    @abc.abstractmethod
+    def __add__(self, other):
+        pass
+
+    @abc.abstractmethod
+    def export(self, file_obj, file_type=None):
+        pass
+
+    def __repr__(self) -> str:
+        """
+        Print quick summary of the current geometry without
+        computing properties.
+
+        Returns
+        -----------
+        repr : str
+          Human readable quick look at the geometry.
+        """
+        elements = []
+        if hasattr(self, "vertices"):
+            # for Trimesh and PointCloud
+            elements.append(f"vertices.shape={self.vertices.shape}")
+        if hasattr(self, "faces"):
+            # for Trimesh
+            elements.append(f"faces.shape={self.faces.shape}")
+        if hasattr(self, "geometry") and isinstance(self.geometry, dict):
+            # for Scene
+            elements.append(f"len(geometry)={len(self.geometry)}")
+        if "Voxel" in type(self).__name__:
+            # for VoxelGrid objects
+            elements.append(str(self.shape)[1:-1])
+        if "file_name" in self.metadata:
+            display = self.metadata["file_name"]
+            elements.append(f"name=`{display}`")
+        return "<trimesh.{}({})>".format(type(self).__name__, ", ".join(elements))
+
+    def apply_translation(self, translation: ArrayLike):
+        """
+        Translate the current mesh.
+
+        Parameters
+        ----------
+        translation : (3,) float
+          Translation in XYZ
+        """
+        translation = np.asanyarray(translation, dtype=np.float64)
+        if translation.shape == (2,):
+            # create a planar matrix if we were passed a 2D offset
+            return self.apply_transform(tf.planar_matrix(offset=translation))
+        elif translation.shape != (3,):
+            raise ValueError("Translation must be (3,) or (2,)!")
+
+        # manually create a translation matrix
+        matrix = np.eye(4)
+        matrix[:3, 3] = translation
+        return self.apply_transform(matrix)
+
+    def apply_scale(self, scaling):
+        """
+        Scale the mesh.
+
+        Parameters
+        ----------
+        scaling : float or (3,) float
+          Scale factor to apply to the mesh
+        """
+        matrix = tf.scale_and_translate(scale=scaling)
+        # apply_transform will work nicely even on negative scales
+        return self.apply_transform(matrix)
+
+    def __radd__(self, other):
+        """
+        Concatenate the geometry allowing concatenation with
+        built in `sum()` function:
+          `sum(Iterable[trimesh.Trimesh])`
+
+        Parameters
+        ------------
+        other : Geometry
+          Geometry or 0
+
+        Returns
+        ----------
+        concat : Geometry
+          Geometry of combined result
+        """
+
+        if other == 0:
+            # adding 0 to a geometry never makes sense
+            return self
+        # 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
+
+    @property
+    def units(self) -> str | None:
+        """
+        Definition of units for the mesh.
+
+        Returns
+        ----------
+        units : str
+          Unit system mesh is in, or None if not defined
+        """
+        return self.metadata.get("units", None)
+
+    @units.setter
+    def units(self, value: str) -> None:
+        """
+        Define the units of the current mesh.
+        """
+        self.metadata["units"] = str(value).lower().strip()
+
+
+class Geometry3D(Geometry):
+    """
+    The `Geometry3D` object is the parent object of geometry objects
+    which are three dimensional, including Trimesh, PointCloud,
+    and Scene objects.
+    """
+
+    @caching.cache_decorator
+    def bounding_box(self):
+        """
+        An axis aligned bounding box for the current mesh.
+
+        Returns
+        ----------
+        aabb : trimesh.primitives.Box
+          Box object with transform and extents defined
+          representing the axis aligned bounding box of the mesh
+        """
+        from . import primitives
+
+        transform = np.eye(4)
+        # translate to center of axis aligned bounds
+        transform[:3, 3] = self.bounds.mean(axis=0)
+
+        return primitives.Box(transform=transform, extents=self.extents, mutable=False)
+
+    @caching.cache_decorator
+    def bounding_box_oriented(self):
+        """
+        An oriented bounding box for the current mesh.
+
+        Returns
+        ---------
+        obb : trimesh.primitives.Box
+          Box object with transform and extents defined
+          representing the minimum volume oriented
+          bounding box of the mesh
+        """
+        from . import bounds, primitives
+
+        to_origin, extents = bounds.oriented_bounds(self)
+        return primitives.Box(
+            transform=np.linalg.inv(to_origin), extents=extents, mutable=False
+        )
+
+    @caching.cache_decorator
+    def bounding_sphere(self):
+        """
+        A minimum volume bounding sphere for the current mesh.
+
+        Note that the Sphere primitive returned has an unpadded
+        exact `sphere_radius` so while the distance of every vertex
+        of the current mesh from sphere_center will be less than
+        sphere_radius, the faceted sphere primitive may not
+        contain every vertex.
+
+        Returns
+        --------
+        minball : trimesh.primitives.Sphere
+          Sphere primitive containing current mesh
+        """
+        from . import nsphere, primitives
+
+        center, radius = nsphere.minimum_nsphere(self)
+        return primitives.Sphere(center=center, radius=radius, mutable=False)
+
+    @caching.cache_decorator
+    def bounding_cylinder(self):
+        """
+        A minimum volume bounding cylinder for the current mesh.
+
+        Returns
+        --------
+        mincyl : trimesh.primitives.Cylinder
+          Cylinder primitive containing current mesh
+        """
+        from . import bounds, primitives
+
+        kwargs = bounds.minimum_cylinder(self)
+        return primitives.Cylinder(mutable=False, **kwargs)
+
+    @caching.cache_decorator
+    def bounding_primitive(self):
+        """
+        The minimum volume primitive (box, sphere, or cylinder) that
+        bounds the mesh.
+
+        Returns
+        ---------
+        bounding_primitive : object
+          Smallest primitive which bounds the mesh:
+          trimesh.primitives.Sphere
+          trimesh.primitives.Box
+          trimesh.primitives.Cylinder
+        """
+        options = [
+            self.bounding_box_oriented,
+            self.bounding_sphere,
+            self.bounding_cylinder,
+        ]
+        volume_min = np.argmin([i.volume for i in options])
+        return options[volume_min]
+
+    def apply_obb(self, **kwargs) -> NDArray[float64]:
+        """
+        Apply the oriented bounding box transform to the current mesh.
+
+        This will result in a mesh with an AABB centered at the
+        origin and the same dimensions as the OBB.
+
+        Parameters
+        ------------
+        kwargs
+          Passed through to `bounds.oriented_bounds`
+
+        Returns
+        ----------
+        matrix : (4, 4) float
+          Transformation matrix that was applied
+          to mesh to move it into OBB frame
+        """
+        # save the pre-transform volume
+        if tol.strict and hasattr(self, "volume"):
+            volume = self.volume
+
+        # calculate the OBB passing keyword arguments through
+        matrix, extents = bounds.oriented_bounds(self, **kwargs)
+        # apply the transform
+        self.apply_transform(matrix)
+
+        if tol.strict:
+            # obb transform should not have changed volume
+            if hasattr(self, "volume") and getattr(self, "is_watertight", False):
+                assert np.isclose(self.volume, volume)
+            # overall extents should match what we expected
+            assert np.allclose(self.extents, extents)
+
+        return matrix

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/__init__.py

@@ -0,0 +1,18 @@
+"""
+trimesh.path
+-------------
+
+Handle 2D and 3D vector paths such as those contained in an
+SVG or DXF file.
+"""
+
+try:
+    from .path import Path2D, Path3D
+except BaseException as E:
+    from .. import exceptions
+
+    Path2D = exceptions.ExceptionWrapper(E)
+    Path3D = exceptions.ExceptionWrapper(E)
+
+# explicitly add objects to all as per pep8
+__all__ = ["Path2D", "Path3D"]

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/arc.py

@@ -0,0 +1,245 @@
+from dataclasses import dataclass
+
+import numpy as np
+
+from .. import util
+from ..constants import res_path as res
+from ..constants import tol_path as tol
+from ..typed import ArrayLike, NDArray, Number, float64
+
+# floating point zero
+_TOL_ZERO = 1e-12
+
+
+@dataclass
+class ArcInfo:
+    # What is the radius of the circular arc?
+    radius: float
+
+    # what is the center of the circular arc
+    # it is either 2D or 3D depending on input.
+    center: NDArray[float64]
+
+    # what is the 3D normal vector of the plane the arc lies on
+    normal: NDArray[float64] | None = None
+
+    # what is the starting and ending angle of the arc.
+    angles: NDArray[float64] | None = None
+
+    # what is the angular span of this circular arc.
+    span: Number | None = None
+
+    def __getitem__(self, item):
+        # add for backwards compatibility
+        return getattr(self, item)
+
+
+def arc_center(
+    points: ArrayLike, return_normal: bool = True, return_angle: bool = True
+) -> ArcInfo:
+    """
+    Given three points on a 2D or 3D arc find the center,
+    radius, normal, and angular span.
+
+    Parameters
+    ---------
+    points : (3, dimension) float
+      Points in space, where dimension is either 2 or 3
+    return_normal : bool
+      If True calculate the 3D normal unit vector
+    return_angle : bool
+      If True calculate the start and stop angle and span
+
+    Returns
+    ---------
+    info
+      Arc center, radius, and other information.
+    """
+    points = np.asanyarray(points, dtype=np.float64)
+
+    # get the non-unit vectors of the three points
+    vectors = points[[2, 0, 1]] - points[[1, 2, 0]]
+    # we need both the squared row sum and the non-squared
+    abc2 = np.dot(vectors**2, [1] * points.shape[1])
+    # same as np.linalg.norm(vectors, axis=1)
+    abc = np.sqrt(abc2)
+
+    # perform radius calculation scaled to shortest edge
+    # to avoid precision issues with small or large arcs
+    scale = abc.min()
+    # get the edge lengths scaled to the smallest
+    edges = abc / scale
+    # half the total length of the edges
+    half = edges.sum() / 2.0
+    # check the denominator for the radius calculation
+    denom = half * np.prod(half - edges)
+    if denom < tol.merge:
+        raise ValueError("arc is colinear!")
+    # find the radius and scale back after the operation
+    radius = scale * ((np.prod(edges) / 4.0) / np.sqrt(denom))
+
+    # use a barycentric approach to get the center
+    ba2 = (abc2[[1, 2, 0, 0, 2, 1, 0, 1, 2]] * [1, 1, -1, 1, 1, -1, 1, 1, -1]).reshape(
+        (3, 3)
+    ).sum(axis=1) * abc2
+    center = points.T.dot(ba2) / ba2.sum()
+
+    if tol.strict:
+        # all points should be at the calculated radius from center
+        assert util.allclose(np.linalg.norm(points - center, axis=1), radius)
+
+    # start with initial results
+    result = {"center": center, "radius": radius}
+    if return_normal:
+        if points.shape == (3, 2):
+            # for 2D arcs still use the cross product so that
+            # the sign of the normal vector is consistent
+            result["normal"] = util.unitize(
+                np.cross(np.append(-vectors[1], 0), np.append(vectors[2], 0))
+            )
+        else:
+            # otherwise just take the cross product
+            result["normal"] = util.unitize(np.cross(-vectors[1], vectors[2]))
+
+    if return_angle:
+        # vectors from points on arc to center point
+        vector = util.unitize(points - center)
+        edge_direction = np.diff(points, axis=0)
+        # find the angle between the first and last vector
+        dot = np.dot(*vector[[0, 2]])
+        if dot < (_TOL_ZERO - 1):
+            angle = np.pi
+        elif dot > 1 - _TOL_ZERO:
+            angle = 0.0
+        else:
+            angle = np.arccos(dot)
+        # if the angle is nonzero and vectors are opposite direction
+        # it means we have a long arc rather than the short path
+        if abs(angle) > _TOL_ZERO and np.dot(*edge_direction) < 0.0:
+            angle = (np.pi * 2) - angle
+        # convoluted angle logic
+        angles = np.arctan2(*vector[:, :2].T[::-1]) + np.pi * 2
+        angles_sorted = np.sort(angles[[0, 2]])
+        reverse = angles_sorted[0] < angles[1] < angles_sorted[1]
+        angles_sorted = angles_sorted[:: (1 - int(not reverse) * 2)]
+        result["angles"] = angles_sorted
+        result["span"] = angle
+
+    return ArcInfo(**result)
+
+
+def discretize_arc(points, close=False, scale=1.0):
+    """
+    Returns a version of a three point arc consisting of
+    line segments.
+
+    Parameters
+    ---------
+    points : (3, d) float
+      Points on the arc where d in [2,3]
+    close :  boolean
+      If True close the arc into a circle
+    scale : float
+      What is the approximate overall drawing scale
+      Used to establish order of magnitude for precision
+
+    Returns
+    ---------
+    discrete : (m, d) float
+      Connected points in space
+    """
+    # make sure points are (n, 3)
+    points, is_2D = util.stack_3D(points, return_2D=True)
+    # find the center of the points
+    try:
+        # try to find the center from the arc points
+        center_info = arc_center(points)
+    except BaseException:
+        # if we hit an exception return a very bad but
+        # technically correct discretization of the arc
+        if is_2D:
+            return points[:, :2]
+        return points
+
+    center, R, N, angle = (
+        center_info.center,
+        center_info.radius,
+        center_info.normal,
+        center_info.span,
+    )
+
+    # if requested, close arc into a circle
+    if close:
+        angle = np.pi * 2
+
+    # the number of facets for the arc
+    # which is the maximum of angle and linear criteria
+    count = max(angle / res.seg_angle, (R * angle) / (res.seg_frac * scale))
+
+    # force at LEAST 4 points for the arc
+    # otherwise the endpoints will diverge
+    count = int(np.ceil(np.clip(count, 4, np.inf)))
+
+    V1 = util.unitize(points[0] - center)
+    V2 = util.unitize(np.cross(-N, V1))
+    # angle spacing
+    t = np.linspace(0.0, angle, count).reshape((-1, 1))
+
+    # apply the vector formula
+    discrete = (np.cos(t) * V1 + np.sin(t) * V2) * R + center
+
+    if close:
+        # snap closed circles to exactly float-equal
+        discrete[-1] = discrete[0]
+    else:
+        # snap the discrete result to exact control points
+        discrete[[0, -1]] = points[[0, -1]]
+
+    # clip to the dimension of input
+    discrete = discrete[:, : (3 - is_2D)]
+
+    return discrete
+
+
+def to_threepoint(center, radius, angles=None):
+    """
+    For 2D arcs, given a center and radius convert them to three
+    points on the arc.
+
+    Parameters
+    -----------
+    center : (2,) float
+      Center point on the plane
+    radius : float
+      Radius of arc
+    angles : (2,) float
+      Angles in radians for start and end angle
+      if not specified, will default to (0.0, pi)
+
+    Returns
+    ----------
+    three : (3, 2) float
+      Arc control points
+    """
+    # if no angles provided assume we want a half circle
+    if angles is None:
+        angles = [0.0, np.pi]
+    # force angles to float64
+    angles = np.asanyarray(angles, dtype=np.float64)
+    if angles.shape != (2,):
+        raise ValueError("angles must be (2,)!")
+    # provide the wrap around
+    if angles[1] < angles[0]:
+        angles[1] += np.pi * 2
+
+    center = np.asanyarray(center, dtype=np.float64)
+    if center.shape != (2,):
+        raise ValueError("only valid on 2D arcs!")
+
+    # turn the angles of [start, end]
+    # into [start, middle, end]
+    angles = np.array([angles[0], angles.mean(), angles[1]], dtype=np.float64)
+    # turn angles into (3, 2) points
+    three = (np.column_stack((np.cos(angles), np.sin(angles))) * radius) + center
+
+    return three

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/creation.py

@@ -0,0 +1,294 @@
+import numpy as np
+
+from .. import transformations, util
+from ..geometry import plane_transform
+from . import arc
+from .entities import Arc, Line
+
+
+def circle_pattern(
+    pattern_radius, circle_radius, count, center=None, angle=None, **kwargs
+):
+    """
+    Create a Path2D representing a circle pattern.
+
+    Parameters
+    ------------
+    pattern_radius : float
+      Radius of circle centers
+    circle_radius : float
+      The radius of each circle
+    count : int
+      Number of circles in the pattern
+    center : (2,) float
+      Center of pattern
+    angle :  float
+      If defined pattern will span this angle
+      If None, pattern will be evenly spaced
+
+    Returns
+    -------------
+    pattern : trimesh.path.Path2D
+      Path containing circular pattern
+    """
+    from .path import Path2D
+
+    if angle is None:
+        angles = np.linspace(0.0, np.pi * 2.0, count + 1)[:-1]
+    elif isinstance(angle, float) or isinstance(angle, int):
+        angles = np.linspace(0.0, angle, count)
+    else:
+        raise ValueError("angle must be float or int!")
+
+    if center is None:
+        center = [0.0, 0.0]
+
+    # centers of circles
+    centers = np.column_stack((np.cos(angles), np.sin(angles))) * pattern_radius
+
+    vert = []
+    ents = []
+    for circle_center in centers:
+        # (3,3) center points of arc
+        three = arc.to_threepoint(
+            angles=[0, np.pi], center=circle_center, radius=circle_radius
+        )
+        # add a single circle entity
+        ents.append(Arc(points=np.arange(3) + len(vert), closed=True))
+        # keep flat array by extend instead of append
+        vert.extend(three)
+
+    # translate vertices to pattern center
+    vert = np.array(vert) + center
+    pattern = Path2D(entities=ents, vertices=vert, **kwargs)
+    return pattern
+
+
+def circle(radius, center=None, **kwargs):
+    """
+    Create a Path2D containing circle with the specified
+    radius.
+
+    Parameters
+    --------------
+    radius : float
+      The radius of the circle
+    center : None or (2,) float
+      Center of the circle, origin by default
+    ** kwargs : dict
+      Passed to trimesh.path.Path2D constructor
+
+    Returns
+    -------------
+    circle : Path2D
+      Path containing specified circle
+    """
+    from .path import Path2D
+
+    if center is None:
+        center = [0.0, 0.0]
+    else:
+        center = np.asanyarray(center, dtype=np.float64)
+    # make sure radius is a float
+    radius = float(radius)
+
+    # (3, 2) float, points on arc
+    three = arc.to_threepoint(angles=[0, np.pi], center=center, radius=radius)
+    # generate the path object
+    result = Path2D(
+        entities=[Arc(points=np.arange(3), closed=True)], vertices=three, **kwargs
+    )
+
+    return result
+
+
+def rectangle(bounds, **kwargs):
+    """
+    Create a Path2D containing a single or multiple rectangles
+    with the specified bounds.
+
+    Parameters
+    --------------
+    bounds : (2, 2) float, or (m, 2, 2) float
+      Minimum XY, Maximum XY
+
+    Returns
+    -------------
+    rect : Path2D
+      Path containing specified rectangles
+    """
+    from .path import Path2D
+
+    # data should be float
+    bounds = np.asanyarray(bounds, dtype=np.float64)
+
+    # bounds are extents, re- shape to origin- centered rectangle
+    if bounds.shape == (2,):
+        half = np.abs(bounds) / 2.0
+        bounds = np.array([-half, half])
+
+    # should have one bounds or multiple bounds
+    if not (util.is_shape(bounds, (2, 2)) or util.is_shape(bounds, (-1, 2, 2))):
+        raise ValueError("bounds must be (m, 2, 2) or (2, 2)")
+
+    # hold Line objects
+    lines = []
+    # hold (n, 2) cartesian points
+    vertices = []
+
+    # loop through each rectangle
+    for lower, upper in bounds.reshape((-1, 2, 2)):
+        lines.append(Line((np.arange(5) % 4) + len(vertices)))
+        vertices.extend([lower, [upper[0], lower[1]], upper, [lower[0], upper[1]]])
+
+    # create the Path2D with specified rectangles
+    rect = Path2D(entities=lines, vertices=vertices, **kwargs)
+
+    return rect
+
+
+def box_outline(extents=None, transform=None, **kwargs):
+    """
+    Return a cuboid.
+
+    Parameters
+    ------------
+    extents : float, or (3,) float
+      Edge lengths
+    transform: (4, 4) float
+      Transformation matrix
+    **kwargs:
+        passed to Trimesh to create box
+
+    Returns
+    ------------
+    geometry : trimesh.Path3D
+      Path outline of a cuboid geometry
+    """
+    from .exchange.load import load_path
+
+    # create vertices for the box
+    vertices = [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1]
+    vertices = np.array(vertices, order="C", dtype=np.float64).reshape((-1, 3))
+    vertices -= 0.5
+
+    # resize the vertices based on passed size
+    if extents is not None:
+        extents = np.asanyarray(extents, dtype=np.float64)
+        if extents.shape != (3,):
+            raise ValueError("Extents must be (3,)!")
+        vertices *= extents
+
+    # apply transform if passed
+    if transform is not None:
+        vertices = transformations.transform_points(vertices, transform)
+
+    # vertex indices
+    indices = [0, 1, 3, 2, 0, 4, 5, 7, 6, 4, 0, 2, 6, 7, 3, 1, 5]
+    outline = load_path(vertices[indices])
+
+    return outline
+
+
+def grid(
+    side,
+    count=5,
+    transform=None,
+    plane_origin=None,
+    plane_normal=None,
+    include_circle=True,
+    sections_circle=32,
+):
+    """
+    Create a Path3D for a grid visualization of a plane.
+
+    Parameters
+    -----------
+    side : float
+      Length of half of a grid side
+    count : int
+      Number of grid lines per grid half
+    transform : None or (4, 4) float
+      Transformation matrix to move grid location.
+      Takes precedence over plane_origin if both are passed.
+    plane_origin : None or (3,) float
+      Plane origin
+    plane_normal : None or (3,) float
+      Unit normal vector
+    include_circle : bool
+      Include a circular pattern inside the grid
+    sections_circle : int
+      How many sections should the smallest circle have
+
+    Returns
+    ----------
+    grid : trimesh.path.Path3D
+      Path containing grid plane visualization
+    """
+    from .path import Path3D
+
+    # change full side length to half-side
+    side = float(side)
+    # make sure count is an integer
+    count = int(count)
+    # get a spaced sequence of radius
+    radii = np.linspace(0.0, side, count + 1)[1:]
+    # what's the maximum radius
+    rmax = radii[-1]
+
+    # keep a count of the current vertex count
+    current = 0
+    # collect vertices and entities
+    vertices = []
+    entities = []
+    for r in radii:
+        if include_circle:
+            # scale the section count by radius
+            circle_res = int((r / radii[0]) * sections_circle)
+            # generate a circule pattern
+            theta = np.linspace(0.0, np.pi * 2, circle_res)
+            circle = np.column_stack((np.cos(theta), np.sin(theta))) * r
+            # append the circle pattern
+            vertices.append(circle)
+            entities.append(Line(points=np.arange(len(circle)) + current))
+            # keep the vertex count correct
+            current += len(circle)
+        # generate a series of grid lines
+        vertices.append(
+            [
+                [-rmax, r],
+                [rmax, r],
+                [-rmax, -r],
+                [rmax, -r],
+                [r, -rmax],
+                [r, rmax],
+                [-r, -rmax],
+                [-r, rmax],
+            ]
+        )
+        # append an entity per grid line
+        for i in [0, 2, 4, 6]:
+            entities.append(Line(points=np.arange(2) + current + i))
+        current += len(vertices[-1])
+
+    # add the middle lines which were skipped
+    vertices.append([[0, rmax], [0, -rmax], [-rmax, 0], [rmax, 0]])
+    entities.append(Line(points=np.arange(2) + current))
+    entities.append(Line(points=np.arange(2) + current + 2))
+    # stack vertices into clean (n, 3) float
+    vertices = np.vstack(vertices)
+
+    # if plane was passed instead of transform create the matrix here
+    if transform is None and plane_origin is not None and plane_normal is not None:
+        transform = np.linalg.inv(
+            plane_transform(origin=plane_origin, normal=plane_normal)
+        )
+
+    # stack vertices to 3D
+    vertices = np.column_stack((vertices, np.zeros(len(vertices))))
+    # apply transform if passed
+    if transform is not None:
+        vertices = transformations.transform_points(vertices, matrix=transform)
+    # combine result into a Path3D object
+    grid_path = Path3D(entities=entities, vertices=vertices)
+    return grid_path

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/curve.py

@@ -0,0 +1,136 @@
+import numpy as np
+
+from ..constants import res_path as res
+from ..constants import tol_path as tol
+from ..typed import Integer
+
+
+def discretize_bezier(points, count=None, scale=1.0):
+    """
+    Parameters
+    ----------
+    points : (order, dimension) float
+      Control points of the bezier curve
+      For a 2D cubic bezier, order=3, dimension=2
+    count : int, or None
+      Number of segments
+    scale : float
+      Scale of curve
+    Returns
+    ----------
+    discrete: (n, dimension) float
+     Points forming a a polyline representation
+    """
+    # make sure we have a numpy array
+    points = np.asanyarray(points, dtype=np.float64)
+
+    if count is None:
+        # how much distance does a small percentage of the curve take
+        # this is so we can figure out how finely we have to sample t
+        norm = np.linalg.norm(np.diff(points, axis=0), axis=1).sum()
+        count = np.ceil(norm / (res.seg_frac * scale))
+        count = int(
+            np.clip(count, res.min_sections * len(points), res.max_sections * len(points))
+        )
+    count = int(count)
+
+    # parameterize incrementing 0.0 - 1.0
+    t = np.linspace(0.0, 1.0, count)
+    # decrementing 1.0-0.0
+    t_d = 1.0 - t
+    n = len(points) - 1
+    # binomial coefficients, i, and each point
+    iterable = zip(binomial(n), np.arange(len(points)), points)
+    # run the actual interpolation
+    stacked = [
+        ((t**i) * (t_d ** (n - i))).reshape((-1, 1)) * p * c for c, i, p in iterable
+    ]
+    result = np.sum(stacked, axis=0)
+
+    # a bezier curve always starts and ends on control points
+    if tol.strict:
+        # test to make sure end points are correct
+        test = np.sum((result[[0, -1]] - points[[0, -1]]) ** 2, axis=1)
+        assert (test < tol.merge).all()
+        assert len(result) >= 2
+
+    # snap the first and last points to the exact control point
+    result[[0, -1]] = points[[0, -1]]
+
+    return result
+
+
+def discretize_bspline(control, knots, count=None, scale=1.0):
+    """
+    Given a B-Splines control points and knot vector, return
+    a sampled version of the curve.
+
+    Parameters
+    ----------
+    control : (o, d) float
+      Control points of the b- spline
+    knots : (j,) float
+      B-spline knots
+    count : int
+      Number of line segments to discretize the spline
+      If not specified will be calculated as something reasonable
+
+    Returns
+    ----------
+    discrete : (count, dimension) float
+       Points on a polyline version of the B-spline
+    """
+
+    # evaluate the b-spline using scipy/fitpack
+    from scipy.interpolate import splev
+
+    # (n, d) control points where d is the dimension of vertices
+    control = np.asanyarray(control, dtype=np.float64)
+    degree = len(knots) - len(control) - 1
+    if count is None:
+        norm = np.linalg.norm(np.diff(control, axis=0), axis=1).sum()
+        count = int(
+            np.clip(
+                norm / (res.seg_frac * scale),
+                res.min_sections * len(control),
+                res.max_sections * len(control),
+            )
+        )
+
+    ipl = np.linspace(knots[0], knots[-1], count)
+    discrete = splev(ipl, [knots, control.T, degree])
+    discrete = np.column_stack(discrete)
+
+    return discrete
+
+
+def binomial(n: Integer) -> list:
+    """
+    Return all binomial coefficients for a given order.
+
+    For n > 5, scipy.special.binom is used, below we hardcode.
+
+    Parameters
+    --------------
+    n : int
+      Order of binomial
+
+    Returns
+    ---------------
+    binom : (n + 1,) int
+      Binomial coefficients of a given order
+    """
+    if n == 1:
+        return [1, 1]
+    elif n == 2:
+        return [1, 2, 1]
+    elif n == 3:
+        return [1, 3, 3, 1]
+    elif n == 4:
+        return [1, 4, 6, 4, 1]
+    elif n == 5:
+        return [1, 5, 10, 10, 5, 1]
+    else:
+        from scipy.special import binom
+
+        return binom(n, np.arange(n + 1))

physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/trimesh/path/entities.py

@@ -0,0 +1,838 @@
+"""
+entities.py
+--------------
+
+Basic geometric primitives which only store references to
+vertex indices rather than vertices themselves.
+"""
+
+from copy import deepcopy
+from logging import getLogger
+
+import numpy as np
+
+from .. import util
+from ..util import ABC
+from .arc import arc_center, discretize_arc
+from .curve import discretize_bezier, discretize_bspline
+
+log = getLogger(__name__)
+
+
+class Entity(ABC):
+    def __init__(
+        self, points, closed=None, layer=None, metadata=None, color=None, **kwargs
+    ):
+        # points always reference vertex indices and are int
+        self.points = np.asanyarray(points, dtype=np.int64)
+        # save explicit closed
+        if closed is not None:
+            self.closed = closed
+        # save the passed layer
+        if layer is not None:
+            self.layer = layer
+        if metadata is not None:
+            self.metadata.update(metadata)
+
+        self._cache = {}
+
+        # save the passed color
+        self.color = color
+        # save any other kwargs for general use
+        self.kwargs = kwargs
+
+    @property
+    def metadata(self):
+        """
+        Get any metadata about the entity.
+
+        Returns
+        ---------
+        metadata : dict
+          Bag of properties.
+        """
+        if not hasattr(self, "_metadata"):
+            self._metadata = {}
+        # note that we don't let a new dict be assigned
+        return self._metadata
+
+    @property
+    def layer(self):
+        """
+        Set the layer the entity resides on as a shortcut
+        to putting it in the entity metadata.
+
+        Returns
+        ----------
+        layer : any
+          Hashable layer identifier.
+        """
+        return self.metadata.get("layer")
+
+    @layer.setter
+    def layer(self, value):
+        """
+        Set the current layer of the entity.
+
+        Returns
+        ----------
+        layer : any
+          Hashable layer indicator
+        """
+        self.metadata["layer"] = value
+
+    def to_dict(self) -> dict:
+        """
+        Returns a dictionary with all of the information
+        about the entity.
+
+        Returns
+        -----------
+        as_dict : dict
+          Has keys 'type', 'points', 'closed'
+        """
+        return {
+            "type": self.__class__.__name__,
+            "points": self.points.tolist(),
+            "closed": self.closed,
+        }
+
+    @property
+    def closed(self):
+        """
+        If the first point is the same as the end point
+        the entity is closed
+
+        Returns
+        -----------
+        closed : bool
+          Is the entity closed or not?
+        """
+        return len(self.points) > 2 and self.points[0] == self.points[-1]
+
+    @property
+    def nodes(self):
+        """
+        Returns an (n,2) list of nodes, or vertices on the path.
+        Note that this generic class function assumes that all of the
+        reference points are on the path which is true for lines and
+        three point arcs.
+
+        If you were to define another class where that wasn't the case
+        (for example, the control points of a bezier curve),
+        you would need to implement an entity- specific version of this
+        function.
+
+        The purpose of having a list of nodes is so that they can then be
+        added as edges to a graph so we can use functions to check
+        connectivity, extract paths, etc.
+
+        The slicing on this function is essentially just tiling points
+        so the first and last vertices aren't repeated. Example:
+
+        self.points = [0,1,2]
+        returns:      [[0,1], [1,2]]
+        """
+        return (
+            np.column_stack((self.points, self.points)).reshape(-1)[1:-1].reshape((-1, 2))
+        )
+
+    @property
+    def end_points(self):
+        """
+        Returns the first and last points. Also note that if you
+        define a new entity class where the first and last vertices
+        in self.points aren't the endpoints of the curve you need to
+        implement this function for your class.
+
+        Returns
+        -------------
+        ends : (2,) int
+          Indices of the two end points of the entity
+        """
+        return self.points[[0, -1]]
+
+    @property
+    def is_valid(self):
+        """
+        Is the current entity valid.
+
+        Returns
+        -----------
+        valid : bool
+          Is the current entity well formed
+        """
+        return True
+
+    def reverse(self, direction=-1):
+        """
+        Reverse the current entity in place.
+
+        Parameters
+        ----------------
+        direction : int
+          If positive will not touch direction
+          If negative will reverse self.points
+        """
+        if direction < 0:
+            self._direction = -1
+        else:
+            self._direction = 1
+
+    def _orient(self, curve):
+        """
+        Reverse a curve if a flag is set.
+
+        Parameters
+        --------------
+        curve : (n, dimension) float
+          Curve made up of line segments in space
+
+        Returns
+        ------------
+        orient : (n, dimension) float
+          Original curve, but possibly reversed
+        """
+        if hasattr(self, "_direction") and self._direction < 0:
+            return curve[::-1]
+        return curve
+
+    def bounds(self, vertices):
+        """
+        Return the AABB of the current entity.
+
+        Parameters
+        -----------
+        vertices : (n, dimension) float
+          Vertices in space
+
+        Returns
+        -----------
+        bounds : (2, dimension) float
+          Coordinates of AABB, in (min, max) form
+        """
+        bounds = np.array(
+            [vertices[self.points].min(axis=0), vertices[self.points].max(axis=0)]
+        )
+        return bounds
+
+    def length(self, vertices):
+        """
+        Return the total length of the entity.
+
+        Parameters
+        --------------
+        vertices : (n, dimension) float
+          Vertices in space
+
+        Returns
+        ---------
+        length : float
+          Total length of entity
+        """
+        diff = np.diff(self.discrete(vertices), axis=0) ** 2
+        length = (np.dot(diff, [1] * vertices.shape[1]) ** 0.5).sum()
+        return length
+
+    def explode(self):
+        """
+        Split the entity into multiple entities.
+
+        Returns
+        ------------
+        explode : list of Entity
+          Current entity split into multiple entities.
+        """
+        return [self.copy()]
+
+    def copy(self):
+        """
+        Return a copy of the current entity.
+
+        Returns
+        ------------
+        copied : Entity
+          Copy of current entity
+        """
+        copied = deepcopy(self)
+        # only copy metadata if set
+        if hasattr(self, "_metadata"):
+            copied._metadata = deepcopy(self._metadata)
+            # check for very annoying subtle copy failures
+            assert id(copied._metadata) != id(self._metadata)
+        assert id(copied.points) != id(self.points)
+        return copied
+
+    def __hash__(self):
+        """
+        Return a hash that represents the current entity.
+
+        Returns
+        ----------
+        hashed : int
+            Hash of current class name, points, and closed
+        """
+        return hash(self._bytes())
+
+    def _bytes(self):
+        """
+        Get hashable bytes that define the current entity.
+
+        Returns
+        ------------
+        data : bytes
+          Hashable data defining the current entity
+        """
+        # give consistent ordering of points for hash
+        if self.points[0] > self.points[-1]:
+            return self.__class__.__name__.encode("utf-8") + self.points.tobytes()
+        else:
+            return self.__class__.__name__.encode("utf-8") + self.points[::-1].tobytes()
+
+
+class Text(Entity):
+    """
+    Text to annotate a 2D or 3D path.
+    """
+
+    def __init__(
+        self,
+        origin,
+        text,
+        height=None,
+        vector=None,
+        normal=None,
+        align=None,
+        layer=None,
+        color=None,
+        metadata=None,
+    ):
+        """
+        An entity for text labels.
+
+        Parameters
+        --------------
+        origin : int
+          Index of a single vertex for text origin
+        text : str
+          The text to label
+        height : float or None
+          The height of text
+        vector : int or None
+          An vertex index for which direction text
+          is written along unitized: vector - origin
+        normal : int or None
+          A vertex index for the plane normal:
+          vector is along unitized: normal - origin
+        align : (2,) str or None
+          Where to draw from for [horizontal, vertical]:
+              'center', 'left', 'right'
+        """
+        # where is text placed
+        self.origin = origin
+        # what direction is the text pointing
+        self.vector = vector
+        # what is the normal of the text plane
+        self.normal = normal
+        # how high is the text entity
+        self.height = height
+        # what layer is the entity on
+        if layer is not None:
+            self.layer = layer
+
+        if metadata is not None:
+            self.metadata.update(metadata)
+
+        # what color is the entity
+        self.color = color
+
+        # None or (2,) str
+        if align is None:
+            # if not set make everything centered
+            align = ["center", "center"]
+        elif isinstance(align, str):
+            # if only one is passed set for both
+            # horizontal and vertical
+            align = [align, align]
+        elif len(align) != 2:
+            # otherwise raise rror
+            raise ValueError("align must be (2,) str")
+
+        self.align = align
+
+        # make sure text is a string
+        if hasattr(text, "decode"):
+            self.text = text.decode("utf-8")
+        else:
+            self.text = str(text)
+
+    @property
+    def origin(self):
+        """
+        The origin point of the text.
+
+        Returns
+        -----------
+        origin : int
+          Index of vertices
+        """
+        return self.points[0]
+
+    @origin.setter
+    def origin(self, value):
+        value = int(value)
+        if not hasattr(self, "points") or np.ptp(self.points) == 0:
+            self.points = np.ones(3, dtype=np.int64) * value
+        else:
+            self.points[0] = value
+
+    @property
+    def vector(self):
+        """
+        A point representing the text direction
+        along the vector: vertices[vector] - vertices[origin]
+
+        Returns
+        ----------
+        vector : int
+          Index of vertex
+        """
+        return self.points[1]
+
+    @vector.setter
+    def vector(self, value):
+        if value is None:
+            return
+        self.points[1] = int(value)
+
+    @property
+    def normal(self):
+        """
+        A point representing the plane normal along the
+        vector: vertices[normal] - vertices[origin]
+
+        Returns
+        ------------
+        normal : int
+          Index of vertex
+        """
+        return self.points[2]
+
+    @normal.setter
+    def normal(self, value):
+        if value is None:
+            return
+        self.points[2] = int(value)
+
+    def plot(self, vertices, show=False):
+        """
+        Plot the text using matplotlib.
+
+        Parameters
+        --------------
+        vertices : (n, 2) float
+          Vertices in space
+        show : bool
+          If True, call plt.show()
+        """
+        if vertices.shape[1] != 2:
+            raise ValueError("only for 2D points!")
+
+        import matplotlib.pyplot as plt  # noqa
+
+        # get rotation angle in degrees
+        angle = np.degrees(self.angle(vertices))
+
+        # TODO: handle text size better
+        plt.text(
+            *vertices[self.origin],
+            s=self.text,
+            rotation=angle,
+            ha=self.align[0],
+            va=self.align[1],
+            size=18,
+        )
+
+        if show:
+            plt.show()
+
+    def angle(self, vertices):
+        """
+        If Text is 2D, get the rotation angle in radians.
+
+        Parameters
+        -----------
+        vertices : (n, 2) float
+          Vertices in space referenced by self.points
+
+        Returns
+        ---------
+        angle : float
+          Rotation angle in radians
+        """
+
+        if vertices.shape[1] != 2:
+            raise ValueError("angle only valid for 2D points!")
+
+        # get the vector from origin
+        direction = vertices[self.vector] - vertices[self.origin]
+        # get the rotation angle in radians
+        angle = np.arctan2(*direction[::-1])
+
+        return angle
+
+    def length(self, vertices):
+        return 0.0
+
+    def discrete(self, *args, **kwargs):
+        return np.array([])
+
+    @property
+    def closed(self):
+        return False
+
+    @property
+    def is_valid(self):
+        return True
+
+    @property
+    def nodes(self):
+        return np.array([])
+
+    @property
+    def end_points(self):
+        return np.array([])
+
+    def _bytes(self):
+        data = b"".join([b"Text", self.points.tobytes(), self.text.encode("utf-8")])
+        return data
+
+
+class Line(Entity):
+    """
+    A line or poly-line entity
+    """
+
+    def discrete(self, vertices, scale=1.0):
+        """
+        Discretize into a world- space path.
+
+        Parameters
+        ------------
+        vertices: (n, dimension) float
+          Points in space
+        scale : float
+          Size of overall scene for numerical comparisons
+
+        Returns
+        -------------
+        discrete: (m, dimension) float
+          Path in space composed of line segments
+        """
+        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):
+        """
+        Is the current entity valid.
+
+        Returns
+        -----------
+        valid : bool
+          Is the current entity well formed
+        """
+        valid = np.any((self.points - self.points[0]) != 0)
+        return valid
+
+    def explode(self):
+        """
+        If the current Line entity consists of multiple line
+        break it up into n Line entities.
+
+        Returns
+        ----------
+        exploded: (n,) Line entities
+        """
+        # copy over the current layer
+        layer = self.layer
+        points = (
+            np.column_stack((self.points, self.points)).ravel()[1:-1].reshape((-1, 2))
+        )
+        exploded = [Line(i, layer=layer) for i in points]
+        return exploded
+
+    def _bytes(self):
+        # give consistent ordering of points for hash
+        if self.points[0] > self.points[-1]:
+            return b"Line" + self.points.tobytes()
+        else:
+            return b"Line" + self.points[::-1].tobytes()
+
+    def to_dict(self) -> dict:
+        """
+        Returns a dictionary with all of the information
+        about the Line. `closed` is not additional information
+        for a Line like it is for Arc where the value determines
+        if it is a partial or complete circle. Rather it is a check
+        which indicates the first and last points are identical,
+        and thus should not be included in the export
+
+        Returns
+        -----------
+        as_dict
+          Has keys 'type', 'points'
+        """
+        return {
+            "type": self.__class__.__name__,
+            "points": self.points.tolist(),
+        }
+
+
+class Arc(Entity):
+    @property
+    def closed(self):
+        """
+        A boolean flag for whether the arc is closed (a circle) or not.
+
+        Returns
+        ----------
+        closed : bool
+          If set True, Arc will be a closed circle
+        """
+        return getattr(self, "_closed", False)
+
+    @closed.setter
+    def closed(self, value):
+        """
+        Set the Arc to be closed or not, without
+        changing the control points
+
+        Parameters
+        ------------
+        value : bool
+          Should this Arc be a closed circle or not
+        """
+        self._closed = bool(value)
+
+    @property
+    def is_valid(self):
+        """
+        Is the current Arc entity valid.
+
+        Returns
+        -----------
+        valid : bool
+          Does the current Arc have exactly 3 control points
+        """
+        return len(np.unique(self.points)) == 3
+
+    def _bytes(self):
+        # give consistent ordering of points for hash
+        order = int(self.points[0] > self.points[-1]) * 2 - 1
+        return b"Arc" + bytes(self.closed) + self.points[::order].tobytes()
+
+    def length(self, vertices):
+        """
+        Return the arc length of the 3-point arc.
+
+        Parameter
+        ----------
+        vertices : (n, d) float
+          Vertices for overall drawing.
+
+        Returns
+        -----------
+        length : float
+          Length of arc.
+        """
+        # find the actual radius and angle span
+        if self.closed:
+            # we don't need the angular span as
+            # it's indicated as a closed circle
+            fit = self.center(vertices, return_normal=False, return_angle=False)
+            return np.pi * fit.radius * 2
+        # get the angular span of the circular arc
+        fit = self.center(vertices, return_normal=False, return_angle=True)
+        return fit.span * fit.radius
+
+    def discrete(self, vertices, scale=1.0):
+        """
+        Discretize the arc entity into line sections.
+
+        Parameters
+        ------------
+        vertices : (n, dimension) float
+            Points in space
+        scale : float
+            Size of overall scene for numerical comparisons
+
+        Returns
+        -------------
+        discrete : (m, dimension) float
+          Path in space made up of line segments
+        """
+
+        return self._orient(
+            discretize_arc(vertices[self.points], close=self.closed, scale=scale)
+        )
+
+    def center(self, vertices, **kwargs):
+        """
+        Return the center information about the arc entity.
+
+        Parameters
+        -------------
+        vertices : (n, dimension) float
+          Vertices in space
+
+        Returns
+        -------------
+        info : dict
+          With keys: 'radius', 'center'
+        """
+        return arc_center(vertices[self.points], **kwargs)
+
+    def bounds(self, vertices):
+        """
+        Return the AABB of the arc entity.
+
+        Parameters
+        -----------
+        vertices: (n, dimension) float
+          Vertices in space
+
+        Returns
+        -----------
+        bounds : (2, dimension) float
+          Coordinates of AABB in (min, max) form
+        """
+        if util.is_shape(vertices, (-1, 2)) and self.closed:
+            # if we have a closed arc (a circle), we can return the actual bounds
+            # this only works in two dimensions, otherwise this would return the
+            # AABB of an sphere
+            info = self.center(vertices, return_normal=False, return_angle=False)
+            bounds = np.array(
+                [info.center - info.radius, info.center + info.radius], dtype=np.float64
+            )
+        else:
+            # since the AABB of a partial arc is hard, approximate
+            # the bounds by just looking at the discrete values
+            discrete = self.discrete(vertices)
+            bounds = np.array(
+                [discrete.min(axis=0), discrete.max(axis=0)], dtype=np.float64
+            )
+        return bounds
+
+
+class Curve(Entity):
+    """
+    The parent class for all wild curves in space.
+    """
+
+    @property
+    def nodes(self):
+        # a point midway through the curve
+        mid = self.points[len(self.points) // 2]
+        return [[self.points[0], mid], [mid, self.points[-1]]]
+
+
+class Bezier(Curve):
+    """
+    An open or closed Bezier curve
+    """
+
+    def discrete(self, vertices, scale=1.0, count=None):
+        """
+        Discretize the Bezier curve.
+
+        Parameters
+        -------------
+        vertices : (n, 2) or (n, 3) float
+          Points in space
+        scale : float
+          Scale of overall drawings (for precision)
+        count : int
+          Number of segments to return
+
+        Returns
+        -------------
+        discrete : (m, 2) or (m, 3) float
+          Curve as line segments
+        """
+        return self._orient(
+            discretize_bezier(vertices[self.points], count=count, scale=scale)
+        )
+
+
+class BSpline(Curve):
+    """
+    An open or closed B- Spline.
+    """
+
+    def __init__(self, points, knots, layer=None, metadata=None, color=None, **kwargs):
+        self.points = np.asanyarray(points, dtype=np.int64)
+        self.knots = np.asanyarray(knots, dtype=np.float64)
+        if layer is not None:
+            self.layer = layer
+        if metadata is not None:
+            self.metadata.update(metadata)
+        self._cache = {}
+        self.kwargs = kwargs
+        self.color = color
+
+    def discrete(self, vertices, count=None, scale=1.0):
+        """
+        Discretize the B-Spline curve.
+
+        Parameters
+        -------------
+        vertices : (n, 2) or (n, 3) float
+          Points in space
+        scale : float
+          Scale of overall drawings (for precision)
+        count : int
+          Number of segments to return
+
+        Returns
+        -------------
+        discrete : (m, 2) or (m, 3) float
+          Curve as line segments
+        """
+        discrete = discretize_bspline(
+            control=vertices[self.points], knots=self.knots, count=count, scale=scale
+        )
+        return self._orient(discrete)
+
+    def _bytes(self):
+        # give consistent ordering of points for hash
+        if self.points[0] > self.points[-1]:
+            return b"BSpline" + self.knots.tobytes() + self.points.tobytes()
+        else:
+            return b"BSpline" + self.knots[::-1].tobytes() + self.points[::-1].tobytes()
+
+    def to_dict(self) -> dict:
+        """
+        Returns a dictionary with all of the information
+        about the entity.
+        """
+        return {
+            "type": self.__class__.__name__,
+            "points": self.points.tolist(),
+            "knots": self.knots.tolist(),
+            "closed": self.closed,
+        }