xslope 0.1.12__py3-none-any.whl → 0.1.14__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:
@@ -1218,7 +1246,9 @@ def build_polygons(slope_data, reinf_lines=None, tol = 0.000001, 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,7 +1266,7 @@ def build_polygons(slope_data, reinf_lines=None, tol = 0.000001, 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)]
+    lines = [list(line['coords']) for line in copy.deepcopy(profile_lines)]
 
     for i in range(n - 1):
         top = lines[i]
@@ -1666,7 +1696,11 @@ def build_polygons(slope_data, reinf_lines=None, tol = 0.000001, 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)
@@ -1683,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:
@@ -1708,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:
@@ -1735,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
 
@@ -1786,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()
 
@@ -2983,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
         
@@ -2999,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):
@@ -3015,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(
@@ -3032,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
@@ -3041,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}")

xslope/plot.py

@@ -54,20 +54,142 @@ def get_dload_legend_handler():
     return None, dummy_line
 
 
-def plot_profile_lines(ax, profile_lines):
+def plot_profile_lines(ax, profile_lines, materials=None, labels=False):
     """
     Plots the profile lines for each material in the slope.
 
     Parameters:
         ax: matplotlib Axes object
-        profile_lines: List of line coordinates representing material boundaries
+        profile_lines: List of profile line dicts, each with 'coords' and 'mat_id' keys
+        materials: List of material dictionaries (optional, for color mapping)
+        labels: If True, add index labels to each profile line (default: False)
 
     Returns:
         None
     """
     for i, line in enumerate(profile_lines):
-        xs, ys = zip(*line)
-        ax.plot(xs, ys, color=get_material_color(i), linewidth=1, label=f'Profile {i+1}')
+        coords = line['coords']
+        xs, ys = zip(*coords)
+        
+        # Get material index from mat_id (already 0-based)
+        if materials and line.get('mat_id') is not None:
+            mat_idx = line['mat_id']
+            if 0 <= mat_idx < len(materials):
+                color = get_material_color(mat_idx)
+            else:
+                # Fallback to index-based color if mat_id out of range
+                color = get_material_color(i)
+        else:
+            # Fallback to index-based color if no materials or mat_id
+            color = get_material_color(i)
+        
+        ax.plot(xs, ys, color=color, linewidth=1, label=f'Profile {i+1}')
+
+        if labels:
+            _add_profile_index_label(ax, coords, i + 1, color)
+
+
+def _add_profile_index_label(ax, line, index, color):
+    """
+    Adds an index label to a profile line, positioned on a suitable segment.
+
+    Parameters:
+        ax: matplotlib Axes object
+        line: List of (x, y) coordinates for the profile line
+        index: The index number to display (1-based)
+        color: Color for the label text
+
+    Returns:
+        None
+    """
+    if len(line) < 2:
+        return
+
+    # Build list of segments with their properties
+    segments = []
+    for j in range(len(line) - 1):
+        x1, y1 = line[j]
+        x2, y2 = line[j + 1]
+        dx = x2 - x1
+        dy = y2 - y1
+        length = np.sqrt(dx**2 + dy**2)
+
+        if length < 1e-9:
+            continue
+
+        # Calculate how horizontal the segment is (1.0 = perfectly horizontal)
+        horizontalness = abs(dx) / length
+
+        # Midpoint of the segment
+        mid_x = (x1 + x2) / 2
+        mid_y = (y1 + y2) / 2
+
+        segments.append({
+            'length': length,
+            'horizontalness': horizontalness,
+            'mid_x': mid_x,
+            'mid_y': mid_y,
+            'position': j  # segment index in the line
+        })
+
+    if not segments:
+        return
+
+    # Calculate the total line length and find segments in the middle third
+    total_length = sum(s['length'] for s in segments)
+
+    # Score segments: prefer longer, more horizontal segments near the middle
+    # Avoid very short segments (less than 5% of total length)
+    min_length_threshold = 0.05 * total_length
+
+    n_segments = len(segments)
+    best_segment = None
+    best_score = -1
+
+    for seg in segments:
+        # Skip very short segments
+        if seg['length'] < min_length_threshold:
+            continue
+
+        # Calculate how close to the middle this segment is (0-1 scale, 1 = center)
+        position_ratio = (seg['position'] + 0.5) / n_segments
+        middle_score = 1.0 - 2.0 * abs(position_ratio - 0.5)  # 1.0 at center, 0.0 at ends
+
+        # Score: weight length, horizontalness, and middle position
+        # Length is normalized by total length
+        length_score = seg['length'] / total_length
+
+        # Combined score: prioritize horizontalness, then middle position, then length
+        score = (seg['horizontalness'] * 2.0 +
+                 middle_score * 1.5 +
+                 length_score * 1.0)
+
+        if score > best_score:
+            best_score = score
+            best_segment = seg
+
+    # Fallback: if no segment passed the threshold, use the longest one
+    if best_segment is None:
+        best_segment = max(segments, key=lambda s: s['length'])
+
+    # Place the label at the midpoint of the chosen segment
+    ax.text(
+        best_segment['mid_x'],
+        best_segment['mid_y'],
+        str(index),
+        fontsize=7,
+        color=color,
+        fontfamily='monospace',
+        ha='center',
+        va='center',
+        bbox=dict(
+            boxstyle='round,pad=0.3',
+            facecolor='white',
+            edgecolor=color,
+            linewidth=0.8
+        ),
+        zorder=10
+    )
 
 def plot_max_depth(ax, profile_lines, max_depth):
     """
@@ -75,7 +197,7 @@ def plot_max_depth(ax, profile_lines, max_depth):
 
     Parameters:
         ax: matplotlib Axes object
-        profile_lines: List of line coordinates representing material boundaries
+        profile_lines: List of profile line dicts, each with 'coords' key containing coordinate tuples
         max_depth: Maximum allowed depth for analysis
 
     Returns:
@@ -83,7 +205,7 @@ def plot_max_depth(ax, profile_lines, max_depth):
     """
     if max_depth is None:
         return
