Update app.py

app.py

@@ -14,7 +14,8 @@ import cv2
 import ezdxf
 import gradio as gr
 import gc
-from scalingtestupdated import calculate_scaling_factor
+# from scalingtestupdated import calculate_scaling_factor
+from scalingtestupdated import calculate_scaling_factor_with_units, calculate_paper_scaling_factor, convert_units
 from scipy.interpolate import splprep, splev
 from scipy.ndimage import gaussian_filter1d
 import json
@@ -153,7 +154,77 @@ def get_birefnet():
         logger.info("BiRefNet model loaded successfully")
     return birefnet
 
-def detect_paper_contour(image: np.ndarray) -> Tuple[np.ndarray, float]:
+# def detect_paper_contour(image: np.ndarray) -> Tuple[np.ndarray, float]:
+#     """
+#     Detect paper in the image using contour detection as fallback
+#     Returns the paper contour and estimated scaling factor
+#     """
+#     logger.info("Using contour-based paper detection")
+    
+#     # Convert to grayscale
+#     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) if len(image.shape) == 3 else image
+    
+#     # Apply bilateral filter to reduce noise while preserving edges
+#     filtered = cv2.bilateralFilter(gray, 9, 75, 75)
+    
+#     # Apply adaptive threshold
+#     thresh = cv2.adaptiveThreshold(filtered, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+#                                    cv2.THRESH_BINARY, 11, 2)
+    
+#     # Edge detection with multiple thresholds
+#     edges1 = cv2.Canny(filtered, 50, 150)
+#     edges2 = cv2.Canny(filtered, 30, 100)
+#     edges = cv2.bitwise_or(edges1, edges2)
+    
+#     # Morphological operations to connect broken edges
+#     kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+#     edges = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
+    
+#     # Find contours
+#     contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+#     # Filter contours by area and aspect ratio to find paper-like rectangles
+#     paper_contours = []
+#     image_area = image.shape[0] * image.shape[1]
+#     min_area = image_area * 0.20  # At least 15% of image
+#     max_area = image_area * 0.85  # At most 95% of image
+    
+#     for contour in contours:
+#         area = cv2.contourArea(contour)
+#         if min_area < area < max_area:
+#             # Approximate contour to polygon
+#             epsilon = 0.015 * cv2.arcLength(contour, True)
+#             approx = cv2.approxPolyDP(contour, epsilon, True)
+            
+#             # Check if it's roughly rectangular (4 corners) or close to it
+#             if len(approx) >= 4:
+#                 # Calculate bounding rectangle
+#                 rect = cv2.boundingRect(approx)
+#                 w, h = rect[2], rect[3]
+#                 aspect_ratio = w / h if h > 0 else 0
+                
+#                 # Check if aspect ratio matches common paper ratios
+#                 # A4: 1.414, A3: 1.414, US Letter: 1.294
+#                 if 1.3 < aspect_ratio < 1.5:  # More lenient tolerance
+#                     # Check if contour area is close to bounding rect area (rectangularity)
+#                     rect_area = w * h
+#                     if rect_area > 0:
+#                         extent = area / rect_area
+#                         if extent > 0.85:  # At least 70% rectangular
+#                             paper_contours.append((contour, area, aspect_ratio, extent))
+    
+#     if not paper_contours:
+#         logger.error("No paper-like contours found")
+#         raise ReferenceBoxNotDetectedError("Could not detect paper in the image using contour detection")
+    
+#     # Select the best paper contour based on area and rectangularity
+#     paper_contours.sort(key=lambda x: (x[1] * x[3]), reverse=True)  # Sort by area * extent
+#     best_contour = paper_contours[0][0]
+    
+#     logger.info(f"Paper detected using contours: area={paper_contours[0][1]}, aspect_ratio={paper_contours[0][2]:.2f}")
+    
+#     return best_contour, 0.0  # Return 0.0 as placeholder scaling factor
+def detect_paper_contour(image: np.ndarray, output_unit: str = "mm") -> Tuple[np.ndarray, float]:
     """
     Detect paper in the image using contour detection as fallback
     Returns the paper contour and estimated scaling factor
@@ -209,7 +280,7 @@ def detect_paper_contour(image: np.ndarray) -> Tuple[np.ndarray, float]:
                     rect_area = w * h
                     if rect_area > 0:
                         extent = area / rect_area
-                        if extent > 0.85:  # At least 70% rectangular
+                        if extent > 0.85:  # At least 85% rectangular
                             paper_contours.append((contour, area, aspect_ratio, extent))
     
     if not paper_contours:
@@ -222,9 +293,10 @@ def detect_paper_contour(image: np.ndarray) -> Tuple[np.ndarray, float]:
     
     logger.info(f"Paper detected using contours: area={paper_contours[0][1]}, aspect_ratio={paper_contours[0][2]:.2f}")
     
-    return best_contour, 0.0  # Return 0.0 as placeholder scaling factor
-
-def detect_paper_bounds(image: np.ndarray, paper_size: str) -> Tuple[np.ndarray, float]:
+    # Return 0.0 as placeholder - will be calculated later based on paper size
+    return best_contour, 0.0
+    
+def detect_paper_bounds(image: np.ndarray, paper_size: str, output_unit: str = "mm") -> Tuple[np.ndarray, float]:
     """
     Detect paper bounds in the image and calculate scaling factor
     """
@@ -233,23 +305,22 @@ def detect_paper_bounds(image: np.ndarray, paper_size: str) -> Tuple[np.ndarray,
         
         if paper_detector is not None:
             # Use trained model if available
-            # FIXED: Add verbose=False to suppress prints, and use proper confidence threshold
-            results = paper_detector.predict(image, conf=0.8, verbose=False)  # Lower confidence threshold
+            results = paper_detector.predict(image, conf=0.8, verbose=False)
             
             if not results or len(results) == 0:
                 logger.warning("No results from paper detector")
-                return detect_paper_contour(image)
+                return detect_paper_contour(image, output_unit)
                 
             # Check if boxes exist and are not empty
             if not hasattr(results[0], 'boxes') or results[0].boxes is None or len(results[0].boxes) == 0:
                 logger.warning("No boxes detected by model, using fallback contour detection")
-                return detect_paper_contour(image)
+                return detect_paper_contour(image, output_unit)
             
             # Get the largest detected paper
-            boxes = results[0].boxes.xyxy.cpu().numpy()  # Convert to numpy
+            boxes = results[0].boxes.xyxy.cpu().numpy()
             if len(boxes) == 0:
                 logger.warning("Empty boxes detected, using fallback")
-                return detect_paper_contour(image)
+                return detect_paper_contour(image, output_unit)
                 
             largest_box = None
             max_area = 0
@@ -263,7 +334,7 @@ def detect_paper_bounds(image: np.ndarray, paper_size: str) -> Tuple[np.ndarray,
             
             if largest_box is None:
                 logger.warning("No valid paper box found, using fallback")
-                return detect_paper_contour(image)
+                return detect_paper_contour(image, output_unit)
                 
             # Convert box to contour-like format
             x_min, y_min, x_max, y_max = map(int, largest_box)
@@ -279,45 +350,120 @@ def detect_paper_bounds(image: np.ndarray, paper_size: str) -> Tuple[np.ndarray,
         else:
             # Use fallback contour detection
             logger.info("Using fallback contour detection for paper")
-            paper_contour, _ = detect_paper_contour(image)
+            paper_contour, _ = detect_paper_contour(image, output_unit)
         
-        # Calculate scaling factor based on paper size
-        scaling_factor = calculate_paper_scaling_factor(paper_contour, paper_size)
+        # Calculate scaling factor based on paper size with proper units
+        scaling_factor = calculate_paper_scaling_factor(paper_contour, paper_size, output_unit)
         
         return paper_contour, scaling_factor
         
     except Exception as e:
         logger.error(f"Error in paper detection: {e}")
-        # Instead of raising PaperNotDetectedError, raise ReferenceBoxNotDetectedError
         raise ReferenceBoxNotDetectedError(f"Failed to detect paper: {str(e)}")
 
-def calculate_paper_scaling_factor(paper_contour: np.ndarray, paper_size: str) -> float:
-    """
-    Calculate scaling factor based on detected paper dimensions
-    """
-    # Get paper dimensions
-    paper_dims = PAPER_SIZES[paper_size]
-    expected_width_mm = paper_dims["width"]
-    expected_height_mm = paper_dims["height"]
+# def detect_paper_bounds(image: np.ndarray, paper_size: str) -> Tuple[np.ndarray, float]:
+#     """
+#     Detect paper bounds in the image and calculate scaling factor
+#     """
+#     try:
+#         paper_detector = get_paper_detector()
+        
+#         if paper_detector is not None:
+#             # Use trained model if available
+#             # FIXED: Add verbose=False to suppress prints, and use proper confidence threshold
+#             results = paper_detector.predict(image, conf=0.8, verbose=False)  # Lower confidence threshold
+            
+#             if not results or len(results) == 0:
+#                 logger.warning("No results from paper detector")
+#                 return detect_paper_contour(image)
+                
+#             # Check if boxes exist and are not empty
+#             if not hasattr(results[0], 'boxes') or results[0].boxes is None or len(results[0].boxes) == 0:
+#                 logger.warning("No boxes detected by model, using fallback contour detection")
+#                 return detect_paper_contour(image)
+            
+#             # Get the largest detected paper
+#             boxes = results[0].boxes.xyxy.cpu().numpy()  # Convert to numpy
+#             if len(boxes) == 0:
+#                 logger.warning("Empty boxes detected, using fallback")
+#                 return detect_paper_contour(image)
+                
+#             largest_box = None
+#             max_area = 0
+            
+#             for box in boxes:
+#                 x_min, y_min, x_max, y_max = box
+#                 area = (x_max - x_min) * (y_max - y_min)
+#                 if area > max_area:
+#                     max_area = area
+#                     largest_box = box
+            
+#             if largest_box is None:
+#                 logger.warning("No valid paper box found, using fallback")
+#                 return detect_paper_contour(image)
+                
+#             # Convert box to contour-like format
+#             x_min, y_min, x_max, y_max = map(int, largest_box)
+#             paper_contour = np.array([
+#                 [[x_min, y_min]],
+#                 [[x_max, y_min]],
+#                 [[x_max, y_max]],
+#                 [[x_min, y_max]]
+#             ])
+            
+#             logger.info(f"Paper detected by model: {x_min},{y_min} to {x_max},{y_max}")
+            
+#         else:
+#             # Use fallback contour detection
+#             logger.info("Using fallback contour detection for paper")
+#             paper_contour, _ = detect_paper_contour(image)
+        
+#         # Calculate scaling factor based on paper size
+#         scaling_factor = calculate_paper_scaling_factor(paper_contour, paper_size)
+        
+#         return paper_contour, scaling_factor
+        
+#     except Exception as e:
+#         logger.error(f"Error in paper detection: {e}")
+#         # Instead of raising PaperNotDetectedError, raise ReferenceBoxNotDetectedError
+#         raise ReferenceBoxNotDetectedError(f"Failed to detect paper: {str(e)}")
+
+# def calculate_paper_scaling_factor(paper_contour: np.ndarray, paper_size: str) -> float:
+#     """
+#     Calculate scaling factor based on detected paper dimensions
+#     """
+#     # Get paper dimensions
+#     paper_dims = PAPER_SIZES[paper_size]
+#     expected_width_mm = paper_dims["width"]
+#     expected_height_mm = paper_dims["height"]
     
