trenchfoot 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

trenchfoot/scenarios/S07_circular_well/sdf_metadata.json

@@ -2,276 +2,211 @@
   "sdf_metadata": {
     "version": "2.0",
     "normal_convention": "into_void",
-    "geometry_type": "open_trench",
+    "geometry_type": "closed_well",
     "trench_opening": {
       "type": "polygon",
       "vertices_xy": [
         [
-          0.5048152733278032,
-          -0.0980171403295607
+          2.5048385723763116,
+          -2.7755575615628914e-15
         ],
         [
-          0.5142375848726368,
-          0.0023508057697296803
+          2.456708801572928,
+          0.4886697636833139
         ],
         [
-          0.5038980344185748,
-          0.10262841172163711
+          2.3141690892632654,
+          0.9585602223974381
         ],
         [
-          0.47419396509108047,
-          0.198962065365758
+          2.082697156654193,
+          1.3916137493315945
         ],
         [
-          0.4262668876161758,
-          0.2876497184170843
+          1.7711883403049211,
+          1.77118834030492
         ],
         [
-          0.3619586127034061,
-          0.36528315410546264
+          1.3916137493315943,
+          2.082697156654193
         ],
         [
-          0.28374047129317204,
-          0.4288789630347212
+          0.9585602223974379,
+          2.3141690892632654
         ],
         [
-          0.1946183426946318,
-          0.47599319393264883
+          0.488669763683314,
+          2.456708801572928
         ],
         [
-          0.0980171403295608,
-          0.5048152733278032
+          9.71445146547012e-17,
+          2.504838572376311
         ],
         [
-          -0.0023508057697296803,
-          0.5142375848726368
+          -0.48866976368331355,
+          2.456708801572928
         ],
         [
-          -0.10262841172163778,
-          0.5038980344185745
+          -0.9585602223974382,
+          2.314169089263265
         ],
         [
-          -0.19896206536575745,
-          0.47419396509108125
+          -1.3916137493315945,
+          2.082697156654193
         ],
         [
-          -0.2876497184170844,
-          0.4262668876161758
+          -1.7711883403049202,
+          1.7711883403049207
         ],
         [
-          -0.36528315410546275,
-          0.361958612703406
+          -2.0826971566541927,
+          1.3916137493315948
         ],
         [
-          -0.4288789630347214,
-          0.2837404712931719
+          -2.314169089263265,
+          0.9585602223974394
         ],
         [
-          -0.47599319393264883,
-          0.1946183426946323
+          -2.456708801572928,
+          0.48866976368331483
         ],
         [
-          -0.5048152733278032,
-          0.09801714032956078
+          -2.504838572376311,
+          1.8041124150158794e-16
         ],
         [
-          -0.5142375848726367,
-          -0.0023508057697302354
+          -2.4567088015729275,
+          -0.48866976368331533
         ],
         [
-          -0.503898034418575,
-          -0.10262841172163728
+          -2.3141690892632654,
+          -0.958560222397438
         ],
         [
-          -0.47419396509108125,
-          -0.19896206536575745
+          -2.0826971566541936,
+          -1.3916137493315939
         ],
         [
-          -0.42626688761617615,
-          -0.287649718417084
+          -1.7711883403049204,
+          -1.7711883403049207
         ],
         [
-          -0.36195861270340507,
-          -0.36528315410546297
+          -1.3916137493315952,
+          -2.0826971566541927
         ],
         [
-          -0.2837404712931731,
-          -0.42887896303472095
+          -0.9585602223974392,
+          -2.314169089263265
         ],
         [
-          -0.19461834269463169,
-          -0.4759931939326486
+          -0.48866976368331394,
+          -2.456708801572928
         ],
         [
-          -0.09801714032956087,
-          -0.5048152733278032
+          -1.0408340855860843e-15,
+          -2.504838572376311
         ],
         [
-          0.0023508057697300133,
-          -0.5142375848726368
+          0.4886697636833134,
+          -2.456708801572928
         ],
         [
-          0.1026284117216375,
-          -0.5038980344185748
+          0.9585602223974385,
+          -2.314169089263265
         ],
         [
-          0.19896206536575722,
-          -0.47419396509108147
+          1.3916137493315957,
+          -2.0826971566541923
         ],
         [
-          0.2876497184170842,
-          -0.4262668876161758
+          1.7711883403049202,
+          -1.7711883403049207
         ],
         [
-          0.36528315410546297,
-          -0.36195861270340507
+          2.0826971566541927,
+          -1.391613749331595
         ],
         [
-          0.42887896303472095,
-          -0.28374047129317304
+          2.314169089263265,
+          -0.9585602223974392
         ],
         [
-          0.4759931939326485,
-          -0.19461834269463185
-        ],
-        [
-          0.5048152733278031,
-          0.09801714032956123
-        ],
-        [
-          2.495184726672197,
-          -0.09801714032956123
-        ],
-        [
-          2.4663626472770424,
-          -0.3906526233537543
-        ],
-        [
-          2.3427596344991386,
-          -0.864309825802098
-        ],
-        [
-          2.1291256828021727,
-          -1.3047520863554014
-        ],
-        [
-          1.8336706251425579,
-          -1.6950534559434671
-        ],
-        [
-          1.4677486336930485,
-          -2.020214871816555
-        ],
-        [
-          1.0454218853736323,
-          -2.267740563115285
-        ],
-        [
-          0.5829201602786549,
-          -2.4281182563370542
-        ],
-        [
-          0.09801714032956031,
-          -2.4951847266721967
-        ],
-        [
-          -0.39065262335375434,
-          -2.4663626472770424
-        ],
-        [
-          -0.864309825802098,
-          -2.3427596344991386
-        ],
-        [
-          -1.3047520863554014,
-          -2.1291256828021727
-        ],
-        [
-          -1.6950534559434667,
-          -1.8336706251425583
-        ],
-        [
-          -2.020214871816555,
-          -1.4677486336930485
-        ],
-        [
-          -2.2677405631152854,
-          -1.045421885373632
-        ],
-        [
-          -2.4281182563370547,
-          -0.5829201602786548
-        ],
-        [
-          -2.4951847266721967,
-          -0.09801714032956042
-        ],
-        [
-          -2.4663626472770424,
-          0.3906526233537535
-        ],
-        [
-          -2.3427596344991386,
-          0.8643098258020978
-        ],
-        [
-          -2.129125682802173,
-          1.3047520863554005
-        ],
-        [
-          -1.8336706251425579,
-          1.6950534559434671
-        ],
-        [
-          -1.4677486336930485,
-          2.020214871816555
-        ],
-        [
-          -1.0454218853736315,
-          2.2677405631152854
-        ],
-        [
-          -0.5829201602786549,
-          2.4281182563370542
-        ],
-        [
-          -0.0980171403295606,
-          2.4951847266721967
-        ],
-        [
-          0.3906526233537532,
-          2.4663626472770424
-        ],
-        [
-          0.8643098258020975,
-          2.3427596344991386
-        ],
-        [
-          1.3047520863554007,
-          2.129125682802173
-        ],
-        [
-          1.6950534559434671,
-          1.833670625142558
-        ],
-        [
-          2.020214871816555,
-          1.4677486336930485
-        ],
-        [
-          2.267740563115285,
-          1.0454218853736321
-        ],
-        [
-          2.4281182563370542,
-          0.5829201602786551
-        ],
-        [
-          2.4951847266721967,
-          0.0980171403295607
+          2.456708801572928,
+          -0.4886697636833141
         ]
       ],
       "z_level": 0.0
+    },
+    "surface_groups": {
+      "trench_bottom": {
+        "normal_direction": "up",
+        "surface_type": "floor"
+      },
+      "trench_walls": {
+        "normal_direction": "inward",
+        "surface_type": "wall"
+      },
+      "ground_surface": {
+        "normal_direction": "up",
+        "surface_type": "ground"
+      },
+      "pipe0_pipe_side": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe0_pipe_cap_neg": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe0_pipe_cap_pos": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe1_pipe_side": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe1_pipe_cap_neg": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe1_pipe_cap_pos": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe2_pipe_side": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe2_pipe_cap_neg": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe2_pipe_cap_pos": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe3_pipe_side": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe3_pipe_cap_neg": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "pipe3_pipe_cap_pos": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      },
+      "sphere0": {
+        "normal_direction": "outward",
+        "surface_type": "embedded_object"
+      }
+    },
+    "embedded_objects": {
+      "pipes": 4,
+      "boxes": 0,
+      "spheres": 1
     }
   }
 }

