Update app.py

app.py

@@ -43,7 +43,7 @@ class DrawerNotDetectedError(Exception):
     pass
 
 class ReferenceBoxNotDetectedError(Exception):
-    """Raised when the reference box cannot be detected in the image"""
+    """Raised when the Reference coin cannot be detected in the image"""
     pass
 
 class BoundaryOverlapError(Exception):
@@ -69,10 +69,10 @@ print("YOLOWorld model loaded in {:.2f} seconds".format(time.time() - start_time
 
 print("Loading YOLO reference model...")
 start_time = time.time()
-reference_model_path = os.path.join(CACHE_DIR, "best.pt")
+reference_model_path = os.path.join(CACHE_DIR, "coin_det.pt")
 if not os.path.exists(reference_model_path):
     print("Caching YOLO reference model to", reference_model_path)
-    shutil.copy("best.pt", reference_model_path)
+    shutil.copy("coin_det.pt", reference_model_path)
 reference_detector_global = YOLO(reference_model_path)
 print("YOLO reference model loaded in {:.2f} seconds".format(time.time() - start_time))
 
@@ -120,7 +120,7 @@ def unload_and_reload_models():
     gc.collect()
     new_drawer_detector = YOLOWorld(os.path.join(CACHE_DIR, "yolov8x-worldv2.pt"))
     new_drawer_detector.set_classes(["box"])
-    new_reference_detector = YOLO(os.path.join(CACHE_DIR, "best.pt"))
+    new_reference_detector = YOLO(os.path.join(CACHE_DIR, "coin_det.pt"))
     new_birefnet = AutoModelForImageSegmentation.from_pretrained(
         "zhengpeng7/BiRefNet", trust_remote_code=True, cache_dir=CACHE_DIR
     )
@@ -155,10 +155,10 @@ 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.15)
+    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 box not detected in the image.")
-    print("Reference detection completed in {:.2f} seconds".format(time.time() - t))
+        raise ReferenceBoxNotDetectedError("Reference Coin not detected in the image.")
+    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]
@@ -243,118 +243,811 @@ 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
+
+# # ---------------------
+# # 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
+
+# #                     # 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
+
+# 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 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)
+
+# ---------------------
+# 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
+#     attempts = 0
+#     timeout_secs = 0.1  # 100ms timeout
+#     start_time = time.perf_counter()
+#     fallback_triggered = False
+#     tool_polygon= tool_polygon1
+
+#     # 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
+
+#                     # 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
+
+#                     # 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
+
+#     # 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]
+
+# ---------------------
+# 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 = []
+
+#     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]
+            
+#             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}")
+    
+#     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
+
+# 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
+
+# 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}")
+    
     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
+        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
 
-# ---------------------
-# 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
+    logger.info(f"Starting extract_outlines with image shape {binary_image.shape}")
+    
+    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
 
-# ---------------------
-# 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
+    logger.info(f"Starting union_tool_and_circle with center at {center_inch}")
+    
+    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):
-    return Polygon(points_inch)
+    logger.info(f"Starting build_tool_polygon with {len(points_inch)} 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):
-    if poly.geom_type == "MultiPolygon":
-        biggest = max(poly.geoms, key=lambda g: g.area)
-        poly = biggest
-    if not poly.exterior:
+# def polygon_to_exterior_coords(poly: Polygon):
+#     logger.info(f"Starting polygon_to_exterior_coords with polygon type {poly.geom_type}")
+    
+#     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 polygon_to_exterior_coords(poly):
+    logger.info(f"Starting polygon_to_exterior_coords with polygon type {poly.geom_type}")
+    
+    try:
+        # Handle GeometryCollection case specifically
+        if poly.geom_type == "GeometryCollection":
+            logger.warning("Converting GeometryCollection to Polygon")
+            # Find the largest geometry in the collection that has an exterior
+            largest_area = 0
+            largest_geom = None
+            for geom in poly.geoms:
+                if hasattr(geom, 'area') and geom.area > largest_area:
+                    if hasattr(geom, 'exterior') or geom.geom_type == "MultiPolygon":
+                        largest_area = geom.area
+                        largest_geom = geom
+            
+            if largest_geom is None:
+                logger.warning("No valid geometry found in GeometryCollection")
+                return []
+                
+            poly = largest_geom
+        
+        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 hasattr(poly, 'exterior') or poly.exterior is None:
+            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}")
+        # Return empty list as fallback
         return []
