Update app.py

app.py

@@ -53,8 +53,7 @@ class BoundaryOverlapError(Exception):
 class TextOverlapError(Exception):
     """Raised when the text overlaps with the inner contours (with a margin of 0.75)."""
     pass
-class boundary_issue(Exception):
-    """Raised when bounds are given but rectangular boundary is no."""
+
 # ---------------------
 # Global Model Initialization with caching and print statements
 # ---------------------
@@ -159,7 +158,7 @@ def detect_reference_square(img: np.ndarray):
     res = reference_detector_global.predict(img, conf=0.3)
     if not res or len(res) == 0 or len(res[0].boxes) == 0:
         raise ReferenceBoxNotDetectedError("Reference Coin not detected in the image.")
-    print("Reference detection completed in {:.2f} seconds".format(time.time() - t))
+    print("Reference coin detection completed in {:.2f} seconds".format(time.time() - t))
     return (
         save_one_box(res[0].cpu().boxes.xyxy, res[0].orig_img, save=False),
         res[0].cpu().boxes.xyxy[0]
@@ -244,88 +243,238 @@ def exclude_scaling_box(image: np.ndarray, bbox: np.ndarray, orig_size: tuple, p
     image[expanded_y_min:expanded_y_max, expanded_x_min:expanded_x_max] = 0
     return image
 
-def resample_contour(contour):
-    num_points = 1000
-    smoothing_factor = 5
-    spline_degree = 3
-    if len(contour) < spline_degree + 1:
-        raise ValueError(f"Contour must have at least {spline_degree + 1} points, but has {len(contour)} points.")
-    contour = contour[:, 0, :]
-    tck, _ = splprep([contour[:, 0], contour[:, 1]], s=smoothing_factor)
-    u = np.linspace(0, 1, num_points)
-    resampled_points = splev(u, tck)
-    smoothed_x = gaussian_filter1d(resampled_points[0], sigma=1)
-    smoothed_y = gaussian_filter1d(resampled_points[1], sigma=1)
-    return np.array([smoothed_x, smoothed_y]).T
+# def resample_contour(contour):
+#     num_points = 1000
+#     smoothing_factor = 5
+#     spline_degree = 3
+#     if len(contour) < spline_degree + 1:
+#         raise ValueError(f"Contour must have at least {spline_degree + 1} points, but has {len(contour)} points.")
+#     contour = contour[:, 0, :]
+#     tck, _ = splprep([contour[:, 0], contour[:, 1]], s=smoothing_factor)
+#     u = np.linspace(0, 1, num_points)
+#     resampled_points = splev(u, tck)
+#     smoothed_x = gaussian_filter1d(resampled_points[0], sigma=1)
+#     smoothed_y = gaussian_filter1d(resampled_points[1], sigma=1)
+#     return np.array([smoothed_x, smoothed_y]).T
+
+# # ---------------------
+# # Add the missing extract_outlines function
+# # ---------------------
+# def extract_outlines(binary_image: np.ndarray) -> (np.ndarray, list):
+#     contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+#     outline_image = np.zeros_like(binary_image)
+#     cv2.drawContours(outline_image, contours, -1, (255), thickness=2)
+#     return cv2.bitwise_not(outline_image), contours
+
+# # # ---------------------
+# # # Functions for Finger Cut Clearance
+# # # ---------------------
+# # 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
+
+
+
+
+# # def build_tool_polygon(points_inch):
+# #     return Polygon(points_inch)
+
+# # def polygon_to_exterior_coords(poly: Polygon):
+# #     if poly.geom_type == "MultiPolygon":
+# #         biggest = max(poly.geoms, key=lambda g: g.area)
+# #         poly = biggest
+# #     if not poly.exterior:
+# #         return []
+# #     return list(poly.exterior.coords)
+
+
+# # from shapely.geometry import Point, Polygon
+# # import numpy as np
+# # import random
+
+# # from shapely.geometry import Point, Polygon
+# # import numpy as np
+# # import random
+
+# # def place_finger_cut_adjusted(
+# #     tool_polygon: Polygon,
+# #     points_inch: list,
+# #     existing_centers: list,
+# #     all_polygons: list,
+# #     circle_diameter: float = 1.0,
+# #     min_gap: float = 0.5,
+# #     max_attempts: int = 100
+# # ) -> (Polygon, tuple):
+
+# #     needed_center_distance = circle_diameter + min_gap
+# #     radius = circle_diameter / 2.0
+# #     attempts = 0
+# #     timeout_secs = 10  # 100s timeout
+# #     start_time = time.perf_counter()
+# #     fallback_triggered = False
+
+# #     # Randomize candidate points order.
+# #     indices = list(range(len(points_inch)))
+# #     random.shuffle(indices)
+
+# #     while attempts < max_attempts and not fallback_triggered:
+# #         for i in indices:
+# #             if time.perf_counter() - start_time >= timeout_secs:
+# #                 fallback_triggered = True
+# #                 break
+# #             cx, cy = points_inch[i]
+# #             # Try small adjustments around the candidate point.
+# #             for dx in np.linspace(-0.3, 0.3, 7):  # adjust by ±0.3 inches in 7 steps
+# #                 for dy in np.linspace(-0.3, 0.3, 7):
+# #                     if time.perf_counter() - start_time >= timeout_secs:
+# #                         fallback_triggered = True
+# #                         break
+# #                     candidate_center = (cx + dx, cy + dy)
+                    
+# #                     # Ensure candidate center is not too close to any already placed centers.
+# #                     if any(np.hypot(candidate_center[0] - ex, candidate_center[1] - ey) < needed_center_distance
+# #                            for ex, ey in existing_centers):
+# #                         continue
 
-# ---------------------
-# Add the missing extract_outlines function
-# ---------------------
-def extract_outlines(binary_image: np.ndarray) -> (np.ndarray, list):
-    contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
-    outline_image = np.zeros_like(binary_image)
-    cv2.drawContours(outline_image, contours, -1, (255), thickness=2)
-    return cv2.bitwise_not(outline_image), contours
+# #                     # Create candidate circle with a high resolution.
+# #                     candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
+                    
+# #                     # Reject candidate if circle is completely inside the tool polygon.
+# #                     if tool_polygon.contains(candidate_circle):
+# #                         continue
+                    
+# #                     # Also reject candidate if circle does not intersect the tool at all.
+# #                     if not candidate_circle.intersects(tool_polygon):
+# #                         continue
+                    
+                    
+# #                     # Ensure that the candidate circle crosses the tool boundary.
+# #                     inter_area = candidate_circle.intersection(tool_polygon).area
+# #                     if inter_area <= 0 or inter_area >= candidate_circle.area:
+# #                         continue
+
+# #                     # Verify candidate circle is not too close to any neighboring tool polygons.
+# #                     too_close = False
+# #                     for other_poly in all_polygons:
+# #                         if other_poly.equals(tool_polygon):
+# #                             continue
+# #                         if candidate_circle.buffer(0.1).intersects(other_poly):
+# #                             too_close = True
+# #                         if other_poly.distance(candidate_circle) < min_gap:
+# #                             too_close = True
+# #                             break
+# #                     if too_close:
+# #                         continue
+                    
+# #                     # Attempt the union, using a buffering trick to fix potential geometry problems.
+# #                     try:
+# #                         union_poly = tool_polygon.union(candidate_circle)
+# #                     except Exception:
+# #                         union_poly = tool_polygon.buffer(0).union(candidate_circle.buffer(0))
+                    
+# #                     # Verify that the union is a single contiguous polygon.
+# #                     if union_poly.geom_type == "MultiPolygon" and len(union_poly.geoms) > 1:
+# #                         continue
+                    
+# #                     # If the union did not change the polygon (no effective union), skip candidate.
+# #                     if union_poly.equals(tool_polygon):
+# #                         continue
+                    
+# #                     # We have found a valid candidate.
+# #                     existing_centers.append(candidate_center)
+# #                     return union_poly, candidate_center
+# #                 if fallback_triggered:
+# #                     break
+# #         attempts += 1
+# #     if fallback_triggered:
+# #         print("In fallback block")
+        
+# #     # Fallback: If no candidate was found after max_attempts, force a candidate from median of points.
+# #     candidate_center = points_inch[len(points_inch) // 2]
+# #     candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
+# #     try:
+# #         too_close= False
+# #         for other_poly in all_polygons:
+            
+# #             if other_poly.equals(tool_polygon):
+# #                 continue
+# #             if candidate_circle.buffer(0.1).intersects(other_poly):
+# #                 too_close = True
+# #             if other_poly.distance(candidate_circle) < min_gap:
+# #                 too_close = True
+# #             if too_close:
+# #                 continue
+# #         union_poly = tool_polygon.union(candidate_circle)
+# #     except Exception:
+# #         too_close= False
+# #         for other_poly in all_polygons:
+            
+# #             if other_poly.equals(tool_polygon):
+# #                 continue
+# #             if candidate_circle.buffer(0.1).intersects(other_poly):
+# #                 too_close = True
+# #             if other_poly.distance(candidate_circle) < min_gap:
+# #                 too_close = True
+# #             if too_close:
+# #                 continue
+# #         union_poly = tool_polygon.buffer(0).union(candidate_circle.buffer(0))
+# #     existing_centers.append(candidate_center)
+# #     return union_poly, candidate_center
+
+# # # ---------------------
+# # # DXF Spline and Boundary Functions
+# # # ---------------------
+# # def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
+#     degree = 3
+#     closed = True
+#     doc = ezdxf.new(units=0)
+#     doc.units = ezdxf.units.IN
+#     doc.header["$INSUNITS"] = ezdxf.units.IN
+#     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]
+#             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 finger_clearance:
+#                 union_poly, center = place_finger_cut_adjusted(tool_polygon, points_inch, finger_cut_centers, final_polygons_inch, circle_diameter=1.0, min_gap=0.25, max_attempts=100)
+#                 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}")
+#     return doc, final_polygons_inch
 
-# ---------------------
-# Functions for Finger Cut Clearance
-# ---------------------
-# def union_tool_and_circle(tool_polygon: Polygon, center_inch, circle_diameter=1.0): #original
+# import random
+# import time
+# import numpy as np
+# from shapely.geometry import Point, Polygon
+
+# # ---------------------
+# # Utility functions
+# # ---------------------
+# 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
 
-def union_tool_and_circle(tool_polygon, center_inch, circle_diameter=1.0):
-    """Union a tool polygon with a circle with extensive validation."""
-    if tool_polygon is None or not isinstance(tool_polygon, Polygon):
-        print("Invalid tool polygon provided")
-        return None
-        
-    radius = circle_diameter / 2.0
-    try:
-        # Create the circle
-        circle_poly = Point(center_inch).buffer(radius, resolution=64)
-        
-        # Make sure both geometries are valid
-        if not tool_polygon.is_valid:
-            tool_polygon = tool_polygon.buffer(0)
-        if not circle_poly.is_valid:
-            print("Invalid circle geometry")
-            return tool_polygon
-            
-        # Perform union
-        result = tool_polygon.union(circle_poly)
-        
-        # Validate result
-        if result.is_empty:
-            print(f"Union resulted in empty geometry at {center_inch}")
-            return tool_polygon
-            
-        # Handle multi-polygon results
-        if result.geom_type == "MultiPolygon":
-            # Take the largest piece to avoid fragmentation
-            result = max(result.geoms, key=lambda g: g.area)
-            
-        # Final validation
-        if not result.is_valid:
-            print("Union produced invalid geometry, returning original polygon")
-            return tool_polygon
-            
-        # Check exterior points
-        if not result.exterior or len(list(result.exterior.coords)) < 4:
-            print(f"Union resulted in degenerate polygon with insufficient points")
-            return tool_polygon
-            
-        return result
-    except Exception as e:
-        print(f"Exception during union operation: {e}")
-        return tool_polygon
+# def build_tool_polygon(points_inch):
+#     return Polygon(points_inch)
 
-def build_tool_polygon(points_inch):
-    return Polygon(points_inch)
-
-# def polygon_to_exterior_coords(poly: Polygon): # works fine original
+# def polygon_to_exterior_coords(poly: Polygon):
 #     if poly.geom_type == "MultiPolygon":
 #         biggest = max(poly.geoms, key=lambda g: g.area)
 #         poly = biggest
@@ -333,456 +482,533 @@ def build_tool_polygon(points_inch):
 #         return []
 #     return list(poly.exterior.coords)
 
-def polygon_to_exterior_coords(poly):
-    """Extract exterior coordinates with robust error handling."""
-    if poly is None:
-        print("Warning: Null polygon provided")
-        return []
-        
-    try:
-        if poly.geom_type == "MultiPolygon":
-            if len(poly.geoms) == 0:
-                print("Warning: Empty MultiPolygon")
-                return []
-            biggest = max(poly.geoms, key=lambda g: g.area)
-            poly = biggest
-            
-        if not poly.exterior:
-            print("Warning: Polygon has no exterior")
-            return []
-            
-        coords = list(poly.exterior.coords)
-        if len(coords) < 4:
-            print(f"Warning: Polygon has insufficient coordinates: {len(coords)}")
-            
-        return coords
-    except Exception as e:
-        print(f"Error extracting polygon coordinates: {e}")
-        return []
-
-
-
-# def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1, min_gap=1, max_attempts=500): #1st best
+# ---------------------
+# Main candidate placement function
+# ---------------------
+# def place_finger_cut_adjusted(
+#     tool_polygon1: Polygon,
+#     points_inch: list,
+#     existing_centers: list,
+#     all_polygons: list,
+#     circle_diameter: float = 1.0,
+#     min_gap: float = 0.5,
+#     max_attempts: int = 100
+# ) -> (Polygon, tuple):
+#     """
+#     Adjust and union a candidate circle (finger cut) with the tool_polygon.
+#     If a candidate meeting all conditions is found, update existing_centers
+#     and return the union and candidate_center.
+    
+#     If no candidate is found after max_attempts (or if a timeout is reached),
+#     use a fallback candidate (the median point from points_inch).
+#     """
 #     needed_center_distance = circle_diameter + min_gap
 #     radius = circle_diameter / 2.0
-#     import random
-#     for _ in range(max_attempts):
-#         idx = random.randint(0, len(points_inch) - 1)
-#         cx, cy = points_inch[idx]
-
-#         # Check if this point is too close to an existing center
-#         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
-
-#         # Create the finger cut circle and try adding it to the tool
-#         circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
-#         union_poly = tool_polygon.union(circle_poly)
-
-#         # Check for overlap and spacing with other tools
-#         overlap_with_others = False
-#         too_close_to_others = False
-
-#         for poly in all_polygons:
-#             if poly.equals(tool_polygon):
-#                 continue  # Skip comparing the tool to itself
-
-#             if union_poly.buffer(min_gap).intersects(poly) > 1e-6:
-#                 overlap_with_others = True
-#                 break
+#     attempts = 0
+#     timeout_secs = 0.1  # 100ms timeout
+#     start_time = time.perf_counter()
+#     fallback_triggered = False
+#     tool_polygon= tool_polygon1
 
-#             if circle_poly.buffer(min_gap).intersects(poly) > 1e-6:
-#                 too_close_to_others = True
+#     # Randomize candidate points order.
+#     indices = list(range(len(points_inch)))
+#     random.shuffle(indices)
+
+#     while attempts < max_attempts and not fallback_triggered:
+#         for i in indices:
+#             if time.perf_counter() - start_time >= timeout_secs:
+#                 fallback_triggered = True
 #                 break
+#             cx, cy = points_inch[i]
+#             # Try small adjustments around the candidate point.
+#             for dx in np.linspace(-0.3, 0.3, 7):
+#                 for dy in np.linspace(-0.3, 0.3, 7):
+#                     if time.perf_counter() - start_time >= timeout_secs:
+#                         fallback_triggered = True
+#                         break
+#                     candidate_center = (cx + dx, cy + dy)
+                    
+#                     # Ensure candidate center is not too close to any already placed centers.
+#                     if any(np.hypot(candidate_center[0] - ex, candidate_center[1] - ey) < needed_center_distance
+#                            for ex, ey in existing_centers):
+#                         continue
 
-#         if overlap_with_others or too_close_to_others:
-#             continue
+#                     # Create candidate circle with high resolution.
+#                     candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
+                    
+#                     # Reject candidate if circle is completely inside the tool polygon.
+#                     if tool_polygon.contains(candidate_circle):
+#                         continue
+#                     # Reject candidate if circle does not intersect the tool at all.
+#                     if not candidate_circle.intersects(tool_polygon):
+#                         continue
+#                     # Ensure that the candidate circle crosses the tool boundary.
+#                     inter_area = candidate_circle.intersection(tool_polygon).area
+#                     if inter_area <= 0 or inter_area >= candidate_circle.area:
+#                         continue
 
-#         existing_centers.append((cx, cy))
-#         return union_poly, (cx, cy)
+#                     # Verify candidate circle is not too close to any neighboring tool polygons.
+#                     too_close = False
+#                     for other_poly in all_polygons:
+#                         if other_poly.equals(tool_polygon):
+#                             continue
+#                         # Use a small buffer around the circle for safety.
+#                         if candidate_circle.buffer(0.1).intersects(other_poly):
+#                             too_close = True
+#                         if other_poly.distance(candidate_circle) < min_gap:
+#                             too_close = True
+#                             break
+#                     if too_close:
+#                         continue
+                    
+#                     # Attempt the union, using buffering to fix any potential geometry issues.
+#                     try:
+#                         union_poly = tool_polygon.union(candidate_circle)
+#                     except Exception:
+#                         union_poly = tool_polygon.buffer(0).union(candidate_circle.buffer(0))
+                    
+#                     # Clean the unioned polygon.
+#                     union_poly = union_poly.buffer(0)
+                    
+#                     # Verify that the union is a single contiguous polygon.
+#                     if union_poly.geom_type == "MultiPolygon" and len(union_poly.geoms) > 1:
+#                         continue
+                    
+#                     # If the union did not change the tool polygon (no effective union), skip candidate.
+#                     if union_poly.equals(tool_polygon):
+#                         continue
+                    
+#                     # We have found a valid candidate. Update the centers list.
+#                     existing_centers.append(candidate_center)
+#                     return tool_polygon1, existing_centers[-1]
+#                 if fallback_triggered:
+#                     break
+#         attempts += 1
 
-#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
-#     return None, None
+#     # Fallback: If no candidate is found (or timeout reached), use a fallback candidate.
+#     if fallback_triggered:
+#         print("Fallback triggered")
+#     # Use a fallback candidate – here the median point is used.
+#     xs = [p[0] for p in points_inch]
+#     ys = [p[1] for p in points_inch]
+#     candidate_center = (np.median(xs), np.median(ys))
+#     candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
+#     try:
+#         union_poly = tool_polygon.union(candidate_circle)
+#     except Exception:
+#         union_poly = tool_polygon.buffer(0).union(candidate_circle.buffer(0))
+#     union_poly = union_poly.buffer(0)
+#     # Add the fallback center to avoid duplicate placements later.
+#     existing_centers.append(candidate_center)
+#     return tool_polygon1, existing_centers[-1]
 
-import numpy as np
-from shapely.geometry import Point
+# ---------------------
+# DXF Spline and Boundary Functions
+# ---------------------
+# def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
+#     import ezdxf  # assuming ezdxf is installed
+#     degree = 3
+#     closed = True
+#     doc = ezdxf.new(units=0)
+#     doc.units = ezdxf.units.IN
+#     doc.header["$INSUNITS"] = ezdxf.units.IN
+#     msp = doc.modelspace()
 
+#     # Global shared lists for finger cut centers and final tool polygons.
+#     finger_cut_centers = []
+#     final_polygons_inch = []
 
-# def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.35, max_attempts=2000): #Best best
-#     import random
-#     import numpy as np
-#     from shapely.geometry import Point
-    
-#     needed_center_distance = circle_diameter + min_gap
-#     radius = circle_diameter / 2.0
-#     attempts = 0
-#     indices = list(range(len(points_inch)))
-#     random.shuffle(indices)  # Shuffle indices for randomness
-    
-#     # Try a grid of adjustments around each candidate point
-#     adjustments = list(np.linspace(-0.15, 0.10, 7))  # More adjustment options
-    
-#     for i in indices:
-#         if attempts >= max_attempts:
-#             break
+#     for contour in inflated_contours:
+#         try:
+#             # resample_contour should be defined elsewhere;
+#             # here it returns a list of (x, y) points.
+#             resampled_contour = resample_contour(contour)
+#             # Scale and flip Y coordinate according to height.
+#             points_inch = [(x * scaling_factor, (height - y) * scaling_factor) for x, y in resampled_contour]
             
-#         cx, cy = points_inch[i]
-        
-#         # Try small adjustments around the chosen candidate
-#         for dx in adjustments:
-#             for dy in adjustments:
-#                 attempts += 1
-#                 if attempts >= max_attempts:
-#                     break
-                    
-#                 candidate_center = (cx + dx, cy + dy)
-                
-#                 # Check distance from already placed centers
-#                 too_close_to_existing = False
-#                 for ex, ey in existing_centers:
-#                     if np.hypot(candidate_center[0] - ex, candidate_center[1] - ey) < needed_center_distance:
-#                         too_close_to_existing = True
-#                         break
-                
-#                 if too_close_to_existing:
-#                     continue
-                    
-#                 # Create circle polygon for this candidate
-#                 circle_poly = Point(candidate_center).buffer(radius, resolution=64)
-                
-#                 # Create the union with the tool polygon
-#                 union_poly = tool_polygon.union(circle_poly)
-                
-#                 # Buffer the circle to check minimum gap requirements
-#                 circle_buffer = circle_poly.buffer(min_gap, resolution=32)
-#                 coords = polygon_to_exterior_coords(union_poly)
-                
-#                 # Check against all other polygons for overlap or proximity issues
-#                 overlap = False
-#                 for poly in all_polygons:
-#                     if poly == tool_polygon:
-#                         continue  # Skip comparing to self
-#                     if len(coords) < 4:
-#                         # It's degenerate or not a valid polygon for your purposes; skip
-#                         break
-                            
-#                     # Check if the union overlaps with any other polygon
-#                     if union_poly.intersects(poly):
-#                         overlap = True
-#                         break
-                        
-#                     # Check if the buffered circle (circle + min_gap) intersects with any other polygon
-#                     if circle_buffer.intersects(poly):
-#                         overlap = True
-#                         break
-                
-#                 if not overlap:
-#                     # If candidate passes all checks, accept it
-#                     existing_centers.append(candidate_center)
-#                     return union_poly, candidate_center
+#             if len(points_inch) < 3:
+#                 continue
+
+#             # Ensure the polygon is closed.
+#             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)
+            
+#             # Add finger clearance cuts if needed.
+#             if finger_clearance:
+#                 tool, center = place_finger_cut_adjusted(
+#                     tool_polygon, points_inch, finger_cut_centers, final_polygons_inch,
+#                     circle_diameter=1.0, min_gap=0.25, max_attempts=100
+#                 )
+#                 union_poly=union_tool_and_circle(tool,center)
+#                 if union_poly is not None:
+#                     tool_polygon = union_poly
+            
+#             exterior_coords = polygon_to_exterior_coords(tool_polygon)
+#             if len(exterior_coords) < 3:
+#                 continue
+
+#             # Add the tool geometry to the DXF document as a spline.
+#             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}")
     
-#     print(f"Warning: Could not place a finger cut circle after {attempts} attempts. Consider adjusting parameters.")
-#     return None, None
+#     return doc, final_polygons_inch
 
+import logging
+import time
+import signal
+import numpy as np
+import cv2
+from scipy.interpolate import splprep, splev
+from scipy.ndimage import gaussian_filter1d
+from shapely.geometry import Point, Polygon
+import random
+import ezdxf
+import functools
 
-# def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.25, max_attempts=100): #working best
-#     import random
-#     needed_center_distance = circle_diameter + min_gap
-#     radius = circle_diameter / 2.0
-#     attempts = 0
-#     indices = list(range(len(points_inch)))
-#     random.shuffle(indices)  # Shuffle indices for randomness
-
-#     for i in indices:
-#         if attempts >= max_attempts:
-#             break
-#         cx, cy = points_inch[i]
-#         # Try small adjustments around the chosen candidate
-#         for dx in np.linspace(-0.1, 0.1, 10):
-#             for dy in np.linspace(-0.1, 0.1, 10):
-#                 candidate_center = (cx + dx, cy + dy)
-#                 # Check distance from already placed centers
-#                 if any(np.hypot(candidate_center[0] - ex, candidate_center[1] - ey) < needed_center_distance for ex, ey in existing_centers):
-#                     continue
-                
-#                 union_poly= union_tool_and_circle(tool_polygon,candidate_center)
-#                 overlap = False
-#                 # Check against other tool polygons for overlap or proximity issues
-#                 for poly in all_polygons:
-#                     if poly == tool_polygon:
-#                         continue  
-#                     if union_poly.intersects(poly) or union_poly.buffer(min_gap).intersects(poly):
-#                         overlap = True
-#                         break
-#                 if overlap:
-#                     continue
-#                 # If candidate passes, accept it
-#                 existing_centers.append(candidate_center)
-#                 return union_poly, candidate_center
-#         attempts += 1
-#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
-#     return None, None
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
+# Custom TimeoutError class
+class TimeoutReachedError(Exception):
+    pass
 
-# def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.25, max_attempts=20):
-#     """Place a finger cut with strategic positioning based on tool shape."""
-#     if tool_polygon is None or len(points_inch) < 4:
-#         return None, None
+# Timeout context manager
+class TimeoutContext:
+    def __init__(self, seconds):
+        self.seconds = seconds
+        self.original_handler = None
+        
+    def timeout_handler(self, signum, frame):
+        raise TimeoutReachedError(f"Function timed out after {self.seconds} seconds")
+        
+    def __enter__(self):
+        if hasattr(signal, 'SIGALRM'):  # Unix-like systems
+            self.original_handler = signal.getsignal(signal.SIGALRM)
+            signal.signal(signal.SIGALRM, self.timeout_handler)
+            signal.alarm(self.seconds)
+        self.start_time = time.time()
+        return self
+        
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if hasattr(signal, 'SIGALRM'):  # Unix-like systems
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, self.original_handler)
+        if exc_type is TimeoutReachedError:
+            logger.warning(f"Timeout reached: {exc_val}")
+            return True  # Suppress the exception
+        return False
+
+def resample_contour(contour):
+    logger.info(f"Starting resample_contour with contour of shape {contour.shape}")
     
-#     import random
-#     needed_center_distance = circle_diameter + min_gap
-#     radius = circle_diameter / 2.0
+    num_points = 1000
+    smoothing_factor = 5
+    spline_degree = 3
     
-#     # Calculate the tool's bounding box and find its center
-#     minx, miny, maxx, maxy = tool_polygon.bounds
-#     bbox_center = ((minx + maxx) / 2, (miny + maxy) / 2)
+    if len(contour) < spline_degree + 1:
+        error_msg = f"Contour must have at least {spline_degree + 1} points, but has {len(contour)} points."
+        logger.error(error_msg)
+        raise ValueError(error_msg)
+        
+    try:
+        contour = contour[:, 0, :]
+        logger.debug(f"Reshaped contour to shape {contour.shape}")
+        
+        tck, _ = splprep([contour[:, 0], contour[:, 1]], s=smoothing_factor)
+        logger.debug("Generated spline parameters")
+        
+        u = np.linspace(0, 1, num_points)
+        resampled_points = splev(u, tck)
+        logger.debug(f"Resampled to {num_points} points")
+        
+        smoothed_x = gaussian_filter1d(resampled_points[0], sigma=1)
+        smoothed_y = gaussian_filter1d(resampled_points[1], sigma=1)
+        
+        result = np.array([smoothed_x, smoothed_y]).T
+        logger.info(f"Completed resample_contour with result shape {result.shape}")
+        return result
+    except Exception as e:
+        logger.error(f"Error in resample_contour: {e}")
+        raise
+
+def extract_outlines(binary_image: np.ndarray) -> (np.ndarray, list):
+    logger.info(f"Starting extract_outlines with image shape {binary_image.shape}")
     
-#     # Strategy 1: Try handle areas first (typically thinner parts)
-#     # Find narrow regions by looking at distance to boundary
-#     narrow_candidates = []
-#     for i, pt in enumerate(points_inch):
-#         # Calculate distance to the opposite side of the polygon
-#         point = Point(pt)
-#         if tool_polygon.boundary.distance(point) < radius * 1.5:  # Points near boundary
-#             narrow_candidates.append(i)
+    try:
+        contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+        logger.debug(f"Found {len(contours)} contours")
+        
+        outline_image = np.zeros_like(binary_image)
+        cv2.drawContours(outline_image, contours, -1, (255), thickness=2)
+        
+        result_image = cv2.bitwise_not(outline_image)
+        logger.info(f"Completed extract_outlines with {len(contours)} contours")
+        return result_image, contours
+    except Exception as e:
+        logger.error(f"Error in extract_outlines: {e}")
+        raise
+
+def union_tool_and_circle(tool_polygon: Polygon, center_inch, circle_diameter=1.0):
+    logger.info(f"Starting union_tool_and_circle with center at {center_inch}")
     
-#     # Strategy 2: Try areas far from existing cuts
-#     far_candidates = []
-#     if existing_centers:
-#         for i, pt in enumerate(points_inch):
-#             min_dist = min(np.hypot(pt[0] - cx, pt[1] - cy) for cx, cy in existing_centers)
-#             if min_dist > needed_center_distance * 1.5:  # Points far from existing cuts
-#                 far_candidates.append(i)
+    try:
+        radius = circle_diameter / 2.0
+        circle_poly = Point(center_inch).buffer(radius, resolution=64)
+        logger.debug(f"Created circle with radius {radius} at {center_inch}")
+        
+        union_poly = tool_polygon.union(circle_poly)
+        logger.info(f"Completed union_tool_and_circle, result area: {union_poly.area}")
+        return union_poly
+    except Exception as e:
+        logger.error(f"Error in union_tool_and_circle: {e}")
+        raise
+
+def build_tool_polygon(points_inch):
+    logger.info(f"Starting build_tool_polygon with {len(points_inch)} points")
     
-#     # Strategy 3: Try concave regions (often good for finger grips)
-#     # This is more complex but could identify good grip points
+    try:
+        polygon = Polygon(points_inch)
+        logger.info(f"Completed build_tool_polygon, polygon area: {polygon.area}")
+        return polygon
+    except Exception as e:
+        logger.error(f"Error in build_tool_polygon: {e}")
+        raise
+
+def polygon_to_exterior_coords(poly: Polygon):
+    logger.info(f"Starting polygon_to_exterior_coords with polygon type {poly.geom_type}")
     
-#     # Combine strategies, prioritizing certain candidates
-#     candidate_indices = (narrow_candidates + far_candidates + 
-#                         list(set(range(len(points_inch))) - 
-#                              set(narrow_candidates) - 
-#                              set(far_candidates)))
-#     random.shuffle(candidate_indices)  # Add randomness
+    try:
+        if poly.geom_type == "MultiPolygon":
+            logger.debug("Converting MultiPolygon to single Polygon")
+            biggest = max(poly.geoms, key=lambda g: g.area)
+            poly = biggest
+            
+        if not poly.exterior:
+            logger.warning("Polygon has no exterior")
+            return []
+            
+        coords = list(poly.exterior.coords)
+        logger.info(f"Completed polygon_to_exterior_coords with {len(coords)} coordinates")
+        return coords
+    except Exception as e:
+        logger.error(f"Error in polygon_to_exterior_coords: {e}")
+        raise
+
+def place_finger_cut_adjusted(
+    tool_polygon: Polygon,
+    points_inch: list,
+    existing_centers: list,
+    all_polygons: list,
+    circle_diameter: float = 1.0,
+    min_gap: float = 0.5,
+    max_attempts: int = 100
+) -> (Polygon, tuple):
+    logger.info(f"Starting place_finger_cut_adjusted with {len(points_inch)} points")
     
-#     # Try candidates
-#     for idx in candidate_indices:
-#         base_pt = points_inch[idx]
+    # Define fallback function for timeout case
+    def fallback_solution():
+        logger.warning("Using fallback approach for finger cut placement")
+        candidate_center = points_inch[len(points_inch) // 2]
+        radius = circle_diameter / 2.0
+        candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
         
-#         # Try at different distances from the point
-#         for dist_factor in [0.0, 0.1, 0.2, 0.3, 0.4]:
-#             # Try different angles
-#             for angle in np.linspace(0, 2*np.pi, 12):
-#                 dx = dist_factor * radius * np.cos(angle)
-#                 dy = dist_factor * radius * np.sin(angle)
-#                 candidate = (base_pt[0] + dx, base_pt[1] + dy)
-                
-#                 # Skip if point isn't inside the polygon
-#                 if not tool_polygon.contains(Point(candidate)):
-#                     continue
-                    
-#                 # Skip if too close to existing centers
-#                 if any(np.hypot(candidate[0] - cx, candidate[1] - cy) < needed_center_distance 
-#                        for cx, cy in existing_centers):
-#                     continue
-                
-#                 # Try creating the union
-#                 new_polygon = union_tool_and_circle(tool_polygon, candidate, circle_diameter)
-#                 if new_polygon is None or new_polygon == tool_polygon:
-#                     continue  # Union failed
-                
-#                 # Check for overlaps with other tools
-#                 overlap = False
-#                 for poly in all_polygons:
-                
-#                     if poly == tool_polygon:
-#                         continue
-#                     # if new_polygon.intersects(poly):
-#                     #     overlap = True
-#                     #     break
-#                     if new_polygon.buffer(0.25).intersects(poly):
-#                         overlap = True
-#                         break
-                                
-#                 if not overlap:
-#                     # Success! This is a good spot for a finger cut
-#                     existing_centers.append(candidate)
-#                     return new_polygon, candidate
-    
-#     # If we get here, we couldn't find a good spot
-#     print("Could not find suitable location for finger cut")
-#     return None, None
-
-def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.25, max_attempts=50):
-    """Place a finger cut with strategic positioning based on tool shape."""
-    if tool_polygon is None or len(points_inch) < 4:
-        return None, None
-    
-    import random
+        try:
+            union_poly = tool_polygon.union(candidate_circle)
+        except Exception as e:
+            logger.warning(f"Fallback union failed, using buffer trick: {e}")
+            union_poly = tool_polygon.buffer(0).union(candidate_circle.buffer(0))
+            
+        existing_centers.append(candidate_center)
+        logger.info(f"Used fallback finger cut at center {candidate_center}")
+        return union_poly, candidate_center
+
     needed_center_distance = circle_diameter + min_gap
     radius = circle_diameter / 2.0
     
-    # Calculate the tool's bounding box and find its center
-    minx, miny, maxx, maxy = tool_polygon.bounds
-    bbox_center = ((minx + maxx) / 2, (miny + maxy) / 2)
-    
-    # Strategy 1: Try handle areas first (typically thinner parts)
-    # Find narrow regions by looking at distance to boundary
-    narrow_candidates = []
-    for i, pt in enumerate(points_inch):
-        # Calculate distance to the opposite side of the polygon
-        point = Point(pt)
-        if tool_polygon.boundary.distance(point) < radius * 1.5:  # Points near boundary
-            narrow_candidates.append(i)
-    
-    # Strategy 2: Try areas far from existing cuts
-    far_candidates = []
-    if existing_centers:
-        for i, pt in enumerate(points_inch):
-            min_dist = min(np.hypot(pt[0] - cx, pt[1] - cy) for cx, cy in existing_centers)
-            if min_dist > needed_center_distance * 1.5:  # Points far from existing cuts
-                far_candidates.append(i)
-    
-    # Strategy 3: Try concave regions (often good for finger grips)
-    # This is more complex but could identify good grip points
+    # Limit points to prevent timeout - use a subset for efficient processing
+    if len(points_inch) > 100:
+        logger.info(f"Limiting points from {len(points_inch)} to 100 for efficiency")
+        step = len(points_inch) // 100
+        points_inch = points_inch[::step]
     
-    # Combine strategies, prioritizing certain candidates
-    candidate_indices = (narrow_candidates + far_candidates + 
-                        list(set(range(len(points_inch))) - 
-                             set(narrow_candidates) - 
-                             set(far_candidates)))
-    random.shuffle(candidate_indices)  # Add randomness
+    # Randomize candidate points order
+    indices = list(range(len(points_inch)))
+    random.shuffle(indices)
+    logger.debug(f"Shuffled {len(indices)} point indices")
+
+    # Use a non-blocking timeout approach with explicit time checks
+    start_time = time.time()
+    timeout_seconds = 5
+    attempts = 0
     
-    # Try candidates
-    for idx in candidate_indices:
-        base_pt = points_inch[idx]
-        
-        # Try at different distances from the point
-        for dist_factor in [0.0, 0.1, 0.2, 0.3, 0.4]:
-            # Try different angles
-            for angle in np.linspace(0, 2*np.pi, 12):
-                dx = dist_factor * radius * np.cos(angle)
-                dy = dist_factor * radius * np.sin(angle)
-                candidate = (base_pt[0] + dx, base_pt[1] + dy)
+    try:
+        while attempts < max_attempts:
+            # Check if we're approaching the timeout
+            current_time = time.time()
+            if current_time - start_time > timeout_seconds - 0.1:  # Leave 0.1s margin
+                logger.warning(f"Approaching timeout after {attempts} attempts")
+                return fallback_solution()
                 
-                # Skip if point isn't inside the polygon
-                if not tool_polygon.contains(Point(candidate)):
-                    continue
+            # Process a batch of points to improve efficiency
+            for i in indices:
+                # Check timeout frequently
+                if time.time() - start_time > timeout_seconds - 0.05:
+                    logger.warning("Timeout during point processing")
+                    return fallback_solution()
                     
-                # Skip if too close to existing centers
-                if any(np.hypot(candidate[0] - cx, candidate[1] - cy) < needed_center_distance 
-                       for cx, cy in existing_centers):
-                    continue
-                
-                # Try creating the union
-                new_polygon = union_tool_and_circle(tool_polygon, candidate, circle_diameter)
-                if new_polygon is None or new_polygon == tool_polygon:
-                    continue  # Union failed
-                
-                # Check for overlaps with other tools
-                overlap = False
-                for poly in all_polygons:
-                    if poly == tool_polygon:
+                cx, cy = points_inch[i]
+                # Reduce the number of adjustments to speed up processing
+                for dx, dy in [(0,0), (-0.2,0), (0.2,0), (0,0.2), (0,-0.2)]:
+                    candidate_center = (cx + dx, cy + dy)
+                    
+                    # Quick check for existing centers distance
+                    if any(np.hypot(candidate_center[0] - ex, candidate_center[1] - ey) < needed_center_distance
+                           for ex, ey in existing_centers):
+                        continue
+
+                    # Create candidate circle
+                    candidate_circle = Point(candidate_center).buffer(radius, resolution=32)  # Reduced resolution
+                    
+                    # Quick geometric checks
+                    if tool_polygon.contains(candidate_circle) or not candidate_circle.intersects(tool_polygon):
+                        continue
+                    
+                    # Check intersection area - use simplified geometry for speed
+                    try:
+                        inter_area = candidate_circle.intersection(tool_polygon).area
+                        if inter_area <= 0 or inter_area >= candidate_circle.area:
+                            continue
+                    except Exception:
+                        continue
+
+                    # Quick distance check to other polygons
+                    too_close = False
+                    for other_poly in all_polygons:
+                        if other_poly.equals(tool_polygon):
+                            continue
+                        if other_poly.distance(candidate_circle) < min_gap:
+                            too_close = True
+                            break
+                    if too_close:
+                        continue
+                    
+                    # Attempt the union
+                    try:
+                        union_poly = tool_polygon.union(candidate_circle)
+                        # Check if we got a multi-polygon when we don't want one
+                        if union_poly.geom_type == "MultiPolygon" and len(union_poly.geoms) > 1:
+                            continue
+                        # Check if the union actually changed anything
+                        if union_poly.equals(tool_polygon):
+                            continue
+                    except Exception:
                         continue
-                    if new_polygon.buffer(0.1).intersects(poly):
-                        overlap = True
-                        break
+                    
+                    # We found a valid candidate
+                    existing_centers.append(candidate_center)
+                    logger.info(f"Completed place_finger_cut_adjusted successfully at center {candidate_center}")
+                    return union_poly, candidate_center
+            
+            attempts += 1
+            # If we've made several attempts and are running out of time, use fallback
+            if attempts >= max_attempts // 2 and (time.time() - start_time) > timeout_seconds * 0.8:
+                logger.warning(f"Approaching timeout after {attempts} attempts")
+                return fallback_solution()
                 
-                if not overlap:
-                    # Success! This is a good spot for a finger cut
-                    existing_centers.append(candidate)
-                    return new_polygon, candidate
+            logger.debug(f"Completed attempt {attempts}/{max_attempts}")
+            
+        # If we reached max attempts without finding a solution
+        logger.warning(f"No suitable finger cut found after {max_attempts} attempts, using fallback")
+        return fallback_solution()
+            
+    except Exception as e:
+        logger.error(f"Error in place_finger_cut_adjusted: {e}")
+        return fallback_solution()
+
+def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
+    logger.info(f"Starting save_dxf_spline with {len(inflated_contours)} contours")
     
-    # If we get here, we couldn't find a good spot
-    print("Could not find suitable location for finger cut")
-    return None, None
-# ---------------------
-# DXF Spline and Boundary Functions
-# ---------------------
-def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False): # works
     degree = 3
     closed = True
