xslope 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

xslope/mesh.py

@@ -55,13 +55,13 @@ def _get_gmsh():
 
 
 
-def build_mesh_from_polygons(polygons, target_size, element_type='tri3', lines=None, debug=False, mesh_params=None, target_size_1d=None):
+def build_mesh_from_polygons(polygons, target_size, element_type='tri3', lines=None, debug=False, mesh_params=None, target_size_1d=None, profile_lines=None):
     """
     Build a finite element mesh with material regions using Gmsh.
     Fixed version that properly handles shared boundaries between polygons.
     
     Parameters:
-        polygons     : List of lists of (x, y) tuples defining material boundaries
+        polygons     : List of polygon coordinate lists or dicts with "coords"/"mat_id"
         target_size  : Desired element size
         element_type : 'tri3' (3-node triangles), 'tri6' (6-node triangles), 
                       'quad4' (4-node quadrilaterals), 'quad8' (8-node quadrilaterals),
@@ -70,6 +70,7 @@ def build_mesh_from_polygons(polygons, target_size, element_type='tri3', lines=N
         debug        : Enable debug output
         mesh_params  : Optional dictionary of GMSH meshing parameters to override defaults
         target_size_1d : Optional target size for 1D elements (default None, which is set to target_size if None)
+        profile_lines: Optional list of profile line dicts with 'mat_id' keys for material assignment
 
     Returns:
         mesh dict containing:
@@ -92,8 +93,35 @@ def build_mesh_from_polygons(polygons, target_size, element_type='tri3', lines=N
         if debug:
             print(f"Using default target_size_1d = target_size = {target_size_1d}")
 
-    # build a list of region ids (list of material IDs - one per polygon)
-    region_ids = [i for i in range(len(polygons))]
+    # Normalize polygons to coordinate lists and optional mat_id
+    polygon_coords = []
+    polygon_mat_ids = []
+    for i, polygon in enumerate(polygons):
+        if isinstance(polygon, dict):
+            polygon_coords.append(polygon.get("coords", []))
+            polygon_mat_ids.append(polygon.get("mat_id"))
+        else:
+            polygon_coords.append(polygon)
+            polygon_mat_ids.append(None)
+
+    # Build a list of region ids (list of material IDs - one per polygon)
+    if any(mat_id is not None for mat_id in polygon_mat_ids):
+        region_ids = [
+            mat_id if mat_id is not None else i
+            for i, mat_id in enumerate(polygon_mat_ids)
+        ]
+    elif profile_lines and len(profile_lines) >= len(polygon_coords):
+        region_ids = []
+        for i in range(len(polygon_coords)):
+            mat_id = profile_lines[i].get('mat_id')
+            if mat_id is not None:
+                region_ids.append(mat_id)
+            else:
+                # Fallback to polygon index if no mat_id
+                region_ids.append(i)
+    else:
+        # Fallback to sequential IDs if no profile_lines provided
+        region_ids = [i for i in range(len(polygon_coords))]
 
     if element_type not in ['tri3', 'tri6', 'quad4', 'quad8', 'quad9']:
         raise ValueError("element_type must be 'tri3', 'tri6', 'quad4', 'quad8', or 'quad9'")
@@ -160,7 +188,7 @@ def build_mesh_from_polygons(polygons, target_size, element_type='tri3', lines=N
     short_edge_points = set()  # Points that are endpoints of short edges
     
     # Pre-pass to identify short edges - improved logic
-    for idx, (poly_pts, region_id) in enumerate(zip(polygons, region_ids)):
+    for idx, (poly_pts, region_id) in enumerate(zip(polygon_coords, region_ids)):
         poly_pts_clean = remove_duplicate_endpoint(list(poly_pts))
         for i in range(len(poly_pts_clean)):
             p1 = poly_pts_clean[i]
@@ -187,7 +215,7 @@ def build_mesh_from_polygons(polygons, target_size, element_type='tri3', lines=N
                 print(f"Short edge ignored (major boundary): {p1} to {p2}, length={edge_length:.2f}")
     
     # Main pass: Create points with appropriate sizes
-    for idx, (poly_pts, region_id) in enumerate(zip(polygons, region_ids)):
+    for idx, (poly_pts, region_id) in enumerate(zip(polygon_coords, region_ids)):
         poly_pts_clean = remove_duplicate_endpoint(list(poly_pts))  # make a copy
         pt_tags = []
         for x, y in poly_pts_clean:
@@ -1206,7 +1234,7 @@ def get_quad_mesh_presets():
 
 
 
-def build_polygons(slope_data, reinf_lines=None, debug=False):
+def build_polygons(slope_data, reinf_lines=None, tol = 0.000001, debug=False):
     """
     Build material zone polygons from slope_data.
     
