trenchfoot 0.2.7__tar.gz → 0.3.0__tar.gz

trenchfoot-0.3.0/.pypi_token.env

@@ -0,0 +1 @@
+PYPI_API_TOKEN="pypi-AgEIcHlwaS5vcmcCJDU5NWZhMThiLTcwZDAtNGQ1NS04NzY5LTUzOWFjNzUyMzBhOQACKlszLCJiYTQ1Nzc2Ni01MDg0LTQ4ZmYtOGU5Yi05MjY4NjM3MTNiY2EiXQAABiCDzIFj_CDx2Hr1RoMANFCByB8X_u1VLbmPLNpe-oOFow"

{trenchfoot-0.2.7 → trenchfoot-0.3.0}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [0.3.0] - 2026-01-07
+
+### Added
+- **SDF metadata export**: Each scenario now exports `sdf_metadata.json` alongside the OBJ mesh, containing:
+  - Normal convention ("into_void")
+  - Geometry type ("open_trench")
+  - Trench opening polygon with z-level
+  - Surface group annotations (floor, walls, ground)
+  - Embedded object counts
+- **SDF readiness tests**: 21 new tests in `tests/test_sdf_readiness.py` validating:
+  - Floor normals point up (+z)
+  - Wall normals point inward toward trench centerline
+  - Ground surface normals point up (+z)
+  - Metadata consistency with mesh geometry
+
+### Fixed
+- **Normal orientation consistency**: All floor and ground surfaces now have upward-pointing normals (+z). Previously, some faces (particularly on S07 circular well ground surface) had incorrect winding order causing downward normals, which broke SDF sign computation in downstream consumers.
+- **`_ensure_upward_normals()` post-processing**: Added helper function that flips face winding order for any horizontal faces with downward normals, applied to all ground surface generation paths.
+
 ## [0.2.7] - 2025-12-24
 
 ### Fixed

{trenchfoot-0.2.7 → trenchfoot-0.3.0}/PKG-INFO

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

{trenchfoot-0.2.7 → trenchfoot-0.3.0}/packages/trenchfoot/trench_scene_generator_v3.py

@@ -425,6 +425,7 @@ class SurfaceMeshFiles:
     obj_path: Path
     metrics_path: Path
     preview_paths: Tuple[Path, ...]
+    sdf_metadata_path: Optional[Path] = None
 
 
 @dataclass
@@ -435,7 +436,73 @@ class SurfaceMeshResult:
     metrics: Dict[str, Any]
     previews: Dict[str, bytes]
 
-    def persist(self, out_dir: str | Path, *, include_previews: bool = False) -> SurfaceMeshFiles:
+    def _build_sdf_metadata(self) -> Dict[str, Any]:
+        """Build SDF metadata for downstream consumers.
+
+        This metadata enables generic mesh-to-SDF pipelines to correctly
+        interpret the mesh geometry without trenchfoot-specific heuristics.
+        """
+        # Extract trench opening polygon from the trench cap geometry
+        trench_opening_vertices = None
+        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()
+
+        # Determine geometry type
+        is_closed = _is_path_closed(self.spec.path_xy)
+        geometry_type = "closed_well" if is_closed else "open_trench"
+
+        # Build surface group info
+        surface_groups = {}
+        for name in self.groups:
+            if name in _INTERNAL_GROUPS:
+                continue
+            if "bottom" in name:
+                surface_groups[name] = {"normal_direction": "up", "surface_type": "floor"}
+            elif "wall" in name:
+                surface_groups[name] = {"normal_direction": "inward", "surface_type": "wall"}
+            elif "ground" in name:
+                surface_groups[name] = {"normal_direction": "up", "surface_type": "ground"}
+            elif "pipe" in name:
+                surface_groups[name] = {"normal_direction": "outward", "surface_type": "embedded_object"}
+            elif "box" in name or "sphere" in name:
+                surface_groups[name] = {"normal_direction": "outward", "surface_type": "embedded_object"}
+            else:
+                surface_groups[name] = {"normal_direction": "unknown", "surface_type": "other"}
+
+        return {
+            "sdf_metadata": {
+                "version": "1.0",
+                "normal_convention": "into_void",
+                "geometry_type": geometry_type,
+                "trench_opening": {
+                    "type": "polygon",
+                    "vertices_xy": trench_opening_vertices,
+                    "z_level": self.spec.ground.z0 if self.spec.ground else 0.0,
+                },
+                "surface_groups": surface_groups,
+                "embedded_objects": {
+                    "pipes": self.object_counts.get("pipes", 0),
+                    "boxes": self.object_counts.get("boxes", 0),
+                    "spheres": self.object_counts.get("spheres", 0),
+                },
+            }
+        }
+
+    def persist(self, out_dir: str | Path, *, include_previews: bool = False, include_sdf_metadata: bool = True) -> SurfaceMeshFiles:
         out_path = Path(out_dir)
         out_path.mkdir(parents=True, exist_ok=True)
         obj_path = out_path / "trench_scene.obj"
