Update processing/two_stage/two_stage_processor.py

processing/two_stage/two_stage_processor.py

@@ -1,14 +1,13 @@
 #!/usr/bin/env python3
 """
-EFFICIENT Two-Stage Green-Screen Processing System ✅ 2025-09-09
-VIDEO-TO-VIDEO PIPELINE: No PNG conversion, direct MP4 processing
+EFFICIENT Two-Stage Alpha Channel Processing System ✅ 2025-09-09
+VIDEO-TO-VIDEO PIPELINE: Direct alpha compositing without green screen
 Stage 1: SAM2 creates reference mask from first 3 frames
-Stage 2: MatAnyone processes entire video → pha.mp4 
-Stage 3: Create green screen video using pha.mp4 as alpha matte
-Stage 4: Adaptive chroma key compositing with background → final.mp4
+Stage 2: MatAnyone processes entire video → pha.mp4 (alpha matte)
+Stage 3: Direct alpha compositing with background → final.mp4
 FEATURES:
-- Auto-detection of optimal chroma key threshold
-- Adaptive iteration to find perfect threshold
+- No green screen or chroma key needed
+- Direct alpha channel compositing
 - Chunked processing for long videos with memory management
 - Dimension mismatch handling
 - Memory optimization with light/deep cleanup modes
@@ -28,6 +27,7 @@
 import gc
 import time
 import traceback
+import subprocess
 from pathlib import Path
 from typing import Optional, Tuple, Dict, Any, List
 from moviepy.editor import VideoFileClip, CompositeVideoClip, ImageClip, concatenate_videoclips
@@ -41,14 +41,6 @@
 )
 logger = logging.getLogger(__name__)
 
-# Try to import sklearn, fallback gracefully
-try:
-    from sklearn.cluster import KMeans
-    SKLEARN_AVAILABLE = True
-except ImportError:
-    SKLEARN_AVAILABLE = False
-    logger.warning("scikit-learn not available, using fallback threshold detection")
-
 # PyTorch memory management
 try:
     import torch
@@ -72,21 +64,6 @@ class ProcessingConfig:
     CHUNK_OVERLAP_FRAMES = 5   # Frames to overlap between chunks for smooth transitions
     MAX_PROCESSING_RESOLUTION = None  # Keep full resolution for chunks
     
-    # Green screen settings
-    GREEN_COLOR = (0, 255, 0)  # RGB green for green screen
-    GREEN_COLOR_NORMALIZED = (0.0, 1.0, 0.0)  # Normalized for compositing
-    
-    # Auto-detection settings
-    AUTO_DETECTION_FRAMES = 5  # Number of frames to analyze for auto-detection
-    AUTO_DETECTION_FALLBACK = 0.1  # Fallback threshold if auto-detection fails
-    MIN_THRESHOLD = 0.02  # Minimum allowed threshold
-    MAX_THRESHOLD = 0.3   # Maximum allowed threshold
-    
-    # Adaptive optimization settings
-    ADAPTIVE_MAX_ITERATIONS = 10  # Maximum iterations for threshold optimization
-    ADAPTIVE_GREEN_TOLERANCE = 0.01  # Acceptable green residue level
-    ADAPTIVE_TRANSPARENCY_TOLERANCE = 0.1  # Acceptable transparency quality
-    
     # Quality settings
     VIDEO_CODEC = 'libx264'
     VIDEO_BITRATE = '8000k' 
@@ -107,11 +84,11 @@ class ProcessingConfig:
     ENABLE_MEMORY_TESTING = False  # DISABLED: Memory testing causes predictor deletion
 
 # ==============================================================================  
-# CHAPTER 3: ENHANCED MEMORY MANAGEMENT UTILITIES
+# CHAPTER 3: MEMORY MANAGEMENT UTILITIES
 # ==============================================================================
 
 class MemoryManager:
-    """Enhanced utilities for managing GPU and system memory."""
+    """Utilities for managing GPU and system memory."""
     
     def __init__(self, config: ProcessingConfig):
         self.config = config
@@ -275,103 +252,8 @@ def get_memory_report(self) -> str:
         report.append("="*60)
         return "\n".join(report)
 
-# ==============================================================================
-# CHAPTER 4: MEMORY TESTING UTILITIES
-# ==============================================================================
-
-class MemoryTester:
-    """Testing utilities for memory management verification."""
-    
-    @staticmethod
-    def test_memory_cleanup(processor: 'TwoStageProcessor') -> Dict[str, Any]:
-        """Test memory cleanup at each stage."""
-        results = {
-            'initial_memory': None,
-            'post_sam2_memory': None,
-            'post_matanyone_memory': None,
-            'post_final_memory': None,
-            'cleanup_effective': False,
-            'memory_leaks': []
-        }
-        
-        try:
-            # Get initial memory
-            results['initial_memory'] = processor.memory_manager.get_current_memory()
-            logger.info(f"Initial memory: {results['initial_memory']['gpu_allocated']:.2f}GB")
-            
-            # Create dummy data for testing
-            dummy_frame = np.random.randint(0, 255, (1080, 1920, 3), dtype=np.uint8)
-            
-            # Test SAM2 cleanup
-            if hasattr(processor.sam2_handler, 'create_mask'):
-                logger.info("Testing SAM2 memory cleanup...")
-                _ = processor._create_sam2_mask(dummy_frame)
-                pre_cleanup = processor.memory_manager.get_current_memory()
-                # Use deep cleanup for testing only
-                processor.memory_manager.cleanup_model(processor.sam2_handler, "SAM2", deep_cleanup=True)
-                processor.memory_manager.cleanup_stage("SAM2_test", force=True)
-                post_cleanup = processor.memory_manager.get_current_memory()
-                
-                results['post_sam2_memory'] = post_cleanup
-                sam2_freed = pre_cleanup['gpu_allocated'] - post_cleanup['gpu_allocated']
-                
-                if sam2_freed > 0:
-                    logger.info(f"SAM2 cleanup freed {sam2_freed:.2f}GB")
-                else:
-                    results['memory_leaks'].append("SAM2 cleanup ineffective")
-            
-            # Check if memory is properly freed
-            final_memory = processor.memory_manager.get_current_memory()
-            results['post_final_memory'] = final_memory
-            
-            # Determine if cleanup was effective
-            memory_increase = final_memory['gpu_allocated'] - results['initial_memory']['gpu_allocated']
-            results['cleanup_effective'] = memory_increase < 0.1  # Less than 100MB increase
-            
-            if not results['cleanup_effective']:
-                results['memory_leaks'].append(f"Memory increased by {memory_increase:.2f}GB")
-            
-            # Generate report
-            logger.info(processor.memory_manager.get_memory_report())
-            
-        except Exception as e:
-            logger.error(f"Memory testing failed: {e}")
-            results['error'] = str(e)
-        
-        return results
-    
-    @staticmethod
-    def monitor_memory_during_processing(func):
-        """Decorator to monitor memory during a function call."""
-        def wrapper(*args, **kwargs):
-            if not TORCH_AVAILABLE:
-                return func(*args, **kwargs)
-            
-            start_memory = torch.cuda.memory_allocated() if torch.cuda.is_available() else 0
-            start_time = time.time()
-            
-            try:
-                result = func(*args, **kwargs)
-                
-                end_memory = torch.cuda.memory_allocated() if torch.cuda.is_available() else 0
-                end_time = time.time()
-                
-                memory_used = (end_memory - start_memory) / 1024**3
-                time_taken = end_time - start_time
-                
-                func_name = func.__name__
-                logger.info(f"{func_name}: {time_taken:.1f}s, {memory_used:.2f}GB memory delta")
-                
-                return result
-                
-            except Exception as e:
-                logger.error(f"Error in {func.__name__}: {e}")
-                raise
-                
-        return wrapper
-
 # ==============================================================================  
-# CHAPTER 5: QUALITY MANAGER
+# CHAPTER 4: QUALITY MANAGER
 # ==============================================================================
 
 class QualityManager:
@@ -404,7 +286,7 @@ def get_profile(cls, quality: str = 'medium') -> Dict[str, Any]:
         return cls.PROFILES.get(quality, cls.PROFILES['medium'])
 
 # ==============================================================================
-# CHAPTER 6: CHUNKED VIDEO PROCESSOR
+# CHAPTER 5: CHUNKED VIDEO PROCESSOR
 # ==============================================================================
 
 class ChunkedVideoProcessor:
@@ -511,21 +393,19 @@ def reassemble_chunks(self, processed_chunk_paths: List[str], output_path: str)
             raise
 
 # ==============================================================================
-# CHAPTER 7: TWOSTAGEPROCESSOR CLASS DEFINITION
+# CHAPTER 6: TWOSTAGEPROCESSOR CLASS DEFINITION
 # ==============================================================================
 
 class TwoStageProcessor:
     """
