xslope 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

xslope/mesh.py

@@ -1235,14 +1235,8 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         if max_depth is None:
             raise ValueError("When using only 1 profile line, max_depth must be specified")
 
-    def get_avg_y(line):
-        return sum(y for _, y in line) / len(line)
-
-    # Sort profile lines from top to bottom by average y
-    sorted_lines = sorted(profile_lines, key=get_avg_y, reverse=True)
-    n = len(sorted_lines)
-    # Deep copy so we can insert points
-    lines = [list(line) for line in copy.deepcopy(sorted_lines)]
+    n = len(profile_lines)
+    lines = [list(line) for line in copy.deepcopy(profile_lines)]
     tol = 1e-8
 
     for i in range(n - 1):
@@ -1282,7 +1276,7 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
                     if not found:
                         insert_idx = np.searchsorted(xs_lower, x_top)
                         lower.insert(insert_idx, (round(x_top, 6), round(y_proj, 6)))
-
+    
     def clean_polygon(poly, tol=1e-8):
         # Remove consecutive duplicate points (except for closing point)
         if not poly:
@@ -1304,38 +1298,267 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         ys_top = np.array(ys_top)
         left_x, left_y = xs_top[0], ys_top[0]
         right_x, right_y = xs_top[-1], ys_top[-1]
+        
+        # Initialize variables for debug output
+        lower_left_x = None
+        lower_right_x = None
+        proj_left_x = None
+        proj_right_x = None
+        bottom_cleaned = []
+        
+        # Initialize vertical edge points (used for intermediate points on vertical edges)
+        left_vertical_points = []  # Intermediate points on left vertical edge (bottom to top)
+        right_vertical_points = []  # Intermediate points on right vertical edge (top to bottom)
+        left_y_bot = -np.inf
+        right_y_bot = -np.inf
 
         if i < n - 1:
+            # Use the immediate next line as the lower boundary
             lower_line = lines[i + 1]
             xs_bot, ys_bot = zip(*lower_line)
             xs_bot = np.array(xs_bot)
             ys_bot = np.array(ys_bot)
