Update app.py

app.py

@@ -676,8 +676,8 @@ def add_rectangular_boundary(doc, polygons_inch, boundary_length, boundary_width
     top = center_y + boundary_length_in / 2
 
     rect_coords = [(left, bottom), (right, bottom), (right, top), (left, top), (left, bottom)]
-    from shapely.geometry import Polygon as ShapelyPolygon
-    boundary_polygon = ShapelyPolygon(rect_coords)
+    from shapely.geometry import Polygon 
+    boundary_polygon = Polygon(rect_coords)
     msp.add_lwpolyline(rect_coords, close=True, dxfattribs={"layer": "BOUNDARY"})
     
     text_top = boundary_polygon.bounds[1] + 1
@@ -708,6 +708,262 @@ def draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color=(0,
     pts_px = np.array(pts_px, dtype=np.int32)
     cv2.polylines(image_rgb, [pts_px], isClosed=True, color=color, thickness=thickness, lineType=cv2.LINE_AA)
 
+# def draw_and_pad(polygons_inch, scaling_factor,boundary_polygon, padding=50, 
+#                  color=(0,0,255), thickness=2):
+#     """
+#     - polygons_inch: list of Shapely Polygons in inch units (already including boundary).
+#     - scaling_factor: inches per pixel.
+#     - padding: padding in pixels.
+#     """
+#     all_x = []
+#     all_y = []
+#     pixel_polys = []
+    
+#     # 1) Convert to pixel coords and collect bounds
+#     for poly in polygons_inch:
+#         coords = list(poly.exterior.coords)
+#         pts = []
+#         for x_in, y_in in coords:
+#             px = int(round(x_in / scaling_factor))
+#             py = int(round(y_in / scaling_factor))
+#             pts.append([px, py])
+#             all_x.append(px)
+#             all_y.append(py)
+#         pixel_polys.append(np.array(pts, dtype=np.int32))
+    
+#     # 2) Compute canvas size
+    
+#     min_x, max_x = min(all_x), max(all_x)
+#     min_y, max_y = min(all_y), max(all_y)
+#     width  = max_x - min_x + 1
+#     height = max_y - min_y + 1
+    
+#     # 3) Create blank white canvas
+#     canvas = 255 * np.ones((height, width, 3), dtype=np.uint8)
+    
+#     # 4) Draw each polygon, flipping y within the local box
+#     for pts in pixel_polys:
+#         # Offset so min corner is (0,0)
+#         pts_off = pts - np.array([[min_x, min_y]])
+#         # Flip y: new_y = height-1 - old_y
+#         pts_off[:,1] = (height - 1) - pts_off[:,1]
+#         cv2.polylines(canvas, [pts_off], isClosed=True, 
+#                       color=color, thickness=thickness, lineType=cv2.LINE_AA)
+    
+#     # 5) Pad the canvas
+
+#         padded = cv2.copyMakeBorder(
+#             canvas,
+#             top=padding, bottom=padding,
+#             left=padding, right=padding,
+#             borderType=cv2.BORDER_CONSTANT,
+#             value=[255,255,255]
+#         )
+#     return padded
+
+# import numpy as np
+# import cv2
+
+# def draw_and_pad(polygons_inch, scaling_factor, boundary_polygon, padding=50,
+#                  color=(0,0,255), thickness=2):
+#     """
+#     - polygons_inch: list of Shapely Polygons in inch units.
+#     - scaling_factor: inches per pixel.
+#     - boundary_polygon: the Shapely boundary polygon, or None.
+#     - padding: base padding in pixels.
+#     """
+#     all_x, all_y = [], []
+#     pixel_polys = []
+    
+#     # 1) Convert to pixel coords and collect bounds
+#     for poly in polygons_inch:
+#         coords = list(poly.exterior.coords)
+#         pts = []
+#         for x_in, y_in in coords:
+#             px = int(round(x_in / scaling_factor))
+#             py = int(round(y_in / scaling_factor))
+#             pts.append([px, py])
+#             all_x.append(px)
+#             all_y.append(py)
+#         pixel_polys.append(np.array(pts, dtype=np.int32))
+    
+#     # 2) Compute canvas size
+#     min_x, max_x = min(all_x), max(all_x)
+#     min_y, max_y = min(all_y), max(all_y)
+#     width  = max_x - min_x + 1
+#     height = max_y - min_y + 1
+    
+#     # 3) Create blank white canvas
+#     canvas = 255 * np.ones((height, width, 3), dtype=np.uint8)
+    
+#     # 4) Draw each polygon, flipping y within the local box
+#     for pts in pixel_polys:
+#         pts_off = pts - np.array([[min_x, min_y]])
+#         pts_off[:,1] = (height - 1) - pts_off[:,1]
+#         cv2.polylines(canvas, [pts_off], isClosed=True, 
+#                       color=color, thickness=thickness, lineType=cv2.LINE_AA)
+    
+#     # 5) Decide padding amounts
+#     if boundary_polygon is not None:
+#         top = bottom = left = right = padding
+#     else:
+#         # Double the padding if there's no boundary, to avoid clipping
+#         top = bottom = left = right = padding * 2
+
+#     # 6) Pad the canvas
+#     padded = cv2.copyMakeBorder(
+#         canvas,
+#         top=top, bottom=bottom,
+#         left=left, right=right,
+#         borderType=cv2.BORDER_CONSTANT,
+#         value=[255,255,255]
+#     )
+#     return padded
+
+import numpy as np
+import cv2
+
+# def draw_and_pad(polygons_inch, scaling_factor, boundary_polygon, padding=50, 
+#                  color=(0, 0, 255), thickness=2):
+#     """
+#     Draws Shapely Polygons (in inch units) on a white canvas.
+    
+#     When boundary_polygon is None, the computed bounds are expanded by the padding value 
+#     so that the drawn contours are not clipped at the edges after adding the final padding.
+    
+#     Arguments:
+#         polygons_inch: list of Shapely Polygons in inch units (already including boundary).
+#         scaling_factor: inches per pixel.
+#         boundary_polygon: the Shapely boundary polygon, or None.
+#         padding: padding in pixels.
+#         color: color of the drawn polylines (in BGR format).
+#         thickness: line thickness.
+
+#     Returns:
+#         padded: an image (numpy array) of the drawn polygons with an external white border.
+#     """
+#     all_x = []
+#     all_y = []
+#     pixel_polys = []
+    
+#     # 1) Convert each polygon to pixel coordinates and compute overall bounds.
+#     for poly in polygons_inch:
+#         coords = list(poly.exterior.coords)
+#         pts = []
+#         for x_in, y_in in coords:
+#             px = int(round(x_in / scaling_factor))
+#             py = int(round(y_in / scaling_factor))
+#             pts.append([px, py])
+#             all_x.append(px)
+#             all_y.append(py)
+#         pixel_polys.append(np.array(pts, dtype=np.int32))
+    
+#     # 2) Compute the basic canvas size from the polygon bounds.
+#     min_x, max_x = min(all_x), max(all_x)
+#     min_y, max_y = min(all_y), max(all_y)
+    
+#     # If no boundary polygon is provided, expand the bounds to add margin
+#     # so that later when we pad externally, the contours do not get clipped.
+#     if boundary_polygon is None:
+#         min_x -= padding
+#         max_x += padding
+#         min_y -= padding
+#         max_y += padding
+
+#     width  = max_x - min_x + 1
+#     height = max_y - min_y + 1
+    
+#     # 3) Create a blank white canvas.
+#     canvas = 255 * np.ones((height, width, 3), dtype=np.uint8)
+    
+#     # 4) Draw each polygon, flipping the y-coordinates to match image coordinates.
+#     for pts in pixel_polys:
+#         # Offset so the minimum corner becomes (0,0) on canvas.
+#         pts_off = pts - np.array([[min_x, min_y]])
+#         # Flip y: image coordinates have (0,0) at the top-left.
+#         pts_off[:, 1] = (height - 1) - pts_off[:, 1]
+#         cv2.polylines(canvas, [pts_off], isClosed=True, 
+#                       color=color, thickness=thickness, lineType=cv2.LINE_AA)
+    
+#     # 5) Finally, add external padding on all sides.
+#     padded = cv2.copyMakeBorder(
+#         canvas,
+#         top=padding, bottom=padding,
+#         left=padding, right=padding,
+#         borderType=cv2.BORDER_CONSTANT,
+#         value=[255, 255, 255]
+#     )
+    
+#     return padded
+
+import numpy as np
+import cv2
+from shapely.geometry import Polygon
+
+import numpy as np
+import cv2
+from shapely.geometry import Polygon
+
+def draw_and_pad(polygons_inch,
+                               scaling_factor,      # inches per pixel
+                               boundary_polygon=None,
+                               max_res=1024,
+                               simplify_tol_px=1.0,
+                               padding_px=50,
+                               color=(0,0,255),
+                               thickness=2):
+    # 1) Simplify & collect raw coords in inches
+    all_x, all_y = [], []
+    simple_polys = []
+    for poly in polygons_inch:
+        tol_in = simplify_tol_px * scaling_factor / max_res
+        simp = poly.simplify(tolerance=tol_in, preserve_topology=True)
+        coords = np.array(simp.exterior.coords)  # (N,2) in inches
+        all_x.extend(coords[:,0])
+        all_y.extend(coords[:,1])
+        simple_polys.append(coords)
+
+    # 2) Compute full‑res pixel extents
+    min_x_in, max_x_in = min(all_x), max(all_x)
+    min_y_in, max_y_in = min(all_y), max(all_y)
+    w_in = (max_x_in - min_x_in) if boundary_polygon is None else (max_x_in - min_x_in)
+    h_in = (max_y_in - min_y_in) if boundary_polygon is None else (max_y_in - min_y_in)
+    full_w_px = np.ceil(w_in / scaling_factor)
+    full_h_px = np.ceil(h_in / scaling_factor)
+
+    # 3) Compute preview scale ≤1 so dims ≤ max_res
+    scale = min(max_res / full_w_px, max_res / full_h_px, 1.0)
+
+    # 4) Compute preview dims & allocate _fully‐padded_ canvas
+    W = int(np.ceil(full_w_px * scale))
+    H = int(np.ceil(full_h_px * scale))
+    PW, PH = W + 2*padding_px, H + 2*padding_px
+    canvas = 255 * np.ones((PH, PW, 3), dtype=np.uint8)
+
+    # Precompute offsets (in preview px) of the “world origin”
+    off_x = int(np.floor(min_x_in / scaling_factor * scale))
+    off_y = int(np.floor(min_y_in / scaling_factor * scale))
+
+    # 5) Draw each polygon, now fully inside the padded canvas
+    for coords in simple_polys:
+        # inch→preview‐px transform
+        pts = ((coords / scaling_factor) * scale).round().astype(int)
+        # shift by both the minimum and the padding:
+        pts[:,0] = pts[:,0] - off_x + padding_px
+        pts[:,1] = pts[:,1] - off_y + padding_px
+        # flip Y into image coords
+        pts[:,1] = PH - 1 - pts[:,1]
+        cv2.polylines(canvas,
+                      [pts],
+                      isClosed=True,
+                      color=color,
+                      thickness=thickness,
+                      lineType=cv2.LINE_AA)
+
+    return canvas, scale, off_y, padding_px, PH
+
+
+
 # ---------------------
 # Main Predict Function with Finger Cut Clearance, Boundary Box, Annotation and Sharpness Enhancement
 # ---------------------
@@ -928,11 +1184,11 @@ def predict(
             
             # Calculate actual text width from the path's bounds
             text_bbox = path.bbox(paths)
-            text_width = text_bbox[2] - text_bbox[0]  # xmax - xmin
-            
+            #text_width = text_bbox[2] - text_bbox[0]  # xmax - xmin
+            #text_width = text_bbox.width
             # Calculate center point of inner tool contours
             center_x = (inner_min_x + inner_max_x) / 2.0
-            
+            text_width = text_bbox.extmax.x - text_bbox.extmin.x
             # Calculate starting x position for truly centered text
             text_x = center_x - (text_width / 2.0)
             
@@ -955,101 +1211,61 @@ def predict(
     # ---------------------
     # 9) For the preview images, draw the polygons and place text similarly
     # ---------------------
-    draw_polygons_inch(final_polygons_inch, output_img, scaling_factor, processed_size[0], color=(0, 0, 255), thickness=2)
-    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)
-
+    #draw_polygons_inch(final_polygons_inch, output_img, scaling_factor, processed_size[0], color=(0, 0, 255), thickness=2)
+    for poly in final_polygons_inch:
+    # Skip the boundary polygon
+        if boundary_polygon is not None and poly == boundary_polygon:
+            continue
+        draw_single_polygon(poly, output_img, scaling_factor, processed_size[0], color=(0, 0, 255), thickness=2)
+    new_outlines,preview_scale, off_y, padding_px, PH= draw_and_pad(final_polygons_inch, scaling_factor,boundary_polygon)
+
+    #draw_polygons_inch(final_polygons_inch, new_outlines, scaling_factor, processed_size[0], color=(0, 0, 255), thickness=2)
+    import math
     if annotation_text.strip():
+        # Common variables
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        text = annotation_text.strip().upper()
+        canvas_height, canvas_width = new_outlines.shape[:2]
+        
         if boundary_polygon is not None:
-            text_height_cv = 0.75
+            # Keep original code for output_img
             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
+            
+            # Process for output_img with mask (keeping your original code)
             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
-            )
-
+            cv2.putText(temp_img, text, org, font, 2, (0, 0, 255), 4, cv2.LINE_AA)
+            cv2.putText(temp_img, text, org, font, 2, (255, 255, 255), 2, 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
-            )
+            # For new_outlines - simple, centered text
+            def optimal_font_dims(img, font_scale = 1e-3, thickness_scale = 2e-3):
+                h, w, _ = img.shape
+                font_scale = min(w, h) * font_scale
+                thickness = math.ceil(min(w, h) * thickness_scale)
+                return font_scale, thickness
+            font_scale,thickness = optimal_font_dims(new_outlines)
+            (text_width, text_height), baseline = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, font_scale, thickness)
+            text_x = (canvas_width - text_width) // 2
+            raw_y       = (text_y_in / scaling_factor) * preview_scale
+            y1          = raw_y - off_y + padding_px
+            text_y_px   = int(round(PH - 1 - y1))
+            text_y_px_adjusted = text_y_px - baseline
+            # bottom_margin_px = int(0.25 / scaling_factor)
+            # font_scale,_ = optimal_font_dims(new_outlines)
+            #text_y_outlines = int(canvas_height - (text_y_in + (0.75) / scaling_factor))
+            
+            # First outline, then inner text
+            cv2.putText(new_outlines, text, (text_x, text_y_px_adjusted), font, font_scale, (0, 0, 255), thickness+2, cv2.LINE_AA)
+            cv2.putText(new_outlines, text, (text_x, text_y_px_adjusted), font, font_scale, (255, 255, 255), thickness-1, cv2.LINE_AA)
+        
 
     outlines_color = cv2.cvtColor(new_outlines, cv2.COLOR_BGR2RGB)
     print("Total prediction time: {:.2f} seconds".format(time.time() - overall_start))
-
     return (
         cv2.cvtColor(output_img, cv2.COLOR_BGR2RGB),
         outlines_color,
@@ -1081,8 +1297,8 @@ if __name__ == "__main__":
             gr.Textbox(label="Annotation (max 20 chars)", max_length=20, placeholder="Type up to 20 characters")
         ],
         outputs=[
-            gr.Image(label="Output Image"),
-            gr.Image(label="Outlines of Objects"),
+            gr.Image(format="png",label="Output Image"),
+            gr.Image(format="png",label="Outlines of Objects"),
             gr.File(label="DXF file"),
             gr.Image(label="Mask"),
             gr.Textbox(label="Scaling Factor (inches/pixel)")