-    # Calculate bounding rectangle of paper contour
-    rect = cv2.boundingRect(paper_contour)
-    detected_width_px = rect[2]
-    detected_height_px = rect[3]
+#     # Calculate bounding rectangle of paper contour
+#     rect = cv2.boundingRect(paper_contour)
+#     detected_width_px = rect[2]
+#     detected_height_px = rect[3]
     
-    # Calculate scaling factors for both dimensions
-    scale_x = expected_width_mm / detected_width_px
-    scale_y = expected_height_mm / detected_height_px
+#     # Calculate scaling factors for both dimensions
+#     scale_x = expected_width_mm / detected_width_px
+#     scale_y = expected_height_mm / detected_height_px
     
-    # Use average of both scales
-    # scaling_factor = (scale_x + scale_y) / 2
-    scaling_factor = min(scale_x, scale_y)
+#     # Use average of both scales
+#     # scaling_factor = (scale_x + scale_y) / 2
+#     scaling_factor = min(scale_x, scale_y)
     
-    logger.info(f"Paper detection: {detected_width_px}x{detected_height_px} px -> {expected_width_mm}x{expected_height_mm} mm")
-    logger.info(f"Calculated scaling factor: {scaling_factor:.4f} mm/px")
+#     logger.info(f"Paper detection: {detected_width_px}x{detected_height_px} px -> {expected_width_mm}x{expected_height_mm} mm")
+#     logger.info(f"Calculated scaling factor: {scaling_factor:.4f} mm/px")
     
