fix: preserve image quality by limiting resize to 3000px, add output verification, improve debug logging

src/core.py

@@ -445,18 +445,35 @@ def get_args_parser():
 def process_inpaint(image, mask, invert_mask=True):
     """
     Process inpainting - handles both alpha-based masks and RGB-based masks.
+    Preserves original image quality and dimensions.
     Reference: https://huggingface.co/spaces/aryadytm/remove-photo-object
     """
     image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
-    original_shape = image.shape
+    original_shape = image.shape  # (H, W, C)
     interpolation = cv2.INTER_CUBIC
 
-    size_limit = max(image.shape)
+    # Preserve original size - only resize if absolutely necessary for memory/performance
+    # Keep original quality by preserving dimensions
+    max_dimension = max(image.shape[:2])
+    # Don't resize unless image is extremely large (over 3000px) to preserve quality
+    if max_dimension > 3000:
+        size_limit = 3000
+        print(f"Very large image detected ({max_dimension}px), resizing to {size_limit}px for processing")
+    else:
+        size_limit = max_dimension  # Keep original size to preserve quality
+        print(f"Preserving original image size: {max_dimension}px (no resize)")
 
     print(f"Origin image shape: {original_shape}")
-    image = resize_max_size(image, size_limit=size_limit, interpolation=interpolation)
-    print(f"Resized image shape: {image.shape}")
-    image = norm_img(image)
+    
+    # Resize image only if needed
+    if size_limit < max_dimension:
+        image_resized = resize_max_size(image, size_limit=size_limit, interpolation=interpolation)
+        print(f"Resized image shape: {image_resized.shape}")
+    else:
+        image_resized = image
+        print(f"Image not resized: {image_resized.shape}")
+    
+    image = norm_img(image_resized)
 
     # Handle mask: check if we should use alpha channel or RGB channels
     alpha_channel = mask[:,:,3]
@@ -471,28 +488,67 @@ def process_inpaint(image, mask, invert_mask=True):
         # alpha=0 (transparent) → 255 (white/remove)
         # alpha=255 (opaque) → 0 (black/keep)
         mask = 255 - alpha_channel
-        print(f"Using alpha channel: {int((alpha_channel < 128).sum())} transparent pixels → white")
+        transparent_count = int((alpha_channel < 128).sum())
+        print(f"Using alpha channel: {transparent_count} transparent pixels → white (to remove)")
     else:
         # Alpha is mostly opaque (255), use RGB channels instead
         # RGB masks: white (255) = remove, black (0) = keep
         gray = cv2.cvtColor(rgb_channels, cv2.COLOR_RGB2GRAY)
         mask = (gray > 128).astype(np.uint8) * 255
-        print(f"Using RGB channels: {int((mask > 128).sum())} white pixels (to remove)")
+        white_count = int((mask > 128).sum())
+        print(f"Using RGB channels: {white_count} white pixels (to remove)")
     
     # Apply invert_mask if user wants opposite behavior
     if not invert_mask:
         mask = 255 - mask  # invert: white becomes black, black becomes white
         print(f"Applied invert_mask=False: inverted mask")
     
-    mask = resize_max_size(mask, size_limit=size_limit, interpolation=interpolation)
+    # Resize mask to match image dimensions
+    if size_limit < max_dimension:
+        mask = resize_max_size(mask, size_limit=size_limit, interpolation=cv2.INTER_NEAREST)
+    else:
+        # Ensure mask matches image dimensions
+        if mask.shape[:2] != image_resized.shape[:2]:
+            mask = cv2.resize(mask, (image_resized.shape[1], image_resized.shape[0]), interpolation=cv2.INTER_NEAREST)
     
     # Debug: log final mask statistics
     mask_nonzero = int((mask > 128).sum())
     mask_total = mask.shape[0] * mask.shape[1]
     print(f"Final mask before normalization: {mask_nonzero}/{mask_total} pixels marked for removal ({100*mask_nonzero/mask_total:.2f}%)")
     
+    if mask_nonzero < 10:
+        print("ERROR: Mask is empty or almost empty! Returning original image.")
+        # Return original image at original size
+        original_rgb = (image_resized * 255).astype(np.uint8)
+        return cv2.resize(cv2.cvtColor(original_rgb, cv2.COLOR_RGB2BGR), 
+                         (original_shape[1], original_shape[0]), 
+                         interpolation=cv2.INTER_CUBIC)
+    
+    # Verify mask is correct before normalization
+    print(f"Mask verification: {mask_nonzero} pixels will be removed, shape: {mask.shape}")
+    
     mask = norm_img(mask)
+    
+    # Verify normalized mask
+    mask_normalized_ones = int((mask > 0.5).sum())
+    print(f"After normalization: {mask_normalized_ones} pixels marked for removal (value > 0.5)")
 
+    # Run inpainting
+    print("Running LaMa model for inpainting...")
     res_np_img = run(image, mask)
+    print(f"Inpainting complete. Output shape: {res_np_img.shape}")
+    
+    # Verify output changed
+    original_for_compare = (image_resized * 255).astype(np.uint8)
+    original_bgr = cv2.cvtColor(original_for_compare, cv2.COLOR_RGB2BGR)
+    diff = np.abs(res_np_img.astype(np.float32) - original_bgr.astype(np.float32))
+    diff_pixels = int((diff.sum(axis=2) > 10).sum())  # Pixels that changed by more than 10 in any channel
+    print(f"Output verification: {diff_pixels} pixels differ from input (should be > 0 if inpainting worked)")
+
+    # Resize back to original dimensions if we resized (use LANCZOS4 for better quality)
+    if size_limit < max_dimension:
+        res_np_img = cv2.resize(res_np_img, (original_shape[1], original_shape[0]), 
+                               interpolation=cv2.INTER_LANCZOS4)
+        print(f"Resized output back to original size: {res_np_img.shape}")
 
     return cv2.cvtColor(res_np_img, cv2.COLOR_BGR2RGB)