fix: simplify mask processing to match reference model - direct white=remove detection

api/main.py

@@ -322,10 +322,24 @@ def inpaint_multipart(
         
         log.info("Auto-converted painted image to black/white mask: %d white pixels (to remove)", 
                  int((binmask_clean > 0).sum()))
+        
+        if int((binmask_clean > 0).sum()) < 50:
+            log.error("CRITICAL: Mask detection found very few pixels! Returning original image.")
+            # Return original image if mask is invalid
+            result = np.array(img.convert("RGB"))
+            result_name = f"output_{uuid.uuid4().hex}.png"
+            result_path = os.path.join(OUTPUT_DIR, result_name)
+            Image.fromarray(result).save(result_path)
+            return {"result": result_name, "error": "mask detection failed - very few pixels detected"}
     else:
         mask_rgba = _load_rgba_mask_from_image(m)
 
-    result = process_inpaint(np.array(img), mask_rgba, invert_mask=invert_mask)
+    # When mask_is_painted=true, we create white=remove masks, so invert_mask should be False
+    # (white pixels should stay white to indicate removal)
+    actual_invert = invert_mask if not mask_is_painted else False
+    log.info("Using invert_mask=%s (mask_is_painted=%s)", actual_invert, mask_is_painted)
+    
+    result = process_inpaint(np.array(img), mask_rgba, invert_mask=actual_invert)
     result_name = f"output_{uuid.uuid4().hex}.png"
     result_path = os.path.join(OUTPUT_DIR, result_name)
     Image.fromarray(result).save(result_path)

src/core.py

@@ -460,40 +460,35 @@ def process_inpaint(image, mask, invert_mask=True):
 
     # Convert RGBA mask to single-channel mask.
     # Standard LaMa convention: 1 = remove, 0 = keep
-    # The mask can come in different formats:
-    # - RGBA with alpha channel encoding (alpha=0 means remove when invert_mask=True)
-    # - RGBA with RGB encoding (white/colored areas mean remove)
+    # Simple approach: white pixels in RGB = remove, black = keep
+    # This matches the reference model behavior
     
     alpha_channel = mask[:,:,3]
     rgb_channels = mask[:,:,:3]
     
-    # Check if alpha channel is meaningful (not all 255)
-    alpha_mean = alpha_channel.mean()
+    # Convert RGB to grayscale to detect white/black
+    gray = cv2.cvtColor(rgb_channels, cv2.COLOR_RGB2GRAY)
+    
+    # Standard: white (255) = remove, black (0) = keep
+    # Detect white pixels (>128) as removal areas
+    mask = (gray > 128).astype(np.uint8) * 255
     
+    # Also explicitly detect magenta (255, 0, 255) which is commonly used for painting
+    magenta = np.all(rgb_channels == [255, 0, 255], axis=2).astype(np.uint8) * 255
+    mask = np.maximum(mask, magenta)
+    
+    # If alpha channel is mostly transparent (<50 mean), use it as mask source
+    alpha_mean = alpha_channel.mean()
     if alpha_mean < 50:
-        # Alpha channel is mostly transparent - use alpha directly
-        # Transparent (0) = remove, Opaque (255) = keep
+        # Transparent areas (alpha=0) should be removed
         if invert_mask:
-            mask = 255 - alpha_channel  # transparent → white (remove)
+            mask = np.maximum(mask, (255 - alpha_channel))  # transparent → white
         else:
-            mask = alpha_channel  # opaque → white (remove)
-    elif alpha_mean > 200:
-        # Alpha channel is mostly opaque - check RGB channels for paint colors
-        # Detect magenta (255, 0, 255) or any bright colored paint
-        gray = cv2.cvtColor(rgb_channels, cv2.COLOR_RGB2GRAY)
-        # White or bright colors (>200) in RGB = remove
-        mask_rgb = (gray > 200).astype(np.uint8) * 255
-        # Also detect magenta specifically
-        magenta = np.all(rgb_channels == [255, 0, 255], axis=2).astype(np.uint8) * 255
-        mask = np.maximum(mask_rgb, magenta)
-        if not invert_mask:
-            mask = 255 - mask  # invert if needed
-    else:
-        # Mixed alpha - use alpha channel with inversion logic
-        if invert_mask:
-            mask = 255 - alpha_channel
-        else:
-            mask = alpha_channel
+            mask = np.maximum(mask, alpha_channel)  # opaque → white
+    
+    # Apply invert_mask if needed (for special cases where black=remove)
+    if not invert_mask:
+        mask = 255 - mask
     
     mask = resize_max_size(mask, size_limit=size_limit, interpolation=interpolation)