@@ -1218,7 +1246,9 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         slope_data: Dictionary containing slope geometry data
         
     Returns:
-        List of polygons, each defined by (x,y) coordinate tuples
+        List of polygons as dicts with keys:
+            "coords": list of (x, y) coordinate tuples
+            "mat_id": optional material ID (0-based) or None
     """
     import numpy as np
     import copy
@@ -1236,8 +1266,7 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
             raise ValueError("When using only 1 profile line, max_depth must be specified")
 
     n = len(profile_lines)
-    lines = [list(line) for line in copy.deepcopy(profile_lines)]
-    tol = 1e-8
+    lines = [list(line['coords']) for line in copy.deepcopy(profile_lines)]
 
     for i in range(n - 1):
         top = lines[i]
@@ -1432,6 +1461,93 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 # Return the lowest y value
                 y_min = min(y_values)
                 return y_min, is_at_endpoint
+
+            def find_projected_y_at_x(line_points, x_query, y_ref, side, tol=1e-8):
+                """
+                For vertical endpoint projections: choose the intersection y at x_query that is
+                closest *below* the point we're projecting from.
+
+                This fixes the case where a candidate profile has a vertical segment at x_query
+                (e.g., (260,229) then (260,202)). In that situation, using the "lowest y" (202)
+                is wrong; we want the first hit when projecting downward (229).
+
+                Behavior is intentionally conservative:
+                - If there is at least one intersection strictly below y_ref, return the highest of those.
+                - Otherwise fall back to the original behavior (lowest y), preserving legacy behavior
+                  in edge cases (e.g., coincident/above intersections).
+                """
+                # Reuse the exact same intersection enumeration logic as find_lowest_y_at_x,
+                # but keep the full set of y-values.
+                if not line_points:
+                    return None, False
+
+                xs = np.array([x for x, y in line_points])
+                ys = np.array([y for x, y in line_points])
+
+                if xs[0] - tol > x_query or xs[-1] + tol < x_query:
+                    return None, False
+
+                is_at_left_endpoint = abs(x_query - xs[0]) < tol
+                is_at_right_endpoint = abs(x_query - xs[-1]) < tol
+                is_at_endpoint = is_at_left_endpoint or is_at_right_endpoint
+
+                y_values = []
+                for k in range(len(line_points)):
+                    if abs(xs[k] - x_query) < tol:
+                        y_values.append(float(ys[k]))
+
+                for k in range(len(line_points) - 1):
+                    x1, y1 = line_points[k]
+                    x2, y2 = line_points[k + 1]
+
+                    if abs(x1 - x_query) < tol and abs(x2 - x_query) < tol:
+                        y_values.append(float(y1))
+                        y_values.append(float(y2))
+                    elif min(x1, x2) - tol <= x_query <= max(x1, x2) + tol:
+                        if abs(x2 - x1) < tol:
+                            y_values.append(float(y1))
+                            y_values.append(float(y2))
+                        else:
+                            t = (x_query - x1) / (x2 - x1)
+                            if 0 <= t <= 1:
+                                y_values.append(float(y1 + t * (y2 - y1)))
+
+                if not y_values:
+                    return None, False
+
+                # If the polyline has multiple *vertices* exactly at this x (vertical segment / duplicate-x),
+                # use a deterministic selection based on which side we are projecting from:
+                # - projecting from LEFT endpoint of the upper line: keep the LAST y encountered
+                # - projecting from RIGHT endpoint of the upper line: keep the FIRST y encountered
+                #
+                # This matches the intended "walk along the lower boundary" behavior and fixes cases like:
+                # - right projection at x=260 with vertices (260,229) then (260,202): choose 229 (first)
+                # - left projection at x=240 with vertices (240,140) then (240,190): choose 190 (last)
+                vertex_y_at_x = [float(y) for (x, y) in line_points if abs(x - x_query) < tol]
+                if len(vertex_y_at_x) >= 2:
+                    if side == "right":
+                        # first encountered vertex at this x
+                        y_pick = vertex_y_at_x[0]
+                        # If we are exactly on a vertex at y_ref, that is the first hit.
+                        if abs(y_pick - y_ref) < tol:
+                            return float(y_ref), is_at_endpoint
+                        if y_pick < (y_ref - tol):
+                            return y_pick, is_at_endpoint
+                    elif side == "left":
+                        # last encountered vertex at this x
+                        y_pick = vertex_y_at_x[-1]
+                        # If we are exactly on a vertex at y_ref, that is the first hit.
+                        if abs(y_pick - y_ref) < tol:
+                            return float(y_ref), is_at_endpoint
+                        if y_pick < (y_ref - tol):
+                            return y_pick, is_at_endpoint
+
+                y_below = [y for y in y_values if y < (y_ref - tol)]
+                if y_below:
+                    return max(y_below), is_at_endpoint
+
+                # Fall back to legacy behavior
+                return min(y_values), is_at_endpoint
             
             # Project endpoints - find highest lower profile or use max_depth
             # When projecting right side: if intersection is at left end of lower line,
@@ -1445,7 +1561,7 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 
                 # Check left endpoint projection
                 if xs_cand[0] - tol <= left_x <= xs_cand[-1] + tol:
-                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, left_x, tol)
+                    y_cand, is_at_endpoint = find_projected_y_at_x(lower_candidate, left_x, left_y, side="left", tol=tol)
                     if y_cand is not None:
                         # If intersection is at the right end of the lower line, add point but continue
                         if is_at_endpoint and abs(left_x - xs_cand[-1]) < tol:  # At right endpoint
@@ -1458,7 +1574,7 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 
                 # Check right endpoint projection
                 if xs_cand[0] - tol <= right_x <= xs_cand[-1] + tol:
-                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, right_x, tol)
+                    y_cand, is_at_endpoint = find_projected_y_at_x(lower_candidate, right_x, right_y, side="right", tol=tol)
                     if y_cand is not None:
                         # If intersection is at the left end of the lower line, add point but continue
                         if is_at_endpoint and abs(right_x - xs_cand[0]) < tol:  # At left endpoint
@@ -1474,6 +1590,25 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                 left_y_bot = max_depth if max_depth is not None else -np.inf
             if right_y_bot == -np.inf:
                 right_y_bot = max_depth if max_depth is not None else -np.inf
+
+            # Filter vertical-edge "continue projecting" points so we only keep points that
+            # actually lie on the final vertical edge between the top and bottom of this zone.
+            #
+            # Without this, a deeper left-endpoint intersection (e.g., (240,190) at the left
+            # endpoint of some deeper line) can be appended to right_vertical_points even after
+            # we've already found the correct bottom (e.g., right_y_bot=229). That creates the
+            # dangling vertical segment you observed.
+            if right_y_bot != -np.inf:
+                right_vertical_points = [
+                    (x, y) for (x, y) in right_vertical_points
+                    if (y < right_y - tol) and (y > right_y_bot + tol)
+                ]
+            if left_y_bot != -np.inf:
+                # Left edge runs from bottom up to top; keep points strictly between bottom and top.
+                left_vertical_points = [
+                    (x, y) for (x, y) in left_vertical_points
+                    if (y > left_y_bot + tol) and (y < left_y - tol)
+                ]
             
             # Deduplicate vertical points (remove points that are too close to each other)
             def deduplicate_points(points, tol=1e-8):
@@ -1561,7 +1696,11 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         
         # Clean up polygon (should rarely do anything)
         poly = clean_polygon(poly)
-        polygons.append(poly)
+        mat_id = profile_lines[i].get("mat_id") if i < len(profile_lines) else None
+        polygons.append({
+            "coords": poly,
+            "mat_id": mat_id
+        })
     
     # Add distributed load points to polygon edges if coincident
     polygons = add_dload_points_to_polygons(polygons, slope_data)
@@ -1578,7 +1717,7 @@ def add_dload_points_to_polygons(polygons, slope_data):
     but not existing vertices.
     
     Parameters:
-        polygons: List of polygons (lists of (x,y) tuples)
+        polygons: List of polygons (list of (x,y) tuples) or dicts with "coords"
         slope_data: Dictionary containing slope data
         
     Returns:
@@ -1603,7 +1742,8 @@ def add_dload_points_to_polygons(polygons, slope_data):
     # Process each polygon
     updated_polygons = []
     for poly in polygons:
-        updated_poly = list(poly)  # Make a copy
+        coords = poly.get("coords", []) if isinstance(poly, dict) else poly
+        updated_poly = list(coords)  # Make a copy
         
         # Check each point against polygon edges
         for check_point in points_to_check:
@@ -1630,7 +1770,12 @@ def add_dload_points_to_polygons(polygons, slope_data):
                     updated_poly.insert(i + 1, (round(x_check, 6), round(y_check, 6)))
                     break  # Only insert once per point
         
-        updated_polygons.append(updated_poly)
+        if isinstance(poly, dict):
+            updated_entry = dict(poly)
+            updated_entry["coords"] = updated_poly
+            updated_polygons.append(updated_entry)
+        else:
+            updated_polygons.append(updated_poly)
     
     return updated_polygons
 
@@ -1681,29 +1826,33 @@ def print_polygon_summary(polygons):
     Prints a summary of the generated polygons for diagnostic purposes.
     
     Parameters:
-        polygons: List of polygon coordinate lists
+        polygons: List of polygon coordinate lists or dicts with "coords"
     """
     print("=== POLYGON SUMMARY ===")
     print(f"Number of material zones: {len(polygons)}")
     print()
     
     for i, polygon in enumerate(polygons):