-    doc = ezdxf.new(units=0)
-    doc.units = ezdxf.units.IN
-    doc.header["$INSUNITS"] = ezdxf.units.IN
-    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]
-            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 finger_clearance:
-                union_poly, center = place_finger_cut_adjusted(tool_polygon, points_inch, finger_cut_centers, final_polygons_inch)
-                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}")
-    return doc, final_polygons_inch
-
-# def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=True):
-#     degree = 3
-#     closed = True
-#     doc = ezdxf.new(units=0)
-#     doc.units = ezdxf.units.IN
-#     doc.header["$INSUNITS"] = ezdxf.units.IN
-#     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]
+    try:
+        doc = ezdxf.new(units=0)
+        doc.units = ezdxf.units.IN
+        doc.header["$INSUNITS"] = ezdxf.units.IN
+        msp = doc.modelspace()
+        
+        finger_cut_centers = []
+        final_polygons_inch = []
+        
+        for idx, contour in enumerate(inflated_contours):
+            logger.debug(f"Processing contour {idx+1}/{len(inflated_contours)}")
             
-#             # Ensure minimum number of points
-#             if len(points_inch) < 4:  # Need at least 4 for a valid polygon and spline
-#                 print(f"Skipping contour with only {len(points_inch)} points")
-#                 continue
+            try:
+                resampled_contour = resample_contour(contour)
+                points_inch = [(x * scaling_factor, (height - y) * scaling_factor) for x, y in resampled_contour]
                 