@@ -445,13 +512,27 @@ class SurfaceMeshResult:
         metrics_path = out_path / "metrics.json"
         with metrics_path.open("w") as fh:
             json.dump(self.metrics, fh, indent=2)
+
+        # Export SDF metadata
+        sdf_metadata_path = None
+        if include_sdf_metadata:
+            sdf_metadata = self._build_sdf_metadata()
+            sdf_metadata_path = out_path / "sdf_metadata.json"
+            with sdf_metadata_path.open("w") as fh:
+                json.dump(sdf_metadata, fh, indent=2)
+
         preview_paths: List[Path] = []
         if include_previews and self.previews:
             for name, data in self.previews.items():
                 target = out_path / f"preview_{name}.png"
                 target.write_bytes(data)
                 preview_paths.append(target)
-        return SurfaceMeshFiles(obj_path=obj_path, metrics_path=metrics_path, preview_paths=tuple(preview_paths))
+        return SurfaceMeshFiles(
+            obj_path=obj_path,
+            metrics_path=metrics_path,
+            preview_paths=tuple(preview_paths),
+            sdf_metadata_path=sdf_metadata_path,
+        )
 
 def _ground_fn(g: GroundSpec):
     sx, sy = g.slope
@@ -620,7 +701,8 @@ def make_trench_from_path_sloped(path_xy: List[Tuple[float,float]], width_top: f
 
         bot_verts, bot_faces = _triangulate_annulus(outer_bot, inner_bot[::-1])
         V_bottom = np.column_stack([bot_verts, np.concatenate([z_outer_bot, z_inner_bot[::-1]])])
-        F_bottom = bot_faces[:, ::-1]  # flip for outward normals
+        # Floor normals point UP (+z) into the trench void for correct SDF sign
+        F_bottom = _ensure_upward_normals(V_bottom, bot_faces)
 
         # Outer wall: connects outer_top to outer_bot (facing outward from trench)
         n_outer = len(outer_top)
@@ -680,7 +762,8 @@ def make_trench_from_path_sloped(path_xy: List[Tuple[float,float]], width_top: f
         V_cap = np.column_stack([poly_top, z_top])
         V_bottom = np.column_stack([poly_bot, z_bot])
         F_cap = tris_top
-        F_bottom = tris_bot[:, ::-1]  # outward
+        # Floor normals point UP (+z) into the trench void for correct SDF sign
+        F_bottom = _ensure_upward_normals(V_bottom, tris_bot)
 
         # Walls: connect corresponding indices
         N = len(poly_top)
@@ -715,6 +798,38 @@ def make_trench_from_path_sloped(path_xy: List[Tuple[float,float]], width_top: f
 
     return groups, poly_top, poly_bot, extra
 
+def _ensure_upward_normals(V: np.ndarray, F: np.ndarray) -> np.ndarray:
+    """Ensure all faces have upward-pointing normals (+z).
+
+    For horizontal surfaces like trench floors, normals should point UP
+    into the void for correct SDF computation. This function flips any
+    faces with downward-pointing normals.
+
+    Parameters
+    ----------
+    V : np.ndarray
+        Vertices (n, 3)
+    F : np.ndarray
+        Faces (m, 3) - indices into V
+
+    Returns
+    -------
+    np.ndarray
+        Faces with consistent upward normals (may have winding flipped)
+    """
+    F_out = F.copy()
+    p0 = V[F[:, 0]]
+    p1 = V[F[:, 1]]
+    p2 = V[F[:, 2]]
+    normals = np.cross(p1 - p0, p2 - p0)
+
+    # Flip faces with negative z-component normals
+    down_mask = normals[:, 2] < 0
+    F_out[down_mask] = F_out[down_mask, ::-1]
+
+    return F_out
+
+
 def _triangulate_annulus(outer: np.ndarray, inner: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
     """Triangulate the annular region between outer and inner polygons.
 
@@ -822,6 +937,9 @@ def make_ground_surface_plane(path_xy: List[Tuple[float,float]], width_top: floa
         combined_xy, tris = _triangulate_annulus(ground_outer, trench_outer)
         Vg = np.array([[x, y, gfun(x, y)] for (x, y) in combined_xy], float)
 
+        # Ground normals should point UP (+z) into the air
+        tris = _ensure_upward_normals(Vg, tris)
+
         return {"ground_surface": (Vg, tris)}
     else:
         # Open paths: ground forms annulus with extensions past trench endpoints.
@@ -844,6 +962,9 @@ def make_ground_surface_plane(path_xy: List[Tuple[float,float]], width_top: floa
         # Apply ground elevation to get 3D vertices
         Vg = np.array([[x, y, gfun(x, y)] for (x, y) in combined_xy], float)
 
+        # Ground normals should point UP (+z) into the air
+        tris = _ensure_upward_normals(Vg, tris)
+
         return {"ground_surface": (Vg, tris)}
 
 def _half_width_at_depth(half_top: float, slope: float, top_z: float, z: float) -> float:

{trenchfoot-0.2.7 → trenchfoot-0.3.0}/pyproject.toml

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

trenchfoot-0.3.0/tests/test_sdf_readiness.py

@@ -0,0 +1,385 @@
+# ABOUTME: Tests for SDF readiness: normal orientation and metadata export.
+# ABOUTME: Ensures meshes are suitable for signed distance field computation.
+"""
+Tests verifying that generated meshes are ready for SDF computation.
+
+These tests validate:
+1. Normal orientation follows "into void" convention
+2. SDF metadata is correctly exported
+3. Trench opening polygon matches actual geometry
+"""
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+PKG_ROOT = ROOT / "packages"
+if str(PKG_ROOT) not in sys.path:
+    sys.path.insert(0, str(PKG_ROOT))
+VENVDIR = ROOT / ".venv"
+if VENVDIR.exists():
+    for candidate in (VENVDIR / "lib").glob("python*/site-packages"):
+        if str(candidate) not in sys.path:
+            sys.path.insert(0, str(candidate))
+            break
+
+from trenchfoot.generate_scenarios import (
+    ScenarioDefinition,
+    default_scenarios,
+    generate_scenarios,
+)
+from trenchfoot.trench_scene_generator_v3 import (
+    scene_spec_from_dict,
+    generate_surface_mesh,
+)
+
+
+def _compute_face_normals(V: np.ndarray, F: np.ndarray) -> np.ndarray:
+    """Compute per-face normals for a triangle mesh."""
+    p0 = V[F[:, 0]]
+    p1 = V[F[:, 1]]
+    p2 = V[F[:, 2]]
+    normals = np.cross(p1 - p0, p2 - p0)
+    # Normalize
+    lengths = np.linalg.norm(normals, axis=1, keepdims=True)
+    lengths = np.maximum(lengths, 1e-10)  # Avoid division by zero
+    return normals / lengths
+
+
+def _minimal_spec_dict() -> dict:
+    """Minimal trench spec for testing."""
+    return {
+        "path_xy": [[0.0, 0.0], [3.0, 0.0]],
+        "width": 1.0,
+        "depth": 1.2,
+        "wall_slope": 0.1,
+        "ground": {"z0": 0.0, "slope": [0.0, 0.0], "size_margin": 2.0},
+        "pipes": [],
+        "boxes": [],
+        "spheres": [],
+        "noise": {"enable": False},
+    }
+
+
+class TestFloorNormalOrientation:
+    """Tests for trench floor normal orientation."""
+
+    def test_floor_normals_point_up_minimal(self):
+        """Floor normals should point UP (+z) for correct SDF sign."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+
+        V, F = result.groups["trench_bottom"]
+        normals = _compute_face_normals(V, F)
+
+        # All floor normals should have positive z component
+        z_components = normals[:, 2]
+        down_count = np.sum(z_components < 0)
+
+        assert down_count == 0, (
+            f"Floor has {down_count}/{len(F)} faces with downward normals. "
+            f"Floor normals should all point UP (+z) into the void."
+        )
+
+        # Check they're strongly upward (nz > 0.5 for mostly-horizontal faces)
+        weak_up_count = np.sum(z_components < 0.5)
+        assert weak_up_count == 0, (
+            f"Floor has {weak_up_count}/{len(F)} faces with weak upward normals (nz < 0.5). "
+            f"Floor should be mostly horizontal."
+        )
+
+    @pytest.mark.parametrize("scenario_name", [
+        "S01_straight_vwalls",
+        "S02_straight_sloped",
+        "S03_angled_corner",
+        "S04_curved_bend",
+        "S05_pipe_cluster",
+        "S06_complex_layout",
+        "S07_circular_well",
+    ])
+    def test_floor_normals_point_up_all_scenarios(self, scenario_name):
+        """Floor normals should point UP (+z) for all standard scenarios."""
+        scenarios = default_scenarios()
+        scenario = next((s for s in scenarios if s.name == scenario_name), None)
+        if scenario is None:
+            pytest.skip(f"{scenario_name} not available")
+
+        spec = scene_spec_from_dict(scenario.spec)
+        result = generate_surface_mesh(spec, make_preview=False)
+
+        V, F = result.groups["trench_bottom"]
+        normals = _compute_face_normals(V, F)
+
+        z_components = normals[:, 2]
+        down_count = np.sum(z_components < 0)
+
+        assert down_count == 0, (
+            f"{scenario_name}: Floor has {down_count}/{len(F)} faces with downward normals. "
+            f"All floor normals should point UP (+z)."
+        )
+
+
+class TestWallNormalOrientation:
+    """Tests for trench wall normal orientation."""
+
+    def test_wall_normals_point_into_void(self):
+        """Wall normals should point INTO the trench void (toward centerline)."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+
+        V, F = result.groups["trench_walls"]
+        normals = _compute_face_normals(V, F)
+
+        # For a straight trench along x-axis (y=0), walls are on either side.
+        # The trench centerline is at y=0.
+        # Left wall (y < 0) should have normals pointing +y (into trench)
+        # Right wall (y > 0) should have normals pointing -y (into trench)
+
+        # Compute face centroids
+        centroids = (V[F[:, 0]] + V[F[:, 1]] + V[F[:, 2]]) / 3
+
+        # Check each face: direction from centroid to centerline should align with normal
+        errors = 0
+        for i, (centroid, normal) in enumerate(zip(centroids, normals)):
+            # Direction toward centerline (y=0)
+            toward_center_y = -np.sign(centroid[1]) if abs(centroid[1]) > 0.01 else 0
+
+            # For wall faces, the y-component of normal should match direction toward center
+            if abs(normal[1]) > 0.3:  # Face has significant y-normal component
+                if np.sign(normal[1]) != toward_center_y:
+                    errors += 1
+
+        assert errors == 0, (
+            f"Wall has {errors}/{len(F)} faces with normals pointing away from trench void. "
+            f"Wall normals should point inward toward the trench centerline."
+        )
+
+    @pytest.mark.parametrize("scenario_name", [
+        "S01_straight_vwalls",
+        "S02_straight_sloped",
+        "S03_angled_corner",
+    ])
+    def test_wall_normals_mostly_horizontal(self, scenario_name):
+        """Wall normals should be mostly horizontal (small z component)."""
+        scenarios = default_scenarios()
+        scenario = next((s for s in scenarios if s.name == scenario_name), None)
+        if scenario is None:
+            pytest.skip(f"{scenario_name} not available")
+
+        spec = scene_spec_from_dict(scenario.spec)
+        result = generate_surface_mesh(spec, make_preview=False)
+
+        V, F = result.groups["trench_walls"]
+        normals = _compute_face_normals(V, F)
+
+        # Wall faces should have mostly horizontal normals
+        # Allow some z component for sloped walls but should be < 0.7
+        z_components = np.abs(normals[:, 2])
+        vertical_wall_ratio = np.mean(z_components < 0.7)
+
+        assert vertical_wall_ratio > 0.8, (
+            f"{scenario_name}: Only {vertical_wall_ratio*100:.1f}% of wall faces have |nz| < 0.7. "
+            f"Wall faces should be mostly vertical (horizontal normals)."
+        )
+
+
+class TestGroundNormalOrientation:
+    """Tests for ground surface normal orientation."""
+
+    def test_ground_normals_point_up(self):
+        """Ground surface normals should point UP (+z)."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+
+        V, F = result.groups["ground_surface"]
+        normals = _compute_face_normals(V, F)
+
+        z_components = normals[:, 2]
+        down_count = np.sum(z_components < 0)
+
+        assert down_count == 0, (
+            f"Ground has {down_count}/{len(F)} faces with downward normals. "
+            f"Ground normals should all point UP (+z)."
+        )
+
+
+class TestSDFMetadata:
+    """Tests for SDF metadata export."""
+
+    def test_metadata_exported(self, tmp_path):
+        """SDF metadata JSON should be exported alongside mesh."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+        files = result.persist(tmp_path)
+
+        assert files.sdf_metadata_path is not None, "sdf_metadata_path should be set"
+        assert files.sdf_metadata_path.exists(), "sdf_metadata.json should exist"
+
+    def test_metadata_has_required_fields(self, tmp_path):
+        """SDF metadata should contain all required fields."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+        files = result.persist(tmp_path)
+
+        with files.sdf_metadata_path.open() as f:
+            data = json.load(f)
+
+        assert "sdf_metadata" in data, "Root key 'sdf_metadata' missing"
+        meta = data["sdf_metadata"]
+
+        required_fields = ["version", "normal_convention", "geometry_type", "trench_opening"]
+        for field in required_fields:
+            assert field in meta, f"Required field '{field}' missing from metadata"
+
+        assert meta["version"] == "1.0"
+        assert meta["normal_convention"] == "into_void"
+        assert meta["geometry_type"] == "open_trench"
+
+    def test_metadata_trench_opening_structure(self, tmp_path):
+        """Trench opening should have proper polygon structure."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+        files = result.persist(tmp_path)
+
+        with files.sdf_metadata_path.open() as f:
+            data = json.load(f)
+
+        opening = data["sdf_metadata"]["trench_opening"]
+        assert opening["type"] == "polygon"
+        assert "vertices_xy" in opening
+        assert "z_level" in opening
+
+        vertices = opening["vertices_xy"]
+        assert len(vertices) >= 4, "Trench opening should have at least 4 vertices"
+
+        # Each vertex should be [x, y]
+        for v in vertices:
+            assert len(v) == 2, f"Vertex should be [x, y], got {v}"
+
+    def test_metadata_polygon_bounds_match_trench(self, tmp_path):
+        """Trench opening polygon should match actual trench geometry bounds."""
+        spec_dict = _minimal_spec_dict()
+        spec = scene_spec_from_dict(spec_dict)
+        result = generate_surface_mesh(spec, make_preview=False)
+        files = result.persist(tmp_path)
+
+        with files.sdf_metadata_path.open() as f:
+            data = json.load(f)
+
+        opening = data["sdf_metadata"]["trench_opening"]
+        vertices = np.array(opening["vertices_xy"])
+
+        # The trench path goes from [0,0] to [3,0] with width 1.0
+        # The metadata uses the base half-width (0.5), which represents the
+        # footprint of the trench floor, not the sloped width at z=0.
+        expected_half_width = 0.5
+
+        # Check x range covers path (0 to 3)
+        x_min, x_max = vertices[:, 0].min(), vertices[:, 0].max()
+        assert x_min <= 0.1, f"Opening x_min ({x_min}) should be near 0"
+        assert x_max >= 2.9, f"Opening x_max ({x_max}) should be near 3"
+
+        # Check y range matches half-width
+        y_min, y_max = vertices[:, 1].min(), vertices[:, 1].max()
+        assert abs(y_min + expected_half_width) < 0.1, (
+            f"Opening y_min ({y_min}) should be near {-expected_half_width}"
+        )
+        assert abs(y_max - expected_half_width) < 0.1, (
+            f"Opening y_max ({y_max}) should be near {expected_half_width}"
+        )
+
+    def test_metadata_surface_groups_present(self, tmp_path):
+        """Surface groups should list all mesh groups with properties."""
+        spec = scene_spec_from_dict(_minimal_spec_dict())
+        result = generate_surface_mesh(spec, make_preview=False)
+        files = result.persist(tmp_path)
+
+        with files.sdf_metadata_path.open() as f:
+            data = json.load(f)
+
+        groups = data["sdf_metadata"]["surface_groups"]
+
+        expected_groups = ["trench_bottom", "trench_walls", "ground_surface"]
+        for group in expected_groups:
+            assert group in groups, f"Expected surface group '{group}' in metadata"
+            assert "normal_direction" in groups[group]
+            assert "surface_type" in groups[group]
+
+        # Verify correct normal conventions documented
+        assert groups["trench_bottom"]["normal_direction"] == "up"
+        assert groups["trench_walls"]["normal_direction"] == "inward"
+        assert groups["ground_surface"]["normal_direction"] == "up"
+
+    def test_metadata_embedded_objects_count(self, tmp_path):
+        """Embedded objects count should match spec."""
+        spec_dict = _minimal_spec_dict()
+        # Note: PipeSpec uses s_center, SphereSpec uses s
+        spec_dict["pipes"] = [
+            {"radius": 0.1, "length": 1.0, "angle_deg": 0, "s_center": 0.5, "z": -0.6, "offset_u": 0},
+            {"radius": 0.05, "length": 0.8, "angle_deg": 90, "s_center": 0.3, "z": -0.4, "offset_u": 0},
+        ]
+        spec_dict["spheres"] = [{"radius": 0.15, "s": 0.7, "z": -0.5}]
+
+        spec = scene_spec_from_dict(spec_dict)
+        result = generate_surface_mesh(spec, make_preview=False)
+        files = result.persist(tmp_path)
+
+        with files.sdf_metadata_path.open() as f:
+            data = json.load(f)
+
+        embedded = data["sdf_metadata"]["embedded_objects"]
+        assert embedded["pipes"] == 2
+        assert embedded["spheres"] == 1
+        assert embedded["boxes"] == 0
+
+
+class TestCircularWellNormals:
+    """Specific tests for circular well (S07) normal orientation."""
+
+    def test_s07_floor_normals_all_upward(self):
+        """S07 circular well floor should have 100% upward normals."""
+        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)
+
+        V, F = result.groups["trench_bottom"]
+        normals = _compute_face_normals(V, F)
+
+        z_components = normals[:, 2]
+        down_count = np.sum(z_components < 0)
+        up_pct = 100 * (1 - down_count / len(F))
+
+        assert down_count == 0, (
+            f"S07 circular well has {down_count}/{len(F)} floor faces with downward normals "
+            f"({up_pct:.1f}% upward). Should be 100% upward."
+        )
+
+    def test_s07_annulus_ground_normals_upward(self):
+        """S07 ground annulus should have upward normals."""
+        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)
+
+        V, F = result.groups["ground_surface"]
+        normals = _compute_face_normals(V, F)
+
+        z_components = normals[:, 2]
+        down_count = np.sum(z_components < 0)
+
+        assert down_count == 0, (
+            f"S07 ground annulus has {down_count}/{len(F)} faces with downward normals. "
+            f"Ground should all point UP."
+        )

{trenchfoot-0.2.7 → trenchfoot-0.3.0}/uv.lock

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