trenchfoot/trench_scene_generator_v3.py

@@ -34,7 +34,7 @@ except Exception:
     Poly3DCollection = None
 
 # Groups kept for internal metrics but excluded from OBJ export and previews
-_INTERNAL_GROUPS = frozenset({"trench_cap_for_volume"})
+_INTERNAL_GROUPS = frozenset({"trench_cap_for_volume", "inner_column_lid"})
 
 # ---------------- Geometry helpers ----------------
 
@@ -123,6 +123,9 @@ def _offset_closed_polyline(path: List[Tuple[float,float]], offset: float) -> Li
     this returns a single continuous closed ring for paths where first ≈ last point.
     """
     P = np.array(path, float)
+    # Remove duplicate closing point if present (first ≈ last)
+    if len(P) > 1 and np.linalg.norm(P[0] - P[-1]) < 0.01:
+        P = P[:-1]
     n = len(P)
     if n < 3:
         raise ValueError("Closed polyline needs at least 3 points")
@@ -195,6 +198,74 @@ def _ear_clipping_triangulation(poly_xy: np.ndarray) -> np.ndarray:
     tris.append([V[0],V[1],V[2]])
     return np.array(tris,int)
 
+
+def _extract_boundary_polygon(V: np.ndarray, F: np.ndarray) -> Optional[np.ndarray]:
+    """Extract ordered boundary polygon from a triangulated mesh.
+
+    Finds boundary edges (edges appearing in only one face) and chains
+    them together to form an ordered polygon. This correctly handles
+    non-convex shapes like L-shaped or U-shaped boundaries.
+
+    Parameters
+    ----------
+    V : np.ndarray
+        Vertices (n, 3) or (n, 2)
+    F : np.ndarray
+        Faces (m, 3) - triangle indices
+
+    Returns
+    -------
+    np.ndarray or None
+        Ordered boundary vertices XY coordinates (k, 2), or None if
+        no boundary edges found (closed mesh).
+    """
+    if F.size == 0:
+        return None
+
+    # Count edge occurrences - boundary edges appear exactly once
+    edge_count: Dict[Tuple[int, int], int] = {}
+    for face in F:
+        for i in range(3):
+            v0, v1 = int(face[i]), int(face[(i + 1) % 3])
+            edge = (min(v0, v1), max(v0, v1))
+            edge_count[edge] = edge_count.get(edge, 0) + 1
+
+    # Boundary edges appear exactly once
+    boundary_edges = [edge for edge, count in edge_count.items() if count == 1]
+
+    if not boundary_edges:
+        return None  # No boundary (closed mesh)
+
+    # Build adjacency from boundary edges
+    adj: Dict[int, List[int]] = {}
+    for v0, v1 in boundary_edges:
+        adj.setdefault(v0, []).append(v1)
+        adj.setdefault(v1, []).append(v0)
+
+    # Chain the boundary edges starting from any vertex
+    start = boundary_edges[0][0]
+    polygon = [start]
+    prev = None
+    curr = start
+
+    max_iter = len(boundary_edges) + 1
+    for _ in range(max_iter):
+        neighbors = adj.get(curr, [])
+        # Pick the neighbor that isn't the previous vertex
+        next_candidates = [n for n in neighbors if n != prev]
+        if not next_candidates:
+            break
+        next_v = next_candidates[0]
+        if next_v == start:
+            break  # Completed the loop
+        polygon.append(next_v)
+        prev = curr
+        curr = next_v
+
+    # Extract XY coordinates
+    return V[polygon, :2]
+
+
 # ---------------- Mesh IO & metrics ----------------
 
 def write_obj_with_groups(path: str, groups: Dict[str, Tuple[np.ndarray, np.ndarray]]):
@@ -405,6 +476,7 @@ class GroundSpec:
     z0: float = 0.0
     slope: Tuple[float,float] = (0.0, 0.0)   # (dz/dx, dz/dy)
     size_margin: float = 3.0
+    fill_interior: bool = False  # For closed paths: fill the interior with ground surface
 
 @dataclass
 class SceneSpec:
@@ -447,19 +519,15 @@ class SurfaceMeshResult:
         if "trench_cap_for_volume" in self.groups:
             V_cap, F_cap = self.groups["trench_cap_for_volume"]
             if V_cap.size > 0:
-                # Get unique vertices at z ≈ ground level (the top cap boundary)
-                # These form the trench opening polygon
-                z_level = float(np.median(V_cap[:, 2]))
-                xy_coords = V_cap[:, :2]
-                # Use convex hull to get ordered boundary vertices
-                try:
-                    from scipy.spatial import ConvexHull
-                    hull = ConvexHull(xy_coords)
-                    boundary_indices = hull.vertices
-                    trench_opening_vertices = xy_coords[boundary_indices].tolist()
-                except ImportError:
-                    # Fallback: just use unique xy coords (unordered)
-                    trench_opening_vertices = xy_coords.tolist()
+                # Extract boundary polygon by finding boundary edges (edges in only one face)
+                # and chaining them together. This correctly handles non-convex shapes
+                # like L-shaped or U-shaped trenches.
+                boundary_xy = _extract_boundary_polygon(V_cap, F_cap)
+                if boundary_xy is not None:
+                    trench_opening_vertices = boundary_xy.tolist()
+                else:
+                    # Fallback: just use all vertices (unordered)
+                    trench_opening_vertices = V_cap[:, :2].tolist()
 
         # Determine geometry type
         is_closed = _is_path_closed(self.spec.path_xy)
@@ -485,7 +553,7 @@ class SurfaceMeshResult:
 
         return {
             "sdf_metadata": {
-                "version": "1.0",
+                "version": "2.0",
                 "normal_convention": "into_void",
                 "geometry_type": geometry_type,
                 "trench_opening": {
@@ -735,6 +803,16 @@ def make_trench_from_path_sloped(path_xy: List[Tuple[float,float]], width_top: f
         V_walls = np.array(walls_V, float)
         F_walls = np.array(walls_F, int)
 
+        # Inner column lid: cap the top of the inner column at ground level
+        # Reverse inner_top to get CCW winding for upward-facing normals
+        inner_top_ccw = inner_top[::-1].copy()
+        z_inner_top_ccw = z_inner_top[::-1].copy()
+        lid_xy, lid_faces = _triangulate_polygon_fan(inner_top_ccw)
+        # Assign z-values: polygon vertices use z_inner_top_ccw, centroid uses average
+        z_lid = np.concatenate([z_inner_top_ccw, [np.mean(z_inner_top_ccw)]])
+        V_lid = np.column_stack([lid_xy, z_lid])
+        F_lid = _ensure_upward_normals(V_lid, lid_faces)
+
         # For closed path, poly_top is the outer ring (used for ground plane hole)
         poly_top = outer_top
         poly_bot = outer_bot
@@ -796,6 +874,10 @@ def make_trench_from_path_sloped(path_xy: List[Tuple[float,float]], width_top: f
         "trench_walls": (V_walls, F_walls)
     }
 
+    # Add inner column lid for closed paths
+    if is_closed:
+        groups["inner_column_lid"] = (V_lid, F_lid)
+
     return groups, poly_top, poly_bot, extra
 
 def _ensure_upward_normals(V: np.ndarray, F: np.ndarray) -> np.ndarray:
@@ -830,6 +912,28 @@ def _ensure_upward_normals(V: np.ndarray, F: np.ndarray) -> np.ndarray:
     return F_out
 
 
+def _triangulate_polygon_fan(polygon: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    """Triangulate a simple polygon using fan triangulation from centroid.
+
+    Works well for convex or nearly-convex polygons. Returns (vertices, faces)
+    where vertices includes the original polygon points plus the centroid.
+    """
+    n = len(polygon)
+    centroid = polygon.mean(axis=0)
+
+    # Vertices: polygon points first, then centroid at the end
+    verts = np.vstack([polygon, centroid.reshape(1, -1)])
+    centroid_idx = n
+
+    # Fan triangles from centroid to each edge
+    tris = []
+    for i in range(n):
+        j = (i + 1) % n
+        tris.append([centroid_idx, i, j])
+
+    return verts, np.array(tris, dtype=int)
+
+
 def _triangulate_annulus(outer: np.ndarray, inner: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Triangulate the annular region between outer and inner polygons.
 
@@ -919,9 +1023,8 @@ def make_ground_surface_plane(path_xy: List[Tuple[float,float]], width_top: floa
     is_closed = _is_path_closed(path_xy)
 
     if is_closed:
-        # For closed paths (like circular wells), the ground is an annulus
-        # from the outer ground boundary to the outer edge of the trench opening.
-        # The center (inside the trench) is left completely open.
+        # For closed paths, ground is an annulus from outer boundary to trench edge.
+        # Optionally, if fill_interior is set, also fill the interior island.
 
         # Trench outer boundary (edge of trench opening)
         trench_outer = np.array(_offset_closed_polyline(path_xy, half_top), float)
@@ -933,14 +1036,23 @@ def make_ground_surface_plane(path_xy: List[Tuple[float,float]], width_top: floa
         trench_outer = _ensure_ccw(trench_outer)
         ground_outer = _ensure_ccw(ground_outer)
 
-        # Ground annulus: from ground_outer to trench_outer
-        combined_xy, tris = _triangulate_annulus(ground_outer, trench_outer)
-        Vg = np.array([[x, y, gfun(x, y)] for (x, y) in combined_xy], float)
+        # Outer ground annulus: from ground_outer to trench_outer
+        outer_xy, outer_tris = _triangulate_annulus(ground_outer, trench_outer)
+        Vg_outer = np.array([[x, y, gfun(x, y)] for (x, y) in outer_xy], float)
+        outer_tris = _ensure_upward_normals(Vg_outer, outer_tris)
 
-        # Ground normals should point UP (+z) into the air
-        tris = _ensure_upward_normals(Vg, tris)
+        result = {"ground_surface": (Vg_outer, outer_tris)}
 
-        return {"ground_surface": (Vg, tris)}
+        # Optionally fill the interior island (for loop trenches, not wells/pits)
+        if getattr(ground, 'fill_interior', False):
+            trench_inner = np.array(_offset_closed_polyline(path_xy, -half_top), float)
+            trench_inner = _ensure_ccw(trench_inner)
+            inner_xy, inner_tris = _triangulate_polygon_fan(trench_inner)
+            Vg_inner = np.array([[x, y, gfun(x, y)] for (x, y) in inner_xy], float)
+            inner_tris = _ensure_upward_normals(Vg_inner, inner_tris)
+            result["ground_island"] = (Vg_inner, inner_tris)
+
+        return result
     else:
         # Open paths: ground forms annulus with extensions past trench endpoints.
         # The outer ring (ground boundary) is extended, but the inner ring (trench

{trenchfoot-0.3.1.dist-info → trenchfoot-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trenchfoot
-Version: 0.3.1
+Version: 0.4.1
 Summary: Synthetic trench scenario generator bundle (surfaces + volumetrics).
 Author: Liam Moore
 License-File: LICENSE