-#             # Ensure first and last points match for closed polygon
-#             if np.linalg.norm(np.array(points_inch[0]) - np.array(points_inch[-1])) > 1e-2:
-#                 points_inch.append(points_inch[0])
+                if len(points_inch) < 3:
+                    logger.warning(f"Skipping contour {idx}: insufficient points ({len(points_inch)})")
+                    continue
+                    
+                if np.linalg.norm(np.array(points_inch[0]) - np.array(points_inch[-1])) > 1e-2:
+                    logger.debug("Closing contour by adding first point to end")
+                    points_inch.append(points_inch[0])
+                    
+                tool_polygon = build_tool_polygon(points_inch)
                 
-#             # Create tool polygon with validation
-#             tool_polygon = build_tool_polygon(points_inch)
-#             if not tool_polygon.is_valid:
-#                 tool_polygon = tool_polygon.buffer(0)  # Fix invalid geometries
+                if finger_clearance:
+                    logger.debug("Applying finger clearance")
+                    try:
+                        # Use a hard 5-second timeout for the entire finger cut operation
+                        start_time = time.time()
+                        union_poly, center = place_finger_cut_adjusted(
+                            tool_polygon, 
+                            points_inch, 
+                            finger_cut_centers, 
+                            final_polygons_inch, 
+                            circle_diameter=1.0, 
+                            min_gap=0.25, 
+                            max_attempts=100
+                        )
+                        
+                        # Check if we exceeded the timeout anyway
+                        if time.time() - start_time > 5:
+                            logger.warning(f"Finger cut took too long for contour {idx} ({time.time() - start_time:.2f}s)")
+                        
+                        if union_poly is not None:
+                            tool_polygon = union_poly
+                            logger.debug(f"Applied finger cut at {center}")
+                    except Exception as e:
+                        logger.warning(f"Finger cut failed for contour {idx}: {e}, using original polygon")
+                        
+                exterior_coords = polygon_to_exterior_coords(tool_polygon)
                 