-            # Project left and right endpoints vertically to lower profile
-            left_y_bot = np.interp(left_x, xs_bot, ys_bot)
-            right_y_bot = np.interp(right_x, xs_bot, ys_bot)
-            # Find all lower profile points between left_x and right_x (exclusive)
-            mask = (xs_bot > left_x) & (xs_bot < right_x)
-            xs_bot_in = xs_bot[mask]
-            ys_bot_in = ys_bot[mask]
-            # Build bottom boundary: right projection, lower profile points (right to left), left projection
+            lower_left_x = xs_bot[0]
+            lower_right_x = xs_bot[-1]
+            
+            # Collect actual points from all lower lines within the top line's x-range
+            # But only include a point if it's actually on the highest lower profile at that x
+            bottom_points = []  # List of (x, y, line_idx) tuples
+            
+            for j in range(i + 1, n):
+                lower_candidate = lines[j]
+                xs_cand = np.array([x for x, y in lower_candidate])
+                ys_cand = np.array([y for x, y in lower_candidate])
+                
+                # Only include points that are within the top line's x-range
+                mask = (xs_cand >= left_x - tol) & (xs_cand <= right_x + tol)
+                for x, y in zip(xs_cand[mask], ys_cand[mask]):
+                    # Check if this point is actually on the highest lower profile at this x
+                    # Compare with all other lower lines at this x-coordinate
+                    is_highest = True
+                    for k in range(i + 1, n):
+                        if k == j:
+                            continue
+                        other_line = lines[k]
+                        xs_other = np.array([x_o for x_o, y_o in other_line])
+                        ys_other = np.array([y_o for x_o, y_o in other_line])
+                        if xs_other[0] - tol <= x <= xs_other[-1] + tol:
+                            y_other = np.interp(x, xs_other, ys_other)
+                            if y_other > y + tol:  # Other line is higher
+                                is_highest = False
+                                break
+                    
+                    if is_highest:
+                        bottom_points.append((x, y, j))
+            
+            # Group by x-coordinate (within tolerance) and keep only the highest y at each x
+            # This handles cases where multiple lines have points at the same x
+            bottom_dict = {}  # x_key -> (y, line_idx, orig_x, orig_y)
+            for x, y, line_idx in bottom_points:
+                x_key = round(x / tol) * tol  # Round to tolerance to group nearby points
+                if x_key not in bottom_dict or y > bottom_dict[x_key][0]:
+                    bottom_dict[x_key] = (y, line_idx, x, y)
+            
+            # Convert to sorted list
+            bottom_cleaned = sorted([(orig_x, orig_y) for _, _, orig_x, orig_y in bottom_dict.values()])
+            
+            # Helper function to check if a point already exists in a list
+            def point_exists(point_list, x, y, tol=1e-8):
+                """Check if a point (x, y) already exists in the point list within tolerance."""
+                for px, py in point_list:
+                    if abs(px - x) < tol and abs(py - y) < tol:
+                        return True
+                return False
+            
+            # Helper function to find the lowest y value at a given x by checking all segments
+            def find_lowest_y_at_x(line_points, x_query, tol=1e-8):
+                """
+                Find the lowest y value at x_query by checking all segments of the line.
+                Handles vertical segments properly by finding all y values at that x and returning the minimum.
+                
+                Returns:
+                    tuple: (y_value, is_at_endpoint) where is_at_endpoint indicates if x_query is at an endpoint
+                """
+                if not line_points:
+                    return None, False
+                
+                xs = np.array([x for x, y in line_points])
+                ys = np.array([y for x, y in line_points])
+                
+                # Check if x_query is within the line's x-range
+                if xs[0] - tol > x_query or xs[-1] + tol < x_query:
+                    return None, False
+                
+                # Check if x_query is at an endpoint
+                is_at_left_endpoint = abs(x_query - xs[0]) < tol
+                is_at_right_endpoint = abs(x_query - xs[-1]) < tol
+                is_at_endpoint = is_at_left_endpoint or is_at_right_endpoint
+                
+                # Find all y values at x_query by checking all segments
+                y_values = []
+                
+                # Check all points that are exactly at x_query
+                for k in range(len(line_points)):
+                    if abs(xs[k] - x_query) < tol:
+                        y_values.append(ys[k])
+                
+                # Check all segments that contain x_query
+                for k in range(len(line_points) - 1):
+                    x1, y1 = line_points[k]
+                    x2, y2 = line_points[k + 1]
+                    
+                    # Check if segment is vertical and contains x_query
+                    if abs(x1 - x_query) < tol and abs(x2 - x_query) < tol:
+                        # Vertical segment - include both y values
+                        y_values.append(y1)
+                        y_values.append(y2)
+                    # Check if segment is horizontal or sloped and contains x_query
+                    elif min(x1, x2) - tol <= x_query <= max(x1, x2) + tol:
+                        # Interpolate y value
+                        if abs(x2 - x1) < tol:
+                            # Segment is vertical (should have been caught above, but just in case)
+                            y_values.append(y1)
+                            y_values.append(y2)
+                        else:
+                            # Linear interpolation
+                            t = (x_query - x1) / (x2 - x1)
+                            if 0 <= t <= 1:
+                                y_interp = y1 + t * (y2 - y1)
+                                y_values.append(y_interp)
+                
+                if not y_values:
+                    return None, False
+                
+                # Return the lowest y value
+                y_min = min(y_values)
+                return y_min, is_at_endpoint
+            
+            # Project endpoints - find highest lower profile or use max_depth
+            # When projecting right side: if intersection is at left end of lower line,
+            # add that point but continue projecting down
+            # When projecting left side: if intersection is at right end of lower line,
+            # add that point but continue projecting down
+            for j in range(i + 1, n):
+                lower_candidate = lines[j]
+                xs_cand = np.array([x for x, y in lower_candidate])
+                ys_cand = np.array([y for x, y in lower_candidate])
+                
+                # Check left endpoint projection
+                if xs_cand[0] - tol <= left_x <= xs_cand[-1] + tol:
+                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, left_x, tol)
+                    if y_cand is not None:
+                        # If intersection is at the right end of the lower line, add point but continue
+                        if is_at_endpoint and abs(left_x - xs_cand[-1]) < tol:  # At right endpoint
+                            # Only add if not duplicate of the endpoint being projected and not already in list
+                            if abs(y_cand - left_y) > tol and not point_exists(left_vertical_points, left_x, y_cand, tol):
+                                left_vertical_points.append((left_x, y_cand))
+                        else:  # Not at endpoint, use as stopping point
+                            if y_cand > left_y_bot:
+                                left_y_bot = y_cand
+                
+                # Check right endpoint projection
+                if xs_cand[0] - tol <= right_x <= xs_cand[-1] + tol:
+                    y_cand, is_at_endpoint = find_lowest_y_at_x(lower_candidate, right_x, tol)
+                    if y_cand is not None:
+                        # If intersection is at the left end of the lower line, add point but continue
+                        if is_at_endpoint and abs(right_x - xs_cand[0]) < tol:  # At left endpoint
+                            # Only add if not duplicate of the endpoint being projected and not already in list
+                            if abs(y_cand - right_y) > tol and not point_exists(right_vertical_points, right_x, y_cand, tol):
+                                right_vertical_points.append((right_x, y_cand))
+                        else:  # Not at endpoint, use as stopping point
+                            if y_cand > right_y_bot:
+                                right_y_bot = y_cand
+            
+            # If no lower profile at endpoints, use max_depth
+            if left_y_bot == -np.inf:
+                left_y_bot = max_depth if max_depth is not None else -np.inf
+            if right_y_bot == -np.inf:
+                right_y_bot = max_depth if max_depth is not None else -np.inf
+            
+            # Deduplicate vertical points (remove points that are too close to each other)
+            def deduplicate_points(points, tol=1e-8):
+                """Remove duplicate points within tolerance."""
+                if not points:
+                    return []
+                unique_points = [points[0]]
+                for p in points[1:]:
+                    # Check if this point is too close to any existing unique point
+                    is_duplicate = False
+                    for up in unique_points:
+                        if abs(p[0] - up[0]) < tol and abs(p[1] - up[1]) < tol:
+                            is_duplicate = True
+                            break
+                    if not is_duplicate:
+                        unique_points.append(p)
+                return unique_points
+            
+            right_vertical_points = deduplicate_points(right_vertical_points, tol)
+            left_vertical_points = deduplicate_points(left_vertical_points, tol)
+            
+            # Sort vertical points: right edge top to bottom, left edge bottom to top
+            right_vertical_points.sort(key=lambda p: -p[1])  # Sort by y descending (top to bottom)
+            left_vertical_points.sort(key=lambda p: p[1])    # Sort by y ascending (bottom to top)
+            
+            # Build bottom boundary: right projection, intermediate points (right to left), left projection
+            # The bottom should go from right to left to close the polygon
             bottom = []
