Update app.py

app.py

@@ -20,6 +20,7 @@ from transformers import AutoModelForImageSegmentation
 from torchvision import transforms
 from scalingtestupdated import calculate_scaling_factor
 from shapely.geometry import Polygon, Point, MultiPolygon, GeometryCollection
+from shapely.validation import make_valid
 from scipy.interpolate import splprep, splev
 from scipy.ndimage import gaussian_filter1d
 from u2net import U2NETP
@@ -260,60 +261,119 @@ def extract_outlines(binary_image: np.ndarray) -> (np.ndarray, list):
 # ---------------------
 # Functions for Finger Cut Clearance
 # ---------------------
+def validate_and_fix_geometry(geom):
+    """Ensure geometry is valid and convert to Polygon if possible"""
+    if geom is None or geom.is_empty:
+        return None
+        
+    if not geom.is_valid:
+        geom = make_valid(geom)
+    
+    # Handle GeometryCollections by extracting the largest valid polygon
+    if geom.geom_type == "GeometryCollection":
+        polygons = [g for g in geom.geoms if g.geom_type in ['Polygon', 'MultiPolygon']]
+        if not polygons:
+            return None
+        # Get the largest polygon by area
+        largest = max(polygons, key=lambda g: g.area)
+        geom = largest
+    
+    # Convert MultiPolygon to single Polygon using convex hull if needed
+    if geom.geom_type == "MultiPolygon":
+        geom = geom.convex_hull
+        
+    if geom.geom_type != 'Polygon':
+        return None
+        
+    return geom
+
 def union_tool_and_circle(tool_polygon: Polygon, center_inch, circle_diameter=1.0):
-    radius = circle_diameter / 2.0
-    circle_poly = Point(center_inch).buffer(radius, resolution=64)
-    union_poly = tool_polygon.union(circle_poly)
-    return union_poly
+    try:
+        radius = circle_diameter / 2.0
+        circle_poly = Point(center_inch).buffer(radius, resolution=64)
+        tool_polygon = validate_and_fix_geometry(tool_polygon)
+        if tool_polygon is None:
+            return None, None
+            
+        union_poly = tool_polygon.union(circle_poly)
+        union_poly = validate_and_fix_geometry(union_poly)
+        return union_poly, center_inch
+    except Exception as e:
+        print(f"Error in union_tool_and_circle: {str(e)}")
+        return None, None
 
 def build_tool_polygon(points_inch):
-    return Polygon(points_inch)
+    try:
+        if len(points_inch) < 3:
+            return None
+        poly = Polygon(points_inch)
+        return validate_and_fix_geometry(poly)
+    except Exception as e:
+        print(f"Error building tool polygon: {str(e)}")
+        return None
 
 def polygon_to_exterior_coords(poly: Polygon):
-    if poly.geom_type == "GeometryCollection":
+    poly = validate_and_fix_geometry(poly)
+    if poly is None:
         return []
+        
     if poly.geom_type == "MultiPolygon":
         biggest = max(poly.geoms, key=lambda g: g.area)
         poly = biggest
-    if not poly.exterior:
+        
+    if not hasattr(poly, 'exterior') or not poly.exterior:
         return []
+        
     return list(poly.exterior.coords)
 
 def place_finger_cut_randomly(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.25, max_attempts=30):
     import random
     needed_center_distance = circle_diameter + min_gap
     radius = circle_diameter / 2.0
+    
+    tool_polygon = validate_and_fix_geometry(tool_polygon)
+    if tool_polygon is None:
+        return None, None
+        
     for _ in range(max_attempts):
         idx = random.randint(0, len(points_inch) - 1)
         cx, cy = points_inch[idx]
-        too_close = False
-        for (ex_x, ex_y) in existing_centers:
-            if np.hypot(cx - ex_x, cy - ex_y) < needed_center_distance:
-                too_close = True
-                break
+        
+        # Check distance to existing centers
+        too_close = any(np.hypot(cx - ex_x, cy - ex_y) < needed_center_distance 
+                    for (ex_x, ex_y) in existing_centers)
         if too_close:
             continue
-        circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
-        union_poly = tool_polygon.union(circle_poly)
-        overlap_with_others = False
-        too_close_to_others = False
-        for poly in all_polygons:
-            if union_poly.intersects(poly):
-                overlap_with_others = True
-                break
-            if circle_poly.buffer(min_gap).intersects(poly):
-                too_close_to_others = True
-                break
-        if overlap_with_others or too_close_to_others:
+            
+        try:
+            circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
+            union_poly = tool_polygon.union(circle_poly)
+            union_poly = validate_and_fix_geometry(union_poly)
+            
+            if union_poly is None:
+                continue
+                
+            # Check for overlaps
+            overlap = False
+            for poly in all_polygons:
+                if union_poly.intersects(poly):
+                    overlap = True
+                    break
+                if circle_poly.buffer(min_gap).intersects(poly):
+                    overlap = True
+                    break
+                    
+            if not overlap:
+                existing_centers.append((cx, cy))
+                return union_poly, (cx, cy)
+                
+        except Exception as e:
+            print(f"Error placing finger cut: {str(e)}")
             continue
-        existing_centers.append((cx, cy))
-        return union_poly, (cx, cy)
+            
     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
     return None, None
 
-# ---------------------
-# DXF Spline and Boundary Functions
-# ---------------------
 def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
     degree = 3
     closed = True
@@ -323,26 +383,43 @@ def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=
     msp = doc.modelspace()
     finger_cut_centers = []
     final_polygons_inch = []
+    
     for contour in inflated_contours:
         try:
             resampled_contour = resample_contour(contour)
-            points_inch = [(x * scaling_factor, (height - y) * scaling_factor) for x, y in resampled_contour]
+            points_inch = [(x * scaling_factor, (height - y) * scaling_factor) 
+                          for x, y in resampled_contour]
+            
             if len(points_inch) < 3:
                 continue
+                
             if np.linalg.norm(np.array(points_inch[0]) - np.array(points_inch[-1])) > 1e-2:
                 points_inch.append(points_inch[0])
+                
             tool_polygon = build_tool_polygon(points_inch)
+            if tool_polygon is None:
+                continue
+                
             if finger_clearance:
-                union_poly, center = place_finger_cut_randomly(tool_polygon, points_inch, finger_cut_centers, final_polygons_inch, circle_diameter=1.0, min_gap=0.25, max_attempts=30)
+                union_poly, center = place_finger_cut_randomly(
+                    tool_polygon, points_inch, finger_cut_centers, 
+                    final_polygons_inch, circle_diameter=1.0, 
+                    min_gap=0.25, max_attempts=30
+                )
                 if union_poly is not None:
                     tool_polygon = union_poly
+                    
             exterior_coords = polygon_to_exterior_coords(tool_polygon)
             if len(exterior_coords) < 3:
                 continue
+                
             msp.add_spline(exterior_coords, degree=degree, dxfattribs={"layer": "TOOLS"})
             final_polygons_inch.append(tool_polygon)
-        except ValueError as e:
-            print(f"Skipping contour: {e}")
+            
+        except Exception as e:
+            print(f"Skipping contour due to error: {str(e)}")
+            continue
+            
     return doc, final_polygons_inch
 
 def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width, offset_unit, annotation_text="", image_height_in=None, image_width_in=None):