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

xslope/plot.py

@@ -17,6 +17,7 @@ import numpy as np
 from matplotlib.lines import Line2D
 from matplotlib.path import Path
 from shapely.geometry import LineString
+import math
 
 from .slice import generate_failure_surface
 
@@ -29,8 +30,9 @@ plt.rcParams.update({
 
 # Consistent color for materials (Tableau tab10)
 def get_material_color(idx):
-    tableau_colors = plt.get_cmap('tab10').colors  # 10 distinct colors
-    return tableau_colors[idx % len(tableau_colors)]
+    cmap = plt.get_cmap("tab10")
+    # Use the colormap callable rather than relying on the (typing-unknown) `.colors` attribute.
+    return cmap(idx % getattr(cmap, "N", 10))
 
 def get_dload_legend_handler():
     """
@@ -52,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):
     """
@@ -73,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:
@@ -81,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')
@@ -173,6 +297,26 @@ def plot_piezo_line(ax, slope_data):
         None
     """
     
+    def _plot_touching_v_marker(ax, x, y, color, markersize=8, extra_gap_points=0.0):
+        """
+        Place an inverted triangle marker so its tip visually touches the line at (x, y).
+        We do this in display coordinates (points/pixels) so it scales consistently.
+        """
+        from matplotlib.markers import MarkerStyle
+        from matplotlib.transforms import offset_copy
+
+        # Compute the distance (in "marker units") from the marker origin to the tip.
+        # Matplotlib scales marker vertices by `markersize` (in points) for Line2D.
+        ms = MarkerStyle("v")
+        path = ms.get_path().transformed(ms.get_transform())
+        verts = np.asarray(path.vertices)
+        min_y = float(verts[:, 1].min())  # tip is the lowest y
+        tip_offset_points = (-min_y) * float(markersize) + float(extra_gap_points)
+
+        # Offset the marker center upward in point units so the tip lands at (x, y).
+        trans = offset_copy(ax.transData, fig=ax.figure, x=0.0, y=tip_offset_points, units="points")
+        ax.plot([x], [y], marker="v", color=color, markersize=markersize, linestyle="None", transform=trans)
+
     def plot_single_piezo_line(ax, piezo_line, color, label):
         """Internal function to plot a single piezometric line"""
         if not piezo_line:
@@ -182,20 +326,146 @@ def plot_piezo_line(ax, slope_data):
         ax.plot(piezo_xs, piezo_ys, color=color, linewidth=2, label=label)
         
         # Find middle x-coordinate and corresponding y value
-        x_min, x_max = min(piezo_xs), max(piezo_xs)
-        mid_x = (x_min + x_max) / 2
-        
-        # Interpolate y value at mid_x
-        from scipy.interpolate import interp1d
         if len(piezo_xs) > 1:
-            f = interp1d(piezo_xs, piezo_ys, kind='linear', bounds_error=False, fill_value='extrapolate')
-            mid_y = f(mid_x)
-            ax.plot(mid_x, mid_y + 6, marker='v', color=color, markersize=8)
+            # Sort by x to ensure monotonic input for interpolation
+            pairs = sorted(zip(piezo_xs, piezo_ys), key=lambda p: p[0])
+            sx, sy = zip(*pairs)
+            x_min, x_max = min(sx), max(sx)
+            mid_x = (x_min + x_max) / 2
+            mid_y = float(np.interp(mid_x, sx, sy))
+            # Slight negative gap so the marker visually "touches" the line (not floating above it)
+            _plot_touching_v_marker(ax, mid_x, mid_y, color=color, markersize=8, extra_gap_points=2.0)
     
     # Plot both piezometric lines
     plot_single_piezo_line(ax, slope_data.get('piezo_line'), 'b', "Piezometric Line")
     plot_single_piezo_line(ax, slope_data.get('piezo_line2'), 'skyblue', "Piezometric Line 2")
 
+def plot_seepage_bc_lines(ax, slope_data):
+    """
+    Plots seep boundary-condition lines for seep-only workflows.
+
+    - Specified head geometry: solid dark blue, thicker than profile lines
+    - Exit face geometry: solid red
+    - Derived "water level" line for each specified head: y = h
+      plotted as a lighter blue solid line with an inverted triangle marker
+      (styled similarly to piezometric line markers).
+    """
+    def _plot_touching_v_marker(ax, x, y, color, markersize=8, extra_gap_points=2.0):
+        """Place an inverted triangle so its tip visually sits on the line at (x, y)."""
+        from matplotlib.markers import MarkerStyle
+        from matplotlib.transforms import offset_copy
+
+        ms = MarkerStyle("v")
+        path = ms.get_path().transformed(ms.get_transform())
+        verts = np.asarray(path.vertices)
+        min_y = float(verts[:, 1].min())
+        tip_offset_points = (-min_y) * float(markersize) + float(extra_gap_points)
+        trans = offset_copy(ax.transData, fig=ax.figure, x=0.0, y=tip_offset_points, units="points")
+        ax.plot([x], [y], marker="v", color=color, markersize=markersize, linestyle="None", transform=trans)
+
+    # Geometry x-extent (used for vertical-head-line derived segment length / side)
+    x_vals = []
+    for line in slope_data.get("profile_lines", []):
+        try:
+            xs_line, _ = zip(*line['coords'])
+            x_vals.extend(xs_line)
+        except Exception:
+            pass
+    gs = slope_data.get("ground_surface", None)
+    if not x_vals and gs is not None and hasattr(gs, "coords"):
+        x_vals.extend([x for x, _ in gs.coords])
+    x_min_geom = min(x_vals) if x_vals else 0.0
+    x_max_geom = max(x_vals) if x_vals else 1.0
+    geom_width = max(1e-9, x_max_geom - x_min_geom)
+
+    seepage_bc = slope_data.get("seepage_bc") or {}
+    specified_heads = seepage_bc.get("specified_heads") or []
+    exit_face = seepage_bc.get("exit_face") or []
+
+    # --- Specified head lines + derived water-level lines ---
+    for i, sh in enumerate(specified_heads):
+        coords = sh.get("coords") or []
+        if len(coords) < 2:
+            continue
+
+        xs, ys = zip(*coords)
+        ax.plot(
+            xs,
+            ys,
+            color="darkblue",
+            linewidth=3,
+            linestyle="--",
+            label="Specified Head Line" if i == 0 else "",
+        )
+
+        # Head values may be scalar (typical) or per-point array-like
+        head_val = sh.get("head", None)
+        if head_val is None:
+            continue
+
+        if isinstance(head_val, (list, tuple, np.ndarray)):
+            if len(head_val) != len(coords):
+                continue
+            heads = [float(h) for h in head_val]
+        else:
+            try:
+                head_scalar = float(head_val)
+            except (TypeError, ValueError):
+                continue
+            heads = [head_scalar] * len(coords)
+
+        # If specified-head geometry is vertical, draw a short horizontal derived line outside the boundary.
+        # This avoids drawing a (nearly) vertical derived line that doesn't convey a water level.
+        tol = 1e-6
+        is_vertical = (max(xs) - min(xs)) <= tol
+        if is_vertical:
+            x0 = float(xs[0])
+            y_head = float(heads[0])
+            seg_len = 0.04 * geom_width
+            gap = 0.01 * geom_width
+            is_right = x0 >= 0.5 * (x_min_geom + x_max_geom)
+            if is_right:
+                wl_xs = [x0 + gap, x0 + gap + seg_len]
+            else:
+                wl_xs = [x0 - gap - seg_len, x0 - gap]
+            wl_ys = [y_head, y_head]
+        else:
+            wl_xs = list(xs)
+            wl_ys = heads
+
+        ax.plot(
+            wl_xs,
+            wl_ys,
+            color="lightskyblue",
+            linewidth=2,
+            linestyle="-",
+            label="Specified Head Water Level" if i == 0 else "",
+        )
+
+        # Inverted triangle marker near the midpoint (like piezometric lines)
+        if len(wl_xs) > 1:
+            try:
+                pairs = sorted(zip(wl_xs, wl_ys), key=lambda p: p[0])
+                sx, sy = zip(*pairs)
+                mid_x = 0.5 * (min(sx) + max(sx))
+                mid_y = float(np.interp(mid_x, sx, sy))
+                _plot_touching_v_marker(ax, mid_x, mid_y, color="lightskyblue", markersize=8, extra_gap_points=2.0)
+            except Exception:
+                # If interpolation fails for any reason, skip marker
+                pass
+
+    # --- Exit face line ---
+    if len(exit_face) >= 2:
+        ex_xs, ex_ys = zip(*exit_face)
+        ax.plot(
+            ex_xs,
+            ex_ys,
+            color="red",
+            linewidth=3,
+            linestyle="--",
+            label="Exit Face",
+        )
+
 def plot_tcrack_surface(ax, tcrack_surface):
     """
     Plots the tension crack surface as a thin dashed red line.
@@ -381,6 +651,8 @@ def plot_circles(ax, slope_data):
             continue  # or handle error
         # result = (x_min, x_max, y_left, y_right, clipped_surface)
         x_min, x_max, y_left, y_right, clipped_surface = result
+        if not isinstance(clipped_surface, LineString):
+            clipped_surface = LineString(clipped_surface)
         x_clip, y_clip = zip(*clipped_surface.coords)
         ax.plot(x_clip, y_clip, 'r--', label="Circle")
 
@@ -423,15 +695,28 @@ def plot_non_circ(ax, non_circ):
     xs, ys = zip(*non_circ)
     ax.plot(xs, ys, 'r--', label='Non-Circular Surface')
 
-def plot_material_table(ax, materials, xloc=0.6, yloc=0.7):
+def plot_lem_material_table(ax, materials, xloc=0.6, yloc=0.7):
     """
-    Adds a material properties table to the plot.
+    Adds a limit equilibrium material properties table to the plot.
+
+    Displays soil properties for limit equilibrium analysis including unit weight (γ),
+    cohesion (c), friction angle (φ), and optionally dilation angle (d) and
+    dilatancy angle (ψ). Supports both Mohr-Coulomb (mc) and constant-phi (cp) options.
 
     Parameters:
-        ax: matplotlib Axes object
-        materials: List of material property dictionaries
-        xloc: x-location of table (0-1)
-        yloc: y-location of table (0-1)
+        ax: matplotlib Axes object to add the table to
+        materials: List of material property dictionaries with keys:
+            - 'name': Material name (str)
+            - 'gamma': Unit weight (float)
+            - 'option': Material model - 'mc' or 'cp' (str)
+            - 'c': Cohesion for mc option (float)
+            - 'phi': Friction angle for mc option (float)
+            - 'cp': Constant phi for cp option (float)
+            - 'r_elev': Reference elevation for cp option (float)
+            - 'd': Dilation angle, optional (float)
+            - 'psi': Dilatancy angle, optional (float)
+        xloc: x-location of table bottom-left corner in axes coordinates (0-1, default: 0.6)
+        yloc: y-location of table bottom-left corner in axes coordinates (0-1, default: 0.7)
 
     Returns:
         None
@@ -505,15 +790,239 @@ def plot_material_table(ax, materials, xloc=0.6, yloc=0.7):
     # Adjust table width based on number of columns
     table_width = 0.25 if has_d_psi else 0.2
 
+    # Choose table height based on number of materials (uniform across table types)
+    num_rows = max(1, len(materials))
+    table_height = 0.06 + 0.035 * num_rows  # header + per-row estimate
+    table_height = min(0.35, table_height)  # cap to avoid overflows for many rows
+
     # Add the table
     table = ax.table(cellText=table_data,
                      colLabels=col_labels,
                      loc='upper right',
                      colLoc='center',
                      cellLoc='center',
-                     bbox=[xloc, yloc, table_width, 0.25])
+                     bbox=[xloc, yloc, table_width, table_height])
     table.auto_set_font_size(False)
     table.set_fontsize(8)
+    # Auto layout based on content (shared method for all table types)
+    auto_size_table_to_content(ax, table, col_labels, table_data, table_width, table_height)
+
+def plot_seep_material_table(ax, seep_data, xloc=0.6, yloc=0.7):
+    """
+    Adds a seep material properties table to the plot.
+
+    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 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)
+            - 'kr0_by_mat': List of relative permeability at residual saturation (float)
+            - 'h0_by_mat': List of pressure head parameters (float)
+            - 'material_names': List of material names (str), optional
+        xloc: x-location of table bottom-left corner in axes coordinates (0-1, default: 0.6)
+        yloc: y-location of table bottom-left corner in axes coordinates (0-1, default: 0.7)
+
+    Returns:
+        None
+    """
+    k1_by_mat = seep_data.get("k1_by_mat")
+    k2_by_mat = seep_data.get("k2_by_mat")
+    angle_by_mat = seep_data.get("angle_by_mat")
+    kr0_by_mat = seep_data.get("kr0_by_mat")
+    h0_by_mat = seep_data.get("h0_by_mat")
+    material_names = seep_data.get("material_names", [])
+    if k1_by_mat is None or len(k1_by_mat) == 0:
+        return
+    col_labels = ["Mat", "Name", "k₁", "k₂", "Angle", "kr₀", "h₀"]
+    table_data = []
+    for idx in range(len(k1_by_mat)):
+        k1 = k1_by_mat[idx]
+        k2 = k2_by_mat[idx] if k2_by_mat is not None else 0.0
+        angle = angle_by_mat[idx] if angle_by_mat is not None else 0.0
+        kr0 = kr0_by_mat[idx] if kr0_by_mat is not None else 0.0
+        h0 = h0_by_mat[idx] if h0_by_mat is not None else 0.0
+        material_name = material_names[idx] if idx < len(material_names) else f"Material {idx+1}"
+        row = [idx + 1, material_name, f"{k1:.3f}", f"{k2:.3f}", f"{angle:.1f}", f"{kr0:.4f}", f"{h0:.2f}"]
+        table_data.append(row)
+    # Dimensions
+    num_rows = max(1, len(k1_by_mat))
+    table_width = 0.45
+    table_height = 0.10 + 0.06 * num_rows
+    table_height = min(0.50, table_height)
+    table = ax.table(cellText=table_data,
+                     colLabels=col_labels,
+                     loc='upper right',
+                     colLoc='center',
+                     cellLoc='center',
+                     bbox=[xloc, yloc, table_width, table_height])
+    table.auto_set_font_size(False)
+    table.set_fontsize(8)
+    auto_size_table_to_content(ax, table, col_labels, table_data, table_width, table_height)
+
+def plot_fem_material_table(ax, fem_data, xloc=0.6, yloc=0.7, width=0.6, height=None):
+    """
+    Adds a finite element material properties table to the plot.
+
+    Displays material properties for FEM analysis including unit weight (γ), cohesion (c),
+    friction angle (φ), Young's modulus (E), and Poisson's ratio (ν).
+
+    Parameters:
+        ax: matplotlib Axes object to add the table to
+        fem_data: Dictionary containing FEM material properties with keys:
+            - 'c_by_mat': List of cohesion values (float)
+            - 'phi_by_mat': List of friction angle values in degrees (float)
+            - 'E_by_mat': List of Young's modulus values (float)
+            - 'nu_by_mat': List of Poisson's ratio values (float)
+            - 'gamma_by_mat': List of unit weight values (float)
+            - 'material_names': List of material names (str), optional
+        xloc: x-location of table bottom-left corner in axes coordinates (0-1, default: 0.6)
+        yloc: y-location of table bottom-left corner in axes coordinates (0-1, default: 0.7)
+        width: Table width in axes coordinates (0-1, default: 0.6)
+        height: Table height in axes coordinates (0-1, default: auto-calculated)
+
+    Returns:
+        None
+    """
+    c_by_mat = fem_data.get("c_by_mat")
+    phi_by_mat = fem_data.get("phi_by_mat")
+    E_by_mat = fem_data.get("E_by_mat")
+    nu_by_mat = fem_data.get("nu_by_mat")
+    gamma_by_mat = fem_data.get("gamma_by_mat")
+    material_names = fem_data.get("material_names", [])
+    if c_by_mat is None or len(c_by_mat) == 0:
+        return
+    col_labels = ["Mat", "Name", "γ", "c", "φ", "E", "ν"]
+    table_data = []
+    for idx in range(len(c_by_mat)):
+        c = c_by_mat[idx]
+        phi = phi_by_mat[idx] if phi_by_mat is not None else 0.0
+        E = E_by_mat[idx] if E_by_mat is not None else 0.0
+        nu = nu_by_mat[idx] if nu_by_mat is not None else 0.0
+        gamma = gamma_by_mat[idx] if gamma_by_mat is not None else 0.0
+        material_name = material_names[idx] if idx < len(material_names) else f"Material {idx+1}"
+        row = [idx + 1, material_name, f"{gamma:.1f}", f"{c:.1f}", f"{phi:.1f}", f"{E:.0f}", f"{nu:.2f}"]
+        table_data.append(row)
+    if height is None:
+        num_rows = max(1, len(c_by_mat))
+        height = 0.06 + 0.035 * num_rows
+        height = min(0.32, height)
+    table = ax.table(cellText=table_data,
+                     colLabels=col_labels,
+                     loc='upper right',
+                     colLoc='center',
+                     cellLoc='center',
+                     bbox=[xloc, yloc, width, height])
+    table.auto_set_font_size(False)
+    table.set_fontsize(8)
+    auto_size_table_to_content(ax, table, col_labels, table_data, width, height)
+def auto_size_table_to_content(ax, table, col_labels, table_data, table_width, table_height, min_row_frac=0.02, row_pad=1.35, col_min_frac=0.08, col_max_frac=0.15):
+    """
+    Automatically adjusts table column widths and row heights based on content.
+
+    Measures text extents using the matplotlib renderer and sets column widths proportional
+    to content while enforcing minimum and maximum constraints. The "Name" column gets
+    more space (18-30%) while numeric columns are constrained to prevent excessive whitespace.
+    Row heights are uniform and based on the tallest content in each row.
+
+    Parameters:
+        ax: matplotlib Axes object containing the table
+        table: matplotlib Table object to be resized
+        col_labels: List of column header labels (str)
+        table_data: List of lists containing table cell data
+        table_width: Total table width in axes coordinates (0-1)
+        table_height: Total table height in axes coordinates (0-1)
+        min_row_frac: Minimum row height as fraction of axes height (default: 0.02)
+        row_pad: Padding factor applied to measured row heights (default: 1.35)
+        col_min_frac: Minimum column width as fraction of table width for numeric columns (default: 0.08)
+        col_max_frac: Maximum column width as fraction of table width for numeric columns (default: 0.15)
+
+    Returns:
+        None
+
+    Notes:
+        - The "Name" column is automatically left-aligned and gets 18-30% of table width
+        - Numeric columns are center-aligned and constrained to 8-15% of table width
+        - All three material table types (LEM, SEEP, FEM) use the same sizing parameters
+    """
+    # Force draw to get a valid renderer
+    try:
+        ax.figure.canvas.draw()
+        renderer = ax.figure.canvas.get_renderer()
+    except Exception:
+        renderer = None
+
+    ncols = len(col_labels)
+    nrows = len(table_data) + 1  # include header
+    # Measure text widths per column in pixels
+    widths_px = [1.0] * ncols
+    if renderer is not None:
+        for c in range(ncols):
+            max_w = 1.0
+            for r in range(nrows):
+                cell = table[(r, c)]
+                text = cell.get_text()
+                try:
+                    bbox = text.get_window_extent(renderer=renderer)
+                    max_w = max(max_w, bbox.width)
+                except Exception:
+                    pass
+            widths_px[c] = max_w
+    total_w = sum(widths_px) if sum(widths_px) > 0 else float(ncols)
+    col_fracs = [w / total_w for w in widths_px]
+    # Clamp extreme column widths to keep numeric columns from becoming too wide
+    clamped = []
+    for i, frac in enumerate(col_fracs):
+        label = str(col_labels[i]).lower()
+        min_frac = col_min_frac
+        max_frac = col_max_frac
+        if label == "name":
+            min_frac = 0.18
+            max_frac = 0.30
+        clamped.append(min(max(frac, min_frac), max_frac))
+    # Re-normalize to sum to 1.0
+    s = sum(clamped)
+    if s > 0:
+        col_fracs = [c / s for c in clamped]
+    # Compute per-row pixel heights based on text extents, convert to axes fraction
+    axes_h_px = None
+    if renderer is not None:
+        try:
+            axes_h_px = ax.get_window_extent(renderer=renderer).height
+        except Exception:
+            axes_h_px = None
+    # Fallback axes height if needed (avoid division by zero)
+    if not axes_h_px or axes_h_px <= 0:
+        axes_h_px = 800.0  # arbitrary but reasonable default
+    row_heights_frac = []
+    for r in range(nrows):
+        max_h_px = 1.0
+        if renderer is not None:
+            for c in range(ncols):
+                try:
+                    bbox = table[(r, c)].get_text().get_window_extent(renderer=renderer)
+                    max_h_px = max(max_h_px, bbox.height)
+                except Exception:
+                    pass
+        # padding factor to provide breathing room around text
+        padded_px = max_h_px * row_pad
+        # Convert to axes fraction with minimum clamp
+        rh = max(padded_px / axes_h_px, min_row_frac)
+        row_heights_frac.append(rh)
+
+    # Apply column widths and per-row heights
+    for r in range(nrows):
+        for c in range(ncols):
+            cell = table[(r, c)]
+            cell.set_width(table_width * col_fracs[c])
+            cell.set_height(row_heights_frac[r])
+            # Left-align the "Name" column if present
+            label = str(col_labels[c]).lower()
+            if label == "name":
+                cell.get_text().set_ha('left')
 
 def plot_base_stresses(ax, slice_df, scale_frac=0.5, alpha=0.3):
     """
@@ -649,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
@@ -717,7 +1227,19 @@ def plot_reinforcement_lines(ax, slope_data):
                 tension_points_plotted = True
 
 
-def plot_inputs(slope_data, title="Slope Geometry and Inputs", figsize=(12, 6), mat_table=True, save_png=False, dpi=300):
+def plot_inputs(
+    slope_data,
+    title="Slope Geometry and Inputs",
+    figsize=(12, 6),
+    mat_table=True,
+    save_png=False,
+    dpi=300,
+    mode="lem",
+    tab_loc="upper left",
+    legend_ncol="auto",
+    legend_max_cols=6,
+    legend_max_rows=4,
+):
     """
     Creates a plot showing the slope geometry and input parameters.
 
@@ -726,11 +1248,32 @@ def plot_inputs(slope_data, title="Slope Geometry and Inputs", figsize=(12, 6),
         title: Title for the plot
         figsize: Tuple of (width, height) in inches for the plot
         mat_table: Controls material table display. Can be:
-            - True: Auto-position material table to avoid overlaps
+            - True: Use tab_loc for positioning (default)
             - False: Don't show material table
-            - 'auto': Auto-position material table to avoid overlaps
-            - String: Specific location for material table ('upper left', 'upper right', 'upper center',
-                     'lower left', 'lower right', 'lower center', 'center left', 'center right', 'center')
+            - 'auto': Use tab_loc for positioning
+            - String: Specific location from valid placements (see tab_loc)
+        save_png: If True, save plot as PNG file (default: False)
+        dpi: Resolution for saved PNG file (default: 300)
+        mode: Which material properties table to display:
+            - "lem": Limit equilibrium materials (γ, c, φ, optional d/ψ)
+            - "seep": Seepage properties (k₁, k₂, Angle, kr₀, h₀)
+            - "fem": FEM properties (γ, c, φ, E, ν)
+        tab_loc: Table placement when mat_table is True or 'auto'. Valid options:
+            - "upper left": Top-left corner of plot area
+            - "upper right": Top-right corner of plot area
+            - "upper center": Top-center of plot area
+            - "lower left": Bottom-left corner of plot area
+            - "lower right": Bottom-right corner of plot area
+            - "lower center": Bottom-center of plot area
+            - "center left": Middle-left of plot area
+            - "center right": Middle-right of plot area
+            - "center": Center of plot area
+            - "top": Above plot area, horizontally centered
+        legend_ncol: Legend column count. Use "auto" (default) to choose a value that
+            keeps the legend from getting too tall, or pass an int to force a width.
+        legend_max_cols: When legend_ncol="auto", cap the number of columns (default: 6).
+        legend_max_rows: When legend_ncol="auto", try to keep legend rows <= this value
+            by increasing columns (default: 4).
 
     Returns:
         None
@@ -738,9 +1281,11 @@ def plot_inputs(slope_data, title="Slope Geometry and Inputs", figsize=(12, 6),
     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":
+        plot_seepage_bc_lines(ax, slope_data)
     plot_dloads(ax, slope_data)
     plot_tcrack_surface(ax, slope_data['tcrack_surface'])
     plot_reinforcement_lines(ax, slope_data)
@@ -752,32 +1297,116 @@ def plot_inputs(slope_data, title="Slope Geometry and Inputs", figsize=(12, 6),
 
     # Handle material table display
     if mat_table:
-        if isinstance(mat_table, str) and mat_table != 'auto':
-            # Convert location string to xloc, yloc coordinates (inside plot area with margins)
-            location_map = {
-                'upper left': (0.05, 0.70),
-                'upper right': (0.70, 0.70),
+        # Helpers to adapt slope_data materials into formats expected by table functions
+        def _build_seep_data():
+            materials = slope_data.get('materials', [])
+            return {
+                "k1_by_mat": [m.get('k1', 0.0) for m in materials],
+                "k2_by_mat": [m.get('k2', 0.0) for m in materials],
+                "angle_by_mat": [m.get('alpha', 0.0) for m in materials],
+                "kr0_by_mat": [m.get('kr0', 0.0) for m in materials],
+                "h0_by_mat": [m.get('h0', 0.0) for m in materials],
+                "material_names": [m.get('name', f"Material {i+1}") for i, m in enumerate(materials)],
+            }
+
+        def _build_fem_data():
+            materials = slope_data.get('materials', [])
+            return {
+                "c_by_mat": [m.get('c', 0.0) for m in materials],
+                "phi_by_mat": [m.get('phi', 0.0) for m in materials],
+                "E_by_mat": [m.get('E', 0.0) for m in materials],
+                "nu_by_mat": [m.get('nu', 0.0) for m in materials],
+                "gamma_by_mat": [m.get('gamma', 0.0) for m in materials],
+                "material_names": [m.get('name', f"Material {i+1}") for i, m in enumerate(materials)],
+            }
+
+        def _estimate_table_dims():
+            """Estimate table dimensions based on mode and materials."""
+            materials = slope_data.get('materials', [])
+            num_rows = max(1, len(materials))
+
+            if mode == "lem":
+                has_d_psi = any(mat.get('d', 0) > 0 or mat.get('psi', 0) > 0 for mat in materials)
+                width = 0.25 if has_d_psi else 0.2
+                height = min(0.35, 0.06 + 0.035 * num_rows)
+            elif mode == "fem":
+                width = 0.60
+                height = min(0.32, 0.06 + 0.035 * num_rows)
+            elif mode == "seep":
+                width = 0.45
+                height = min(0.50, 0.10 + 0.06 * num_rows)
+            else:
+                raise ValueError(f"Unknown mode '{mode}'. Expected one of: 'lem', 'seep', 'fem'.")
+
+            return width, height
+
+        def _plot_table(ax, xloc, yloc):
+            """Plot the appropriate material table based on mode."""
+            if mode == "lem":
+                plot_lem_material_table(ax, slope_data['materials'], xloc=xloc, yloc=yloc)
+            elif mode == "seep":
+                plot_seep_material_table(ax, _build_seep_data(), xloc=xloc, yloc=yloc)
+            elif mode == "fem":
+                width, height = _estimate_table_dims()
+                plot_fem_material_table(ax, _build_fem_data(), xloc=xloc, yloc=yloc, width=width, height=height)
+
+        def _calculate_position(location, margin=0.03):
+            """Calculate xloc, yloc for a given location string."""
+            width, height = _estimate_table_dims()
+
+            # Location map with default coordinates
+            position_map = {
+                'upper left': (margin, max(0.0, 1.0 - margin - height)),
+                'upper right': (max(0.0, 1.0 - width - margin), max(0.0, 1.0 - margin - height)),
                 'upper center': (0.35, 0.70),
                 'lower left': (0.05, 0.05),
                 'lower right': (0.70, 0.05),
                 'lower center': (0.35, 0.05),
                 'center left': (0.05, 0.35),
                 'center right': (0.70, 0.35),
-                'center': (0.35, 0.35)
+                'center': (0.35, 0.35),
+                'top': ((1.0 - width) / 2.0, 1.16)
             }
-            if mat_table in location_map:
-                xloc, yloc = location_map[mat_table]
-                plot_material_table(ax, slope_data['materials'], xloc=xloc, yloc=yloc)
-            else:
-                # Default to upper right if invalid location
-                plot_material_table(ax, slope_data['materials'], xloc=0.75, yloc=0.75)
-        else:
-            # Auto-position or default: find best location
-            plot_elements_bounds = get_plot_elements_bounds(ax, slope_data)
-            xloc, yloc = find_best_table_position(ax, slope_data['materials'], plot_elements_bounds)
-            plot_material_table(ax, slope_data['materials'], xloc=xloc, yloc=yloc)
+
+            return position_map.get(location, position_map['upper right'])
+
+        # Determine which location to use
+        placement = mat_table if isinstance(mat_table, str) and mat_table != 'auto' else tab_loc
+
+        # Validate placement
+        valid_placements = ['upper left', 'upper right', 'upper center', 'lower left',
+                          'lower right', 'lower center', 'center left', 'center right', 'center', 'top']
+        if placement not in valid_placements:
+            raise ValueError(f"Unknown placement '{placement}'. Expected one of: {', '.join(valid_placements)}.")
+
+        # Calculate position and plot table
+        xloc, yloc = _calculate_position(placement)
+        _plot_table(ax, xloc, yloc)
+
+        # Adjust y-limits to prevent table overlap with plot data
+        if placement in ("upper left", "upper right", "upper center"):
+            _, height = _estimate_table_dims()
+            margin = 0.03
+            bottom_fraction = max(0.0, 1.0 - margin - height)
+
+            y_min_curr, y_max_curr = ax.get_ylim()
+            y_range = y_max_curr - y_min_curr
+            if y_range > 0:
+                elem_bounds = get_plot_elements_bounds(ax, slope_data)
+                if elem_bounds:
+                    y_top = max(b[3] for b in elem_bounds)
+                    y_norm = (y_top - y_min_curr) / y_range
+                    if y_norm >= bottom_fraction and bottom_fraction > 0:
+                        y_max_new = y_min_curr + (y_top - y_min_curr) / bottom_fraction
+                        ax.set_ylim(y_min_curr, y_max_new)
 
     ax.set_aspect('equal')  # ✅ Equal aspect
+
+    # Add a bit of headroom so plotted lines/markers don't touch the top border
+    y0, y1 = ax.get_ylim()
+    if y1 > y0:
+        pad = 0.05 * (y1 - y0)
+        ax.set_ylim(y0, y1 + pad)
     ax.set_xlabel("x")
     ax.set_ylabel("y")
     ax.grid(False)
@@ -791,16 +1420,38 @@ def plot_inputs(slope_data, title="Slope Geometry and Inputs", figsize=(12, 6),
         handles.append(dummy_line)
         labels.append('Distributed Load')
     
+    # --- Legend layout ---
+    # Historically this legend used ncol=2 and was anchored below the axes.
+    # If there are many entries, that makes the legend tall and it can fall
+    # off the bottom of the window. We auto-increase columns to cap row count,
+    # and we also reserve bottom margin so the legend stays visible.
+    n_items = len(labels)
+    if legend_ncol == "auto":
+        # Choose enough columns to keep row count <= legend_max_rows (as best we can),
+        # but never exceed legend_max_cols.
+        required_cols = max(1, math.ceil(n_items / max(1, int(legend_max_rows))))
+        ncol = min(int(legend_max_cols), required_cols)
+        # Keep at least 2 columns once there's more than one entry (matches prior look).
+        if n_items > 1:
+            ncol = max(2, ncol)
+    else:
+        ncol = max(1, int(legend_ncol))
+
+    n_rows = max(1, math.ceil(n_items / max(1, ncol)))
+    # Reserve a bit more space as the legend grows so it doesn't get clipped.
+    bottom_margin = min(0.45, 0.10 + 0.04 * n_rows)
+
     ax.legend(
         handles=handles,
         labels=labels,
-        loc='upper center',
+        loc="upper center",
         bbox_to_anchor=(0.5, -0.12),
-        ncol=2
+        ncol=ncol,
     )
 
     ax.set_title(title)
 
+    plt.subplots_adjust(bottom=bottom_margin)
     plt.tight_layout()
     
     if save_png:
@@ -830,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)
@@ -892,6 +1543,8 @@ def plot_solution(slope_data, slice_df, failure_surface, results, figsize=(12, 7
         title = f'Corps Engineers: FS = {fs:.3f}, θ = {theta:.2f}°'
     elif method == 'lowe_karafiath':
         title = f'Lowe & Karafiath: FS = {fs:.3f}'
+    else:
+        title = f'{method}: FS = {fs:.3f}'
     ax.set_title(title)
 
     # zoom y‐axis to just cover the slope and depth, with a little breathing room (thrust line can be outside)
@@ -980,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)
@@ -1026,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)
@@ -1093,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)
@@ -1360,26 +2013,56 @@ def plot_mesh(mesh, materials=None, figsize=(14, 6), pad_frac=0.05, show_nodes=T
     plt.show()
 
 
-def plot_polygons(polygons, 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]
-        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)
+        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 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 {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)
     ax.set_xlabel('X Coordinate')
     ax.set_ylabel('Y Coordinate')
     ax.set_title(title)
-    ax.legend()
+    if legend:
+        ax.legend()
     ax.grid(True, alpha=0.3)
     ax.set_aspect('equal')
     plt.tight_layout()
@@ -1391,35 +2074,51 @@ def plot_polygons(polygons, title="Material Zone Polygons", save_png=False, dpi=
     plt.show()
 
 
-def plot_polygons_separately(polygons, title_prefix='Material Zone', save_png=False, dpi=300):
+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
-        title_prefix: Prefix for each subplot title
+        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.
     """
     import matplotlib.pyplot as plt
     
     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')
-        ax.set_title(f'{title_prefix} {i}')
+        mat_name = None
+        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 {mat_idx}: {mat_name}')
+        else:
+            ax.set_title(f'Material {mat_idx}')
         ax.grid(True, alpha=0.3)
         ax.set_aspect('equal')
-        ax.legend()
+        # Intentionally no legend: these plots are typically used for debugging geometry,
+        # and legends can obscure key vertices/edges.
     plt.tight_layout()
     
     if save_png:
-        filename = 'plot_' + title_prefix.lower().replace(' ', '_').replace(':', '').replace(',', '') + '_separate.png'
+        filename = 'plot_polygons_separately.png'
         plt.savefig(filename, dpi=dpi, bbox_inches='tight')
     
     plt.show()
@@ -1500,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