-            bottom.append((right_x, right_y_bot))
-            for x, y in zip(xs_bot_in[::-1], ys_bot_in[::-1]):
-                bottom.append((x, y))
-            bottom.append((left_x, left_y_bot))
+            
+            # Start with right endpoint
+            if right_y_bot != -np.inf:
+                bottom.append((right_x, right_y_bot))
+            
+            # Add intermediate points in reverse order (right to left)
+            # Filter out points too close to endpoints
+            for x, y in reversed(bottom_cleaned):
+                if abs(x - left_x) > tol and abs(x - right_x) > tol:
+                    bottom.append((x, y))
+            
+            # End with left endpoint
+            if left_y_bot != -np.inf:
+                bottom.append((left_x, left_y_bot))
+            
+            # Store for debug output
+            proj_left_x = left_x
+            proj_right_x = right_x
         else:
             # For the lowest polygon, bottom is at max_depth
             # Only need endpoints - no intermediate points
+            left_y_bot = max_depth if max_depth is not None else -np.inf
+            right_y_bot = max_depth if max_depth is not None else -np.inf
             bottom = []
             bottom.append((right_x, max_depth))
             bottom.append((left_x, max_depth))
 
-        # Build polygon: top left-to-right, bottom right-to-left
+        # Build polygon: top left-to-right, right vertical edge (with intermediate points),
+        # bottom right-to-left, left vertical edge (with intermediate points)
         poly = []
