blr

correct_fgr.py

@@ -14,7 +14,8 @@ The foreground correction process:
 4. Invert selection to create a mask
 5. Apply minimum filter with 4px radius to the RGB image using the inverted selection mask
    (equivalent to Filter > Other > Minimum in Photoshop)
-6. Export both versions:
+6. Apply Gaussian blur on ±0.5 pixel region of selection mask boundaries for smooth transitions
+7. Export both versions:
    - FGR: RGB image with the processed regions 
    - Masked: RGBA image using the contracted alpha (before inversion) as the alpha channel
 """
@@ -78,7 +79,70 @@ def apply_minimum_filter_to_rgb(rgb_image, mask, radius=4):
     return filtered_rgb
 
 
-def process_foreground_correction(expanded_path, automatte_path, fgr_output_path, masked_output_path):
+def create_boundary_mask(mask, boundary_width=1):
+    """
+    Create a boundary mask that covers the edge region of the given mask.
+    
+    Args:
+        mask: Binary mask (0 or 255)
+        boundary_width: Width of the boundary region in pixels (default: 1 for ±0.5 pixels)
+    
+    Returns:
+        Boundary mask where boundaries are white (255)
+    """
+    # Create kernels for dilation and erosion
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*boundary_width+1, 2*boundary_width+1))
+    
+    # Dilate and erode the mask to find boundaries
+    dilated = cv2.dilate(mask, kernel, iterations=1)
+    eroded = cv2.erode(mask, kernel, iterations=1)
+    
+    # Boundary is the difference between dilated and eroded versions
+    boundary = cv2.subtract(dilated, eroded)
+    
+    return boundary
+
+
+def apply_boundary_blur(rgb_image, boundary_mask, blur_sigma=0.5):
+    """
+    Apply Gaussian blur to the RGB image only in the boundary regions.
+    
+    Args:
+        rgb_image: Input RGB image
+        boundary_mask: Binary mask indicating boundary regions
+        blur_sigma: Gaussian blur sigma value
+    
+    Returns:
+        RGB image with blurred boundaries
+    """
+    # Convert sigma to kernel size (OpenCV uses kernel size, not sigma directly)
+    # Rule of thumb: kernel_size = 2 * int(3 * sigma) + 1
+    kernel_size = 2 * int(3 * blur_sigma) + 1
+    if kernel_size < 3:
+        kernel_size = 3
+    
+    # Make sure kernel size is odd
+    if kernel_size % 2 == 0:
+        kernel_size += 1
+    
+    # Apply Gaussian blur to the entire image
+    blurred_rgb = cv2.GaussianBlur(rgb_image, (kernel_size, kernel_size), blur_sigma)
+    
+    # Create a normalized boundary mask (0.0 to 1.0)
+    boundary_mask_norm = (boundary_mask > 0).astype(np.float32)
+    
+    # Blend the original and blurred images based on the boundary mask
+    result = rgb_image.copy().astype(np.float32)
+    
+    for channel in range(3):
+        result[:, :, channel] = (1.0 - boundary_mask_norm) * rgb_image[:, :, channel].astype(np.float32) + \
+                               boundary_mask_norm * blurred_rgb[:, :, channel].astype(np.float32)
+    
+    return result.astype(np.uint8)
+
+
+def process_foreground_correction(expanded_path, automatte_path, fgr_output_path, masked_output_path, 
+                                 threshold=253, contract_pixels=1, minimum_radius=4, blur_sigma=0.5):
     """
     Process a single image pair for foreground correction.
     
