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,9 +155,9 @@ 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.")
+        raise ReferenceBoxNotDetectedError("Reference Coin not detected in the image.")
     print("Reference detection completed in {:.2f} seconds".format(time.time() - t))
     return (
         save_one_box(res[0].cpu().boxes.xyxy, res[0].orig_img, save=False),
@@ -286,42 +286,441 @@ def polygon_to_exterior_coords(poly: Polygon):
         return []
     return list(poly.exterior.coords)
 
-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
+# def place_finger_cut_adjusted(
+#     tool_polygon,
+#     points_inch,
+#     existing_centers,
+#     all_polygons,
+#     circle_diameter=1,  # Finger cut circle diameter in inches.
+#     min_gap=0.25,         # Minimum clearance (in inches) between the finger cut and adjacent contours.
+#     max_attempts=50       # Maximum candidate attempts.
+# ):
+#     """
+#     Attempts to place a finger-cut circle along the tool polygon's contour, biased toward one side
+#     (the boundary side) by shifting the candidate center away from the polygon centroid.
+#     The candidate circle is merged with the tool polygon via union_tool_and_circle().
+#     Debug information is printed to help trace candidate evaluation.
+
+#     :param tool_polygon: Shapely Polygon representing the tool contour.
+#     :param points_inch: List of (x, y) points (in inches) along the contour.
+#     :param existing_centers: List of already accepted finger cut centers.
+#     :param all_polygons: List of all polygons (for overlap checking).
+#     :param circle_diameter: Diameter of the finger cut (in inches).
+#     :param min_gap: Clearance (in inches) required between the finger cut and any adjacent contour.
+#     :param max_attempts: Maximum number of candidate attempts.
+#     :return: (updated_polygon, candidate_center) if successful; otherwise, (None, None).
+#     """
+#     import random
+#     from shapely.geometry import Point
+#     import numpy as np
+
+#     needed_center_distance = circle_diameter + min_gap
+#     radius = circle_diameter / 2.0
+#     attempts = 0
+
+#     # Parameter: how far to push the candidate center outward.
+#     # Here we set it to half the circle radius, but you can adjust this as needed.
+#     outward_offset = radius * 0.1
+
+#     # Compute the centroid of the tool polygon once.
+#     polygon_centroid = tool_polygon.centroid
+
+#     # Create a safe version of the polygon via an inward buffer.
+#     safe_tool_polygon = tool_polygon.buffer(-min_gap)
+#     if safe_tool_polygon.is_empty:
+#         safe_tool_polygon = tool_polygon
+
+#     # Shuffle the contour indices for randomness.
+#     indices = list(range(len(points_inch)))
+#     random.shuffle(indices)
+
+#     for i in indices:
+#         if attempts >= max_attempts:
+#             break
+
+#         # Base candidate point from the resampled contour:
+#         base_x, base_y = points_inch[i]
+
+#         # Try a grid of offsets from this candidate base point.
+#         for dx in np.linspace(-0.3, 0.3, 15):
+#             for dy in np.linspace(-0.3, 0.3, 15):
+#                 # Compute an initial candidate point.
+#                 candidate_unshifted = (base_x + dx, base_y + dy)
+                
+#                 # Compute the outward direction based on the vector from the centroid to candidate.
+#                 vec_x = candidate_unshifted[0] - polygon_centroid.x
+#                 vec_y = candidate_unshifted[1] - polygon_centroid.y
+#                 norm = np.hypot(vec_x, vec_y)
+#                 if norm == 0:
+#                     continue  # Skip degenerate case.
+#                 # Normalize the outward vector.
+#                 unit_vec = (vec_x / norm, vec_y / norm)
+#                 # Push the candidate center further out so it lies along the boundary.
+#                 candidate_center = (candidate_unshifted[0] + unit_vec[0] * outward_offset,
+#                                     candidate_unshifted[1] + unit_vec[1] * outward_offset)
+
+#                 # Check that candidate center is not too close to previously accepted centers.
+#                 if any(np.hypot(candidate_center[0] - ex, candidate_center[1] - ey) < needed_center_distance 
+#                        for ex, ey in existing_centers):
+#                     continue
+
+#                 # Create the candidate circle.
+#                 candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
+                
+#                 # Check if the candidate circle is mostly on the boundary:
+#                 area_ratio = candidate_circle.intersection(tool_polygon).area / candidate_circle.area
+#                 # Debug: Show candidate center and its area ratio.
+#                 #print(f"Candidate center: {candidate_center}, area_ratio: {area_ratio:.2f}")
+#                 # Accept if at least 70% of the circle's area lies within the tool polygon.
+#                 if area_ratio < 0.6:  
+#                     continue
+
+#                 # Merge candidate circle with tool polygon using the existing union function.
+#                 candidate_union = union_tool_and_circle(tool_polygon, candidate_center, circle_diameter)
+
+#                 # Overlap check: ensure this candidate does not intrude on any other object.
+#                 overlap = False
+#                 for other_poly in all_polygons:
+#                     if other_poly.equals(tool_polygon):
+#                         continue
+#                     if candidate_union.intersects(other_poly) or candidate_circle.buffer(min_gap).intersects(other_poly):
+#                         overlap = True
+#                         #print(f"Candidate at {candidate_center} rejected due to overlap.")
+#                         break
+#                 if overlap:
+#                     continue
+
+#                 # Candidate accepted.
+#                 print(f"Accepted candidate center: {candidate_center} with area_ratio: {area_ratio:.2f}")
+#                 existing_centers.append(candidate_center)
+#                 return candidate_union, candidate_center
+
+#         attempts += 1
+
+#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
+#     return None, None
+
+
+# def place_finger_cut_adjusted(
+#     tool_polygon,
+#     points_inch,
+#     existing_centers,
+#     all_polygons,
+#     circle_diameter=1.0,  # Finger cut circle diameter in inches.
+#     min_gap=0.25,         # Minimum clearance (in inches) between the finger cut and adjacent contours.
+#     max_attempts=50       # Maximum candidate attempts.
+# ):
+#     """
+#     Attempts to place a finger-cut circle along the tool polygon's contour, biased toward one side
+#     (the boundary side) by shifting the candidate center away from the polygon centroid.
+#     Simplified version that maintains core functionality while using a more streamlined approach.
+    
+#     :param tool_polygon: Shapely Polygon representing the tool contour.
+#     :param points_inch: List of (x, y) points (in inches) along the contour.
+#     :param existing_centers: List of already accepted finger cut centers.
+#     :param all_polygons: List of all polygons (for overlap checking).
+#     :param circle_diameter: Diameter of the finger cut (in inches).
+#     :param min_gap: Clearance (in inches) required between the finger cut and any adjacent contour.
+#     :param max_attempts: Maximum number of candidate attempts.
+#     :return: (updated_polygon, candidate_center) if successful; otherwise, (None, None).
+#     """
+#     import random
+#     import numpy as np
+#     from shapely.geometry import Point
+    
+#     needed_center_distance = circle_diameter + min_gap
+#     radius = circle_diameter / 2.0
+    
+#     # Compute the centroid of the tool polygon once.
+#     polygon_centroid = tool_polygon.centroid
+    
+#     # Parameter: how far to push the candidate center outward.
+#     outward_offset = radius * 0.5
+    
+#     # Try random points along the contour
+#     indices = list(range(len(points_inch)))
+#     random.shuffle(indices)
+    
+#     for idx in indices[:max_attempts]:
+#         # Get base point from contour
+#         base_x, base_y = points_inch[idx]
+        
+#         # Calculate the outward vector from centroid to point
+#         vec_x = base_x - polygon_centroid.x
+#         vec_y = base_y - polygon_centroid.y
+#         norm = np.hypot(vec_x, vec_y)
+        
+#         if norm == 0:
+#             continue  # Skip if point is at centroid
+            
+#         # Normalize and calculate shifted candidate center
+#         unit_vec = (vec_x / norm, vec_y / norm)
+#         candidate_center = (base_x + unit_vec[0] * outward_offset,
+#                            base_y + unit_vec[1] * outward_offset)
+        
+#         # Check distance from existing centers
+#         too_close = False
+#         for (ex_x, ex_y) in existing_centers:
+#             if np.hypot(candidate_center[0] - ex_x, candidate_center[1] - ex_y) < needed_center_distance:
+#                 too_close = True
+#                 break
+                
+#         if too_close:
+#             continue
+            
+#         # Create the candidate circle
+#         candidate_circle = Point(candidate_center).buffer(radius, resolution=64)
+        
+#         # Check if circle is mostly on the boundary (at least 60% inside)
+#         area_ratio = candidate_circle.intersection(tool_polygon).area / candidate_circle.area
+#         if area_ratio < 0.6:
+#             continue
+            
+#         # Merge candidate with tool polygon
+#         union_poly = union_tool_and_circle(tool_polygon, candidate_center, circle_diameter)
+        
+#         # Check for overlaps with other polygons
+#         overlap = False
+#         for other_poly in all_polygons:
+#             if other_poly.equals(tool_polygon):
+#                 continue
+#             if union_poly.intersects(other_poly) or candidate_circle.buffer(min_gap).intersects(other_poly):
+#                 overlap = True
+#                 break
+                
+#         if overlap:
+#             continue
+            
+#         # Candidate accepted
+#         print(f"Accepted candidate center: {candidate_center} with area_ratio: {area_ratio:.2f}")
+#         existing_centers.append(candidate_center)
+#         return union_poly, candidate_center
+    
+#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
+#     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=100):
+#     import random
+#     needed_center_distance = circle_diameter + min_gap
+#     radius = circle_diameter / 2.0
+#     for _ in range(max_attempts):
+#         idx = random.randint(0, len(points_inch) - 1)
+#         cx, cy = points_inch[idx]
+#         too_close = False
+#         for (ex_x, ex_y) in existing_centers:
+#             if np.hypot(cx - ex_x, cy - ex_y) < needed_center_distance:
+#                 too_close = True
+#                 break
+#         if too_close:
+#             continue
+#         circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
+#         union_poly = tool_polygon.union(circle_poly)
+#         overlap_with_others = False
+#         too_close_to_others = False
+#         for poly in all_polygons:
+#             if union_poly.intersects(poly):
+#                 overlap_with_others = True
+#                 break
+#             if circle_poly.buffer(min_gap).intersects(poly):
+#                 too_close_to_others = True
+#                 break
+#         if overlap_with_others or too_close_to_others:
+#             continue
+#         existing_centers.append((cx, cy))
+#         return union_poly, (cx, cy)
+#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
+#     return None, None
+
+# def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, 2nd best
+#                               circle_diameter=1.0, min_gap=0.25, max_attempts=30):
+#     import random
+#     from shapely.geometry import Point
+
+#     # Analyze bounding box
+#     bounds = tool_polygon.bounds  # (minx, miny, maxx, maxy)
+#     width = bounds[2] - bounds[0]
+#     height = bounds[3] - bounds[1]
+#     min_dim = min(width, height)
+
+#     # Adjust circle diameter based on tool size
+#     scale_factor = min(1.0, min_dim / 2.0)  # Adjust this factor to control size sensitivity
+#     adjusted_diameter = circle_diameter * scale_factor
+#     radius = adjusted_diameter / 2.0
+#     needed_center_distance = adjusted_diameter + min_gap
+
+#     for _ in range(max_attempts):
+#         idx = random.randint(0, len(points_inch) - 1)
+#         cx, cy = points_inch[idx]
+
+#         # Check distance from existing centers
+#         if any(np.hypot(cx - ex_x, cy - ex_y) < needed_center_distance for ex_x, ex_y in existing_centers):
+#             continue
+
+#         circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
+#         union_poly = tool_polygon.union(circle_poly)
+
+#         overlap_with_others = any(union_poly.intersects(poly) for poly in all_polygons)
+#         too_close_to_others = any(circle_poly.buffer(min_gap).intersects(poly) for poly in all_polygons)
+
+#         if overlap_with_others or too_close_to_others:
+#             continue
+
+#         existing_centers.append((cx, cy))
+#         return union_poly, (cx, cy)
+
+#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
+#     return None, None
+
+
+def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.25, max_attempts=30): #1st best
     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, 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