+        
+        # Top edge: left to right along profile line
         for x, y in zip(xs_top, ys_top):
             poly.append((round(x, 6), round(y, 6)))
+        
+        # Right vertical edge: from (right_x, right_y) down to (right_x, right_y_bot)
+        # Include intermediate points where we intersect left endpoints of lower lines
+        # Note: (right_x, right_y_bot) will be added as part of the bottom edge, so don't add it here
+        if i < n - 1:
+            for x, y in right_vertical_points:
+                # Only add if it's between top and bottom (not duplicate of endpoints)
+                if abs(y - right_y) > tol and abs(y - right_y_bot) > tol:
+                    poly.append((round(x, 6), round(y, 6)))
+        
+        # Bottom edge: right to left (already includes (right_x, right_y_bot) and (left_x, left_y_bot))
         for x, y in bottom:
             poly.append((round(x, 6), round(y, 6)))
+        
+        # Left vertical edge: from (left_x, left_y_bot) up to (left_x, left_y)
+        # Include intermediate points where we intersect right endpoints of lower lines
+        # Note: (left_x, left_y_bot) was already added as part of the bottom edge
+        if i < n - 1:
+            for x, y in reversed(left_vertical_points):  # Reverse to go bottom to top
+                # Only add if it's between bottom and top (not duplicate of endpoints)
+                if abs(y - left_y_bot) > tol and abs(y - left_y) > tol:
+                    poly.append((round(x, 6), round(y, 6)))
+        
         # Clean up polygon (should rarely do anything)
         poly = clean_polygon(poly)
         polygons.append(poly)

xslope/plot.py

@@ -86,8 +86,10 @@ def plot_max_depth(ax, profile_lines, max_depth):
     x_max = max(x_vals)
     ax.hlines(max_depth, x_min, x_max, colors='black', linewidth=1.5, label='Max Depth')
 
-    spacing = 5
-    length = 4
+    x_diff = x_max - x_min
+    spacing = x_diff / 100
+    length = x_diff / 80
+
     angle_rad = np.radians(60)
     dx = length * np.cos(angle_rad)
     dy = length * np.sin(angle_rad)

