Update app.py

app.py

@@ -13,7 +13,7 @@ from ezdxf.addons.text2path import make_paths_from_str
 from ezdxf import path
 from ezdxf.addons import text2path
 from ezdxf.enums import TextEntityAlignment
-from ezdxf.fonts.fonts import FontFace,get_font_face
+from ezdxf.fonts.fonts import FontFace, get_font_face
 import gradio as gr
 from PIL import Image, ImageEnhance
 from pathlib import Path
@@ -155,7 +155,7 @@ def yolo_detect(image: Union[str, Path, int, Image.Image, list, tuple, np.ndarra
 
 def detect_reference_square(img: np.ndarray):
     t = time.time()
-    res = reference_detector_global.predict(img, conf=0.25)
+    res = reference_detector_global.predict(img, conf=0.15)
     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))
@@ -286,35 +286,39 @@ def polygon_to_exterior_coords(poly: Polygon):
         return []
     return list(poly.exterior.coords)
 
-def place_finger_cut_randomly(tool_polygon, points_inch, existing_centers, all_polygons, circle_diameter=1.0, min_gap=0.25, max_attempts=30):
+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
-    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)
+    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
     print("Warning: Could not place a finger cut circle meeting all spacing requirements.")
     return None, None
 
@@ -340,7 +344,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_randomly(tool_polygon, points_inch, finger_cut_centers, final_polygons_inch, circle_diameter=1.0, min_gap=0.25, max_attempts=30)
+                union_poly, center = place_finger_cut_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)
@@ -391,11 +395,6 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     if annotation_text.strip():
         clearance_tb = 0.75
 
-    # Check if boundary dimensions are at least larger than inner box plus clearance
-    # 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.")
-   
-
     # Calculate center of inner contours
     center_x = (min_x + max_x) / 2
     center_y = (min_y + max_y) / 2
@@ -411,8 +410,8 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     boundary_polygon = ShapelyPolygon(rect_coords)
     msp.add_lwpolyline(rect_coords, close=True, dxfattribs={"layer": "BOUNDARY"})
     
-    text_top=boundary_polygon.bounds[1] + 1
-    if text_top > (min_y-0.75):
+    text_top = boundary_polygon.bounds[1] + 1
+    if text_top > (min_y - 0.75):
         raise TextOverlapError("Error: The Text is overlapping the inner contours of the object.")
     
     return boundary_polygon
@@ -561,7 +560,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=1.7)
+    objects_mask = exclude_scaling_box(objects_mask, scaling_box_coords, orig_size, processed_size, expansion_factor=2)
     objects_mask = resize_img(objects_mask, (shrunked_img.shape[1], shrunked_img.shape[0]))
     del scaling_box_coords
     gc.collect()
@@ -635,19 +634,9 @@ 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 #+ text_height_dxf#inner_min_y - 0.125 - text_height_dxf  
-        # text_entity = msp.add_text(
-        #     annotation_text.strip().upper(),
-        #     dxfattribs={
-        #         "height": text_height_dxf,
-        #         "layer": "ANNOTATION",
-        #         "style": "Simplex",
-        #     }   
-        # )
-        # text_entity.dxf.insert = (text_x, text_y_dxf)
+        text_y_dxf = boundary_polygon.bounds[1] + 0.25
         font = get_font_face("Arial")
         paths = text2path.make_paths_from_str(
             annotation_text.strip().upper(),
@@ -658,7 +647,7 @@ def predict(
         
         # Create a translation matrix
         translation = ezdxf.math.Matrix44.translate(text_x, text_y_dxf, 0)
-            # Apply the translation to each path
+        # Apply the translation to each path
         translated_paths = [p.transform(translation) for p in paths]
     
         # Render the paths as splines and polylines
@@ -679,33 +668,6 @@ def predict(
     new_outlines = np.ones_like(output_img) * 255
     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_height_cv#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().upper(),
-    #         org,
-    #         cv2.FONT_HERSHEY_SIMPLEX,
-    #         1.2,
-    #         (0, 0, 255),
-    #         2,
-    #         cv2.LINE_AA
-    #     )
-    #     cv2.putText(
-    #         new_outlines,
-    #         annotation_text.strip().upper(),
-    #         org,
-    #         cv2.FONT_HERSHEY_SIMPLEX,
-    #         1.2,
-    #         (0, 0, 255),
-    #         2,
-    #         cv2.LINE_AA
-    #     )
     if annotation_text.strip():
         text_height_cv = 0.75
         text_x_img = int(((inner_min_x + inner_max_x) / 2.0) / scaling_factor)
@@ -715,10 +677,8 @@ def predict(
 
         # Method 2: Use two different thicknesses
         # Draw thicker outline
-        # Create a clean temporary image for drawing the text outline
         temp_img = np.zeros_like(output_img)
 
-        # Draw thick text on temp image
         cv2.putText(
             temp_img,
             annotation_text.strip().upper(),
@@ -730,7 +690,6 @@ def predict(
             cv2.LINE_AA
         )
 
-        # Draw inner text in black on temp image
         cv2.putText(
             temp_img,
             annotation_text.strip().upper(),
@@ -742,27 +701,11 @@ def predict(
             cv2.LINE_AA
         )
 
-        # Create a mask from the temp image
         outline_mask = cv2.cvtColor(temp_img, cv2.COLOR_BGR2GRAY)
         _, outline_mask = cv2.threshold(outline_mask, 1, 255, cv2.THRESH_BINARY)
 
-        # Apply only the red channel from the temp image to the output image
-        # This preserves the original background where the outline isn't
         output_img[outline_mask > 0] = temp_img[outline_mask > 0]
                 
-        # Draw inner part with background color
-        # cv2.putText(
-        #     output_img,
-        #     annotation_text.strip().upper(),
-        #     org,
-        #     cv2.FONT_HERSHEY_SIMPLEX,
-        #     2,
-        #     (255, 255, 255),  # Assuming black background, adjust as needed
-        #     2,  # Thinner inner part
-        #     cv2.LINE_AA
-        # )
-        
-        # Do the same for new_outlines
         cv2.putText(
             new_outlines,
             annotation_text.strip().upper(),
@@ -780,7 +723,7 @@ def predict(
             org,
             cv2.FONT_HERSHEY_SIMPLEX,
             2,
-            (255, 255, 255),  # Assuming black background, adjust as needed
+            (255, 255, 255),  # Inner text in white
             2,  # Thinner inner part
             cv2.LINE_AA
         )