trenchfoot 0.2.2__tar.gz → 0.2.4__tar.gz

{trenchfoot-0.2.2 → trenchfoot-0.2.4}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.2.4] - 2025-12-24
+
+### Added
+- **Ground end caps**: For open-path trenches, the ground surface now extends past the trench endpoints with semicircular caps, providing a buffer of ground at each end instead of terminating abruptly.
+
+## [0.2.3] - 2025-12-20
+
+### Fixed
+- **Closed path offset direction bug**: `_offset_closed_polyline` was using CCW rotation for normals, causing positive offsets to go inward instead of outward. Fixed to use CW rotation for correct outward-pointing normals on CCW polygons.
+- **Circular well ground surface**: Removed incorrect center island from closed path ground surfaces. For circular wells, only the outer ground ring exists, leaving the trench opening completely open.
+
+### Added
+- **Open-topped trench tests**: New tests to verify trenches are truly open (no geometry covering the trench opening):
+  - `test_trench_opening_is_open_for_straight_trench`
+  - `test_circular_well_trench_opening_is_open`
+  - `test_ground_surface_annular_structure`
+
 ## [0.2.2] - 2025-12-20
 
 ### Fixed

{trenchfoot-0.2.2 → trenchfoot-0.2.4}/PKG-INFO

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

{trenchfoot-0.2.2 → trenchfoot-0.2.4}/packages/trenchfoot/trench_scene_generator_v3.py

@@ -128,6 +128,7 @@ def _offset_closed_polyline(path: List[Tuple[float,float]], offset: float) -> Li
         raise ValueError("Closed polyline needs at least 3 points")
 
     # Compute tangents treating path as closed loop
+    # For CCW-oriented polygons, use CW rotation to get outward-pointing normals
     tangents = []
     normals = []
     for i in range(n):
@@ -135,7 +136,7 @@ def _offset_closed_polyline(path: List[Tuple[float,float]], offset: float) -> Li
         if np.linalg.norm(t) < 1e-12:
             t = np.array([1.0, 0.0])
         tangents.append(t)
-        normals.append(_rotate_ccw(t))
+        normals.append(_rotate_cw(t))  # CW rotation gives outward normal for CCW polygon
 
     # Compute offset points with proper miter at each vertex
     offset_pts = []
