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,194 @@ 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
+
 # ---------------------
 # Main Predict Function with Finger Cut Clearance, Boundary Box, Annotation and Sharpness Enhancement
 # ---------------------
@@ -955,97 +1143,55 @@ 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= draw_and_pad(final_polygons_inch, scaling_factor,boundary_polygon, padding=50)
+
+    #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
+            font_scale = 1
+            def optimal_font_dims(img, font_scale = 2e-3, thickness_scale = 5e-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_x = (canvas_width - text_width) // 2
+            # 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_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)
+        
 
     outlines_color = cv2.cvtColor(new_outlines, cv2.COLOR_BGR2RGB)
     print("Total prediction time: {:.2f} seconds".format(time.time() - overall_start))
@@ -1081,8 +1227,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)")