+    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.intersects(poly):
+                overlap_with_others = True
+                break
+
+            if circle_poly.buffer(min_gap).intersects(poly):
+                too_close_to_others = True
+                break
+
+        if overlap_with_others or too_close_to_others:
+            continue
+
+        existing_centers.append((cx, cy))
+        return union_poly, (cx, cy)
+
     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
     return None, None
 
+
+# def place_finger_cut_adjusted(tool_polygon, points_inch, existing_centers, all_polygons,
+#                               circle_diameter=1.0, min_gap=0.25, max_attempts=30):
+#     fallback_diameters = [circle_diameter, 0.75, 0.5, 0.4]  # Try these in order
+
+#     for fallback_d in fallback_diameters:
+#         radius = fallback_d / 2.0
+#         needed_center_distance = fallback_d + min_gap
+
+#         for _ in range(max_attempts):
+#             idx = random.randint(0, len(points_inch) - 1)
+#             cx, cy = points_inch[idx]
+
+#             # Check distance from existing centers
+#             too_close = any(np.hypot(cx - ex_x, cy - ex_y) < needed_center_distance
+#                             for ex_x, ex_y in existing_centers)
+#             if too_close:
+#                 continue
+
+#             # Create and check the finger cut circle
+#             circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
+#             union_poly = tool_polygon.union(circle_poly)
+
+#             if not union_poly.is_valid:
+#                 continue  # Skip invalid geometry
+
+#             # Check against all other polygons strictly
+#             overlap = False
+#             for poly in all_polygons:
+#                 if poly.equals(tool_polygon):
+#                     continue
+
+#                 # Shrink slightly to avoid even edge contact
+#                 if union_poly.intersects(poly.buffer(-1e-3)):
+#                     overlap = True
+#                     break
+#                 if circle_poly.buffer(min_gap).intersects(poly):
+#                     overlap = True
+#                     break
+
+#             if overlap:
+#                 continue
+
+#             # Final sanity check
+#             for poly in all_polygons:
+#                 if poly.equals(tool_polygon):
+#                     continue
+#                 if union_poly.intersects(poly):
+#                     print("Overlap slipped through. Rejecting.")
+#                     overlap = True
+#                     break
+
+#             if overlap:
+#                 continue
+
+#             existing_centers.append((cx, cy))
+#             return union_poly, (cx, cy)
+
+#     # If we get here, all attempts failed — still try placing smallest fallback
+#     print("Warning: Could not place cleanly. Forcing smallest fallback.")
+#     smallest_radius = fallback_diameters[-1] / 2.0
+#     for _ in range(100):
+#         idx = random.randint(0, len(points_inch) - 1)
+#         cx, cy = points_inch[idx]
+#         circle_poly = Point((cx, cy)).buffer(smallest_radius, resolution=64)
+#         union_poly = tool_polygon.union(circle_poly)
+#         if union_poly.is_valid:
+#             existing_centers.append((cx, cy))
+#             return union_poly, (cx, cy)
+
+#     # Absolute fallback — return original tool without finger cut
+#     print("Failed to place even smallest fallback. No cutout added.")
+#     return tool_polygon, None
+
+
+# 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
+#     import numpy as np
+#     from shapely.geometry import Point, Polygon
+
+#     needed_center_distance = circle_diameter + min_gap
+#     radius = circle_diameter / 2.0
+#     for _ in range(max_attempts):
+#         idx = random.randint(0, len(points_inch) - 1)
+#         cx, cy = points_inch[idx]
+#         # Check against existing centers
+#         too_close = any(np.hypot(cx - ex_x, cy - ex_y) < needed_center_distance for (ex_x, ex_y) in existing_centers)
+#         if too_close:
+#             continue
+#         circle_poly = Point((cx, cy)).buffer(radius, resolution=64)
+#         # Ensure circle intersects the tool to form a valid cut
+#         if not circle_poly.intersects(tool_polygon):
+#             continue
+#         # Check proximity to other polygons
+#         if any(circle_poly.buffer(min_gap).intersects(poly) for poly in all_polygons):
+#             continue
+#         # Subtract circle from tool and check for overlaps
+#         difference_poly = tool_polygon.difference(circle_poly)
+#         if any(difference_poly.intersects(poly) for poly in all_polygons):
+#             continue
+#         existing_centers.append((cx, cy))
+#         return difference_poly, (cx, cy)
+#     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
+#     return None, None
+
+
 # ---------------------
 # DXF Spline and Boundary Functions
 # ---------------------
@@ -344,7 +743,7 @@ def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=
                 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)
+                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)
@@ -411,13 +810,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 +898,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 +908,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 +927,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))
 
@@ -564,7 +962,7 @@ def predict(
     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()