feat: use fixed pink RGB bounds (lower=[150,0,100], upper=[255,120,255]) for /remove-pink and mask_is_painted in /inpaint-multipart; keep white=remove logic

api/main.py

@@ -193,7 +193,7 @@ def inpaint(req: InpaintRequest, _: None = Depends(bearer_auth)) -> Dict[str, st
     img_rgba = _load_rgba_image(file_store[req.image_id]["path"])
     mask_img = Image.open(file_store[req.mask_id]["path"])  # may be RGB/gray/RGBA
     mask_rgba = _load_rgba_mask_from_image(mask_img)
-    
+
     # Debug: check mask before processing
     white_pixels = int((mask_rgba[:,:,0] > 128).sum())
     log.info(f"Inpaint request: mask has {white_pixels} white pixels, invert_mask={req.invert_mask}")
@@ -279,12 +279,13 @@ def inpaint_multipart(
         
         m_rgb = cv2.cvtColor(np.array(m), cv2.COLOR_RGBA2RGB)
         
-        # Method 1: Detect magenta/pink paint directly (RGB: 255, 0, 255)
-        # Allow some tolerance for slight variations (e.g., 250-255 for R/B, 0-10 for G)
+        # Detect pink/magenta using fixed RGB bounds (same as /remove-pink)
+        lower = np.array([150, 0, 100], dtype=np.uint8)
+        upper = np.array([255, 120, 255], dtype=np.uint8)
         magenta_detected = (
-            (m_rgb[:, :, 0] > 240) &  # Red channel: high (240-255)
-            (m_rgb[:, :, 1] < 30) &   # Green channel: low (0-30) 
-            (m_rgb[:, :, 2] > 240)    # Blue channel: high (240-255)
+            (m_rgb[:, :, 0] >= lower[0]) & (m_rgb[:, :, 0] <= upper[0]) &
+            (m_rgb[:, :, 1] >= lower[1]) & (m_rgb[:, :, 1] <= upper[1]) &
+            (m_rgb[:, :, 2] >= lower[2]) & (m_rgb[:, :, 2] <= upper[2])
         ).astype(np.uint8) * 255
         
         # Method 2: Also check if original image was provided to find differences
@@ -313,13 +314,8 @@ def inpaint_multipart(
         nonzero = int((binmask > 0).sum())
         log.info("Pink/magenta paint detected: %d pixels marked for removal (white)", nonzero)
         
-        if nonzero < 50:
-            log.warning("Very few pixels detected! Trying stricter magenta detection...")
-            # Try more strict magenta detection (exact match)
-            magenta_strict = np.all(m_rgb == [255, 0, 255], axis=2).astype(np.uint8) * 255
-            binmask = cv2.morphologyEx(magenta_strict, cv2.MORPH_CLOSE, kernel, iterations=3)
-            nonzero = int((binmask > 0).sum())
-            log.info("Strict magenta detection: %d pixels", nonzero)
+        # If very few pixels detected, assume the user may already be providing a BW mask
+        # and proceed without forcing strict detection
         
         if nonzero < 50:
             log.error("CRITICAL: Could not detect pink/magenta paint! Returning original image.")
@@ -344,7 +340,7 @@ def inpaint_multipart(
         log.info("Successfully created binary mask: %d pink pixels → white (255), %d pixels → black (0)",
                  nonzero, binmask.shape[0] * binmask.shape[1] - nonzero)
     else:
-        mask_rgba = _load_rgba_mask_from_image(m)
+    mask_rgba = _load_rgba_mask_from_image(m)
 
     # When mask_is_painted=true, we encode pink as alpha=0, so process_inpaint's default invert_mask=True works correctly
     actual_invert = invert_mask  # Use default True for painted masks
@@ -394,27 +390,15 @@ def remove_pink_segments(
     # Pink/Magenta → white in mask (remove)
     # Everything else (natural image colors, including dark areas) → black in mask (keep)
     
-    # More robust pink/magenta detection - try multiple methods
-    # Method 1: Detect bright magenta (RGB: R>200, G<80, B>200) - more lenient
-    magenta_detected_loose = (
-        (img_rgb[:, :, 0] > 200) &  # Red: high
-        (img_rgb[:, :, 1] < 80) &   # Green: low (allow more tolerance)
-        (img_rgb[:, :, 2] > 200)    # Blue: high
+    # Detect pink/magenta using fixed RGB bounds per requested logic
+    lower = np.array([150, 0, 100], dtype=np.uint8)
+    upper = np.array([255, 120, 255], dtype=np.uint8)
+    binmask = (
+        (img_rgb[:, :, 0] >= lower[0]) & (img_rgb[:, :, 0] <= upper[0]) &
+        (img_rgb[:, :, 1] >= lower[1]) & (img_rgb[:, :, 1] <= upper[1]) &
+        (img_rgb[:, :, 2] >= lower[2]) & (img_rgb[:, :, 2] <= upper[2])
     ).astype(np.uint8) * 255
     
-    # Method 2: Detect exact magenta (255, 0, 255)
-    magenta_strict = np.all(img_rgb == [255, 0, 255], axis=2).astype(np.uint8) * 255
-    
-    # Method 3: Detect pink-ish colors (high red+blue, low green)
-    pink_detected = (
-        (img_rgb[:, :, 0] > 220) &  # Red: very high
-        (img_rgb[:, :, 1] < 100) &  # Green: low
-        (img_rgb[:, :, 2] > 220)    # Blue: very high
-    ).astype(np.uint8) * 255
-    
-    # Combine all detection methods
-    binmask = np.maximum.reduce([magenta_detected_loose, magenta_strict, pink_detected])
-    
     # Clean up the pink mask
     kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
     binmask = cv2.morphologyEx(binmask, cv2.MORPH_CLOSE, kernel, iterations=2)
@@ -424,8 +408,8 @@ def remove_pink_segments(
     total_pixels = binmask.shape[0] * binmask.shape[1]
     log.info(f"Detected {nonzero} pink pixels ({100*nonzero/total_pixels:.2f}% of image) to remove")
     
-    # Debug: show detection stats
-    log.info(f"Detection stats - Loose: {int((magenta_detected_loose > 0).sum())}, Strict: {int((magenta_strict > 0).sum())}, Pink: {int((pink_detected > 0).sum())}")
+    # Debug: log bounds used
+    log.info("Pink detection bounds used: lower=[150,0,100], upper=[255,120,255]")
     
     if nonzero < 50:
         log.error("No pink segments detected! Returning original image.")