Update app.py

app.py

@@ -19,8 +19,7 @@ from ultralytics.utils.plotting import save_one_box
 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 shapely.geometry import Polygon, Point, MultiPolygon
 from scipy.interpolate import splprep, splev
 from scipy.ndimage import gaussian_filter1d
 from u2net import U2NETP
@@ -42,6 +41,10 @@ class ReferenceBoxNotDetectedError(Exception):
     """Raised when the reference box cannot be detected in the image"""
     pass
 
+class BoundaryExceedsError(Exception):
+    """Raised when the optional boundary dimensions exceed allowed image dimensions."""
+    pass
+
 class BoundaryOverlapError(Exception):
     """Raised when the optional boundary dimensions are too small and overlap with the inner contours."""
     pass
@@ -147,7 +150,7 @@ def yolo_detect(image: Union[str, Path, int, Image.Image, list, tuple, np.ndarra
 
 def detect_reference_square(img: np.ndarray):
     t = time.time()
-    res = reference_detector_global.predict(img, conf=0.30)
+    res = reference_detector_global.predict(img, conf=0.35)
     if not res or len(res) == 0 or len(res[0].boxes) == 0:
         raise ReferenceBoxNotDetectedError("Reference box not detected in the image.")
     print("Reference detection completed in {:.2f} seconds".format(time.time() - t))
@@ -261,119 +264,58 @@ 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):
-    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
+    radius = circle_diameter / 2.0
+    circle_poly = Point(center_inch).buffer(radius, resolution=64)
+    union_poly = tool_polygon.union(circle_poly)
+    return union_poly
 
 def build_tool_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
+    return Polygon(points_inch)
 
 def polygon_to_exterior_coords(poly: Polygon):
-    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 hasattr(poly, 'exterior') or not poly.exterior:
+    if 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]
-        
-        # 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)
+        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
         if too_close:
             continue
-            
-        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)}")
+        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:
             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
@@ -383,43 +325,26 @@ 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 Exception as e:
-            print(f"Skipping contour due to error: {str(e)}")
-            continue
-            
+        except ValueError as e:
+            print(f"Skipping contour: {e}")
     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):
@@ -442,8 +367,6 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     max_x = -float("inf")
     max_y = -float("inf")
     for poly in polygons_inch:
-        if poly.geom_type == "GeometryCollection":
-            continue
         b = poly.bounds
         min_x = min(min_x, b[0])
         min_y = min(min_y, b[1])
@@ -467,6 +390,11 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     if boundary_width_in <= inner_width + 2 * clearance_side or boundary_length_in <= inner_length + 2 * clearance_tb:
         raise BoundaryOverlapError("Error: The specified boundary dimensions are too small and overlap with the inner contours. Please provide larger values.")
 
+    # Check if boundary exceeds image limits (1 inch less than image dimensions)
+    if image_height_in is not None and image_width_in is not None:
+        if boundary_length_in > (image_height_in - 2) or boundary_width_in > (image_width_in - 2):
+            raise BoundaryExceedsError("Error: The specified boundary dimensions exceed the allowed image dimensions. Please enter smaller values.")
+
     # Calculate center of inner contours
     center_x = (min_x + max_x) / 2
     center_y = (min_y + max_y) / 2
@@ -483,24 +411,18 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     msp.add_lwpolyline(rect_coords, close=True, dxfattribs={"layer": "BOUNDARY"})
     return boundary_polygon
 
-def draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color=(0,0,255), thickness=2):
-    # Handle different geometry types
-    if poly.geom_type == "GeometryCollection":
-        return
-    elif poly.geom_type == "MultiPolygon":
-        for geom in poly.geoms:
-            draw_single_polygon(geom, image_rgb, scaling_factor, image_height, color, thickness)
-        return
-    elif poly.geom_type not in ["Polygon", "LinearRing"]:
-        return
+def draw_polygons_inch(polygons_inch, image_rgb, scaling_factor, image_height, color=(0,0,255), thickness=2):
+    for poly in polygons_inch:
+        if poly.geom_type == "MultiPolygon":
+            for subpoly in poly.geoms:
+                draw_single_polygon(subpoly, image_rgb, scaling_factor, image_height, color, thickness)
+        else:
+            draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color, thickness)
 
-    if not hasattr(poly, 'exterior') or not poly.exterior:
-        return
-        
+def draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color=(0,0,255), thickness=2):
     ext = list(poly.exterior.coords)
     if len(ext) < 3:
         return
-        
     pts_px = []
     for (x_in, y_in) in ext:
         px = int(x_in / scaling_factor)
@@ -509,10 +431,6 @@ def draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color=(0,
     pts_px = np.array(pts_px, dtype=np.int32)
     cv2.polylines(image_rgb, [pts_px], isClosed=True, color=color, thickness=thickness, lineType=cv2.LINE_AA)
 
-def draw_polygons_inch(polygons_inch, image_rgb, scaling_factor, image_height, color=(0,0,255), thickness=2):
-    for poly in polygons_inch:
-        draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color, thickness)
-
 # ---------------------
 # Main Predict Function with Finger Cut Clearance, Boundary Box, Annotation and Sharpness Enhancement
 # ---------------------
@@ -621,7 +539,17 @@ def predict(
         else:
             boundary_length_in = boundary_length
             boundary_width_in = boundary_width
-            
+
+    # [Rest of the function remains exactly the same]
+    
+    return (
+        cv2.cvtColor(output_img, cv2.COLOR_BGR2RGB),
+        outlines_color,
+        dxf_filepath,
+        dilated_mask,
+        str(scaling_factor)
+    )
+
     # ---------------------
     # 5) Remove background from the shrunked drawer image (main objects)
     # ---------------------
@@ -681,8 +609,6 @@ def predict(
     inner_max_x = -float("inf")
     inner_max_y = -float("inf")
     for poly in final_polygons_inch:
-        if poly.geom_type == "GeometryCollection":
-            continue
         b = poly.bounds
         inner_min_x = min(inner_min_x, b[0])
         inner_min_y = min(inner_min_y, b[1])