erosion max

correct_fgr.py

@@ -52,28 +52,78 @@ def apply_minimum_filter(alpha_channel, radius=4):
     return filtered
 
 
-def apply_minimum_filter_to_rgb(rgb_image, mask, radius=4):
+def apply_minimum_filter_to_rgb(rgb_image, mask, radius=4, method='erosion'):
     """
     Apply minimum filter to RGB image using a mask selection.
     Only pixels where mask is white (255) will be affected.
-    """
-    # Create kernel for minimum filter
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*radius+1, 2*radius+1))
     
-    # Apply erosion (minimum filter) to each color channel
+    Args:
+        rgb_image: Input RGB image
+        mask: Binary mask (white = process, black = leave unchanged)
+        radius: Filter radius in pixels
+        method: 'erosion' (standard), 'radial' (distance-based), 'opening', 'closing'
+    """
     filtered_rgb = rgb_image.copy()
+    mask_binary = (mask == 255).astype(np.uint8)
+    
+    if method == 'radial':
+        # Distance transform based radial approach
+        return apply_radial_filter_to_rgb(rgb_image, mask, radius)
+    elif method == 'opening':
+        # Morphological opening (erosion + dilation)
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*radius+1, 2*radius+1))
+        for channel in range(3):
+            opened_channel = cv2.morphologyEx(rgb_image[:, :, channel], cv2.MORPH_OPEN, kernel)
+            filtered_rgb[:, :, channel] = np.where(mask_binary, opened_channel, rgb_image[:, :, channel])
+    elif method == 'closing':
+        # Morphological closing (dilation + erosion)
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*radius+1, 2*radius+1))
+        for channel in range(3):
+            closed_channel = cv2.morphologyEx(rgb_image[:, :, channel], cv2.MORPH_CLOSE, kernel)
+            filtered_rgb[:, :, channel] = np.where(mask_binary, closed_channel, rgb_image[:, :, channel])
+    else:  # 'erosion' (default)
+        # Standard erosion (minimum filter)
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*radius+1, 2*radius+1))
+        for channel in range(3):
+            eroded_channel = cv2.erode(rgb_image[:, :, channel], kernel, iterations=1)
+            filtered_rgb[:, :, channel] = np.where(mask_binary, eroded_channel, rgb_image[:, :, channel])
     
-    # Only apply filter where mask is white (255)
+    return filtered_rgb
+
+
+def apply_radial_filter_to_rgb(rgb_image, mask, radius=4):
+    """
+    Apply radial minimum filter using distance transform.
+    This method works more radially than standard morphological erosion.
+    """
+    filtered_rgb = rgb_image.copy()
     mask_binary = (mask == 255).astype(np.uint8)
     
-    for channel in range(3):  # B, G, R channels
-        # Apply erosion to the channel
-        eroded_channel = cv2.erode(rgb_image[:, :, channel], kernel, iterations=1)
+    # Create distance transform of the mask
+    dist_transform = cv2.distanceTransform(mask_binary, cv2.DIST_L2, 5)
+    
+    # Create a radial kernel based on distance
+    height, width = rgb_image.shape[:2]
+    y, x = np.ogrid[:height, :width]
+    
+    for channel in range(3):
+        channel_data = rgb_image[:, :, channel].astype(np.float32)
+        filtered_channel = channel_data.copy()
+        
+        # For each pixel in the mask, find minimum in radial neighborhood
+        mask_coords = np.where(mask_binary > 0)
+        
+        for my, mx in zip(mask_coords[0], mask_coords[1]):
+            # Create circular mask around current pixel
+            distances = np.sqrt((y - my)**2 + (x - mx)**2)
+            circle_mask = distances <= radius
+            
+            # Find minimum value in the circular neighborhood
+            if np.any(circle_mask):
+                min_val = np.min(channel_data[circle_mask])
+                filtered_channel[my, mx] = min_val
         
-        # Use the mask to selectively apply the filtered result
-        filtered_rgb[:, :, channel] = np.where(mask_binary, 
-                                               eroded_channel, 
-                                               rgb_image[:, :, channel])
+        filtered_rgb[:, :, channel] = filtered_channel.astype(np.uint8)
     
     return filtered_rgb
 
@@ -141,7 +191,7 @@ def apply_boundary_blur(rgb_image, boundary_mask, blur_sigma=0.5):
 
 
 def process_foreground_correction(expanded_path, automatte_path, fgr_output_path, masked_output_path, 
-                                 threshold=230, contract_pixels=1, minimum_radius=2, blur_sigma=0.5):
+                                 threshold=230, contract_pixels=1, minimum_radius=2, blur_sigma=0.5, filter_method='erosion'):
     """
     Process a single image pair for foreground correction.
     
@@ -154,6 +204,7 @@ def process_foreground_correction(expanded_path, automatte_path, fgr_output_path
         contract_pixels: Number of pixels to contract alpha channel
         minimum_radius: Radius for minimum filter operation
         blur_sigma: Gaussian blur sigma for boundary smoothing
+        filter_method: Method for minimum filter ('erosion', 'radial', 'opening', 'closing')
     """
     # Load the expanded image (RGB)
     expanded_img = cv2.imread(expanded_path, cv2.IMREAD_COLOR)
@@ -186,7 +237,7 @@ def process_foreground_correction(expanded_path, automatte_path, fgr_output_path
     selection_mask = invert_selection(contracted_alpha)
 
     # Step 5: Apply minimum filter to RGB image using the selection mask
-    filtered_rgb = apply_minimum_filter_to_rgb(expanded_img, selection_mask, radius=minimum_radius)
+    filtered_rgb = apply_minimum_filter_to_rgb(expanded_img, selection_mask, radius=minimum_radius, method=filter_method)
 
     # Step 6: Apply Gaussian blur on ±0.5 region of selection mask boundaries
     boundary_mask = create_boundary_mask(selection_mask, boundary_width=1)
@@ -266,10 +317,13 @@ def main():
                        help="Threshold value for alpha binarization (default: 230)")
     parser.add_argument("--contract-pixels", type=int, default=1,
                        help="Number of pixels to contract alpha channel (default: 1)")
-    parser.add_argument("--minimum-radius", type=int, default=3,
-                       help="Radius for minimum filter operation (default: 2)")
+    parser.add_argument("--minimum-radius", type=int, default=50,
+                       help="Radius for minimum filter operation (default: 3)")
     parser.add_argument("--blur-sigma", type=float, default=0.5,
                        help="Gaussian blur sigma for boundary smoothing (default: 0.5)")
+    parser.add_argument("--filter-method", type=str, default="erosion",
+                       choices=["erosion", "radial", "opening", "closing"],
+                       help="Method for minimum filter (default: erosion). 'radial' works more radially.")
     parser.add_argument("--sample", type=str, default=None,
                        help="Process only specific sample (e.g., 'sample-000')")
     
@@ -304,7 +358,8 @@ def main():
                                        threshold=args.threshold, 
                                        contract_pixels=args.contract_pixels,
                                        minimum_radius=args.minimum_radius,
-                                       blur_sigma=args.blur_sigma):
+                                       blur_sigma=args.blur_sigma,
+                                       filter_method=args.filter_method):
             successful += 1
         else:
             failed += 1