@@ -87,6 +151,10 @@ def process_foreground_correction(expanded_path, automatte_path, fgr_output_path
         automatte_path: Path to the automatte (alpha) image
         fgr_output_path: Path where the processed RGB image will be saved
         masked_output_path: Path where the masked RGBA image will be saved
+        threshold: Threshold value for alpha binarization
+        contract_pixels: Number of pixels to contract alpha channel
+        minimum_radius: Radius for minimum filter operation
+        blur_sigma: Gaussian blur sigma for boundary smoothing
     """
     # Load the expanded image (RGB)
     expanded_img = cv2.imread(expanded_path, cv2.IMREAD_COLOR)
@@ -109,18 +177,21 @@ def process_foreground_correction(expanded_path, automatte_path, fgr_output_path
     # Step 1: Alpha channel is already loaded from automatte
     alpha = automatte_img.copy()
     
-    # Step 2: Apply thresholding (white = anything >235, black otherwise)
-    thresholded_alpha = apply_threshold(alpha, threshold=235)
+    # Step 2: Apply thresholding (white = anything >threshold, black otherwise)
+    thresholded_alpha = apply_threshold(alpha, threshold=threshold)
 
-    # Step 3: Contract the alpha channel 1px
-    contracted_alpha = contract_alpha(thresholded_alpha, pixels=1)
-    # contracted_alpha = thresholded_alpha
+    # Step 3: Contract the alpha channel
+    contracted_alpha = contract_alpha(thresholded_alpha, pixels=contract_pixels)
     
     # Step 4: Invert selection
     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=2)
+    filtered_rgb = apply_minimum_filter_to_rgb(expanded_img, selection_mask, radius=minimum_radius)
+
+    # Step 6: Apply Gaussian blur on ±0.5 region of selection mask boundaries
+    boundary_mask = create_boundary_mask(selection_mask, boundary_width=1)
+    final_rgb = apply_boundary_blur(filtered_rgb, boundary_mask, blur_sigma=blur_sigma)
     
     # # DO NOT COMMIT: save alpha and exit
     # cv2.imwrite("debug_expanded.png", expanded_img)
@@ -132,17 +203,17 @@ def process_foreground_correction(expanded_path, automatte_path, fgr_output_path
     # cv2.imwrite("debug_filtered_rgb.png", filtered_rgb)
     # import sys; sys.exit(0)
     
-    # Apply the original contracted alpha (before inversion) to the filtered RGB image
+    # Apply the original contracted alpha (before inversion) to the final RGB image
     # Convert to RGBA for masked output
-    masked_rgba = cv2.cvtColor(filtered_rgb, cv2.COLOR_BGR2BGRA)
-    masked_rgba[:, :, 3] = alpha  # Use the contracted alpha (before inversion)
+    masked_rgba = cv2.cvtColor(final_rgb, cv2.COLOR_BGR2BGRA)
+    masked_rgba[:, :, 3] = contracted_alpha  # Use the contracted alpha (before inversion)
     
     # Create output directories if they don't exist
     os.makedirs(os.path.dirname(fgr_output_path), exist_ok=True)
     os.makedirs(os.path.dirname(masked_output_path), exist_ok=True)
     
     # Save the processed RGB image (without alpha)
-    success_fgr = cv2.imwrite(fgr_output_path, filtered_rgb)
+    success_fgr = cv2.imwrite(fgr_output_path, final_rgb)
     if not success_fgr:
         print(f"Error: Could not save RGB image to {fgr_output_path}")
         return False
@@ -198,6 +269,8 @@ def main():
                        help="Number of pixels to contract alpha channel (default: 1)")
     parser.add_argument("--minimum-radius", type=int, default=4,
                        help="Radius for minimum filter operation (default: 4)")
+    parser.add_argument("--blur-sigma", type=float, default=0.5,
+                       help="Gaussian blur sigma for boundary smoothing (default: 0.5)")
     parser.add_argument("--sample", type=str, default=None,
                        help="Process only specific sample (e.g., 'sample-000')")
     
@@ -228,7 +301,11 @@ def main():
     for i, (expanded_path, automatte_path, fgr_output_path, masked_output_path) in enumerate(pairs):
         print(f"Processing {i+1}/{len(pairs)}: {os.path.basename(fgr_output_path)}")
         
-        if process_foreground_correction(expanded_path, automatte_path, fgr_output_path, masked_output_path):
+        if process_foreground_correction(expanded_path, automatte_path, fgr_output_path, masked_output_path,
+                                       threshold=args.threshold, 
+                                       contract_pixels=args.contract_pixels,
+                                       minimum_radius=args.minimum_radius,
+                                       blur_sigma=args.blur_sigma):
             successful += 1
         else:
             failed += 1