-#             # Add finger clearance if requested
-#             if finger_clearance:
-#                 for attempt in range(3):  # Try multiple finger cuts per tool
-#                     union_poly, center = place_finger_cut_adjusted(
-#                         tool_polygon, points_inch, finger_cut_centers, final_polygons_inch)
-#                     if union_poly is not None:
-#                         tool_polygon = union_poly
-#                     else:
-#                         break  # Stop if we can't place more cuts
-            
-#             # Get exterior coordinates with validation
-#             exterior_coords = polygon_to_exterior_coords(tool_polygon)
-#             if len(exterior_coords) < 4:
-#                 print(f"Warning: Insufficient exterior points ({len(exterior_coords)})")
-#                 continue
+                if len(exterior_coords) < 3:
+                    logger.warning(f"Skipping contour {idx}: insufficient exterior points ({len(exterior_coords)})")
+                    continue
+                    
+                msp.add_spline(exterior_coords, degree=degree, dxfattribs={"layer": "TOOLS"})
+                final_polygons_inch.append(tool_polygon)
+                logger.debug(f"Added spline for contour {idx}")
                 
-#             # Add to DXF
-#             msp.add_spline(exterior_coords, degree=degree, dxfattribs={"layer": "TOOLS"})
-#             final_polygons_inch.append(tool_polygon)
-            
-#         except Exception as e:
-#             print(f"Error processing contour: {e}")
-            
-#     return doc, final_polygons_inch
-
+            except ValueError as e:
+                logger.warning(f"Skipping contour {idx}: {e}")
+                
+        logger.info(f"Completed save_dxf_spline with {len(final_polygons_inch)} successful polygons")
+        return doc, final_polygons_inch
+        
+    except Exception as e:
+        logger.error(f"Error in save_dxf_spline: {e}")
+        raise
 
 def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width, offset_unit, annotation_text="", image_height_in=None, image_width_in=None):
     msp = doc.modelspace()
