trenchfoot 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

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.dist-info → trenchfoot-0.2.4.dist-info}/METADATA

@@ -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.dist-info → trenchfoot-0.2.4.dist-info}/RECORD

@@ -6,7 +6,7 @@ trenchfoot/gmsh_sloped_trench_mesher.py,sha256=D7EL6V0wkE6tvDARmm006yZE6KEzCl25O
 trenchfoot/plot_mesh.py,sha256=26dOlVfaM1WsUfr_sXVqA7axtY9qjY3WCNM7cUBTS7Q,3810
 trenchfoot/render_colors.py,sha256=EfldvoshgaZ6iZFk-UDL67-tvwGYaiZFS2NQZBMwhDM,1596
 trenchfoot/scene_spec_example.json,sha256=UcV25ku422UO0ZZPDrJwrT1zwmjoOIpnBdLuEdh-AZA,1028
-trenchfoot/trench_scene_generator_v3.py,sha256=gNYT_D8-7kI23RGCQeBCXG0lJTwttGKKuCy1diNoOR4,43324
+trenchfoot/trench_scene_generator_v3.py,sha256=EDG_ChbnDEbLiIU0GsA5IfWmuknQDUTx2DRiL5lEv4k,45665
 trenchfoot/scenarios/SUMMARY.json,sha256=PUT7ID4nl5BJ6A0M3MhbOkx5bm2HAy0Gwzq8cc6JBAE,18492
 trenchfoot/scenarios/S01_straight_vwalls/metrics.json,sha256=_AoK-WCgTKKdu_zUJL-HiSnsxMJvr6GDxlet7Ojmtk4,691
 trenchfoot/scenarios/S01_straight_vwalls/preview.png,sha256=adsx3-6oMu9WaixggXRhuXi_KM-q5s2RNSBLR_stq80,199624
@@ -71,8 +71,8 @@ trenchfoot/scenarios/S07_circular_well/preview_top.png,sha256=XW7DQLDEYmSV6Lnfo1
 trenchfoot/scenarios/S07_circular_well/scene.json,sha256=bvror2YX6aNbsEc25-N7JO3ysH2dTLGyEE6zGzZysXQ,3146
 trenchfoot/scenarios/S07_circular_well/trench_scene.obj,sha256=1MAsyGkJ4-tCRXLDWi_7ruumgpCpcl_Ca5poRLtTua0,1619846
 trenchfoot/scenarios/S07_circular_well/volumetric/trench_volume.msh,sha256=dqhtd3SFKj5RLT_BcWIIvVGCbAqvOx7RX25-K7NKX10,615212
-trenchfoot-0.2.2.dist-info/METADATA,sha256=32oD4purZc8D9BqvfiYh6Tj--UaJD6VXXMo9LQfxcc8,5292
-trenchfoot-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-trenchfoot-0.2.2.dist-info/entry_points.txt,sha256=5TejAGmc4GnNYLn7MhhLtSCNz9240RvzcNaetF4IHfg,119
-trenchfoot-0.2.2.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-trenchfoot-0.2.2.dist-info/RECORD,,
+trenchfoot-0.2.4.dist-info/METADATA,sha256=6OadSF2ZjBflziGJrQxUQMLNwIy9QDwyr3J03BJneiA,5292
+trenchfoot-0.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+trenchfoot-0.2.4.dist-info/entry_points.txt,sha256=5TejAGmc4GnNYLn7MhhLtSCNz9240RvzcNaetF4IHfg,119
+trenchfoot-0.2.4.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+trenchfoot-0.2.4.dist-info/RECORD,,