-    Efficient two-stage green screen processor with video-to-video pipeline.
+    Efficient two-stage alpha channel processor with video-to-video pipeline.
     
-    This processor avoids PNG conversion by working directly with MP4 files:
+    This processor avoids green screen entirely by using alpha channels:
     1. SAM2 creates reference mask from first few frames
-    2. MatAnyone processes entire video using reference mask → pha.mp4
-    3. Create green screen video using pha.mp4 as alpha matte
-    4. Adaptive chroma key compositing with background → final.mp4
-    5. Auto-detects and iteratively optimizes chroma key threshold
-    6. Chunked processing for long videos with memory management
-    7. Dimension mismatch handling for robust processing
+    2. MatAnyone processes entire video using reference mask → pha.mp4 (alpha matte)
+    3. Direct alpha compositing with background → final.mp4
+    
+    No chroma key or green screen needed!
     """
     
     def __init__(self, sam2_handler, matanyone_handler, temp_dir: Optional[str] = None):
@@ -536,7 +416,6 @@ def __init__(self, sam2_handler, matanyone_handler, temp_dir: Optional[str] = No
         self.config = ProcessingConfig()
         self.memory_manager = MemoryManager(self.config)
         self.chunked_processor = ChunkedVideoProcessor(self.temp_dir, self.config)
-        self.memory_tester = MemoryTester()
         
         # Ensure temp directory exists
         os.makedirs(self.temp_dir, exist_ok=True)
@@ -544,29 +423,6 @@ def __init__(self, sam2_handler, matanyone_handler, temp_dir: Optional[str] = No
         
         # Log initial memory state
         logger.info(self.memory_manager.get_gpu_memory_info())
-        
-        # Memory test DISABLED - it deletes the predictor causing failures
-        if self.config.ENABLE_MEMORY_TESTING:
-            logger.info("Memory testing is disabled to prevent predictor deletion")
-            # self.run_memory_test()  # DO NOT RUN - causes predictor deletion
-    
-    def run_memory_test(self):
-        """Run memory management tests. WARNING: This will delete the predictor!"""
-        try:
-            logger.warning("Running memory tests - this may affect handler state!")
-            test_results = self.memory_tester.test_memory_cleanup(self)
-            
-            if test_results['cleanup_effective']:
-                logger.info("✅ Memory management tests passed")
-            else:
-                logger.warning(f"⚠️ Memory management issues detected: {test_results['memory_leaks']}")
-            
-            # Try to restore predictor after test
-            if hasattr(self.sam2_handler, 'predictor') and self.sam2_handler.predictor is None:
-                logger.warning("SAM2 predictor was deleted by memory test - manual restoration required")
-                
-        except Exception as e:
-            logger.warning(f"Memory tests failed: {e}")
     
     def process_video(self, 
                      video_path: str, 
@@ -577,13 +433,13 @@ def process_video(self,
                      callback: Optional[callable] = None,
                      **kwargs) -> Tuple[str, str]:
         """
