grabcut

app.py

@@ -347,6 +347,91 @@ def apply_thresholding(image, method, threshold_value, max_value):
     return result_rgb, info
 
 
+def apply_grabcut(image, margin_percent, iterations):
+    """
+    Apply GrabCut algorithm for background subtraction
+    
+    GrabCut is an interactive foreground extraction algorithm that uses
+    graph cuts and Gaussian Mixture Models (GMM) to separate foreground
+    from background.
+    """
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    
+    # Ensure RGB format
+    if len(image.shape) == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+    
+    # Create a copy for processing
+    img = image.copy()
+    h, w = img.shape[:2]
+    
+    # Create mask (0 = background, 1 = foreground, 2 = probably background, 3 = probably foreground)
+    mask = np.zeros(img.shape[:2], np.uint8)
+    
+    # Initialize background and foreground models (used internally by GrabCut)
+    bgd_model = np.zeros((1, 65), np.float64)
+    fgd_model = np.zeros((1, 65), np.float64)
+    
+    # Define rectangle around the object (margin from edges)
+    margin_h = int(h * margin_percent / 100)
+    margin_w = int(w * margin_percent / 100)
+    rect = (margin_w, margin_h, w - 2*margin_w, h - 2*margin_h)
+    
+    # Apply GrabCut algorithm
+    # Iterations: more iterations = more accurate but slower
+    cv2.grabCut(img, mask, rect, bgd_model, fgd_model, iterations, cv2.GC_INIT_WITH_RECT)
+    
+    # Create binary mask where foreground (1 or 3) = 1, background (0 or 2) = 0
+    mask_binary = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8')
+    
+    # Extract foreground
+    foreground = img * mask_binary[:, :, np.newaxis]
+    
+    # Create visualization showing the mask
+    mask_vis = mask_binary * 255
+    mask_rgb = cv2.cvtColor(mask_vis, cv2.COLOR_GRAY2RGB)
+    
+    # Create combined view: Original | Mask | Foreground
+    # Resize for side-by-side display
+    scale = 0.33
+    h_new, w_new = int(h * scale), int(w * scale)
+    
+    original_small = cv2.resize(image, (w_new, h_new))
+    mask_small = cv2.resize(mask_rgb, (w_new, h_new))
+    foreground_small = cv2.resize(foreground, (w_new, h_new))
+    
+    # Concatenate horizontally
+    combined = np.hstack([original_small, mask_small, foreground_small])
+    
+    # Add labels
+    label_height = 30
+    labeled_img = np.zeros((combined.shape[0] + label_height, combined.shape[1], 3), dtype=np.uint8)
+    labeled_img[label_height:, :] = combined
+    
+    # Add text labels
+    cv2.putText(labeled_img, "Original", (10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+    cv2.putText(labeled_img, "Mask", (w_new + 10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+    cv2.putText(labeled_img, "Foreground", (2*w_new + 10, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+    
+    info = f"""
+### GrabCut Background Subtraction Applied
+- **Margin**: {margin_percent}% from edges
+- **Iterations**: {iterations}
+- **Algorithm**: Graph cuts with Gaussian Mixture Models
+- **Output**: Shows Original | Mask | Extracted Foreground
+- **Use Case**: Object extraction, background removal, photo editing
+
+**How it works**:
+1. Rectangle defines initial foreground region (inside margins)
+2. GMM models learn foreground/background color distributions
+3. Graph cuts optimize the boundary between them
+4. White mask = foreground, Black = background
+"""
+    
+    return labeled_img, foreground, info
+
+
 def analyze_image_stats(image):
     """Provide detailed statistical analysis"""
     if isinstance(image, Image.Image):
@@ -587,6 +672,34 @@ with gr.Blocks(title="Image Preprocessing Analyzer", theme=gr.themes.Soft()) as
                 inputs=[input_image, thresh_method, thresh_value, thresh_max],
                 outputs=[thresh_output, thresh_info]
             )
+        
+        # GrabCut Background Subtraction Tab
+        with gr.TabItem("✂️ Background Subtraction (GrabCut)"):
+            gr.Markdown("""
+            **GrabCut** is an advanced algorithm for extracting foreground objects from images.
+            It uses graph cuts and Gaussian Mixture Models to intelligently separate foreground from background.
+            
+            Perfect for: Product photography, portrait backgrounds, object isolation
+            """)
+            
+            with gr.Row():
+                grabcut_margin = gr.Slider(5, 25, value=10, step=1, label="Margin from Edges (%)")
+                grabcut_iter = gr.Slider(1, 10, value=5, step=1, label="Iterations")
+            
+            grabcut_btn = gr.Button("Extract Foreground", variant="primary")
+            
+            with gr.Row():
+                grabcut_output = gr.Image(label="Comparison View (Original | Mask | Foreground)")
+            
+            with gr.Row():
+                grabcut_foreground = gr.Image(label="Extracted Foreground (Full Size)")
+                grabcut_info = gr.Markdown()
+            
+            grabcut_btn.click(
+                fn=apply_grabcut,
+                inputs=[input_image, grabcut_margin, grabcut_iter],
+                outputs=[grabcut_output, grabcut_foreground, grabcut_info]
+            )
     
     # Documentation
     with gr.Accordion("📚 Filter Documentation", open=False):
@@ -637,6 +750,15 @@ with gr.Blocks(title="Image Preprocessing Analyzer", theme=gr.themes.Soft()) as
         - **Binary**: Simple cutoff threshold
         - **Otsu**: Automatically finds optimal threshold
         - **Adaptive**: Different thresholds for different regions
+        
+        #### GrabCut Background Subtraction
+        - **Purpose**: Extract foreground objects from images
+        - **How it works**: Uses graph cuts and Gaussian Mixture Models (GMM)
+        - **Margin**: Defines initial foreground region (rectangle inside margins)
+        - **Iterations**: More iterations = more accurate segmentation (but slower)
+        - **Use Case**: Product photography, portrait background removal, object isolation
+        - **Algorithm**: Iteratively learns color distributions of foreground/background
+        - **Output**: Binary mask and extracted foreground object
         """)
 
 if __name__ == "__main__":