+#     return scaling_factor
+
+def calculate_paper_scaling_factor(paper_contour: np.ndarray, paper_size: str, output_unit: str = "mm") -> float:
+    """
+    Calculate scaling factor based on detected paper dimensions with proper unit handling.
+    """
+    from scalingtestupdated import calculate_paper_scaling_factor as calc_paper_scale
+    scaling_factor, unit_string = calc_paper_scale(paper_contour, paper_size, output_unit)
     return scaling_factor
 
+
 def validate_single_object(mask: np.ndarray, paper_contour: np.ndarray) -> None:
     """
     Validate that only a single object is present on the paper
@@ -524,35 +670,83 @@ def resample_contour(contour, edge_radius_px: int = 0):
         logger.error(f"Error in resample_contour: {e}")
         raise
 
+# def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
+#     """Save contours as DXF splines with optional finger cuts"""
+#     doc = ezdxf.new(units=ezdxf.units.MM)
+#     doc.header["$INSUNITS"] = ezdxf.units.MM
+#     msp = doc.modelspace()
+#     final_polygons_inch = []
+#     finger_centers = []
+#     original_polygons = []
+
+#     # Scale correction factor
+#     scale_correction = 1.0
+
+#     for contour in inflated_contours:
+#         try:
+#             resampled_contour = resample_contour(contour)  
+
+#             points_inch = [(x * scaling_factor, (height - y) * scaling_factor) 
+#                           for x, y in resampled_contour]
+
+#             if len(points_inch) < 3:
+#                 continue
+
+#             tool_polygon = build_tool_polygon(points_inch)
+#             original_polygons.append(tool_polygon)
+
+#             if finger_clearance:
+#                 try:
+#                     tool_polygon, center = place_finger_cut_adjusted(
+#                         tool_polygon, points_inch, finger_centers, final_polygons_inch
+#                     )
+#                 except FingerCutOverlapError:
+#                     tool_polygon = original_polygons[-1]
+
+#             exterior_coords = polygon_to_exterior_coords(tool_polygon)
+#             if len(exterior_coords) < 3:
+#                 continue
+
+#             # Apply scale correction
+#             corrected_coords = [(x * scale_correction, y * scale_correction) for x, y in exterior_coords]
+
+#             msp.add_spline(corrected_coords, degree=3, dxfattribs={"layer": "TOOLS"})
+#             final_polygons_inch.append(tool_polygon)
+
+#         except ValueError as e:
+#             logger.warning(f"Skipping contour: {e}")
+
+#     dxf_filepath = os.path.join("./outputs", "out.dxf")
+#     doc.saveas(dxf_filepath)
+#     return dxf_filepath, final_polygons_inch, original_polygons
+
 def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=False):
-    """Save contours as DXF splines with optional finger cuts"""
+    """Save contours as DXF splines with optional finger cuts - scaling_factor should be in mm/px"""
     doc = ezdxf.new(units=ezdxf.units.MM)
     doc.header["$INSUNITS"] = ezdxf.units.MM
     msp = doc.modelspace()
-    final_polygons_inch = []
+    final_polygons_mm = []  # Use mm instead of inch for clarity
     finger_centers = []
     original_polygons = []
 
-    # Scale correction factor
-    scale_correction = 1.0
-
     for contour in inflated_contours:
         try:
             resampled_contour = resample_contour(contour)  
 
-            points_inch = [(x * scaling_factor, (height - y) * scaling_factor) 
-                          for x, y in resampled_contour]
+            # Convert pixel coordinates to mm using the scaling factor
+            points_mm = [(x * scaling_factor, (height - y) * scaling_factor) 
+                        for x, y in resampled_contour]
 
-            if len(points_inch) < 3:
+            if len(points_mm) < 3:
                 continue
 
-            tool_polygon = build_tool_polygon(points_inch)
+            tool_polygon = build_tool_polygon(points_mm)
             original_polygons.append(tool_polygon)
 
             if finger_clearance:
                 try:
                     tool_polygon, center = place_finger_cut_adjusted(
-                        tool_polygon, points_inch, finger_centers, final_polygons_inch
+                        tool_polygon, points_mm, finger_centers, final_polygons_mm
                     )
                 except FingerCutOverlapError:
                     tool_polygon = original_polygons[-1]
@@ -561,18 +755,16 @@ def save_dxf_spline(inflated_contours, scaling_factor, height, finger_clearance=
             if len(exterior_coords) < 3:
                 continue
 
-            # Apply scale correction
-            corrected_coords = [(x * scale_correction, y * scale_correction) for x, y in exterior_coords]
-
-            msp.add_spline(corrected_coords, degree=3, dxfattribs={"layer": "TOOLS"})
-            final_polygons_inch.append(tool_polygon)
+            # Coordinates are already in mm, so add directly to DXF
+            msp.add_spline(exterior_coords, degree=3, dxfattribs={"layer": "TOOLS"})
+            final_polygons_mm.append(tool_polygon)
 
         except ValueError as e:
             logger.warning(f"Skipping contour: {e}")
 
     dxf_filepath = os.path.join("./outputs", "out.dxf")
     doc.saveas(dxf_filepath)
-    return dxf_filepath, final_polygons_inch, original_polygons
+    return dxf_filepath, final_polygons_mm, original_polygons
 
 def build_tool_polygon(points_inch):
     """Build a polygon from inch-converted points"""
@@ -866,14 +1058,152 @@ def make_square(img: np.ndarray):
     
     return padded
 
-def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=False):
+# def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=False):
+#     """Main prediction function using paper as reference"""
+    
+#     logger.info(f"Starting prediction with image shape: {image.shape}")
+#     logger.info(f"Paper size: {paper_size}")
+    
+#     if offset_unit == "inches":
+#         offset_mm = offset * 25.4  # Convert to mm for internal calculations
+#     else:
+#         offset_mm = offset
+        
+#     edge_radius = None
+#     if edge_radius is None or edge_radius == 0:
+#         edge_radius = 0.0001
+
+#     if offset < 0:
+#         raise gr.Error("Offset Value Can't be negative")
+
+#     try:
+#         # Detect paper bounds and calculate scaling factor
+#         logger.info("Starting paper detection...")
+#         paper_contour, scaling_factor = detect_paper_bounds(image, paper_size)
+#         logger.info(f"Paper detected successfully with scaling factor: {scaling_factor:.4f} mm/px")
+        
+#     except ReferenceBoxNotDetectedError as e:
+#         logger.error(f"Paper detection failed: {e}")
+#         return (
+#             None, None, None, None,
+#             f"Error: {str(e)}"
+#         )
+#     except Exception as e:
+#         logger.error(f"Unexpected error in paper detection: {e}")
+#         raise gr.Error(f"Error processing image: {str(e)}")
+
+#     try:
+#         # Remove background from main objects
+#         # orig_size = image.shape[:2]
+#         # objects_mask = remove_bg(image)
+        
+#         # Mask paper area in input image first
+#         masked_input_image = mask_paper_area_in_image(image, paper_contour)
+        
+#         # Remove background from main objects
+#         orig_size = image.shape[:2]
+#         objects_mask = remove_bg(image)
+#         processed_size = objects_mask.shape[:2]
+        
+#         # Resize mask to match original image
+#         objects_mask = cv2.resize(objects_mask, (image.shape[1], image.shape[0]))
+        
+#         # Remove paper area from mask to focus only on objects
+#         objects_mask = exclude_paper_area(objects_mask, paper_contour)
+        
+#         # Check if we actually have object pixels after paper exclusion
+#         object_pixels = np.count_nonzero(objects_mask)
+#         if object_pixels < 1000:  # Minimum threshold
+#             raise NoObjectDetectedError("No significant object detected after excluding paper area")
+        
+#         # Validate single object
+#         validate_single_object(objects_mask, paper_contour)
+        
+#     except (MultipleObjectsError, NoObjectDetectedError) as e:
+#         return (
+#             None, None, None, None,
+#             f"Error: {str(e)}"
+#         )
+#     except Exception as e:
+#         raise gr.Error(f"Error in object detection: {str(e)}")
+
+#     # Apply edge rounding if specified
+#     rounded_mask = objects_mask.copy()
+    
+#     # Apply dilation for offset - more precise calculation
+#     if offset_mm > 0:
+#         offset_pixels = int(round(float(offset_mm) / scaling_factor))
+#         if offset_pixels > 0:
+#             kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (offset_pixels*2+1, offset_pixels*2+1))
+#             dilated_mask = cv2.dilate(rounded_mask, kernel, iterations=1)
+#         else:
+#             dilated_mask = rounded_mask.copy()
+
+#     # Save original dilated mask for output
+#     Image.fromarray(dilated_mask).save("./outputs/scaled_mask_original.jpg")
+#     dilated_mask_orig = dilated_mask.copy()
+
+#     # Extract contours
+#     outlines, contours = extract_outlines(dilated_mask)
+
+#     try:
+#         # Generate DXF
+#         dxf, finger_polygons, original_polygons = save_dxf_spline(
+#             contours,
+#             scaling_factor,
+#             processed_size[0],
+#             finger_clearance=(finger_clearance == "On")
+#         )
+#     except FingerCutOverlapError as e:
+#         raise gr.Error(str(e))
+
+#     # Create annotated image
+#     shrunked_img_contours = image.copy()
+
+#     if finger_clearance == "On":
+#         outlines = np.full_like(dilated_mask, 255)
+#         for poly in finger_polygons:
+#             try:
+#                 coords = np.array([
+#                     (int(x / scaling_factor), int(processed_size[0] - y / scaling_factor))
+#                     for x, y in poly.exterior.coords
+#                 ], np.int32).reshape((-1, 1, 2))
+
+#                 cv2.drawContours(shrunked_img_contours, [coords], -1, (0, 255, 0), thickness=2)
+#                 cv2.drawContours(outlines, [coords], -1, 0, thickness=2)
+#             except Exception as e:
+#                 logger.warning(f"Failed to draw finger cut: {e}")
+#                 continue
+#     else:
+#         outlines = np.full_like(dilated_mask, 255)
+#         cv2.drawContours(shrunked_img_contours, contours, -1, (0, 255, 0), thickness=2)
+#         cv2.drawContours(outlines, contours, -1, 0, thickness=2)
+    
+#     # # Draw paper bounds on annotated image
+#     # cv2.drawContours(shrunked_img_contours, [paper_contour], -1, (255, 0, 0), thickness=3)
+    
+#     # # Add paper size text
+#     # paper_text = f"Paper: {paper_size}"
+#     # cv2.putText(shrunked_img_contours, paper_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
+    
+#     cleanup_models()
+
+#     return (
+#         shrunked_img_contours,
+#         outlines,
+#         dxf,
+#         dilated_mask_orig,
+#         f"Scale: {scaling_factor:.4f} mm/px | Paper: {paper_size}"
+#     )
+def predict_with_paper(image, paper_size, offset, offset_unit, finger_clearance=False):
     """Main prediction function using paper as reference"""
     
     logger.info(f"Starting prediction with image shape: {image.shape}")
-    logger.info(f"Paper size: {paper_size}")
+    logger.info(f"Paper size: {paper_size}, Offset: {offset} {offset_unit}")
     
+    # Convert offset to mm for internal calculations (DXF generation expects mm)
     if offset_unit == "inches":
-        offset_mm = offset * 25.4  # Convert to mm for internal calculations
+        offset_mm = convert_units(offset, "inches", "mm")
     else:
         offset_mm = offset
         
@@ -885,10 +1215,10 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
         raise gr.Error("Offset Value Can't be negative")
 
     try:
-        # Detect paper bounds and calculate scaling factor
+        # Detect paper bounds and calculate scaling factor (always in mm for DXF)
         logger.info("Starting paper detection...")
-        paper_contour, scaling_factor = detect_paper_bounds(image, paper_size)
-        logger.info(f"Paper detected successfully with scaling factor: {scaling_factor:.4f} mm/px")
+        paper_contour, scaling_factor = detect_paper_bounds(image, paper_size, output_unit="mm")
+        logger.info(f"Paper detected successfully with scaling factor: {scaling_factor:.6f} mm/px")
         
     except ReferenceBoxNotDetectedError as e:
         logger.error(f"Paper detection failed: {e}")
@@ -900,11 +1230,10 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
         logger.error(f"Unexpected error in paper detection: {e}")
         raise gr.Error(f"Error processing image: {str(e)}")
 
+    # Rest of the function remains the same...
+    # [Keep all the existing object detection and DXF generation code]
+    
     try:
-        # Remove background from main objects
-        # orig_size = image.shape[:2]
-        # objects_mask = remove_bg(image)
-        
         # Mask paper area in input image first
         masked_input_image = mask_paper_area_in_image(image, paper_contour)
         
@@ -938,14 +1267,16 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
     # Apply edge rounding if specified
     rounded_mask = objects_mask.copy()
     
-    # Apply dilation for offset - more precise calculation
+    # Apply dilation for offset - more precise calculation using mm values
     if offset_mm > 0:
-        offset_pixels = int(round(float(offset_mm) / scaling_factor))
+        offset_pixels = max(1, int(round(float(offset_mm) / scaling_factor)))
         if offset_pixels > 0:
             kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (offset_pixels*2+1, offset_pixels*2+1))
             dilated_mask = cv2.dilate(rounded_mask, kernel, iterations=1)
         else:
             dilated_mask = rounded_mask.copy()
+    else:
+        dilated_mask = rounded_mask.copy()
 
     # Save original dilated mask for output
     Image.fromarray(dilated_mask).save("./outputs/scaled_mask_original.jpg")
@@ -955,10 +1286,10 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
     outlines, contours = extract_outlines(dilated_mask)
 
     try:
-        # Generate DXF
+        # Generate DXF - scaling_factor should be in mm/px for proper DXF units
         dxf, finger_polygons, original_polygons = save_dxf_spline(
             contours,
-            scaling_factor,
+            scaling_factor,  # This should be mm/px
             processed_size[0],
             finger_clearance=(finger_clearance == "On")
         )
@@ -987,21 +1318,22 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
         cv2.drawContours(shrunked_img_contours, contours, -1, (0, 255, 0), thickness=2)
         cv2.drawContours(outlines, contours, -1, 0, thickness=2)
     
-    # # Draw paper bounds on annotated image
-    # cv2.drawContours(shrunked_img_contours, [paper_contour], -1, (255, 0, 0), thickness=3)
-    
-    # # Add paper size text
-    # paper_text = f"Paper: {paper_size}"
-    # cv2.putText(shrunked_img_contours, paper_text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
-    
     cleanup_models()
 
+    # Format scaling info with proper unit display
+    if offset_unit == "inches":
+        offset_display = f"{offset} inches ({offset_mm:.3f} mm)"
+    else:
+        offset_display = f"{offset} mm"
+    
+    scale_info = f"Scale: {scaling_factor:.6f} mm/px | Paper: {paper_size} | Offset: {offset_display}"
+
     return (
         shrunked_img_contours,
         outlines,
         dxf,
         dilated_mask_orig,
-        f"Scale: {scaling_factor:.4f} mm/px | Paper: {paper_size}"
+        scale_info
     )
 
 def predict_full_paper(image, paper_size, offset_value_mm,offset_unit, enable_finger_cut, selected_outputs):