@@ -956,8 +1182,8 @@ def predict(
         print(f"Error calculating scaling factor: {e}")
 
     if scaling_factor is None or scaling_factor == 0:
-        scaling_factor = 0.05
-        print("Using default scaling factor of 0.05 due to calculation error")
+        scaling_factor = 0.7
+        print("Using default scaling factor of 0.7 due to calculation error")
     gc.collect()
     print("Scaling factor determined: {}".format(scaling_factor))
 
@@ -975,7 +1201,7 @@ def predict(
         else:
             boundary_length_in = boundary_length
             boundary_width_in = boundary_width
-        
+            
     # ---------------------
     # 5) Remove background from the shrunked drawer image (main objects)
     # ---------------------
@@ -983,8 +1209,14 @@ def predict(
         if offset_value < 1:
             offset_value = offset_value * 25.4
         offset_inches = offset_value / 25.4
+        if offset_value==0:
+            offset_value = offset_value * 25.4
+            offset_inches = offset_value / 25.4
+            offset_inches+=0.005
     else:
         offset_inches = offset_value
+        if offset_inches==0:
+            offset_inches+=0.005
 
     t = time.time()
     orig_size = shrunked_img.shape[:2]
@@ -1058,8 +1290,7 @@ def predict(
         )
         if boundary_polygon is not None:
             final_polygons_inch.append(boundary_polygon)
-        # else:
-        #     raise boundary_issue("Raised when bounds are given but rectangular boundary is no.")
+
     # ---------------------
     # 8) Add annotation text (if provided) in the DXF
     # ---------------------
@@ -1089,7 +1320,7 @@ def predict(
                 translated_paths, 
                 dxfattribs={"layer": "ANNOTATION", "color": 7}
             )
-    
+
     # Save the DXF
     dxf_filepath = os.path.join("./outputs", "out.dxf")
     doc.saveas(dxf_filepath)
@@ -1161,17 +1392,44 @@ def predict(
                 2,  # Thinner inner part
                 cv2.LINE_AA
             )
+        else:
+            text_height_cv = 0.75
+            text_x_img = int(((inner_min_x + inner_max_x) / 2.0) / scaling_factor)
+            text_y_in = inner_min_y - 0.125 - text_height_cv  
+            text_y_img = int(processed_size[0] - (text_y_in / scaling_factor))
+            org = (text_x_img - int(len(annotation_text.strip()) * 6), text_y_img)
+
+            cv2.putText(
+                output_img,
+                annotation_text.strip(),
+                org,
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1.2,
+                (0, 0, 255),
+                2,
+                cv2.LINE_AA
+            )
+            cv2.putText(
+                new_outlines,
+                annotation_text.strip(),
+                org,
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1.2,
+                (0, 0, 255),
+                2,
+                cv2.LINE_AA
+            )
 
-        outlines_color = cv2.cvtColor(new_outlines, cv2.COLOR_BGR2RGB)
-        print("Total prediction time: {:.2f} seconds".format(time.time() - overall_start))
+    outlines_color = cv2.cvtColor(new_outlines, cv2.COLOR_BGR2RGB)
+    print("Total prediction time: {:.2f} seconds".format(time.time() - overall_start))
 
-        return (
-            cv2.cvtColor(output_img, cv2.COLOR_BGR2RGB),
-            outlines_color,
-            dxf_filepath,
-            dilated_mask,
-            str(scaling_factor)
-        )
+    return (
+        cv2.cvtColor(output_img, cv2.COLOR_BGR2RGB),
+        outlines_color,
+        dxf_filepath,
+        dilated_mask,
+        str(scaling_factor)
+    )
 
 # ---------------------
 # Gradio Interface
@@ -1189,10 +1447,10 @@ if __name__ == "__main__":
             gr.Image(label="Input Image"),
             gr.Number(label="Offset value for Mask", value=0.075),
             gr.Dropdown(label="Offset Unit", choices=["mm", "inches"], value="inches"),
-            gr.Dropdown(label="Add Finger Clearance?", choices=["Yes", "No"], value="Yes"),
-            gr.Dropdown(label="Add Rectangular Boundary?", choices=["Yes", "No"], value="Yes"),
-            gr.Number(label="Boundary Length", value=30.0, precision=2),
-            gr.Number(label="Boundary Width", value=30.0, precision=2),
+            gr.Dropdown(label="Add Finger Clearance?", choices=["Yes", "No"], value="No"),
+            gr.Dropdown(label="Add Rectangular Boundary?", choices=["Yes", "No"], value="No"),
+            gr.Number(label="Boundary Length", value=300.0, precision=2),
+            gr.Number(label="Boundary Width", value=200.0, precision=2),
             gr.Textbox(label="Annotation (max 20 chars)", max_length=20, placeholder="Type up to 20 characters")
         ],
         outputs=[
@@ -1203,8 +1461,9 @@ if __name__ == "__main__":
             gr.Textbox(label="Scaling Factor (inches/pixel)")
         ],
         examples=[
-            ["./Test20.jpg", 0.075, "inches", "Yes", "No", 30.0, 30.0, "MyTool"],
-            ["./Test21.jpg", 0.075, "inches", "Yes", "Yes", 30.0, 30.0, "Tool2"]
+            ["./Test20.jpg", 0.075, "inches", "No", "No", 300.0, 200.0, "MyTool"],
+            ["./Test21.jpg", 0.075, "inches", "Yes", "Yes", 300.0, 200.0, "Tool2"]
         ]
     )
-    iface.launch(share=True)
+    iface.launch(share=True)
+