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

xslope/mesh.py

@@ -1305,6 +1305,12 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         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
@@ -1356,21 +1362,112 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
             # 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
-            left_y_bot = -np.inf
-            right_y_bot = -np.inf
+            # 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 = np.interp(left_x, xs_cand, ys_cand)
-                    if y_cand > left_y_bot:
-                        left_y_bot = y_cand
+                    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 = np.interp(right_x, xs_cand, ys_cand)
-                    if y_cand > right_y_bot:
-                        right_y_bot = y_cand
+                    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:
@@ -1378,6 +1475,30 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
             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 = []
@@ -1402,16 +1523,42 @@ def build_polygons(slope_data, reinf_lines=None, debug=False):
         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.6.dist-info → xslope-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xslope
-Version: 0.1.6
+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.6.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=El5otyOm5tn7_NTNUcawnWQ_lZMwfYOTw_-GGhANHSI,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=OhaAMlunbO86Sx4iF5sRsk4eEN7-AG-_TYPUvYVTGA4,122513
-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.6.dist-info/LICENSE,sha256=NU5J88FUai_4Ixu5DqOQukA-gcXAyX8pXLhIg8OB3AM,10969
-xslope-0.1.6.dist-info/METADATA,sha256=8eM1VvzchbN-xSlSrTzbRMX86Vy2L3WDUVrdt3_BJq4,2027
-xslope-0.1.6.dist-info/NOTICE,sha256=E-sbN0MWwvJC27Z-2_G4VUHIx4IsfvLDTmOstvY4-OQ,530
-xslope-0.1.6.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-xslope-0.1.6.dist-info/top_level.txt,sha256=5qHbWJ1R2pdTNIainFyrVtFk8R1tRcwIn0kzTuwuV1Q,7
-xslope-0.1.6.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,,