trenchfoot 0.2.2__tar.gz → 0.2.3__tar.gz

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

@@ -1,5 +1,17 @@
 # Changelog
 
+## [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.3}/PKG-INFO

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

{trenchfoot-0.2.2 → trenchfoot-0.2.3}/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 = []
@@ -763,8 +764,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,36 +773,23 @@ 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:

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

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

{trenchfoot-0.2.2 → trenchfoot-0.2.3}/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.3}/uv.lock

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