-        Main processing pipeline - video to video with chunked processing.
+        Main processing pipeline - video to video with alpha compositing.
         
         Returns:
             Tuple[str, str]: (final_output_path, status_message)
         """
         try:
-            logger.info(f"🎬 Two-Stage Video Pipeline: {video_path}")
+            logger.info(f"🎬 Two-Stage Alpha Pipeline: {video_path}")
             logger.info(f"🎯 Background: {background_path}")
             logger.info(f"📁 Temp: {self.temp_dir}")
             logger.info(f"🧠 Initial {self.memory_manager.get_gpu_memory_info()}")
@@ -649,7 +505,7 @@ def _process_chunked_video(self,
                 else:
                     raise RuntimeError(f"Chunk {i+1} processing failed: {status}")
                 
-                # Aggressive memory cleanup between chunks - but don't delete predictor
+                # Memory cleanup between chunks
                 logger.info(f"Cleaning up after chunk {i+1}...")
                 self.memory_manager.cleanup_stage(f"Chunk_{i+1}", force=True)
                 
@@ -675,7 +531,6 @@ def _process_chunked_video(self,
             logger.error(f"Chunked processing failed: {e}")
             raise
     
-    @MemoryTester.monitor_memory_during_processing
     def _process_single_video(self, 
                              video_path: str, 
                              background_path: str,
@@ -707,21 +562,11 @@ def _process_single_video(self,
             self.memory_manager.cleanup_model(self.matanyone_handler, "MatAnyone", deep_cleanup=False)
             self.memory_manager.cleanup_stage("MatAnyone", force=True)
             
-            # Stage 3: Create green screen video
-            if callback:
-                callback("Creating green screen intermediate video...", 70)
-            logger.info("STAGE 3: Creating green screen intermediate video...")
-            green_screen_path = self._stage3_create_green_screen_video(video_path, alpha_video_path)
-            
-            # Memory cleanup after green screen
-            if self.memory_manager.should_clear_memory():
-                self.memory_manager.cleanup_stage("GreenScreen")
-            
-            # Stage 4: Adaptive final compositing
+            # Stage 3: Direct alpha compositing (no green screen!)
             if callback:
-                callback("Adaptive compositing with background...", 90)
-            logger.info("STAGE 4: Adaptive compositing with background...")
-            final_path = self._stage4_adaptive_compositing(green_screen_path, background_path, output_path, quality)
+                callback("Alpha compositing with background...", 70)
+            logger.info("STAGE 3: Direct alpha compositing with background...")
+            final_path = self._stage3_alpha_composite(video_path, alpha_video_path, background_path, output_path, quality)
             
             # Final memory cleanup
             self.memory_manager.cleanup_stage("Final")
@@ -760,10 +605,9 @@ def cleanup(self):
             logger.warning(f"Failed to cleanup: {e}")
 
 # ==============================================================================
-# CHAPTER 8: STAGE 1 - REFERENCE MASK CREATION (SAM2)
+# CHAPTER 7: STAGE 1 - REFERENCE MASK CREATION (SAM2)
 # ==============================================================================
 
-    @MemoryTester.monitor_memory_during_processing
     def _stage1_create_reference_mask(self, video_path: str) -> str:
         """
         Stage 1: Create robust reference mask from first few frames using SAM2.
@@ -886,10 +730,9 @@ def _combine_reference_masks(self, masks: list) -> np.ndarray:
         return result
 
 # ==============================================================================
-# CHAPTER 9: STAGE 2 - MATANYONE PROCESSING WITH FIXED PARAMETERS
+# CHAPTER 8: STAGE 2 - MATANYONE PROCESSING
 # ==============================================================================
 
-    @MemoryTester.monitor_memory_during_processing
     def _stage2_matanyone_processing(self, video_path: str, reference_mask_path: str, trim_seconds: Optional[int]) -> str:
         """
         Stage 2: Process entire video through MatAnyone using reference mask.
@@ -929,7 +772,7 @@ def _stage2_matanyone_processing(self, video_path: str, reference_mask_path: str
                     r_dilate=15,
                     suffix='pha',
                     save_image=False,
-                    max_size=max_size  # FIXED: Use actual number instead of None
+                    max_size=max_size  # Use actual number instead of None
                 )
                 
             except Exception as e:
@@ -948,7 +791,6 @@ def _stage2_matanyone_processing(self, video_path: str, reference_mask_path: str
             
             # Verify MatAnyone output
             if not alpha_output_path or not os.path.exists(alpha_output_path):
-                # List what files were actually created
                 files_created = os.listdir(matanyone_dir) if os.path.exists(matanyone_dir) else []
                 raise RuntimeError(f"MatAnyone did not create pha.mp4. Files created: {files_created}")
                 
@@ -990,24 +832,22 @@ def _trim_video(self, input_path: str, output_path: str, seconds: int):
             raise
 
 # ==============================================================================
-# CHAPTER 10: STAGE 3 - GREEN SCREEN VIDEO CREATION WITH DIMENSION FIX
+# CHAPTER 9: STAGE 3 - DIRECT ALPHA COMPOSITING (NO GREEN SCREEN!)
 # ==============================================================================
 
-    @MemoryTester.monitor_memory_during_processing
-    def _stage3_create_green_screen_video(self, original_video_path: str, alpha_video_path: str) -> str:
+    def _stage3_alpha_composite(self, original_video_path: str, alpha_video_path: str,
+                                background_path: str, output_path: str, quality: str) -> str:
         """