-    return list(poly.exterior.coords)
+    
+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")
+    
+    # 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:
+            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
 
-def place_finger_cut_adjusted(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
-    attempts = 0
+    
+    # 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]
+    
+    # Randomize candidate points order
     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, 5):
-            for dy in np.linspace(-0.1, 0.1, 5):
-                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
-                circle_poly = Point(candidate_center).buffer(radius, resolution=64)
-                union_poly = tool_polygon.union(circle_poly)
-                overlap = False
-                # Check against other tool polygons for overlap or proximity issues
-                for poly in all_polygons:
-                    if union_poly.intersects(poly) or circle_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
+    random.shuffle(indices)
+    logger.debug(f"Shuffled {len(indices)} point indices")
 
-# ---------------------
-# DXF Spline and Boundary Functions
-# ---------------------
-def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
+    # Use a non-blocking timeout approach with explicit time checks
+    start_time = time.time()
+    timeout_seconds = 5
+    attempts = 0
+    
+    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()
+                
+            # 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()
+                    
+                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
+                    
+                    # 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()
+                
+            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(offset_value,inflated_contours, scaling_factor, height, finger_clearance=False):
+    logger.info(f"Starting save_dxf_spline with {len(inflated_contours)} contours")
+    
     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=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}")
-    return doc, final_polygons_inch
+    
+    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)}")
+            
+            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:
+                    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)
+                
+                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+offset_value), 
+                            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)
+                
+                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}")
+                
+            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()
@@ -411,13 +1104,11 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     msp.add_lwpolyline(rect_coords, close=True, dxfattribs={"layer": "BOUNDARY"})
     
     text_top = boundary_polygon.bounds[1] + 1
-    if (annotation_text.strip()==0):
-        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.")
-    else:
-        if text_top > (min_y - 0.75):
-            raise TextOverlapError("Error: The Text is overlapping the inner contours of the object.")
-        
+    too_small = boundary_width_in < inner_width + 2 * clearance_side or boundary_length_in < inner_length + 2 * clearance_tb
+    if too_small:
+        raise BoundaryOverlapError("Error: The specified boundary dimensions are too small and overlap with the inner contours. Please provide larger values.")
+    if annotation_text.strip() and text_top > min_y - 0.75:
+        raise TextOverlapError("Error: The text is too close to the inner contours. Please increase boundary length.")
     return boundary_polygon
 
 def draw_polygons_inch(polygons_inch, image_rgb, scaling_factor, image_height, color=(0,0,255), thickness=2):