-        print(f"Material Zone {i+1} (Material ID: {i}):")
-        print(f"  Number of vertices: {len(polygon)}")
+        coords = polygon.get("coords") if isinstance(polygon, dict) else polygon
+        mat_id = polygon.get("mat_id") if isinstance(polygon, dict) else i
+        if mat_id is None:
+            mat_id = i
+        print(f"Material Zone {i+1} (Material ID: {mat_id}):")
+        print(f"  Number of vertices: {len(coords)}")
         
         # Calculate area (simple shoelace formula)
         area = 0
-        for j in range(len(polygon) - 1):
-            x1, y1 = polygon[j]
-            x2, y2 = polygon[j + 1]
+        for j in range(len(coords) - 1):
+            x1, y1 = coords[j]
+            x2, y2 = coords[j + 1]
             area += (x2 - x1) * (y2 + y1) / 2
         area = abs(area)
         
         print(f"  Approximate area: {area:.2f} square units")
         
         # Print bounding box
-        xs = [x for x, y in polygon]
-        ys = [y for x, y in polygon]
+        xs = [x for x, y in coords]
+        ys = [y for x, y in coords]
         print(f"  Bounding box: x=[{min(xs):.2f}, {max(xs):.2f}], y=[{min(ys):.2f}, {max(ys):.2f}]")
         print()
 