-    x_vals = [x for line in profile_lines for x, _ in line]
+    x_vals = [x for line in profile_lines for x, _ in line['coords']]
     x_min = min(x_vals)
     x_max = max(x_vals)
     ax.hlines(max_depth, x_min, x_max, colors='black', linewidth=1.5, label='Max Depth')
@@ -220,7 +342,7 @@ def plot_piezo_line(ax, slope_data):
 
 def plot_seepage_bc_lines(ax, slope_data):
     """
-    Plots seepage boundary-condition lines for seepage-only workflows.
+    Plots seep boundary-condition lines for seep-only workflows.
 
     - Specified head geometry: solid dark blue, thicker than profile lines
     - Exit face geometry: solid red
@@ -245,7 +367,7 @@ def plot_seepage_bc_lines(ax, slope_data):
     x_vals = []
     for line in slope_data.get("profile_lines", []):
         try:
-            xs_line, _ = zip(*line)
+            xs_line, _ = zip(*line['coords'])
             x_vals.extend(xs_line)
         except Exception:
             pass
@@ -551,11 +673,16 @@ def plot_circles(ax, slope_data):
             dx /= length
             dy /= length
 
-        # Shorten shaft length slightly
-        shaft_length = R - 5
-
-        ax.arrow(Xo, Yo, dx * shaft_length, dy * shaft_length,
-                 head_width=5, head_length=5, fc='red', ec='red')
+        # Draw arrow with pixel-based head size
+        ax.annotate('',
+                    xy=(Xo + dx * R, Yo + dy * R),  # arrow tip
+                    xytext=(Xo, Yo),                 # arrow start
+                    arrowprops=dict(
+                        arrowstyle='-|>',
+                        color='red',
+                        lw=1.0,            # shaft width in points
+                        mutation_scale=20  # head size in points
+                    ))
 
 def plot_non_circ(ax, non_circ):
     """