-        Stage 3: Create green screen intermediate video using alpha matte.
-        
-        Uses the alpha video from MatAnyone to create a green screen version:
-        - Where alpha = 1 (person): keep original video
-        - Where alpha = 0 (background): make it green (#00FF00)
+        Stage 3: Direct alpha compositing without any green screen.
         
-        Returns path to green screen video.
+        Uses the alpha matte from MatAnyone to composite the person
+        directly onto the new background.
         """
         try:
-            green_screen_path = os.path.join(self.temp_dir, "green_screen.mp4")
+            # Get quality profile
+            profile = QualityManager.get_profile(quality)
             
-            # Open both videos
+            # Open videos
             original_cap = cv2.VideoCapture(original_video_path)
             alpha_cap = cv2.VideoCapture(alpha_video_path)
             
@@ -1026,12 +866,26 @@ def _stage3_create_green_screen_video(self, original_video_path: str, alpha_vide
             alpha_width = int(alpha_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
             alpha_height = int(alpha_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
             
-            logger.info(f"Green screen processing: {width}x{height} @ {fps} FPS, {total_frames} frames")
+            logger.info(f"Original video: {width}x{height} @ {fps} FPS, {total_frames} frames")
             logger.info(f"Alpha video dimensions: {alpha_width}x{alpha_height}")
             
-            # Setup video writer with original dimensions
+            # Load and prepare background
+            if background_path.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
+                # Video background - process frame by frame
+                bg_cap = cv2.VideoCapture(background_path)
+                bg_is_video = True
+            else:
+                # Image background
+                bg_image = cv2.imread(background_path)
+                if bg_image is None:
+                    raise RuntimeError(f"Cannot load background image: {background_path}")
+                # Resize to match video
+                bg_image = cv2.resize(bg_image, (width, height))
+                bg_is_video = False
+            
+            # Setup video writer
             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-            out = cv2.VideoWriter(green_screen_path, fourcc, fps, (width, height))
+            out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
             
             frame_count = 0
             while True:
@@ -1042,13 +896,24 @@ def _stage3_create_green_screen_video(self, original_video_path: str, alpha_vide
                 if not ret_orig or not ret_alpha:
                     break
                 
+                # Get background frame
+                if bg_is_video:
+                    ret_bg, bg_frame = bg_cap.read()
+                    if not ret_bg:
+                        # Loop background if it's shorter
+                        bg_cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                        ret_bg, bg_frame = bg_cap.read()
+                    bg_frame = cv2.resize(bg_frame, (width, height))
+                else:
+                    bg_frame = bg_image.copy()
+                
                 # Convert alpha frame to grayscale mask
                 if len(alpha_frame.shape) == 3:
                     alpha_mask = cv2.cvtColor(alpha_frame, cv2.COLOR_BGR2GRAY)
                 else:
                     alpha_mask = alpha_frame
                 
-                # FIX: Handle dimension mismatch - resize alpha to match original if needed
+                # Handle dimension mismatch - resize alpha to match original if needed
                 if alpha_mask.shape[:2] != orig_frame.shape[:2]:
                     if frame_count == 0:  # Log only once
                         logger.info(f"Resizing alpha from {alpha_mask.shape[:2]} to {orig_frame.shape[:2]}")
@@ -1057,515 +922,59 @@ def _stage3_create_green_screen_video(self, original_video_path: str, alpha_vide
                 # Normalize alpha to 0-1 range
                 alpha_normalized = alpha_mask.astype(np.float32) / 255.0
                 
-                # Create green background
-                green_bg = np.full_like(orig_frame, self.config.GREEN_COLOR, dtype=np.uint8)
-                
-                # Composite: person where alpha=1, green where alpha=0
-                # alpha_3d for broadcasting across color channels
+                # Create 3-channel alpha for compositing
                 alpha_3d = np.stack([alpha_normalized] * 3, axis=2)
                 
-                # CRITICAL: Ensure both inputs are same data type
+                # Composite: background where alpha=0, person where alpha=1
                 orig_frame_float = orig_frame.astype(np.float32)
-                green_bg_float = green_bg.astype(np.float32)
+                bg_frame_float = bg_frame.astype(np.float32)
                 
-                # Composite with proper scaling
-                composite = alpha_3d * orig_frame_float + (1 - alpha_3d) * green_bg_float
+                # Direct alpha compositing
+                composite = alpha_3d * orig_frame_float + (1 - alpha_3d) * bg_frame_float
                 composite = np.clip(composite, 0, 255).astype(np.uint8)
                 
                 # Write frame
                 out.write(composite)
                 frame_count += 1
                 
-                # Debug logging and memory check
+                # Progress logging
                 if frame_count % self.config.MEMORY_CHECK_INTERVAL == 0:
-                    logger.info(f"Green screen progress: {frame_count}/{total_frames}")
+                    logger.info(f"Compositing progress: {frame_count}/{total_frames}")
                     if self.memory_manager.should_clear_memory():
-                        logger.info("Memory high during green screen creation, clearing...")
+                        logger.info("Memory high during compositing, clearing...")
                         self.memory_manager.clear_gpu_cache()
                 
                 # Save debug frame occasionally
                 if self.config.SAVE_DEBUG_FILES and frame_count % self.config.DEBUG_FRAME_INTERVAL == 0:
-                    debug_path = os.path.join(self.temp_dir, f"debug_green_frame_{frame_count:04d}.png")
+                    debug_path = os.path.join(self.temp_dir, f"debug_composite_{frame_count:04d}.png")
                     cv2.imwrite(debug_path, composite)
             
             # Cleanup
             original_cap.release()
             alpha_cap.release()
             out.release()
+            if bg_is_video:
+                bg_cap.release()
             
             if frame_count == 0:
-                raise RuntimeError("No frames processed for green screen video")
-            
-            logger.info(f"✅ Green screen video created: {frame_count} frames → {green_screen_path}")
-            return green_screen_path
-            
-        except Exception as e:
-            logger.error(f"Stage 3 failed: {e}")
-            raise
-
-# ==============================================================================
-# CHAPTER 11: STAGE 4 - ADAPTIVE CHROMA KEY COMPOSITING
-# ==============================================================================
-
-    @MemoryTester.monitor_memory_during_processing  
-    def _stage4_adaptive_compositing(self, green_screen_path: str, background_path: str, 
-                                    output_path: str, quality: str) -> str:
-        """
-        Stage 4: Final compositing with adaptive threshold optimization.
-        
-        Iteratively adjusts chroma key threshold until green is properly removed.
-        """
-        try:
-            # Get quality profile
-            profile = QualityManager.get_profile(quality)
-            
-            # Load videos/images
-            green_clip = VideoFileClip(green_screen_path)
-            
-            if background_path.lower().endswith(('.mp4', '.avi', '.mov', '.mkv')):
-                bg_clip = VideoFileClip(background_path)
-                if bg_clip.duration < green_clip.duration:
-                    bg_clip = bg_clip.loop(duration=green_clip.duration)
-                bg_clip = bg_clip.subclip(0, green_clip.duration)
-            else:
-                bg_clip = ImageClip(background_path, duration=green_clip.duration)
-            
-            bg_clip = bg_clip.resize((green_clip.w, green_clip.h))
-            
-            # Start with auto-detected threshold
-            initial_threshold = self._auto_detect_chroma_threshold(green_screen_path)
-            logger.info(f"Initial auto-detected threshold: {initial_threshold:.4f}")
-            
-            # Adaptive optimization
-            best_threshold = self._optimize_chroma_threshold(
-                green_clip, bg_clip, initial_threshold, 
-                max_iterations=self.config.ADAPTIVE_MAX_ITERATIONS
-            )
-            
-            logger.info(f"✅ Optimized threshold: {best_threshold:.4f} (started from {initial_threshold:.4f})")
-            
-            # Apply final chroma key with optimized threshold
-            green_screen_keyed = green_clip.fx(vfx.mask_color, 
-                                             color=self.config.GREEN_COLOR_NORMALIZED,
-                                             thr=best_threshold,
-                                             s=0.1)  # Reduced smoothing for sharper edges
-            
-            # Composite and write
-            final_clip = CompositeVideoClip([bg_clip, green_screen_keyed])
-            
-            write_params = {
-                'codec': self.config.VIDEO_CODEC,
-                'bitrate': profile['bitrate'],
-                'audio_codec': self.config.AUDIO_CODEC,
-                'verbose': False,
-                'logger': None
-            }
-            
-            if 'crf' in profile:
-                write_params['ffmpeg_params'] = ['-crf', str(profile['crf'])]
-            
-            final_clip.write_videofile(output_path, **write_params)
-            
-            # Cleanup
-            green_clip.close()
-            bg_clip.close()
-            final_clip.close()
+                raise RuntimeError("No frames processed for output video")
             
+            # Verify output
             if not os.path.exists(output_path):
-                raise RuntimeError("Final output file was not created")
-            
-            file_size = os.path.getsize(output_path) / (1024 * 1024)
-            logger.info(f"✅ Adaptive compositing completed: {output_path} ({file_size:.1f} MB)")
+                raise RuntimeError("Output file was not created")
+                
+            file_size = os.path.getsize(output_path) / (1024 * 1024)  # MB
+            logger.info(f"✅ Alpha compositing completed: {output_path} ({file_size:.1f} MB)")
+            logger.info(f"   Processed {frame_count} frames")
             
             return output_path
             
         except Exception as e:
-            logger.error(f"Stage 4 adaptive failed: {e}")
+            logger.error(f"Stage 3 alpha compositing failed: {e}")
             raise
-    
-    def _optimize_chroma_threshold(self, green_clip, bg_clip, initial_threshold: float, 
-                                  max_iterations: int = 10) -> float:
-        """
-        Iteratively optimize chroma key threshold by analyzing output quality.
-        """
-        threshold = initial_threshold
-        best_threshold = threshold
-        best_score = float('inf')
-        
-        # Binary search bounds
-        low = max(self.config.MIN_THRESHOLD, initial_threshold * 0.5)
-        high = min(self.config.MAX_THRESHOLD, initial_threshold * 2.0)
-        
-        # Track tested thresholds to avoid repetition
-        tested_thresholds = set()
-        
-        for iteration in range(max_iterations):
-            # Round threshold to avoid tiny differences
-            threshold = round(threshold, 4)
-            
-            # Skip if already tested
-            if threshold in tested_thresholds:
-                logger.info(f"  Threshold {threshold:.4f} already tested, adjusting...")
-                threshold = (low + high) / 2
-                continue
-                
-            tested_thresholds.add(threshold)
-            logger.info(f"🔄 Optimization iteration {iteration + 1}/{max_iterations}, testing threshold: {threshold:.4f}")
-            
-            # Apply chroma key with current threshold
-            keyed = green_clip.fx(vfx.mask_color,
-                                color=self.config.GREEN_COLOR_NORMALIZED,
-                                thr=threshold,
-                                s=0.1)
-            
-            # Composite
-            test_composite = CompositeVideoClip([bg_clip, keyed])
-            
-            # Extract test frames (beginning, middle, end)
-            test_times = [
-                green_clip.duration * 0.1,
-                green_clip.duration * 0.5,
-                green_clip.duration * 0.9
-            ]
-            
-            total_green_score = 0
-            total_transparency_score = 0
-            
-            for test_time in test_times:
-                test_frame = test_composite.get_frame(test_time)
-                bg_frame = bg_clip.get_frame(test_time)
-                
-                # Analyze the frame for green residue
-                green_score = self._analyze_green_residue(test_frame)
-                transparency_score = self._analyze_transparency_quality(test_frame, bg_frame)
-                
-                total_green_score += green_score
-                total_transparency_score += transparency_score
-            
-            # Average scores
-            avg_green_score = total_green_score / len(test_times)
-            avg_transparency_score = total_transparency_score / len(test_times)
-            
-            # Combined score (lower is better)
-            total_score = avg_green_score + avg_transparency_score * 0.5
-            
-            logger.info(f"  📊 Green residue: {avg_green_score:.4f}, Transparency: {avg_transparency_score:.4f}, Total: {total_score:.4f}")
-            
-            # Update best if improved
-            if total_score < best_score:
-                best_score = total_score
-                best_threshold = threshold
-                logger.info(f"  ✅ New best threshold: {best_threshold:.4f} (score: {best_score:.4f})")
-            
-            # Check if we're good enough
-            if avg_green_score < self.config.ADAPTIVE_GREEN_TOLERANCE and \
-               avg_transparency_score < self.config.ADAPTIVE_TRANSPARENCY_TOLERANCE:
-                logger.info(f"  🎯 Acceptable quality reached! Stopping optimization.")
-                break
-            
-            # Adjust threshold using binary search
-            if avg_green_score > 0.05:  # Too much green remains
-                logger.info(f"  🟢 Too much green, decreasing threshold")
-                high = threshold
-                threshold = (low + threshold) / 2
-            elif avg_transparency_score > 0.3:  # Too much was removed
-                logger.info(f"  👤 Subject too transparent, increasing threshold")
-                low = threshold
-                threshold = (threshold + high) / 2
-            else:
-                # Fine-tune around current value
-                if avg_green_score > avg_transparency_score:
-                    threshold *= 0.95  # Slightly more aggressive
-                else:
-                    threshold *= 1.05  # Slightly less aggressive
-            
-            # Ensure we stay in bounds
-            threshold = np.clip(threshold, self.config.MIN_THRESHOLD, self.config.MAX_THRESHOLD)
-            
-            # Clean up test composite
-            test_composite.close()
-            keyed.close()
-            
-            # Stop if converged
-            if abs(threshold - best_threshold) < 0.001 and iteration > 3:
-                logger.info("  📍 Converged, stopping optimization")
-                break
-        
-        return best_threshold
-    
-    def _analyze_green_residue(self, frame: np.ndarray) -> float:
-        """
-        Analyze how much green remains in the frame.
-        Returns score from 0 (no green) to 1 (lots of green).
-        """
-        # Convert to float
-        img = frame.astype(np.float32) / 255.0
-        
-        # Detect pure green pixels
-        green_pixels = (
-            (img[:,:,1] > 0.7) &   # High green
-            (img[:,:,0] < 0.3) &   # Low red
-            (img[:,:,2] < 0.3)     # Low blue
-        )
-        
-        # Calculate percentage of green pixels
-        green_ratio = np.sum(green_pixels) / (frame.shape[0] * frame.shape[1])
-        
-        # Also check for greenish tint in other pixels
-        greenish_pixels = (
-            (img[:,:,1] > img[:,:,0] * 1.5) &  # Green > Red * 1.5
-            (img[:,:,1] > img[:,:,2] * 1.5) &  # Green > Blue * 1.5
-            (img[:,:,1] > 0.4)                 # Significant green
-        )
-        
-        greenish_ratio = np.sum(greenish_pixels) / (frame.shape[0] * frame.shape[1])
-        
-        # Combined score
-        score = green_ratio + greenish_ratio * 0.3
-        
-        return min(1.0, score)
-    
-    def _analyze_transparency_quality(self, composite_frame: np.ndarray, bg_frame: np.ndarray) -> float:
-        """
-        Analyze if too much of the subject was removed.
-        Returns score from 0 (good) to 1 (too much removed).
-        """
-        # Calculate difference between composite and background
-        diff = np.abs(composite_frame.astype(np.float32) - bg_frame.astype(np.float32))
-        
-        # Sum of differences (more difference = more of subject preserved)
-        total_diff = np.sum(diff) / (255.0 * 3 * composite_frame.shape[0] * composite_frame.shape[1])
-        
-        # If difference is too small, too much was removed
-        if total_diff < 0.05:  # Less than 5% different from background
-            return 1.0  # Bad - subject was removed
-        elif total_diff > 0.3:  # More than 30% different
-            return 0.0  # Good - subject well preserved
-        else:
-            # Linear interpolation
-            return 1.0 - (total_diff - 0.05) / 0.25
-
-# ==============================================================================
-# CHAPTER 12: AUTO CHROMA KEY THRESHOLD DETECTION
-# ==============================================================================
-
-    def _auto_detect_chroma_threshold(self, green_screen_path: str) -> float:
-        """
-        Auto-detect initial chroma key threshold by analyzing green screen video.
-        
-        This method:
-        1. Samples frames from the green screen video
-        2. Identifies green background pixels vs person pixels
-        3. Calculates color distance between greenest background and person
-        4. Sets threshold as percentage of that distance for initial guess
-        """
-        try:
-            logger.info("Analyzing green screen video for initial threshold detection...")
-            
-            # Open green screen video
-            cap = cv2.VideoCapture(green_screen_path)
-            if not cap.isOpened():
-                logger.warning("Cannot open green screen video for analysis")
-                return self.config.AUTO_DETECTION_FALLBACK
-            
-            # Get video properties
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            
-            # Sample frames evenly across the video
-            frame_indices = np.linspace(0, total_frames - 1, 
-                                      min(self.config.AUTO_DETECTION_FRAMES, total_frames), 
-                                      dtype=int)
-            
-            green_pixels = []
-            person_pixels = []
-            
-            for frame_idx in frame_indices:
-                # Seek to specific frame
-                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
-                ret, frame = cap.read()
-                
-                if not ret:
-                    continue
-                
-                # Convert BGR to RGB for analysis
-                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                
-                # Analyze this frame
-                green_px, person_px = self._analyze_frame_colors(frame_rgb)
-                green_pixels.extend(green_px)
-                person_pixels.extend(person_px)
-            
-            cap.release()
-            
-            if len(green_pixels) == 0 or len(person_pixels) == 0:
-                logger.warning("Insufficient color data for auto-detection")
-                return self.config.AUTO_DETECTION_FALLBACK
-            
-            # Convert to numpy arrays
-            green_pixels = np.array(green_pixels)
-            person_pixels = np.array(person_pixels)
-            
-            logger.info(f"Analyzed {len(green_pixels)} green pixels and {len(person_pixels)} person pixels")
-            
-            # Calculate initial threshold
-            threshold = self._calculate_initial_threshold(green_pixels, person_pixels)
-            
-            # Clamp to safe range
-            threshold = np.clip(threshold, self.config.MIN_THRESHOLD, self.config.MAX_THRESHOLD)
-            
-            logger.info(f"Initial threshold calculated: {threshold:.4f}")
-            return threshold
-            
-        except Exception as e:
-            logger.warning(f"Auto-detection failed: {e}, using fallback")
-            return self.config.AUTO_DETECTION_FALLBACK
-    
-    def _analyze_frame_colors(self, frame_rgb: np.ndarray) -> Tuple[list, list]:
-        """
-        Analyze a single frame to identify green pixels vs person pixels.
-        
-        Returns:
-            Tuple[list, list]: (green_pixels, person_pixels) as lists of RGB values
-        """
-        try:
-            # Convert to normalized float
-            frame_norm = frame_rgb.astype(np.float32) / 255.0
-            
-            # Identify likely green pixels (high green, low red/blue)
-            green_mask = (
-                (frame_norm[:, :, 1] > 0.7) &  # High green
-                (frame_norm[:, :, 0] < 0.3) &  # Low red
-                (frame_norm[:, :, 2] < 0.3)    # Low blue
-            )
-            
-            # Identify likely person pixels (balanced colors, not green-dominant)
-            person_mask = (
-                (frame_norm[:, :, 1] < 0.6) |  # Not too green
-                ((frame_norm[:, :, 0] > 0.2) & (frame_norm[:, :, 2] > 0.2))  # Some red and blue
-            )
-            
-            # Sample pixels (subsample for performance)
-            # Sample green pixels
-            green_coords = np.where(green_mask)
-            if len(green_coords[0]) > 1000:
-                indices = np.random.choice(len(green_coords[0]), 1000, replace=False)
-                green_coords = (green_coords[0][indices], green_coords[1][indices])
-            
-            green_pixels = frame_norm[green_coords].tolist()
-            
-            # Sample person pixels
-            person_coords = np.where(person_mask)
-            if len(person_coords[0]) > 1000:
-                indices = np.random.choice(len(person_coords[0]), 1000, replace=False)
-                person_coords = (person_coords[0][indices], person_coords[1][indices])
-            
-            person_pixels = frame_norm[person_coords].tolist()
-            
-            return green_pixels, person_pixels
-            
-        except Exception as e:
-            logger.warning(f"Frame color analysis failed: {e}")
-            return [], []
-    
-    def _calculate_initial_threshold(self, green_pixels: np.ndarray, person_pixels: np.ndarray) -> float:
-        """
-        Calculate initial threshold based on color analysis.
-        
-        Strategy:
-        1. Find the "least green" green pixels (edge of green screen)
-        2. Find the "most green" person pixels (skin tones, clothing with green)
-        3. Calculate color distance between these clusters
-        4. Set threshold as percentage of that distance
-        """
-        try:
-            if SKLEARN_AVAILABLE and len(green_pixels) > 50 and len(person_pixels) > 50:
-                # Convert to LAB color space for better perceptual distance
-                green_lab = self._rgb_to_lab_batch(green_pixels)
-                person_lab = self._rgb_to_lab_batch(person_pixels)
-                
-                # Use clustering to find representative colors
-                kmeans_green = KMeans(n_clusters=min(5, len(green_lab)//10), random_state=42, n_init=10)
-                green_clusters = kmeans_green.fit_predict(green_lab)
-                green_centers = kmeans_green.cluster_centers_
-                
-                # Find cluster closest to the target green
-                target_green_lab = self._rgb_to_lab(np.array([[[0, 1, 0]]]))[0][0]
-                distances_to_target = np.linalg.norm(green_centers - target_green_lab, axis=1)
-                main_green_cluster = green_centers[np.argmin(distances_to_target)]
-                
-                # Find the most green of the person pixels
-                kmeans_person = KMeans(n_clusters=min(5, len(person_lab)//10), random_state=42, n_init=10)
-                person_clusters = kmeans_person.fit_predict(person_lab)
-                person_centers = kmeans_person.cluster_centers_
-                
-                # Find person cluster closest to green
-                distances_to_green = np.linalg.norm(person_centers - main_green_cluster, axis=1)
-                closest_person_cluster = person_centers[np.argmin(distances_to_green)]
-                
-                # Calculate color distance
-                color_distance = np.linalg.norm(main_green_cluster - closest_person_cluster)
-                
-                # Convert LAB distance to threshold
-                # Start conservative - use 40% of distance for initial guess
-                threshold = (color_distance / 100.0) * 0.4
-                
-                logger.info(f"Color distance analysis: LAB distance={color_distance:.2f}, initial threshold={threshold:.3f}")
-                
-                return threshold
-            else:
-                # Fallback: analyze in RGB space
-                return self._simple_rgb_threshold(green_pixels, person_pixels)
-                
-        except Exception as e:
-            logger.warning(f"Threshold calculation failed: {e}")
-            return self._simple_rgb_threshold(green_pixels, person_pixels)
-    
-    def _simple_rgb_threshold(self, green_pixels: np.ndarray, person_pixels: np.ndarray) -> float:
-        """Fallback RGB-based threshold calculation."""
-        try:
-            # Find average green pixel
-            avg_green = np.mean(green_pixels, axis=0)
-            
-            # Find person pixel closest to green
-            green_distances = np.linalg.norm(person_pixels - avg_green, axis=1)
-            min_distance = np.min(green_distances)
-            
-            # Use 50% of minimum distance as initial threshold
-            threshold = min_distance * 0.5
-            
-            logger.info(f"RGB fallback: min_distance={min_distance:.3f}, threshold={threshold:.3f}")
-            return threshold
-            
-        except Exception as e:
-            logger.warning(f"RGB fallback failed: {e}")
-            return self.config.AUTO_DETECTION_FALLBACK
-    
-    def _rgb_to_lab_batch(self, rgb_batch: np.ndarray) -> np.ndarray:
-        """Convert batch of RGB values to LAB color space."""
-        try:
-            # Reshape for OpenCV
-            rgb_reshaped = rgb_batch.reshape(-1, 1, 3).astype(np.float32)
-            
-            # Convert to LAB
-            lab = cv2.cvtColor(rgb_reshaped, cv2.COLOR_RGB2LAB)
-            
-            # Reshape back
-            return lab.reshape(-1, 3)
-            
-        except Exception as e:
-            logger.warning(f"LAB conversion failed: {e}")
-            return rgb_batch  # Return RGB as fallback
-    
-    def _rgb_to_lab(self, rgb: np.ndarray) -> np.ndarray:
-        """Convert single RGB image to LAB."""
-        try:
-            return cv2.cvtColor(rgb.astype(np.float32), cv2.COLOR_RGB2LAB)
-        except Exception as e:
-            logger.warning(f"Single LAB conversion failed: {e}")
-            return rgb
 
 # ==============================================================================
-# CHAPTER 13: DEBUG AND UTILITY FUNCTIONS
+# CHAPTER 10: DEBUG AND UTILITY FUNCTIONS
 # ==============================================================================
 
     def _debug_video_info(self, video_path: str, label: str = "Video"):
@@ -1622,7 +1031,7 @@ def get_processing_stats(self) -> Dict[str, Any]:
         return stats
 
 # ==============================================================================
-# CHAPTER 14: EXPORT INTERFACE AND COMPATIBILITY
+# CHAPTER 11: EXPORT INTERFACE AND COMPATIBILITY
 # ==============================================================================
 
 def create_two_stage_processor(sam2_handler, matanyone_handler, **kwargs):
@@ -1636,14 +1045,13 @@ def create_two_stage_processor(sam2_handler, matanyone_handler, **kwargs):
 # Main execution example
 if __name__ == "__main__":
     # Example usage - replace with your actual handlers
-    logger.info("TwoStageProcessor module loaded successfully")
+    logger.info("TwoStageProcessor (Alpha Channel Version) loaded successfully")
     logger.info("Use create_two_stage_processor(sam2_handler, matanyone_handler) to initialize")
     
     # Print configuration
     config = ProcessingConfig()
-    logger.info(f"Default config: {config.REFERENCE_FRAMES} reference frames, green={config.GREEN_COLOR}")
-    logger.info(f"Auto-detection: {config.AUTO_DETECTION_FRAMES} analysis frames, fallback={config.AUTO_DETECTION_FALLBACK}")
-    logger.info(f"Adaptive optimization: {config.ADAPTIVE_MAX_ITERATIONS} max iterations")
+    logger.info(f"Pipeline: SAM2 → MatAnyone → Direct Alpha Compositing")
+    logger.info(f"No green screen or chroma key needed!")
+    logger.info(f"Default config: {config.REFERENCE_FRAMES} reference frames")
     logger.info(f"Chunked processing: {config.MAX_CHUNK_DURATION}s chunks with {config.CHUNK_OVERLAP_FRAMES} frame overlap")
-    logger.info(f"Memory management: Cache clearing={'ON' if config.CLEAR_CACHE_AFTER_STAGE else 'OFF'}")
-    logger.info(f"Memory testing: {'DISABLED' if not config.ENABLE_MEMORY_TESTING else 'ENABLED'}")
+    logger.info(f"Memory management: Cache clearing={'ON' if config.CLEAR_CACHE_AFTER_STAGE else 'OFF'}")