@@ -501,7 +1192,7 @@ def predict(
     try:
         t = time.time()
         reference_obj_img, scaling_box_coords = detect_reference_square(shrunked_img)
-        print("Reference square detection completed in {:.2f} seconds".format(time.time() - t))
+        print("Reference coin detection completed in {:.2f} seconds".format(time.time() - t))
     except ReferenceBoxNotDetectedError as e:
         return None, None, None, None, f"Error: {str(e)}"
 
@@ -511,14 +1202,15 @@ def predict(
     t = time.time()
     reference_obj_img = make_square(reference_obj_img)
     reference_square_mask = remove_bg_u2netp(reference_obj_img)
+    reference_square_mask= resize_img(reference_square_mask,(reference_obj_img.shape[1],reference_obj_img.shape[0]))
     print("Reference image processing completed in {:.2f} seconds".format(time.time() - t))
 
     t = time.time()
     try:
         cv2.imwrite("mask.jpg", cv2.cvtColor(reference_obj_img, cv2.COLOR_RGB2GRAY))
         scaling_factor = calculate_scaling_factor(
-            reference_image_path="./Reference_ScalingBox.jpg",
             target_image=reference_square_mask,
+            reference_obj_size_mm=0.955,
             feature_detector="ORB",
         )
     except ZeroDivisionError:
@@ -529,8 +1221,8 @@ def predict(
         print(f"Error calculating scaling factor: {e}")
 
     if scaling_factor is None or scaling_factor == 0:
-        scaling_factor = 1.0
-        print("Using default scaling factor of 1.0 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))
 
@@ -556,15 +1248,21 @@ 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]
     objects_mask = remove_bg(shrunked_img)
     processed_size = objects_mask.shape[:2]
 
-    objects_mask = exclude_scaling_box(objects_mask, scaling_box_coords, orig_size, processed_size, expansion_factor=2)
+    objects_mask = exclude_scaling_box(objects_mask, scaling_box_coords, orig_size, processed_size, expansion_factor=1.2)
     objects_mask = resize_img(objects_mask, (shrunked_img.shape[1], shrunked_img.shape[0]))
     del scaling_box_coords
     gc.collect()
@@ -594,7 +1292,7 @@ def predict(
     t = time.time()
     use_finger_clearance = True if finger_clearance.lower() == "yes" else False
     doc, final_polygons_inch = save_dxf_spline(
-        contours, scaling_factor, processed_size[0], finger_clearance=use_finger_clearance
+        offset_inches,contours, scaling_factor, processed_size[0], finger_clearance=use_finger_clearance
     )
     del contours
     gc.collect()
@@ -638,28 +1336,29 @@ def predict(
     msp = doc.modelspace()
     
     if annotation_text.strip():
-        text_x = ((inner_min_x + inner_max_x) / 2.0) - (int(len(annotation_text.strip()) / 2.0))
-        text_height_dxf = 0.75  
-        text_y_dxf = boundary_polygon.bounds[1] + 0.25
-        font = get_font_face("Arial")
-        paths = text2path.make_paths_from_str(
-            annotation_text.strip().upper(),
-            font=font,  # Use default font
-            size=text_height_dxf,
-            align=TextEntityAlignment.LEFT
-        )
+        if boundary_polygon is not None:
+            text_x = ((inner_min_x + inner_max_x) / 2.0) - (int(len(annotation_text.strip()) / 2.0))
+            text_height_dxf = 0.75  
+            text_y_dxf = boundary_polygon.bounds[1] + 0.25
+            font = get_font_face("Arial")
+            paths = text2path.make_paths_from_str(
+                annotation_text.strip().upper(),
+                font=font,  # Use default font
+                size=text_height_dxf,
+                align=TextEntityAlignment.LEFT
+            )
+            
+            # Create a translation matrix
+            translation = ezdxf.math.Matrix44.translate(text_x, text_y_dxf, 0)
+            # Apply the translation to each path
+            translated_paths = [p.transform(translation) for p in paths]
         
-        # Create a translation matrix
-        translation = ezdxf.math.Matrix44.translate(text_x, text_y_dxf, 0)
-        # Apply the translation to each path
-        translated_paths = [p.transform(translation) for p in paths]
-    
-        # Render the paths as splines and polylines
-        path.render_splines_and_polylines(
-            msp, 
-            translated_paths, 
-            dxfattribs={"layer": "ANNOTATION", "color": 7}
-        )
+            # Render the paths as splines and polylines
+            path.render_splines_and_polylines(
+                msp, 
+                translated_paths, 
+                dxfattribs={"layer": "ANNOTATION", "color": 7}
+            )
 
     # Save the DXF
     dxf_filepath = os.path.join("./outputs", "out.dxf")
@@ -673,64 +1372,92 @@ def predict(
     draw_polygons_inch(final_polygons_inch, new_outlines, scaling_factor, processed_size[0], color=(0, 0, 255), thickness=2)
 
     if annotation_text.strip():
-        text_height_cv = 0.75
-        text_x_img = int(((inner_min_x + inner_max_x) / 2.0) / scaling_factor)
-        text_y_in = boundary_polygon.bounds[1] + 0.25
-        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)
-
-        # Method 2: Use two different thicknesses
-        # Draw thicker outline
-        temp_img = np.zeros_like(output_img)
-
-        cv2.putText(
-            temp_img,
-            annotation_text.strip().upper(),
-            org,
-            cv2.FONT_HERSHEY_SIMPLEX,
-            2,
-            (0, 0, 255),  # Red color
-            4,  # Thicker outline
-            cv2.LINE_AA
-        )
-
-        cv2.putText(
-            temp_img,
-            annotation_text.strip().upper(),
-            org,
-            cv2.FONT_HERSHEY_SIMPLEX,
-            2,
-            (0, 0, 0),  # Black to create hole
-            2,  # Thinner inner part
-            cv2.LINE_AA
-        )
-
-        outline_mask = cv2.cvtColor(temp_img, cv2.COLOR_BGR2GRAY)
-        _, outline_mask = cv2.threshold(outline_mask, 1, 255, cv2.THRESH_BINARY)
-
-        output_img[outline_mask > 0] = temp_img[outline_mask > 0]
-                
-        cv2.putText(
-            new_outlines,
-            annotation_text.strip().upper(),
-            org,
-            cv2.FONT_HERSHEY_SIMPLEX,
-            2,
-            (0, 0, 255),  # Red color
-            4,  # Thicker outline
-            cv2.LINE_AA
-        )
-        
-        cv2.putText(
-            new_outlines,
-            annotation_text.strip().upper(),
-            org,
-            cv2.FONT_HERSHEY_SIMPLEX,
-            2,
-            (255, 255, 255),  # Inner text in white
-            2,  # Thinner inner part
-            cv2.LINE_AA
-        )
+        if boundary_polygon is not None:
+            text_height_cv = 0.75
+            text_x_img = int(((inner_min_x + inner_max_x) / 2.0) / scaling_factor)
+            text_y_in = boundary_polygon.bounds[1] + 0.25
+            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)
+
+            # Method 2: Use two different thicknesses
+            # Draw thicker outline
+            temp_img = np.zeros_like(output_img)
+
+            cv2.putText(
+                temp_img,
+                annotation_text.strip().upper(),
+                org,
+                cv2.FONT_HERSHEY_SIMPLEX,
+                2,
+                (0, 0, 255),  # Red color
+                4,  # Thicker outline
+                cv2.LINE_AA
+            )
+
+            cv2.putText(
+                temp_img,
+                annotation_text.strip().upper(),
+                org,
+                cv2.FONT_HERSHEY_SIMPLEX,
+                2,
+                (0, 0, 0),  # Black to create hole
+                2,  # Thinner inner part
+                cv2.LINE_AA
+            )
+
+            outline_mask = cv2.cvtColor(temp_img, cv2.COLOR_BGR2GRAY)
+            _, outline_mask = cv2.threshold(outline_mask, 1, 255, cv2.THRESH_BINARY)
+
+            output_img[outline_mask > 0] = temp_img[outline_mask > 0]
+                    
+            cv2.putText(
+                new_outlines,
+                annotation_text.strip().upper(),
+                org,
+                cv2.FONT_HERSHEY_SIMPLEX,
+                2,
+                (0, 0, 255),  # Red color
+                4,  # Thicker outline
+                cv2.LINE_AA
+            )
+            
+            cv2.putText(
+                new_outlines,
+                annotation_text.strip().upper(),
+                org,
+                cv2.FONT_HERSHEY_SIMPLEX,
+                2,
+                (255, 255, 255),  # Inner text in white
+                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))
@@ -759,10 +1486,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="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.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=50, precision=2),
+            gr.Number(label="Boundary Width", value=50, precision=2),
             gr.Textbox(label="Annotation (max 20 chars)", max_length=20, placeholder="Type up to 20 characters")
         ],
         outputs=[
@@ -773,8 +1500,9 @@ if __name__ == "__main__":
             gr.Textbox(label="Scaling Factor (inches/pixel)")
         ],
         examples=[
-            ["./Test20.jpg", 0.075, "inches", "No", "No", 300.0, 200.0, "MyTool"],
+            ["./Test20.jpg", 0.075, "inches", "Yes", "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)
+