Update app.py

app.py

@@ -185,14 +185,14 @@ def detect_paper_contour(image: np.ndarray) -> Tuple[np.ndarray, float]:
     # 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.15  # At least 15% of image
-    max_area = image_area * 0.95  # At most 95% of image
+    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.02 * cv2.arcLength(contour, True)
+            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
@@ -204,12 +204,12 @@ def detect_paper_contour(image: np.ndarray) -> Tuple[np.ndarray, float]:
                 
                 # Check if aspect ratio matches common paper ratios
                 # A4: 1.414, A3: 1.414, US Letter: 1.294
-                if 0.6 < aspect_ratio < 2.0:  # More lenient tolerance
+                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.7:  # At least 70% rectangular
+                        if extent > 0.85:  # At least 70% rectangular
                             paper_contours.append((contour, area, aspect_ratio, extent))
     
     if not paper_contours:
@@ -467,27 +467,31 @@ def exclude_paper_area(mask: np.ndarray, paper_contour: np.ndarray, expansion_fa
     """
     Remove paper area from the mask to focus only on objects
     """
-    # Create paper mask - this will be the area to EXCLUDE
-    paper_mask = np.zeros(mask.shape[:2], dtype=np.uint8)
-    
-    # Create a more aggressive inward shrinking of paper bounds
+    # Get paper bounding rectangle
     rect = cv2.boundingRect(paper_contour)
-    shrink_pixels = int(min(rect[2], rect[3]) * 0.05)  # Shrink by 5% of smaller dimension
-    
-    # Create shrunken rectangle (area INSIDE paper bounds)
     x, y, w, h = rect
-    inner_contour = np.array([
-        [[x + shrink_pixels, y + shrink_pixels]],
-        [[x + w - shrink_pixels, y + shrink_pixels]],
-        [[x + w - shrink_pixels, y + h - shrink_pixels]],
-        [[x + shrink_pixels, y + h - shrink_pixels]]
-    ])
     
-    # Fill the INNER area as white (255) - this is where objects should be
-    cv2.fillPoly(paper_mask, [inner_contour], 255)
+    # Create much more aggressive inward shrinking
+    shrink_x = int(w * 0.15)  # Shrink 15% from each side
+    shrink_y = int(h * 0.15)  # Shrink 15% from top/bottom
+    
+    # Create inner object area (much smaller than paper)
+    inner_x = x + shrink_x
+    inner_y = y + shrink_y
+    inner_w = w - (2 * shrink_x)
+    inner_h = h - (2 * shrink_y)
+    
+    # Create mask for object area only
+    object_area_mask = np.zeros(mask.shape[:2], dtype=np.uint8)
+    cv2.rectangle(object_area_mask, (inner_x, inner_y), (inner_x + inner_w, inner_y + inner_h), 255, -1)
+    
+    # Apply mask: keep only pixels in the inner object area
+    result_mask = cv2.bitwise_and(mask, object_area_mask)
     
-    # Apply mask: keep only pixels that are both in original mask AND inside paper bounds
-    result_mask = cv2.bitwise_and(mask, paper_mask)
+    # Additional cleanup: remove small noise and fill gaps
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+    result_mask = cv2.morphologyEx(result_mask, cv2.MORPH_OPEN, kernel, iterations=1)
+    result_mask = cv2.morphologyEx(result_mask, cv2.MORPH_CLOSE, kernel, iterations=2)
     
     return result_mask
 
@@ -893,10 +897,9 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
         # Mask paper area in input image first
         masked_input_image = mask_paper_area_in_image(image, paper_contour)
         
-        # Remove background from main objects using masked image
+        # Remove background from main objects
         orig_size = image.shape[:2]
-        objects_mask = remove_bg(masked_input_image)
-        
+        objects_mask = remove_bg(image)
         processed_size = objects_mask.shape[:2]
         
         # Resize mask to match original image
@@ -905,6 +908,11 @@ def predict_with_paper(image, paper_size, offset,offset_unit, finger_clearance=F
         # 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)