@@ -2878,7 +3027,7 @@ def add_intersection_points_to_polygons(polygons, lines, debug=False):
     This ensures that polygons have vertices at all intersection points with reinforcement lines.
     
     Parameters:
-        polygons: List of polygons (lists of (x,y) tuples)
+        polygons: List of polygons (lists of (x,y) tuples) or dicts with "coords"
         lines: List of reinforcement lines (lists of (x,y) tuples)
         debug: Enable debug output
         
@@ -2894,7 +3043,12 @@ def add_intersection_points_to_polygons(polygons, lines, debug=False):
     # Make a copy of polygons to modify
     updated_polygons = []
     for poly in polygons:
-        updated_polygons.append(list(poly))  # Convert to list for modification
+        if isinstance(poly, dict):
+            updated_entry = dict(poly)
+            updated_entry["coords"] = list(poly.get("coords", []))
+            updated_polygons.append(updated_entry)
+        else:
+            updated_polygons.append(list(poly))  # Convert to list for modification
     
     # Find all intersections
     for line_idx, line_pts in enumerate(lines):
@@ -2910,10 +3064,11 @@ def add_intersection_points_to_polygons(polygons, lines, debug=False):
             
             # Check intersection with each polygon
             for poly_idx, poly in enumerate(updated_polygons):
+                poly_coords = poly.get("coords", []) if isinstance(poly, dict) else poly
                 # Check each edge of this polygon
-                for j in range(len(poly)):
-                    poly_edge_start = poly[j]
-                    poly_edge_end = poly[(j + 1) % len(poly)]
+                for j in range(len(poly_coords)):
+                    poly_edge_start = poly_coords[j]
+                    poly_edge_end = poly_coords[(j + 1) % len(poly_coords)]
                     
                     # Find intersection point if it exists
                     intersection = line_segment_intersection(
@@ -2927,7 +3082,7 @@ def add_intersection_points_to_polygons(polygons, lines, debug=False):
                         
                         # Check if intersection point is already a vertex of this polygon
                         is_vertex = False
-                        for vertex in poly:
+                        for vertex in poly_coords:
                             if abs(vertex[0] - intersection[0]) < 1e-8 and abs(vertex[1] - intersection[1]) < 1e-8:
                                 is_vertex = True
                                 break
@@ -2936,7 +3091,10 @@ def add_intersection_points_to_polygons(polygons, lines, debug=False):
                             # Insert intersection point into polygon at the correct position
                             # Insert after vertex j (which is the start of the edge)
                             insert_idx = j + 1
-                            updated_polygons[poly_idx].insert(insert_idx, intersection)
+                            if isinstance(updated_polygons[poly_idx], dict):
+                                updated_polygons[poly_idx]["coords"].insert(insert_idx, intersection)
+                            else:
+                                updated_polygons[poly_idx].insert(insert_idx, intersection)
                             
                             if debug:
                                 print(f"Added intersection point {intersection} to polygon {poly_idx} at position {insert_idx}")