xslope 0.1.12__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:
@@ -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
@@ -687,14 +809,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 +1158,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
@@ -1158,7 +1281,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 +1481,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 +1633,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 +1679,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 +1746,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 +2013,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 +2079,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 +2088,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 +2199,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

xslope/plot_seep.py

@@ -10,7 +10,7 @@ def plot_seep_data(seep_data, figsize=(14, 6), show_nodes=False, show_bc=False,
     Supports both triangular and quadrilateral elements.
     
     Args:
-        seep_data: Dictionary containing seepage data from import_seep2d
+        seep_data: Dictionary containing seep data from import_seep2d
         show_nodes: If True, plot node points
         show_bc: If True, plot boundary condition nodes
         label_elements: If True, label each element with its number at its centroid
@@ -206,11 +206,11 @@ def plot_seep_data(seep_data, figsize=(14, 6), show_nodes=False, show_bc=False,
     num_triangles = np.sum(element_types == 3)
     num_quads = np.sum(element_types == 4)
     if num_triangles > 0 and num_quads > 0:
-        title = f"SEEP2D Mesh with Material Zones ({num_triangles} triangles, {num_quads} quads)"
+        title = f"Finite Element Mesh with Material Zones ({num_triangles} triangles, {num_quads} quads)"
     elif num_quads > 0:
-        title = f"SEEP2D Mesh with Material Zones ({num_quads} quadrilaterals)"
+        title = f"Finite Element Mesh with Material Zones ({num_quads} quadrilaterals)"
     else:
-        title = f"SEEP2D Mesh with Material Zones ({num_triangles} triangles)"
+        title = f"Finite Element Mesh with Material Zones ({num_triangles} triangles)"
     
     ax.set_title(title)
     # plt.subplots_adjust(bottom=0.2)  # Add vertical cushion
@@ -225,9 +225,9 @@ def plot_seep_data(seep_data, figsize=(14, 6), show_nodes=False, show_bc=False,
 
 def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat=1, fill_contours=True, phreatic=True, alpha=0.4, pad_frac=0.05, mesh=True, variable="head", vectors=False, vector_scale=0.05, flowlines=True, save_png=False, dpi=300):
     """
-    Plot seepage analysis results including head contours, flowlines, and phreatic surface.
+    Plot seep analysis results including head contours, flowlines, and phreatic surface.
     
-    This function visualizes the results of a seepage analysis by plotting contours of various
+    This function visualizes the results of a seep analysis by plotting contours of various
     nodal variables (head, pore pressure, velocity magnitude, or gradient magnitude). When
     plotting head, flowlines are also overlaid. The plot properly handles mesh aspect ratios
     and supports both linear and quadratic triangular and quadrilateral elements.
@@ -235,7 +235,7 @@ def plot_seep_solution(seep_data, solution, figsize=(14, 6), levels=20, base_mat
     Parameters:
     -----------
     seep_data : dict
-        Dictionary containing seepage mesh data from import_seep2d. Required keys include:
+        Dictionary containing seep mesh data from import_seep2d. Required keys include:
         'nodes', 'elements', 'element_materials', 'element_types' (optional), and
         'k1_by_mat' (optional, for flowline calculation).
     solution : dict