@@ -687,14 +814,14 @@ def plot_lem_material_table(ax, materials, xloc=0.6, yloc=0.7):
 
 def plot_seep_material_table(ax, seep_data, xloc=0.6, yloc=0.7):
     """
-    Adds a seepage material properties table to the plot.
+    Adds a seep material properties table to the plot.
 
-    Displays hydraulic properties for seepage analysis including hydraulic conductivities
+    Displays hydraulic properties for seep analysis including hydraulic conductivities
     (k₁, k₂), anisotropy angle, and unsaturated flow parameters (kr₀, h₀).
 
     Parameters:
         ax: matplotlib Axes object to add the table to
-        seep_data: Dictionary containing seepage material properties with keys:
+        seep_data: Dictionary containing seep material properties with keys:
             - 'k1_by_mat': List of primary hydraulic conductivity values (float)
             - 'k2_by_mat': List of secondary hydraulic conductivity values (float)
             - 'angle_by_mat': List of anisotropy angles in degrees (float)
@@ -1036,10 +1163,11 @@ def compute_ylim(data, slice_df, scale_frac=0.5, pad_fraction=0.1):
 
     # 1) collect all profile line elevations
     for line in data.get('profile_lines', []):
-        if hasattr(line, "xy"):
-            _, ys = line.xy
+        coords = line['coords']
+        if hasattr(coords, "xy"):
+            _, ys = coords.xy
         else:
-            _, ys = zip(*line)
+            _, ys = zip(*coords)
         y_vals.extend(ys)
 
     # 2) explicitly include the deepest allowed depth
@@ -1108,11 +1236,11 @@ def plot_inputs(
     slope_data,
     title="Slope Geometry and Inputs",
     figsize=(12, 6),
-    mat_table=True,
+    mat_table=False,
     save_png=False,
     dpi=300,
     mode="lem",
-    tab_loc="upper left",
+    tab_loc="top",
     legend_ncol="auto",
     legend_max_cols=6,
     legend_max_rows=4,
@@ -1158,7 +1286,7 @@ def plot_inputs(
     fig, ax = plt.subplots(figsize=figsize)
 
     # Plot contents
-    plot_profile_lines(ax, slope_data['profile_lines'])
+    plot_profile_lines(ax, slope_data['profile_lines'], materials=slope_data.get('materials'), labels=True)
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     if mode == "seep":
@@ -1358,7 +1486,7 @@ def plot_solution(slope_data, slice_df, failure_surface, results, figsize=(12, 7
     ax.set_ylabel("y")
     ax.grid(False)
 
-    plot_profile_lines(ax, slope_data['profile_lines'])
+    plot_profile_lines(ax, slope_data['profile_lines'], materials=slope_data.get('materials'))
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_slices(ax, slice_df, fill=False)
     plot_failure_surface(ax, failure_surface)
@@ -1510,7 +1638,7 @@ def plot_circular_search_results(slope_data, fs_cache, search_path=None, highlig
     """
     fig, ax = plt.subplots(figsize=figsize)
 
-    plot_profile_lines(ax, slope_data['profile_lines'])
+    plot_profile_lines(ax, slope_data['profile_lines'], materials=slope_data.get('materials'))
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
@@ -1556,7 +1684,7 @@ def plot_noncircular_search_results(slope_data, fs_cache, search_path=None, high
     fig, ax = plt.subplots(figsize=figsize)
 
     # Plot basic profile elements
-    plot_profile_lines(ax, slope_data['profile_lines'])
+    plot_profile_lines(ax, slope_data['profile_lines'], materials=slope_data.get('materials'))
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
@@ -1623,7 +1751,7 @@ def plot_reliability_results(slope_data, reliability_data, figsize=(12, 7), save
     fig, ax = plt.subplots(figsize=figsize)
 
     # Plot basic slope elements (same as other search functions)
-    plot_profile_lines(ax, slope_data['profile_lines'])
+    plot_profile_lines(ax, slope_data['profile_lines'], materials=slope_data.get('materials'))
     plot_max_depth(ax, slope_data['profile_lines'], slope_data['max_depth'])
     plot_piezo_line(ax, slope_data)
     plot_dloads(ax, slope_data)
@@ -1890,34 +2018,48 @@ def plot_mesh(mesh, materials=None, figsize=(14, 6), pad_frac=0.05, show_nodes=T
     plt.show()
 
 
-def plot_polygons(polygons, materials=None, nodes=False, legend=True, title="Material Zone Polygons", save_png=False, dpi=300):
+def plot_polygons(
+    polygons,
+    materials=None,
+    nodes=False,
+    legend=True,
+    title="Material Zone Polygons",
+    figsize=(10, 6),
+    save_png=False,
+    dpi=300,
+):
     """
     Plot all material zone polygons in a single figure.
     
     Parameters:
-        polygons: List of polygon coordinate lists
+        polygons: List of polygon coordinate lists or dicts with "coords"/"mat_id"
         materials: Optional list of material dicts (with key "name") or list of material
             name strings. If provided, the material name will be used in the legend.
         nodes: If True, plot each polygon vertex as a dot.
         legend: If True, show the legend.
         title: Plot title
+        figsize: Matplotlib figure size tuple, e.g. (10, 6)
     """
     import matplotlib.pyplot as plt
     
-    fig, ax = plt.subplots(figsize=(12, 8))
+    fig, ax = plt.subplots(figsize=figsize)
     for i, polygon in enumerate(polygons):
-        xs = [x for x, y in polygon]
-        ys = [y for x, y in polygon]
+        coords = polygon.get("coords", []) if isinstance(polygon, dict) else polygon
+        xs = [x for x, y in coords]
+        ys = [y for x, y in coords]
+        mat_idx = polygon.get("mat_id") if isinstance(polygon, dict) else i
+        if mat_idx is None:
+            mat_idx = i
         mat_name = None
-        if materials is not None and i < len(materials):
-            item = materials[i]
+        if materials is not None and 0 <= mat_idx < len(materials):
+            item = materials[mat_idx]
             if isinstance(item, dict):
                 mat_name = item.get("name", None)
             elif isinstance(item, str):
                 mat_name = item
-        label = mat_name if mat_name else f"Material {i}"
-        ax.fill(xs, ys, color=get_material_color(i), alpha=0.6, label=label)
-        ax.plot(xs, ys, color=get_material_color(i), linewidth=1)
+        label = mat_name if mat_name else f"Material {mat_idx}"
+        ax.fill(xs, ys, color=get_material_color(mat_idx), alpha=0.6, label=label)
+        ax.plot(xs, ys, color=get_material_color(mat_idx), linewidth=1)
         if nodes:
             # Avoid legend clutter by not adding a label here.
             ax.scatter(xs, ys, color='k', s=30, marker='o', zorder=3)
@@ -1942,7 +2084,7 @@ def plot_polygons_separately(polygons, materials=None, save_png=False, dpi=300):
     Plot each polygon in a separate matplotlib frame (subplot), with vertices as round dots.
     
     Parameters:
-        polygons: List of polygon coordinate lists
+        polygons: List of polygon coordinate lists or dicts with "coords"/"mat_id"
         materials: Optional list of material dicts (with key "name") or list of material
             name strings. If provided, the material name will be included in each subplot title.
     """
@@ -1951,25 +2093,29 @@ def plot_polygons_separately(polygons, materials=None, save_png=False, dpi=300):
     n = len(polygons)
     fig, axes = plt.subplots(n, 1, figsize=(8, 3 * n), squeeze=False)
     for i, polygon in enumerate(polygons):
-        xs = [x for x, y in polygon]
-        ys = [y for x, y in polygon]
+        coords = polygon.get("coords", []) if isinstance(polygon, dict) else polygon
+        xs = [x for x, y in coords]
+        ys = [y for x, y in coords]
         ax = axes[i, 0]
-        ax.fill(xs, ys, color=get_material_color(i), alpha=0.6, label=f'Material {i}')
-        ax.plot(xs, ys, color=get_material_color(i), linewidth=1)
+        mat_idx = polygon.get("mat_id") if isinstance(polygon, dict) else i
+        if mat_idx is None:
+            mat_idx = i
+        ax.fill(xs, ys, color=get_material_color(mat_idx), alpha=0.6, label=f'Material {mat_idx}')
+        ax.plot(xs, ys, color=get_material_color(mat_idx), linewidth=1)
         ax.scatter(xs, ys, color='k', s=30, marker='o', zorder=3, label='Vertices')
         ax.set_xlabel('X Coordinate')
         ax.set_ylabel('Y Coordinate')
         mat_name = None
-        if materials is not None and i < len(materials):
-            item = materials[i]
+        if materials is not None and 0 <= mat_idx < len(materials):
+            item = materials[mat_idx]
             if isinstance(item, dict):
                 mat_name = item.get("name", None)
             elif isinstance(item, str):
                 mat_name = item
         if mat_name:
-            ax.set_title(f'Material {i}: {mat_name}')
+            ax.set_title(f'Material {mat_idx}: {mat_name}')
         else:
-            ax.set_title(f'Material {i}')
+            ax.set_title(f'Material {mat_idx}')
         ax.grid(True, alpha=0.3)
         ax.set_aspect('equal')
         # Intentionally no legend: these plots are typically used for debugging geometry,
@@ -2058,8 +2204,9 @@ def get_plot_elements_bounds(ax, slope_data):
     if 'profile_lines' in slope_data:
         for line in slope_data['profile_lines']:
             if line:
-                xs = [p[0] for p in line]
-                ys = [p[1] for p in line]
+                coords = line['coords']
+                xs = [p[0] for p in coords]
+                ys = [p[1] for p in coords]
                 bounds.append((min(xs), max(xs), min(ys), max(ys)))
     
     # Distributed loads bounds