Update app.py

app.py

@@ -361,100 +361,6 @@ def detect_paper_bounds(image: np.ndarray, paper_size: str, output_unit: str = "
         logger.error(f"Error in paper detection: {e}")
         raise ReferenceBoxNotDetectedError(f"Failed to detect paper: {str(e)}")
 
-# 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 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)
-    
-#     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.
@@ -671,55 +577,6 @@ 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 - scaling_factor should be in mm/px"""
@@ -1105,7 +962,7 @@ def predict_with_paper(image, paper_size, offset, offset_unit, finger_clearance=
         orig_size = image.shape[:2]
         # objects_mask = remove_bg(image)
         # objects_mask = remove_bg(image)
-        objects_mask = remove_bg_u2netp(image)
+        objects_mask = remove_bg(image)
         processed_size = objects_mask.shape[:2]
         
         # Resize mask to match original image