@@ -546,6 +547,64 @@ def make_sphere(center: np.ndarray, radius: float, n_theta: int=48, n_phi: int=2
 def _ring_from_LR(L: List[np.ndarray], R: List[np.ndarray]) -> np.ndarray:
     return np.array(L + list(R[::-1]), float)
 
+
+def _ring_from_LR_with_end_caps(
+    L: List[np.ndarray], R: List[np.ndarray],
+    path_xy: List[Tuple[float, float]], end_extension: float, n_cap_points: int = 5
+) -> np.ndarray:
+    """Create a ring from L/R offsets with semicircular end caps.
+
+    Extends the outer boundary past the path endpoints to create ground buffer
+    at the ends of open trenches.
+    """
+    P = np.array(path_xy, float)
+
+    # Get tangent directions at endpoints
+    t_start = _normalize(P[1] - P[0])
+    t_end = _normalize(P[-1] - P[-2])
+
+    # Start cap: semicircle from R[0] around to L[0], extending in -t_start direction
+    # Center of cap is at path start, offset backward by end_extension
+    cap_center_start = P[0] - end_extension * t_start
+    # Radius is distance from center to L[0] or R[0]
+    radius_start = np.linalg.norm(np.array(L[0]) - cap_center_start)
+
+    # Generate semicircle points from R[0] to L[0] going around the back
+    # R[0] is at angle theta_r, L[0] is at angle theta_l
+    # We go from theta_r counterclockwise to theta_l (the long way around the back)
+    vec_r = np.array(R[0]) - cap_center_start
+    vec_l = np.array(L[0]) - cap_center_start
+    theta_r = np.arctan2(vec_r[1], vec_r[0])
+    theta_l = np.arctan2(vec_l[1], vec_l[0])
+
+    # Ensure we go the "back" way (counterclockwise from R to L)
+    if theta_l > theta_r:
+        theta_l -= 2 * np.pi
+
+    angles_start = np.linspace(theta_r, theta_l, n_cap_points + 2)[1:-1]  # Exclude endpoints (already have R[0], L[0])
+    cap_start = [cap_center_start + radius_start * np.array([np.cos(a), np.sin(a)]) for a in angles_start]
+
+    # End cap: semicircle from L[-1] around to R[-1], extending in +t_end direction
+    cap_center_end = P[-1] + end_extension * t_end
+    radius_end = np.linalg.norm(np.array(L[-1]) - cap_center_end)
+
+    vec_l_end = np.array(L[-1]) - cap_center_end
+    vec_r_end = np.array(R[-1]) - cap_center_end
+    theta_l_end = np.arctan2(vec_l_end[1], vec_l_end[0])
+    theta_r_end = np.arctan2(vec_r_end[1], vec_r_end[0])
+
+    # Go counterclockwise from L[-1] to R[-1] (the back way)
+    if theta_r_end > theta_l_end:
+        theta_r_end -= 2 * np.pi
+
+    angles_end = np.linspace(theta_l_end, theta_r_end, n_cap_points + 2)[1:-1]
+    cap_end = [cap_center_end + radius_end * np.array([np.cos(a), np.sin(a)]) for a in angles_end]
+
+    # Build the full ring: L + end_cap + R_reversed + start_cap
+    ring_points = list(L) + cap_end + list(R[::-1]) + cap_start
+
+    return np.array(ring_points, float)
+
 def make_trench_from_path_sloped(path_xy: List[Tuple[float,float]], width_top: float, depth: float, wall_slope: float, ground) -> Tuple[Dict,str,str,dict]:
     # Build top and bottom rings by offsetting centerline
     half_top = width_top/2.0
@@ -763,8 +822,8 @@ def make_ground_surface_plane(path_xy: List[Tuple[float,float]], width_top: floa
     the trench opening as an open hole. This creates a natural shape that
     hugs L-shaped, U-shaped, and curved trenches.
 
-    For closed paths (like circles), also creates a center island inside
-    the inner edge of the annular trench.
+    For closed paths (like circles), the ground surface is a ring around the
+    outer edge of the trench, with the trench opening left completely open.
     """
     half_top = width_top / 2.0
     m = float(max(0.5, ground.size_margin))
@@ -772,47 +831,36 @@ 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, we have:
-        # - Outer ground: annulus from ground_outer to trench_outer
-        # - Center island: filled polygon inside trench_inner
+        # 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.
 
-        # Trench boundaries
+        # Trench outer boundary (edge of trench opening)
         trench_outer = np.array(_offset_closed_polyline(path_xy, half_top), float)
-        trench_inner = np.array(_offset_closed_polyline(path_xy, -half_top), float)
 
-        # Ground outer boundary
+        # Ground outer boundary (edge of ground surface)
         ground_outer = np.array(_offset_closed_polyline(path_xy, half_top + m), float)
 
         # Ensure proper orientations
         trench_outer = _ensure_ccw(trench_outer)
-        trench_inner = _ensure_ccw(trench_inner)
         ground_outer = _ensure_ccw(ground_outer)
 
-        # Outer ground annulus
-        outer_combined_xy, outer_tris = _triangulate_annulus(ground_outer, trench_outer)
-        outer_Vg = np.array([[x, y, gfun(x, y)] for (x, y) in outer_combined_xy], float)
-
-        # Center island (simple filled polygon)
-        center_tris = _ear_clipping_triangulation(trench_inner)
-        center_Vg = np.array([[x, y, gfun(x, y)] for (x, y) in trench_inner], float)
-
-        # Combine into single ground surface
-        n_outer_verts = len(outer_Vg)
-        center_tris_offset = center_tris + n_outer_verts
-
-        Vg = np.vstack([outer_Vg, center_Vg])
-        tris = np.vstack([outer_tris, center_tris_offset])
+        # 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)
 
         return {"ground_surface": (Vg, tris)}
     else:
-        # Original logic for open paths
+        # Open paths: ground forms annulus with end caps extending past trench endpoints
         # Inner boundary: the trench opening (same as trench top ring)
         L_inner, R_inner = _offset_polyline(path_xy, half_top)
         inner_ring = _ensure_ccw(_ring_from_LR(L_inner, R_inner))
 
-        # Outer boundary: offset by additional margin
+        # Outer boundary: offset by additional margin, with semicircular end caps
         L_outer, R_outer = _offset_polyline(path_xy, half_top + m)
-        outer_ring = _ensure_ccw(_ring_from_LR(L_outer, R_outer))
+        outer_ring = _ensure_ccw(_ring_from_LR_with_end_caps(
+            L_outer, R_outer, path_xy, end_extension=m
+        ))
 
         # Triangulate the annular region (leaves hole open)
         combined_xy, tris = _triangulate_annulus(outer_ring, inner_ring)

{trenchfoot-0.2.2 → trenchfoot-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trenchfoot"
-version = "0.2.2"
+version = "0.2.4"
 description = "Synthetic trench scenario generator bundle (surfaces + volumetrics)."
 readme = "README.md"
 requires-python = ">=3.12"

{trenchfoot-0.2.2 → trenchfoot-0.2.4}/tests/test_trenchfoot_generation.py

@@ -372,3 +372,115 @@ def test_circular_well_generates_surface(tmp_path):
 
     # Verify it has expected pipe count from scenario summary
     assert summary.object_counts["pipes"] >= 4, "Should have at least 4 pipes"
+
+
+def test_trench_opening_is_open_for_straight_trench():
+    """Verify straight trench has open top with no geometry covering the opening."""
+    import numpy as np
+
+    spec = scene_spec_from_dict(_minimal_spec_dict())
+    result = generate_surface_mesh(spec, make_preview=False)
+
+    # Get ground surface vertices at z=0
+    V_ground, F_ground = result.groups["ground_surface"]
+
+    # Ground surface should be an annulus (ring) with the trench opening as a hole.
+    # Check that no face covers the center region (trench opening).
+    # The trench in _minimal_spec_dict has width=1.0 centered on y=0,
+    # so the opening is roughly y in [-0.5, 0.5].
+
+    for face in F_ground:
+        verts = V_ground[face]
+        centroid = np.mean(verts, axis=0)
+        # Centroid should NOT be inside the trench opening region (y between -0.5 and 0.5)
+        y_coords = verts[:, 1]
+        # If all vertices are inside trench y-range, this face is covering the opening
+        if np.all(np.abs(y_coords) < 0.45):  # small margin
+            pytest.fail(
+                f"Found face covering trench opening: centroid={centroid}, y_coords={y_coords}"
+            )
+
+
+def test_circular_well_trench_opening_is_open():
+    """Verify S07 circular well has open center with no lid geometry."""
+    import numpy as np
+
+    scenarios = default_scenarios()
+    s07 = next((s for s in scenarios if s.name == "S07_circular_well"), None)
+    if s07 is None:
+        pytest.skip("S07_circular_well not available")
+
+    spec = scene_spec_from_dict(s07.spec)
+    result = generate_surface_mesh(spec, make_preview=False)
+
+    # Ground surface should be an annulus around the outer edge of the circular trench,
+    # with the center (trench opening) completely open.
+    V_ground, F_ground = result.groups["ground_surface"]
+
+    # The circular well has inner radius ~0.5m and outer radius ~2.5m from center.
+    # Ground vertices should all be at radius > outer_trench_edge (about 2.0-2.5m)
+    # or at the outer_trench_edge itself as the inner boundary.
+
+    # Calculate radius of each ground vertex from center (0,0)
+    radii = np.sqrt(V_ground[:, 0] ** 2 + V_ground[:, 1] ** 2)
+
+    # The minimum radius should be at the trench outer edge (~2.5m), not near center
+    min_radius = np.min(radii)
+    assert min_radius > 1.0, (
+        f"Ground surface vertices extend too close to center (min_radius={min_radius:.3f}m). "
+        f"For an open circular well, ground should only surround the outer trench edge."
+    )
+
+    # No face should have centroid inside the trench opening (radius < ~2.0m)
+    for face in F_ground:
+        face_verts = V_ground[face]
+        centroid = np.mean(face_verts, axis=0)
+        centroid_radius = np.sqrt(centroid[0] ** 2 + centroid[1] ** 2)
+        if centroid_radius < 1.5:  # Well inside the trench
+            pytest.fail(
+                f"Found ground face covering trench opening: centroid radius={centroid_radius:.3f}m"
+            )
+
+
+def test_ground_surface_annular_structure():
+    """Verify ground surface properly forms an annulus with the trench as a hole."""
+    import numpy as np
+
+    # Test with L-shaped trench to ensure annular structure works for complex shapes
+    spec_dict = {
+        "path_xy": [[0.0, 0.0], [3.0, 0.0], [3.0, 2.0]],
+        "width": 0.8,
+        "depth": 0.6,
+        "wall_slope": 0.0,
+        "ground": {"z0": 0.0, "slope": [0.0, 0.0], "size_margin": 1.0},
+        "pipes": [],
+        "boxes": [],
+        "spheres": [],
+        "noise": {"enable": False},
+    }
+    spec = scene_spec_from_dict(spec_dict)
+    result = generate_surface_mesh(spec, make_preview=False)
+
+    V_ground, F_ground = result.groups["ground_surface"]
+
+    # All ground vertices should be at z=0 (ground elevation)
+    assert np.allclose(V_ground[:, 2], 0.0), "Ground surface should be at z=0"
+
+    # Ground should have both inner vertices (near trench edge) and outer vertices
+    # The trench edge is at offset half_width = 0.4m from path
+    # Ground outer edge is at half_width + margin = 0.4 + 1.0 = 1.4m from path
+
+    # Check that there are vertices at different distances from the origin
+    # (indicating annular structure with inner and outer boundaries)
+    x_coords = V_ground[:, 0]
+    y_coords = V_ground[:, 1]
+
+    # The L-shaped path goes from (0,0) to (3,0) to (3,2)
+    # Inner boundary should be close to path, outer boundary further away
+    # For a proper annulus, we should have spread in both x and y
+
+    x_range = np.max(x_coords) - np.min(x_coords)
+    y_range = np.max(y_coords) - np.min(y_coords)
+
+    assert x_range > 2.0, f"Ground should span significant x range: {x_range:.2f}"
+    assert y_range > 2.0, f"Ground should span significant y range: {y_range:.2f}"

{trenchfoot-0.2.2 → trenchfoot-0.2.4}/uv.lock

@@ -501,7 +501,7 @@ wheels = [
 
 [[package]]
 name = "trenchfoot"
-version = "0.2.1"
+version = "0.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },