Update app.py

app.py

@@ -823,78 +823,146 @@ def draw_single_polygon(poly, image_rgb, scaling_factor, image_height, color=(0,
 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.
+# 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.
+#     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 = []
+#     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.int8))
+#     # 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)
+#     # 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
+#     # 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)
+#     # 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)
+#     # 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]
-    )
+#     # 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
+#     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=20,
+                               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
@@ -1149,7 +1217,7 @@ def predict(
         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= draw_and_pad(final_polygons_inch, scaling_factor,boundary_polygon, padding=50)
+    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
@@ -1175,27 +1243,29 @@ def predict(
             output_img[outline_mask > 0] = temp_img[outline_mask > 0]
             
             # For new_outlines - simple, centered text
-            font_scale = 1
-            def optimal_font_dims(img, font_scale = 2e-3, thickness_scale = 5e-3):
+            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) = cv2.getTextSize(text, font, font_scale, thickness)[0]
+            (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))
+            #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_outlines), font, font_scale, (0, 0, 255), thickness+(2), cv2.LINE_AA)
-            cv2.putText(new_outlines, text, (text_x, text_y_outlines), font, font_scale, (255, 255, 255), thickness-(1), cv2.LINE_AA)
+            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,
@@ -1227,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)")