yapCAD 0.5.0__py2.py3-none-any.whl → 0.5.1__py2.py3-none-any.whl

yapcad/geom3d.py

@@ -6,7 +6,21 @@ from yapcad.geom import *
 from yapcad.geom_util import *
 from yapcad.xform import *
 from functools import reduce
+import os
+from yapcad.octtree import NTree
+
 from yapcad.triangulator import triangulate_polygon
+import yapcad.boolean.native as _boolean_native
+_DEFAULT_RAY_TOL = _boolean_native._DEFAULT_RAY_TOL
+invalidate_surface_octree = _boolean_native.invalidate_surface_octree
+surface_octree = _boolean_native.surface_octree
+_surface_from_triangles = _boolean_native._surface_from_triangles
+_iter_triangles_from_surface = _boolean_native._iter_triangles_from_surface
+_iter_triangles_from_solid = _boolean_native._iter_triangles_from_solid
+stitch_open_edges = _boolean_native.stitch_open_edges
+stitch_solid = _boolean_native.stitch_solid
+solid_contains_point = _boolean_native.solid_contains_point
+solids_intersect = _boolean_native.solids_intersect
 
 
 """
@@ -125,7 +139,7 @@ function call with parameters for algorithmically-generated geometry.
 
 ``solid = ['solid', surfaces, material, construction ]``, where:
 
-           ``surfaces`` is a list of surfaces with contiguous boundaries 
+           ``surfaces`` is a list of surfaces with contiguous boundaries
            that completely encloses an interior space,
 
            ``material`` is a list of domain-specific representation of
@@ -136,6 +150,30 @@ function call with parameters for algorithmically-generated geometry.
            ``construction`` is a list that contains information about
            how the solid was constructed, and may be empty
 
+Topology Analysis
+-----------------
+
+Two key functions are provided for analyzing solid topology:
+
+``issolidclosed(solid)`` -- Verifies that a solid is topologically closed
+by ensuring every edge is shared by exactly two faces across all surfaces.
+This is essential for determining if a solid properly encloses a volume
+without gaps or holes. Returns True if closed, False otherwise.
+
+``volumeof(solid)`` -- Calculates the volume enclosed by a closed solid
+using the divergence theorem. Requires that the solid be topologically
+closed (verified by calling ``issolidclosed()``). Returns the volume
+as a non-negative floating point number.
+
+Example usage::
+
+    from yapcad.geom3d_util import prism
+    from yapcad.geom3d import issolidclosed, volumeof
+
+    cube = prism(2, 2, 2)
+    if issolidclosed(cube):
+        vol = volumeof(cube)  # Returns 8.0
+
 
 Assembly
 --------
@@ -475,7 +513,25 @@ def surfacebbox(s):
     if not issurface(s):
         raise ValueError('bad surface passed to surfacebbox')
     return polybbox(s[1])
-            
+    
+
+
+
+def solid_boolean(a, b, operation, tol=_DEFAULT_RAY_TOL, *, stitch=False, engine=None):
+    selected_raw = engine or os.environ.get('YAPCAD_BOOLEAN_ENGINE', 'native')
+    backend = None
+    if selected_raw and ':' in selected_raw:
+        selected, backend = selected_raw.split(':', 1)
+    else:
+        selected = selected_raw
+    if selected == 'native':
+        return _boolean_native.solid_boolean(a, b, operation, tol=tol, stitch=stitch)
+    if selected == 'trimesh':
+        from yapcad.boolean import trimesh_engine
+        backend = backend or os.environ.get('YAPCAD_TRIMESH_BACKEND')
+        return trimesh_engine.solid_boolean(a, b, operation, tol=tol, stitch=stitch, backend=backend)
+    raise ValueError(f'unknown boolean engine {selected_raw!r}')
+
 def issurface(s,fast=True):
     """
     Check to see if ``s`` is a valid surface.
@@ -487,8 +543,8 @@ def issurface(s,fast=True):
         return (len(list(filter(lambda x: not (isinstance(x,int) or
                                                x < 0 or x >= l),
                                 inds))) == 0)
-    
-    if not isinstance(s,list) or s[0] != 'surface' or len(s) not in (6,7):
+
+    if not isinstance(s,list) or len(s) not in (6,7) or s[0] != 'surface':
         return False
     if fast:
         return True