{xslope-0.1.5.dist-info → xslope-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xslope
-Version: 0.1.5
+Version: 0.1.7
 Summary: Slope stability analysis (limit equilibrium and FEM) in Python.
 Author: Norman L. Jones
 Project-URL: Homepage, https://github.com/njones61/xslope

{xslope-0.1.5.dist-info → xslope-0.1.7.dist-info}/RECORD

@@ -1,20 +1,21 @@
 xslope/__init__.py,sha256=ZygAIkX6Nbjag1czWdQa-yP-GM1mBE_9ss21Xh__JFc,34
-xslope/_version.py,sha256=m--aui80RX-2veIS6xYj8NeTcDQvEfbRibez2Th5nKQ,50
+xslope/_version.py,sha256=Lc9xqzzg7cCgDTKs34dvk6NG0CArmowG_5qV27pZmSs,50
 xslope/advanced.py,sha256=35k_ekQJ-mQJ1wHnoIHMc5TVfYn-2EPCJyHz827Cpbc,18281
 xslope/fem.py,sha256=K4_Pq06HFBpRkN3JwtXF2zw_AMnCkXvj0ggrlRFMQQw,115731
 xslope/fileio.py,sha256=DnFUYmJedjKXOuVPZUfTRxGfTjiIz8KyHkRDK7ddQg0,28840
 xslope/global_config.py,sha256=Cj8mbPidIuj5Ty-5cZM-c8H12kNvyHsk5_ofNGez-3M,2253
-xslope/mesh.py,sha256=t3rD3H59epXeH-7RR_PDK7QUg13DRwl3qMRVERAhuv0,118744
-xslope/plot.py,sha256=rr1D-6KzYyJtq51o4yLyaFkowBa1LtygIk9rtA3GxgQ,54592
+xslope/mesh copy.py,sha256=qtMH1yKFgHM4kNuIrxco7tKV86R3Dbf7Nok5j6MtlLY,131013
+xslope/mesh.py,sha256=qtMH1yKFgHM4kNuIrxco7tKV86R3Dbf7Nok5j6MtlLY,131013
+xslope/plot.py,sha256=OW2eZyrT5h3Y95qjNFgGMnC_Am7TurUB2S7b_BgnO6E,54641
 xslope/plot_fem.py,sha256=al9zjqjxWKooLl4SAds77Zz-j9cjD4TJGygyU9QK5vo,71111
 xslope/plot_seep.py,sha256=3wbKp85cmK_6EniFnK9x-FaZtYBZ3KZbRn9U1GsInmk,28775
 xslope/search.py,sha256=dvgKn8JCobuvyD7fClF5lcbeHESCvV8gZ_U_lQnYRok,16867
 xslope/seep.py,sha256=zVX8NJOp8e6VJ6y99YLkmOh_RPQFly9Z9UI3tka6yQQ,85765
 xslope/slice.py,sha256=QHawTk7XPLziHoN_ZS0jrEPYKlhPT62caUc_q-_EGjs,45236
 xslope/solve.py,sha256=j7N66QBjBpDAo-aizTiP8auwd5Ey1SiYAYeySaMVzkw,48554
-xslope-0.1.5.dist-info/LICENSE,sha256=NU5J88FUai_4Ixu5DqOQukA-gcXAyX8pXLhIg8OB3AM,10969
-xslope-0.1.5.dist-info/METADATA,sha256=-s6Lcc-tEGy2KJhBcP5oZTOlRXjnLO9bq4D3Mx0uLIA,2027
-xslope-0.1.5.dist-info/NOTICE,sha256=E-sbN0MWwvJC27Z-2_G4VUHIx4IsfvLDTmOstvY4-OQ,530
-xslope-0.1.5.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-xslope-0.1.5.dist-info/top_level.txt,sha256=5qHbWJ1R2pdTNIainFyrVtFk8R1tRcwIn0kzTuwuV1Q,7
-xslope-0.1.5.dist-info/RECORD,,
+xslope-0.1.7.dist-info/LICENSE,sha256=NU5J88FUai_4Ixu5DqOQukA-gcXAyX8pXLhIg8OB3AM,10969
+xslope-0.1.7.dist-info/METADATA,sha256=9oE9ygroQ0pg5sj1iz3KZ4GxKCUYg0N2oNDh9Kks6jI,2027
+xslope-0.1.7.dist-info/NOTICE,sha256=E-sbN0MWwvJC27Z-2_G4VUHIx4IsfvLDTmOstvY4-OQ,530
+xslope-0.1.7.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+xslope-0.1.7.dist-info/top_level.txt,sha256=5qHbWJ1R2pdTNIainFyrVtFk8R1tRcwIn0kzTuwuV1Q,7
+xslope-0.1.7.dist-info/RECORD,,