something close to what we desire

correct_fgr.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Foreground Correction Script
+
+This script processes images from data/expanded/*/*.png and matching pairs 
+from data/automatte/*/*.png to generate corrected foreground images in 
+data/fgr/*/*.png with the same names.
+
+The foreground correction process:
+1. Load alpha (from automatte folder)
+2. Apply thresholding (white = anything >253, black otherwise)
+3. Contract the alpha channel 1px (equivalent to Select > Modify > Contract in Photoshop)
+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. Use the contracted alpha (before inversion) as the final alpha channel
+"""
+
+import os
+import glob
+import cv2
+import numpy as np
+from pathlib import Path
+import argparse
+
+
+def apply_threshold(alpha_channel, threshold=253):
+    """Apply thresholding: white for values > threshold, black otherwise."""
+    _, thresholded = cv2.threshold(alpha_channel, threshold, 255, cv2.THRESH_BINARY)
+    return thresholded
+
+
+def contract_alpha(alpha_channel, pixels=1):
+    """Contract the alpha channel by specified pixels (erosion operation)."""
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*pixels+1, 2*pixels+1))
+    contracted = cv2.erode(alpha_channel, kernel, iterations=1)
+    return contracted
+
+
+def invert_selection(alpha_channel):
+    """Invert the selection (white becomes black, black becomes white)."""
+    return cv2.bitwise_not(alpha_channel)
+
+
+def apply_minimum_filter(alpha_channel, radius=4):
+    """Apply minimum filter with specified radius (erosion operation)."""
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2*radius+1, 2*radius+1))
+    filtered = cv2.erode(alpha_channel, kernel, iterations=1)
+    return filtered
+
+
+def apply_minimum_filter_to_rgb(rgb_image, mask, radius=4):
+    """
+    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
+    filtered_rgb = rgb_image.copy()
+    
+    # Only apply filter where mask is white (255)
+    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)
+        
+        # Use the mask to selectively apply the filtered result
+        filtered_rgb[:, :, channel] = np.where(mask_binary, 
+                                               eroded_channel, 
+                                               rgb_image[:, :, channel])
+    
+    return filtered_rgb
+
+
+def process_foreground_correction(expanded_path, automatte_path, output_path):
+    """
+    Process a single image pair for foreground correction.
+    
+    Args:
+        expanded_path: Path to the expanded image
+        automatte_path: Path to the automatte (alpha) image
+        output_path: Path where the corrected image will be saved
+    """
+    # Load the expanded image (RGB)
+    expanded_img = cv2.imread(expanded_path, cv2.IMREAD_COLOR)
+    if expanded_img is None:
+        print(f"Error: Could not load expanded image: {expanded_path}")
+        return False
+    
+    # Load the automatte image (alpha channel)
+    automatte_img = cv2.imread(automatte_path, cv2.IMREAD_GRAYSCALE)
+    if automatte_img is None:
+        print(f"Error: Could not load automatte image: {automatte_path}")
+        return False
+    
+    # Ensure both images have the same dimensions
+    if expanded_img.shape[:2] != automatte_img.shape[:2]:
+        print(f"Warning: Size mismatch between {expanded_path} and {automatte_path}")
+        # Resize automatte to match expanded image
+        automatte_img = cv2.resize(automatte_img, (expanded_img.shape[1], expanded_img.shape[0]))
+    
+    # Step 1: Alpha channel is already loaded from automatte
+    alpha = automatte_img.copy()
+    
+    # Step 2: Apply thresholding (white = anything >253, black otherwise)
+    thresholded_alpha = apply_threshold(alpha, threshold=253)
+    
+    # # DO NOT COMMIT: save alpha and exit
+    # cv2.imwrite("debug_alpha.png", alpha)
+    # import sys; sys.exit(0)
+    
+    # Step 3: Contract the alpha channel 1px
+    contracted_alpha = contract_alpha(thresholded_alpha, pixels=1)
+    
+    # # DO NOT COMMIT: save alpha and exit
+    # cv2.imwrite("debug_contracted_alpha.png", alpha)
+    # import sys; sys.exit(0)
+
+    # Step 4: Invert selection
+    selection_mask = invert_selection(contracted_alpha)
+
+    # # DO NOT COMMIT: save alpha and exit
+    # cv2.imwrite("debug_inverted_alpha.png", selection_mask)
+    # import sys; sys.exit(0)
+    
+    # Step 5: Apply minimum filter to RGB image using the selection mask
+    filtered_rgb = apply_minimum_filter_to_rgb(expanded_img, selection_mask, radius=4)
+    
+    # Apply the original contracted alpha (before inversion) to the filtered RGB image
+    # Convert to RGBA
+    expanded_rgba = cv2.cvtColor(filtered_rgb, cv2.COLOR_BGR2BGRA)
+    expanded_rgba[:, :, 3] = alpha  # Use the contracted alpha (before inversion)
+    
+    # Create output directory if it doesn't exist
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    
+    # Save the result
+    success = cv2.imwrite(output_path, filtered_rgb)
+    if not success:
+        print(f"Error: Could not save image to {output_path}")
+        return False
+    
+    return True
+
+
+def find_matching_pairs():
+    """Find all matching pairs between expanded and automatte folders."""
+    expanded_base = "data/expanded"
+    automatte_base = "data/automatte"
+    
+    pairs = []
+    
+    # Get all PNG files in expanded folders
+    expanded_pattern = os.path.join(expanded_base, "*", "*.png")
+    expanded_files = glob.glob(expanded_pattern)
+    
+    for expanded_path in expanded_files:
+        # Extract relative path from expanded base
+        rel_path = os.path.relpath(expanded_path, expanded_base)
+        
+        # Construct corresponding automatte path
+        automatte_path = os.path.join(automatte_base, rel_path)
+        
+        # Check if the automatte file exists
+        if os.path.exists(automatte_path):
+            # Construct output path
+            output_path = os.path.join("data/fgr", rel_path)
+            pairs.append((expanded_path, automatte_path, output_path))
+        else:
+            print(f"Warning: No matching automatte file for {expanded_path}")
+    
+    return pairs
+
+
+def main():
+    """Main function to process all image pairs."""
+    parser = argparse.ArgumentParser(description="Apply foreground correction to image pairs")
+    parser.add_argument("--threshold", type=int, default=253, 
+                       help="Threshold value for alpha binarization (default: 253)")
+    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=4,
+                       help="Radius for minimum filter operation (default: 4)")
+    parser.add_argument("--sample", type=str, default=None,
+                       help="Process only specific sample (e.g., 'sample-000')")
+    
+    args = parser.parse_args()
+    
+    # Find all matching pairs
+    pairs = find_matching_pairs()
+    
+    if not pairs:
+        print("No matching pairs found!")
+        return
+    
+    # Filter by sample if specified
+    if args.sample:
+        pairs = [p for p in pairs if args.sample in p[0]]
+        print(f"Processing {len(pairs)} files for {args.sample}")
+    else:
+        print(f"Found {len(pairs)} matching pairs to process")
+    
+    # Create output base directory
+    os.makedirs("data/fgr", exist_ok=True)
+    
+    # Process each pair
+    successful = 0
+    failed = 0
+    
+    for i, (expanded_path, automatte_path, output_path) in enumerate(pairs):
+        print(f"Processing {i+1}/{len(pairs)}: {os.path.basename(output_path)}")
+        
+        if process_foreground_correction(expanded_path, automatte_path, output_path):
+            successful += 1
+        else:
+            failed += 1
+    
+    print(f"\nProcessing complete!")
+    print(f"Successful: {successful}")
+    print(f"Failed: {failed}")
+    print(f"Total: {len(pairs)}")
+
+
+if __name__ == "__main__":
+    main()