@@ -633,7 +689,7 @@ def issolid(s,fast=True):
     of surfaces completely bounds a volume of space without holes
     """
 
-    if not isinstance(s,list) or s[0] != 'solid' or len(s) not in (4,5):
+    if not isinstance(s,list) or len(s) not in (4,5) or s[0] != 'solid':
         return False
     if fast:
         return True
@@ -653,8 +709,17 @@ def solidbbox(sld):
         raise ValueError('bad argument to solidbbox')
 
     box = []
-    for s in sld[1]:
-        box = surfacebbox(s + box)
+    for surf in sld[1]:
+        sb = surfacebbox(surf)
+        if not box:
+            box = sb
+        else:
+            box = [point(min(box[0][0], sb[0][0]),
+                         min(box[0][1], sb[0][1]),
+                         min(box[0][2], sb[0][2])),
+                   point(max(box[1][0], sb[1][0]),
+                         max(box[1][1], sb[1][1]),
+                         max(box[1][2], sb[1][2]))]
 
     return box
 
@@ -691,6 +756,171 @@ def mirrorsolid(x,plane,preserveNormal=True):
     s2[1] = surfs
     return s2
 
+def _point_to_key(p):
+    """
+    Convert a point to a hashable key for edge/vertex identification.
+    Uses rounded coordinates to handle floating point precision issues.
+    """
+    # Round to a reasonable precision to handle floating point comparison
+    return (round(p[0] / epsilon) * epsilon,
+            round(p[1] / epsilon) * epsilon,
+            round(p[2] / epsilon) * epsilon)
+
+def _canonical_edge_key(p1, p2):
+    """
+    Create a canonical edge key from two points.
+    Returns tuple of keys in sorted order so (p1,p2) and (p2,p1) map to same edge.
+    """
+    k1 = _point_to_key(p1)
+    k2 = _point_to_key(p2)
+    return (min(k1, k2), max(k1, k2))
+
+def issolidclosed(x):
+    """
+    Check if solid x is topologically closed.
+
+    A solid is closed if and only if every edge is shared by exactly two
+    faces across all surfaces. This ensures no holes or gaps exist in the
+    solid's boundary.
+
+    The function analyzes face adjacency by:
+    1. Building a global edge map using vertex positions (not indices)
+    2. Counting how many faces share each edge
+    3. Verifying that every edge is shared by exactly 2 faces
+
+    Args:
+        x: A solid data structure
+
+    Returns:
+        True if the solid is topologically closed, False otherwise
+
+    Raises:
+        ValueError: if x is not a valid solid
+
+    Example:
+        >>> from yapcad.geom3d_util import prism, sphere
+        >>> cube = prism(2, 2, 2)
+        >>> issolidclosed(cube)
+        True
+    """
+    # First verify this is a valid solid
+    if not issolid(x, fast=False):
+        raise ValueError('invalid solid passed to issolidclosed')
+
+    surfaces = x[1]
+
+    # Empty solid is trivially closed
+    if not surfaces:
+        return True
+
+    # Build a global edge map across all surfaces
+    # Key: canonical edge tuple (point_key1, point_key2)
+    # Value: count of faces that share this edge
+    global_edge_count = {}
+
+    for surf_idx, surf in enumerate(surfaces):
+        faces = surf[3]
+        vertices = surf[1]
+
+        # Process each face in this surface
+        for face_idx, face in enumerate(faces):
+            if len(face) != 3:
+                raise ValueError(f'non-triangular face in surface {surf_idx}, face {face_idx}')
+
+            # Get the three vertex positions
+            p0 = vertices[face[0]]
+            p1 = vertices[face[1]]
+            p2 = vertices[face[2]]
+
+            # Extract the three edges of this triangular face
+            edges = [
+                _canonical_edge_key(p0, p1),
+                _canonical_edge_key(p1, p2),
+                _canonical_edge_key(p2, p0)
+            ]
+
+            # Count this face's contribution to each edge
+            for edge in edges:
+                if edge not in global_edge_count:
+                    global_edge_count[edge] = 0
+                global_edge_count[edge] += 1
+
+    # Check that every edge is shared by exactly 2 faces
+    for edge, count in global_edge_count.items():
+        if count != 2:
+            return False
+
+    return True
+
+def volumeof(x):
+    """
+    Calculate the volume enclosed by a solid.
+
+    Uses the divergence theorem to compute volume from the surface triangulation.
+    For each triangular face with vertices (p0, p1, p2), the signed volume
+    contribution is: V_i = (1/6) * dot(p0, cross(p1-p0, p2-p0))
+
+    The total volume is the sum of absolute values of all face contributions.
+
+    Args:
+        x: A solid data structure (must be topologically closed)
+
+    Returns:
+        float: The volume of the solid (always non-negative)
+
+    Raises:
+        ValueError: if x is not a valid solid or is not closed
+
+    Example:
+        >>> from yapcad.geom3d_util import prism
+        >>> cube = prism(2, 2, 2)
+        >>> abs(volumeof(cube) - 8.0) < 0.001
+        True
+    """
+    # Verify this is a valid, closed solid
+    if not issolid(x, fast=False):
+        raise ValueError('invalid solid passed to volumeof')
+
+    if not issolidclosed(x):
+        raise ValueError('solid must be topologically closed to compute volume')
+
+    surfaces = x[1]
+
+    # Handle empty solid
+    if not surfaces:
+        return 0.0
+
+    total_volume = 0.0
+
+    # Accumulate signed volume contributions from all faces
+    for surf in surfaces:
+        vertices = surf[1]
+        faces = surf[3]
+
+        for face in faces:
+            if len(face) != 3:
+                raise ValueError('non-triangular face encountered')
+
+            # Get the three vertices of this face and normalise to w=1 if needed
+            p0 = point(vertices[face[0]])
+            p1 = point(vertices[face[1]])
+            p2 = point(vertices[face[2]])
+
+            # Compute vectors from p0 to other vertices
+            v1 = sub(p1, p0)
+            v2 = sub(p2, p0)
+
+            # Signed volume contribution: (1/6) * dot(p0, cross(v1, v2))
+            # This is the volume of the tetrahedron formed by the origin
+            # and the three face vertices
+            cross_product = cross(v1, v2)
+            signed_volume = dot(p0, cross_product) / 6.0
+
+            total_volume += signed_volume
+
+    # Return absolute value (orientation might cause negative result)
+    return abs(total_volume)
+
 def normfunc(tri):
     """
     utility funtion to compute normals for a flat facet triangle