Update app.py

app.py

@@ -1,416 +1,816 @@
 #!/usr/bin/env python3
 """
-SAM2 (Segment Anything Model 2) for Video
-Correct implementation with dynamic model loading
-Optimized for video processing
+BackgroundFX - Professional Video Background Replacement
+Priority: MatAnyone > SAM2 > Rembg > OpenCV
+Optimized for HuggingFace Spaces L4 GPU
 """
 
+import streamlit as st
+import cv2
+import numpy as np
+import tempfile
 import os
+from PIL import Image
+import requests
+from io import BytesIO
+import logging
+import gc
 import torch
-import numpy as np
-import streamlit as st
+import time
 from pathlib import Path
-import logging
-import requests
 from tqdm import tqdm
-import cv2
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # ============================================
-# SAM2 DYNAMIC LOADER FOR VIDEO
+# GPU SETUP AND INITIALIZATION
 # ============================================
 
-@st.cache_resource(show_spinner=False)
-def load_sam2_model_dynamic():
-    """
-    Download and load SAM2 model dynamically
-    SAM2 is specifically designed for video segmentation
-    """
+def setup_gpu_environment():
+    """Setup GPU environment with optimal settings for L4"""
+    os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+    os.environ['TORCH_CUDA_ARCH_LIST'] = '8.9'  # L4 architecture
+    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:512'
+    
     try:
-        # Import SAM2 (not SAM1!)
-        from sam2.build_sam import build_sam2
-        from sam2.sam2_image_predictor import SAM2ImagePredictor
-        from sam2.automatic_mask_generator import SAM2AutomaticMaskGenerator
-        
-        # SAM2 Model URLs (these are the NEW video-optimized models)
-        MODEL_URLS = {
-            'sam2_hiera_large': {
-                'config': 'sam2_hiera_l.yaml',
-                'checkpoint': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt',
-                'size': '897MB',
-                'quality': 'Best for video'
-            },
-            'sam2_hiera_base_plus': {
-                'config': 'sam2_hiera_b+.yaml', 
-                'checkpoint': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_base_plus.pt',
-                'size': '323MB',
-                'quality': 'Balanced'
-            },
-            'sam2_hiera_small': {
-                'config': 'sam2_hiera_s.yaml',
-                'checkpoint': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt',
-                'size': '155MB',
-                'quality': 'Fast'
-            },
-            'sam2_hiera_tiny': {
-                'config': 'sam2_hiera_t.yaml',
-                'checkpoint': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt',
-                'size': '77MB',
-                'quality': 'Fastest'
-            }
-        }
-        
-        # Choose model based on GPU
         if torch.cuda.is_available():
+            gpu_name = torch.cuda.get_device_name(0)
             gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
-            if gpu_memory > 20:  # L4 has 24GB
-                model_name = 'sam2_hiera_large'
-            elif gpu_memory > 10:
-                model_name = 'sam2_hiera_base_plus'
-            elif gpu_memory > 6:
-                model_name = 'sam2_hiera_small'
-            else:
-                model_name = 'sam2_hiera_tiny'
+            
+            logger.info(f"🚀 GPU Detected: {gpu_name} ({gpu_memory:.1f}GB)")
+            
+            # Initialize CUDA
+            torch.cuda.init()
+            torch.cuda.set_device(0)
+            
+            # Enable TF32 for L4
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+            torch.backends.cudnn.benchmark = True
+            
+            # Warm up
+            dummy = torch.randn(512, 512, device='cuda')
+            del dummy
+            torch.cuda.empty_cache()
+            
+            return True, gpu_name, gpu_memory
         else:
-            model_name = 'sam2_hiera_tiny'  # CPU = smallest
-        
-        logger.info(f"Selected SAM2 model: {model_name} ({MODEL_URLS[model_name]['quality']})")
+            logger.warning("⚠️ CUDA not available - running in CPU mode")
+            return False, None, 0
+    except Exception as e:
+        logger.error(f"GPU setup failed: {e}")
+        return False, None, 0
+
+# Initialize GPU
+CUDA_AVAILABLE, GPU_NAME, GPU_MEMORY = setup_gpu_environment()
+DEVICE = 'cuda' if CUDA_AVAILABLE else 'cpu'
+
+# ============================================
+# MATANYONE - PRIMARY METHOD (BEST QUALITY)
+# ============================================
+
+class MatAnyoneProcessor:
+    """MatAnyone for superior video matting with temporal consistency"""
+    
+    def __init__(self):
+        self.model = None
+        self.predictor = None
+        self.loaded = False
+        self.previous_alpha = None
+        self.previous_trimap = None
+        self.frame_count = 0
         
-        # Setup cache directory
-        cache_dir = Path("/tmp/sam2_models")
+    @st.cache_resource
+    def load_model(_self):
+        """Load MatAnyone model with caching"""
+        try:
+            # Try to import MatAnyone
+            from matanyone import MatAnyoneModel, MatAnyonePredictor
+            
+            # Download model if needed
+            model_path = _self._download_model_if_needed()
+            
+            # Load model
+            model = MatAnyoneModel.from_pretrained(
+                model_path,
+                device=DEVICE,
+                fp16=(DEVICE == 'cuda')
+            )
+            
+            # Create predictor
+            predictor = MatAnyonePredictor(
+                model,
+                enable_temporal=True,
+                enable_refinement=True,
+                alpha_quality='high'
+            )
+            
+            logger.info("✅ MatAnyone loaded successfully")
+            return model, predictor, True
+            
+        except ImportError:
+            logger.warning("⚠️ MatAnyone not installed, falling back to other methods")
+            return None, None, False
+        except Exception as e:
+            logger.error(f"❌ MatAnyone loading failed: {e}")
+            return None, None, False
+    
+    def _download_model_if_needed(self):
+        """Download MatAnyone model dynamically"""
+        cache_dir = Path("/tmp/matanyone_models")
         cache_dir.mkdir(exist_ok=True)
         
-        model_path = cache_dir / f"{model_name}.pt"
-        config_name = MODEL_URLS[model_name]['config']
+        model_path = cache_dir / "matanyone_video.pth"
         
-        # Download if not cached
         if not model_path.exists():
-            logger.info(f"Downloading SAM2 {model_name} ({MODEL_URLS[model_name]['size']})...")
-            
-            # Show progress in Streamlit
-            progress_text = st.empty()
-            progress_bar = st.progress(0)
-            
-            # Download with progress
-            response = requests.get(MODEL_URLS[model_name]['checkpoint'], stream=True)
-            total_size = int(response.headers.get('content-length', 0))
-            
-            with open(model_path, 'wb') as f:
-                downloaded = 0
-                for chunk in response.iter_content(chunk_size=8192):
-                    f.write(chunk)
-                    downloaded += len(chunk)
-                    
-                    if total_size > 0:
-                        progress = downloaded / total_size
-                        progress_bar.progress(progress)
-                        progress_text.text(f"Downloading SAM2: {downloaded/(1024**2):.1f}MB / {total_size/(1024**2):.1f}MB")
-            
-            progress_text.empty()
-            progress_bar.empty()
-            
-            logger.info(f"✅ SAM2 model downloaded to {model_path}")
-        else:
-            logger.info(f"✅ Using cached SAM2 model from {model_path}")
+            # MatAnyone model URL
+            model_url = "https://huggingface.co/matanyone/matanyone-video/resolve/main/model.pth"
+            
+            with st.spinner("Downloading MatAnyone model (first time only)..."):
+                response = requests.get(model_url, stream=True)
+                total_size = int(response.headers.get('content-length', 0))
+                
+                progress_bar = st.progress(0)
+                with open(model_path, 'wb') as f:
+                    downloaded = 0
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                        downloaded += len(chunk)
+                        if total_size > 0:
+                            progress_bar.progress(downloaded / total_size)
+                
+                progress_bar.empty()
+        
+        return str(model_path)
+    
+    def process_frame(self, frame, use_temporal=True):
+        """Process frame with MatAnyone"""
+        if not self.loaded:
+            self.model, self.predictor, self.loaded = self.load_model()
+            
+        if not self.loaded or self.predictor is None:
+            return None
+            
+        try:
+            # Generate or update trimap
+            if use_temporal and self.previous_trimap is not None:
+                trimap = self._update_trimap(self.previous_trimap, frame)
+            else:
+                trimap = self._generate_trimap(frame)
+            
+            # Process with temporal consistency
+            if use_temporal and self.previous_alpha is not None:
+                alpha = self.predictor.predict(
+                    image=frame,
+                    trimap=trimap,
+                    previous_alpha=self.previous_alpha,
+                    temporal_weight=0.3
+                )
+            else:
+                alpha = self.predictor.predict(image=frame, trimap=trimap)
+            
+            # Refine alpha
+            alpha = self._refine_alpha(alpha, frame)
+            
+            # Store for next frame
+            self.previous_alpha = alpha.copy()
+            self.previous_trimap = trimap.copy()
+            self.frame_count += 1
+            
+            return alpha
+            
+        except Exception as e:
+            logger.error(f"MatAnyone processing failed: {e}")
+            return None
+    
+    def _generate_trimap(self, frame):
+        """Generate initial trimap"""
+        h, w = frame.shape[:2]
+        trimap = np.zeros((h, w), dtype=np.uint8)
         
-        # Build SAM2 model
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+        # Create center region as unknown
+        center_x, center_y = w // 2, h // 2
+        radius_x, radius_y = w // 3, h // 2
         
-        sam2_model = build_sam2(
-            config_file=config_name,
-            ckpt_path=str(model_path),
-            device=device,
-            apply_postprocessing=True
-        )
+        y, x = np.ogrid[:h, :w]
+        mask = ((x - center_x)**2 / radius_x**2 + (y - center_y)**2 / radius_y**2) <= 1
+        trimap[mask] = 128  # Unknown
         
-        # Create predictor for frame-by-frame processing
-        predictor = SAM2ImagePredictor(sam2_model)
+        inner_mask = ((x - center_x)**2 / (radius_x*0.5)**2 + (y - center_y)**2 / (radius_y*0.5)**2) <= 1
+        trimap[inner_mask] = 255  # Foreground
         
-        logger.info(f"✅ SAM2 loaded successfully on {device}")
-        return predictor, model_name
+        return trimap
+    
+    def _update_trimap(self, prev_trimap, frame):
+        """Update trimap with motion compensation"""
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+        unknown = (prev_trimap == 128).astype(np.uint8)
+        unknown = cv2.dilate(unknown, kernel, iterations=1)
         
-    except ImportError as e:
-        logger.error(f"SAM2 not installed. Install with: pip install sam-2")
-        return None, None
-    except Exception as e:
-        logger.error(f"Failed to load SAM2 model: {e}")
-        return None, None
+        trimap = prev_trimap.copy()
+        trimap[unknown == 1] = 128
+        
+        return trimap
+    
+    def _refine_alpha(self, alpha, frame):
+        """Refine alpha matte"""
+        # Guided filter if available
+        try:
+            alpha = cv2.ximgproc.guidedFilter(frame, alpha, 5, 1e-4)
+        except:
+            # Fallback to Gaussian blur
+            alpha = cv2.GaussianBlur(alpha, (5, 5), 0)
+        
+        return np.clip(alpha, 0, 1)
+    
+    def reset(self):
+        """Reset for new video"""
+        self.previous_alpha = None
+        self.previous_trimap = None
+        self.frame_count = 0
 
 # ============================================
-# SAM2 VIDEO PROCESSOR
+# SAM2 - SECONDARY METHOD (VIDEO OPTIMIZED)
 # ============================================
 
-class SAM2VideoProcessor:
-    """
-    SAM2 optimized for video processing
-    Handles temporal consistency across frames
-    """
+class SAM2Processor:
+    """SAM2 for video segmentation"""
     
     def __init__(self):
         self.predictor = None
-        self.model_name = None
         self.loaded = False
         self.previous_mask = None
-        self.frame_count = 0
         
-    def load_model(self):
-        """Load SAM2 model if not already loaded"""
-        if not self.loaded:
-            with st.spinner("🎬 Loading SAM2 Video Model..."):
-                self.predictor, self.model_name = load_sam2_model_dynamic()
-                self.loaded = True
-                if self.predictor:
-                    logger.info(f"SAM2 Video Processor ready with {self.model_name}")
-        return self.predictor is not None
+    @st.cache_resource
+    def load_model(_self):
+        """Load SAM2 model dynamically"""
+        try:
+            from sam2.build_sam import build_sam2
+            from sam2.sam2_image_predictor import SAM2ImagePredictor
+            
+            # Model configurations
+            models = {
+                'large': ('sam2_hiera_l.yaml', 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt', 897),
+                'base': ('sam2_hiera_b+.yaml', 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_base_plus.pt', 323),
+                'small': ('sam2_hiera_s.yaml', 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt', 155),
+                'tiny': ('sam2_hiera_t.yaml', 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt', 77)
+            }
+            
+            # Select model based on GPU
+            if CUDA_AVAILABLE and GPU_MEMORY > 20:
+                model_key = 'large'
+            elif CUDA_AVAILABLE and GPU_MEMORY > 10:
+                model_key = 'base'
+            else:
+                model_key = 'tiny'
+            
+            config, url, size = models[model_key]
+            
+            # Download model
+            cache_dir = Path("/tmp/sam2_models")
+            cache_dir.mkdir(exist_ok=True)
+            model_path = cache_dir / f"sam2_{model_key}.pt"
+            
+            if not model_path.exists():
+                with st.spinner(f"Downloading SAM2 {model_key} model ({size}MB)..."):
+                    response = requests.get(url, stream=True)
+                    with open(model_path, 'wb') as f:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            f.write(chunk)
+            
+            # Build model
+            sam2_model = build_sam2(config, str(model_path), device=DEVICE)
+            predictor = SAM2ImagePredictor(sam2_model)
+            
+            logger.info(f"✅ SAM2 {model_key} loaded successfully")
+            return predictor, True
+            
+        except ImportError:
+            logger.warning("⚠️ SAM2 not installed")
+            return None, False
+        except Exception as e:
+            logger.error(f"❌ SAM2 loading failed: {e}")
+            return None, False
     
-    def segment_frame(self, frame, use_previous=True):
-        """
-        Segment a single frame with temporal consistency
-        
-        Args:
-            frame: Input frame (H, W, 3) numpy array
-            use_previous: Use previous frame's mask for consistency
-        
-        Returns:
-            mask: Segmentation mask (H, W) float32
-        """
-        if not self.load_model():
+    def process_frame(self, frame, use_temporal=True):
+        """Process frame with SAM2"""
+        if not self.loaded:
+            self.predictor, self.loaded = self.load_model()
+            
+        if not self.loaded or self.predictor is None:
             return None
-        
+            
         try:
-            # Set the image
             self.predictor.set_image(frame)
             
             h, w = frame.shape[:2]
             
-            # Generate point prompts
-            if use_previous and self.previous_mask is not None:
-                # Use previous mask to guide current segmentation
-                # Find center of mass of previous mask
+            # Generate prompts
+            if use_temporal and self.previous_mask is not None:
                 y_coords, x_coords = np.where(self.previous_mask > 0.5)
                 if len(y_coords) > 0:
                     center_y = int(np.mean(y_coords))
                     center_x = int(np.mean(x_coords))
-                    
-                    # Add points around previous center
-                    point_coords = np.array([
-                        [center_x, center_y],
-                        [center_x, center_y - h//8],  # Above
-                        [center_x, center_y + h//8],  # Below
-                    ])
+                    point_coords = np.array([[center_x, center_y]])
                 else:
-                    # Fallback to center points
-                    point_coords = np.array([
-                        [w//2, h//2],
-                        [w//2, h//3],
-                        [w//2, 2*h//3]
-                    ])
+                    point_coords = np.array([[w//2, h//2]])
             else:
-                # Initial frame - use center points
-                point_coords = np.array([
-                    [w//2, h//2],      # Center
-                    [w//2, h//3],      # Upper (head)
-                    [w//2, 2*h//3],    # Lower (body)
-                    [w//3, h//2],      # Left
-                    [2*w//3, h//2],    # Right
-                ])
-            
-            point_labels = np.ones(len(point_coords))  # All foreground
-            
-            # Generate masks with SAM2
-            masks, scores, logits = self.predictor.predict(
+                point_coords = np.array([[w//2, h//2], [w//2, h//3], [w//2, 2*h//3]])
+            
+            point_labels = np.ones(len(point_coords))
+            
+            # Predict
+            masks, scores, _ = self.predictor.predict(
                 point_coords=point_coords,
                 point_labels=point_labels,
-                multimask_output=True,
-                return_logits=True
+                multimask_output=True
             )
             
-            # Select best mask
-            best_idx = np.argmax(scores)
-            mask = masks[best_idx].astype(np.float32)
+            mask = masks[np.argmax(scores)].astype(np.float32)
             
-            # Apply temporal smoothing if we have previous mask
-            if use_previous and self.previous_mask is not None:
-                # Blend with previous mask for temporal consistency
-                alpha = 0.3  # Smoothing factor
-                mask = (1 - alpha) * mask + alpha * self.previous_mask
-                mask = np.clip(mask, 0, 1)
+            # Temporal smoothing
+            if use_temporal and self.previous_mask is not None:
+                mask = 0.7 * mask + 0.3 * self.previous_mask
             
-            # Post-processing for better quality
-            # Morphological operations
+            # Refine
             kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
             mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-            mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
-            
-            # Gaussian blur for smooth edges
-            mask = cv2.GaussianBlur(mask, (7, 7), 0)
-            
-            # Store for next frame
-            self.previous_mask = mask.copy()
-            self.frame_count += 1
+            mask = cv2.GaussianBlur(mask, (5, 5), 0)
             
+            self.previous_mask = mask
             return mask
             
         except Exception as e:
-            logger.error(f"SAM2 segmentation failed: {e}")
+            logger.error(f"SAM2 processing failed: {e}")
             return None
     
     def reset(self):
-        """Reset temporal state for new video"""
         self.previous_mask = None
-        self.frame_count = 0
-        logger.info("SAM2 Video Processor reset for new video")
 
 # ============================================
-# LAZY LOADER FOR SAM2
+# REMBG - TERTIARY METHOD (FAST)
 # ============================================
 
-class SAM2LazyLoader:
-    """
-    Lazy loading for SAM2 - only loads when needed
-    """
-    def __init__(self):
-        self.processor = SAM2VideoProcessor()
+REMBG_AVAILABLE = False
+rembg_session = None
+
+try:
+    from rembg import remove, new_session
     
-    def segment_frame(self, frame, use_temporal=True):
-        """
-        Segment frame with lazy loading
-        Model loads on first call
-        """
-        return self.processor.segment_frame(frame, use_previous=use_temporal)
+    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if CUDA_AVAILABLE else ['CPUExecutionProvider']
+    rembg_session = new_session('u2net_human_seg', providers=providers)
     
-    def reset(self):
-        """Reset for new video"""
-        self.processor.reset()
+    # Warm up
+    dummy_img = Image.new('RGB', (256, 256), color='white')
+    _ = remove(dummy_img, session=rembg_session)
     
-    @property
-    def is_available(self):
-        """Check if SAM2 can be loaded"""
-        try:
-            import sam2
-            return True
-        except ImportError:
-            return False
+    REMBG_AVAILABLE = True
+    logger.info(f"✅ Rembg initialized with providers: {providers}")
     
-    @property
-    def is_loaded(self):
-        """Check if model is already loaded"""
-        return self.processor.loaded
+except Exception as e:
+    logger.warning(f"⚠️ Rembg not available: {e}")
+
+def segment_with_rembg(frame):
+    """Segment using Rembg"""
+    if not REMBG_AVAILABLE:
+        return None
+        
+    try:
+        pil_image = Image.fromarray(frame)
+        output = remove(
+            pil_image,
+            session=rembg_session,
+            alpha_matting=True,
+            alpha_matting_foreground_threshold=240,
+            alpha_matting_background_threshold=10
+        )
+        
+        output_array = np.array(output)
+        if output_array.shape[2] == 4:
+            mask = output_array[:, :, 3].astype(np.float32) / 255.0
+        else:
+            mask = np.ones((frame.shape[0], frame.shape[1]), dtype=np.float32)
+        
+        return mask
+    except Exception as e:
+        logger.error(f"Rembg segmentation failed: {e}")
+        return None
+
+# ============================================
+# OPENCV - FALLBACK METHOD (ALWAYS WORKS)
+# ============================================
+
+def segment_with_opencv(frame):
+    """Basic OpenCV segmentation"""
+    try:
+        hsv = cv2.cvtColor(frame, cv2.COLOR_RGB2HSV)
+        
+        lower_skin = np.array([0, 20, 70], dtype=np.uint8)
+        upper_skin = np.array([20, 255, 255], dtype=np.uint8)
+        
+        mask = cv2.inRange(hsv, lower_skin, upper_skin)
+        
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel, iterations=2)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=1)
+        
+        mask = mask.astype(np.float32) / 255.0
+        mask = cv2.GaussianBlur(mask, (5, 5), 0)
+        
+        return mask
+        
+    except Exception as e:
+        logger.error(f"OpenCV segmentation failed: {e}")
+        return None
 
 # ============================================
-# INTEGRATION WITH VIDEO PROCESSING
+# BACKGROUND UTILITIES
 # ============================================
 
-# Global SAM2 instance
-SAM2_VIDEO = SAM2LazyLoader()
+def load_background_image(background_url):
+    """Load background image from URL"""
+    try:
+        response = requests.get(background_url, timeout=10)
+        response.raise_for_status()
+        image = Image.open(BytesIO(response.content))
+        return np.array(image.convert('RGB'))
+    except Exception as e:
+        logger.error(f"Failed to load background: {e}")
+        return create_default_background()
+
+def create_default_background():
+    """Create gradient background"""
+    background = np.zeros((720, 1280, 3), dtype=np.uint8)
+    for y in range(720):
+        color_value = int(255 * (1 - y / 720))
+        background[y, :] = [color_value, int(color_value * 0.7), int(color_value * 0.9)]
+    return background
 
-def process_video_with_sam2(video_path, background_image, progress_callback=None):
-    """
-    Process video using SAM2 with temporal consistency
-    """
+def get_professional_backgrounds():
+    """Professional background collection"""
+    return {
+        "🏢 Modern Office": "https://images.unsplash.com/photo-1497366216548-37526070297c?w=1920&h=1080&fit=crop",
+        "🌆 City Skyline": "https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=1920&h=1080&fit=crop",
+        "🏖️ Tropical Beach": "https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=1920&h=1080&fit=crop",
+        "🌲 Forest Path": "https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=1920&h=1080&fit=crop",
+        "🎨 Abstract Gradient": "https://images.unsplash.com/photo-1557683316-973673baf926?w=1920&h=1080&fit=crop",
+        "🏔️ Mountain Vista": "https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=1920&h=1080&fit=crop",
+        "🌅 Sunset Sky": "https://images.unsplash.com/photo-1495616811223-4d98c6e9c869?w=1920&h=1080&fit=crop",
+        "💼 Conference Room": "https://images.unsplash.com/photo-1497366811353-6870744d04b2?w=1920&h=1080&fit=crop",
+        "🎬 Studio Setup": "https://images.unsplash.com/photo-1565438222132-3654b8b88d4a?w=1920&h=1080&fit=crop",
+        "🌃 Night City": "https://images.unsplash.com/photo-1519501025264-65ba15a82390?w=1920&h=1080&fit=crop"
+    }
+
+# ============================================
+# VIDEO PROCESSING PIPELINE
+# ============================================
+
+# Initialize processors
+matanyone_processor = MatAnyoneProcessor()
+sam2_processor = SAM2Processor()
+
+def process_video(video_path, background_url, method='auto', progress_callback=None):
+    """Process video with selected method"""
     try:
+        # Load background
+        background_image = load_background_image(background_url)
+        
         # Open video
         cap = cv2.VideoCapture(video_path)
-        
-        # Get video properties
         fps = int(cap.get(cv2.CAP_PROP_FPS))
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
         total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         
-        # Create output writer
-        output_path = '/tmp/output_sam2.mp4'
+        logger.info(f"Processing video: {width}x{height}, {total_frames} frames, {fps} FPS")
+        
+        # Create output
+        output_path = tempfile.mktemp(suffix='.mp4')
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
         
         # Resize background
         background_resized = cv2.resize(background_image, (width, height))
         
-        # Reset SAM2 for new video
-        SAM2_VIDEO.reset()
+        # Reset processors
+        matanyone_processor.reset()
+        sam2_processor.reset()
         
         frame_count = 0
+        processing_times = []
         
         while True:
             ret, frame = cap.read()
             if not ret:
                 break
             
+            start_time = time.time()
+            
             # Convert BGR to RGB
             frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
             
-            # Segment with SAM2 (with temporal consistency)
-            mask = SAM2_VIDEO.segment_frame(frame_rgb, use_temporal=(frame_count > 0))
+            # Select method and process
+            mask = None
+            method_used = "None"
             
+            if method == 'auto' or method == 'matanyone':
+                # Try MatAnyone first (BEST)
+                mask = matanyone_processor.process_frame(frame_rgb, use_temporal=(frame_count > 0))
+                if mask is not None:
+                    method_used = "MatAnyone"
+            
+            if mask is None and (method == 'auto' or method == 'sam2'):
+                # Try SAM2 (GOOD)
+                mask = sam2_processor.process_frame(frame_rgb, use_temporal=(frame_count > 0))
+                if mask is not None:
+                    method_used = "SAM2"
+            
+            if mask is None and (method == 'auto' or method == 'rembg'):
+                # Try Rembg (FAST)
+                mask = segment_with_rembg(frame_rgb)
+                if mask is not None:
+                    method_used = "Rembg"
+            
+            if mask is None:
+                # Fallback to OpenCV
+                mask = segment_with_opencv(frame_rgb)
+                method_used = "OpenCV"
+            
+            # Apply mask and composite
             if mask is not None:
-                # Apply mask
                 if mask.ndim == 2:
                     mask = np.expand_dims(mask, axis=2)
                 
-                # Composite
-                composite = frame_rgb * mask + background_resized * (1 - mask)
-                composite = composite.astype(np.uint8)
+                # High-quality compositing
+                foreground = frame_rgb.astype(np.float32)
+                background = background_resized.astype(np.float32)
                 
-                # Convert back to BGR
-                composite_bgr = cv2.cvtColor(composite, cv2.COLOR_RGB2BGR)
+                composite = foreground * mask + background * (1 - mask)
+                composite = np.clip(composite, 0, 255).astype(np.uint8)
             else:
-                composite_bgr = frame
+                composite = frame_rgb
             
+            # Convert back to BGR
+            composite_bgr = cv2.cvtColor(composite, cv2.COLOR_RGB2BGR)
             out.write(composite_bgr)
+            
+            # Track time
+            processing_time = time.time() - start_time
+            processing_times.append(processing_time)
+            
             frame_count += 1
             
-            # Progress callback
+            # Progress update
             if progress_callback:
                 progress = frame_count / total_frames
-                progress_callback(progress, f"SAM2 Processing: {frame_count}/{total_frames}")
+                avg_time = np.mean(processing_times[-10:])
+                eta = avg_time * (total_frames - frame_count)
+                progress_callback(
+                    progress,
+                    f"{method_used}: Frame {frame_count}/{total_frames} | ETA: {eta:.1f}s"
+                )
             
-            # Memory cleanup every 50 frames
-            if frame_count % 50 == 0 and torch.cuda.is_available():
+            # Memory cleanup
+            if frame_count % 50 == 0 and CUDA_AVAILABLE:
                 torch.cuda.empty_cache()
         
+        # Release
         cap.release()
         out.release()
         
-        logger.info(f"✅ SAM2 video processing complete: {frame_count} frames")
+        if CUDA_AVAILABLE:
+            torch.cuda.empty_cache()
+        gc.collect()
+        
+        logger.info(f"✅ Video processing complete: {output_path}")
+        logger.info(f"Average time per frame: {np.mean(processing_times):.3f}s")
+        
         return output_path
         
     except Exception as e:
-        logger.error(f"SAM2 video processing failed: {e}")
+        logger.error(f"Video processing failed: {e}")
         return None
 
 # ============================================
-# EXAMPLE USAGE
+# STREAMLIT UI
 # ============================================
 
 def main():
-    st.title("🎬 Video Background Replacer with SAM2")
+    st.set_page_config(
+        page_title="BackgroundFX - Professional Video Processing",
+        page_icon="🎬",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
     
-    # Status display
-    col1, col2, col3 = st.columns(3)
+    # Header
+    st.title("🎬 BackgroundFX - Professional Video Background Replacement")
+    st.markdown("**Production-quality processing with MatAnyone, SAM2, and Rembg**")
+    
+    # System Status
+    col1, col2, col3, col4 = st.columns(4)
     
     with col1:
-        if SAM2_VIDEO.is_available:
-            if SAM2_VIDEO.is_loaded:
-                st.success("✅ SAM2 Loaded")
-            else:
-                st.info("🎯 SAM2 Ready (loads on demand)")
+        if CUDA_AVAILABLE:
+            st.success(f"🚀 GPU: {GPU_NAME}")
+            st.caption(f"VRAM: {GPU_MEMORY:.1f}GB")
         else:
-            st.error("❌ SAM2 not installed")
+            st.info("💻 CPU Mode")
     
-    # Process button
-    if st.button("Process with SAM2"):
+    with col2:
+        methods = []
+        if matanyone_processor.loaded:
+            methods.append("MatAnyone")
+        if sam2_processor.loaded:
+            methods.append("SAM2")
+        if REMBG_AVAILABLE:
+            methods.append("Rembg")
+        methods.append("OpenCV")
+        st.info(f"📦 Methods: {', '.join(methods)}")
+    
+    with col3:
+        if CUDA_AVAILABLE:
+            allocated = torch.cuda.memory_allocated() / 1024**3
+            st.metric("GPU Usage", f"{allocated:.1f}GB")
+        else:
+            st.metric("Mode", "CPU")
+    
+    with col4:
+        st.metric("Device", DEVICE.upper())
+    
+    # Sidebar
+    with st.sidebar:
+        st.markdown("### ⚙️ Processing Options")
+        
+        # Method selection with quality indicators
+        method_options = {
+            'auto': 'Auto (Best Available)',
+            'matanyone': 'MatAnyone (★★★★★ Production)',
+            'sam2': 'SAM2 (★★★★ Video-Optimized)',
+            'rembg': 'Rembg (★★★ Fast)',
+            'opencv': 'OpenCV (★ Fallback)'
+        }
+        
+        selected_method = st.selectbox(
+            "Segmentation Method",
+            options=list(method_options.keys()),
+            format_func=lambda x: method_options[x],
+            index=0
+        )
+        
+        # Method info
+        if selected_method == 'matanyone':
+            st.info("""
+            **MatAnyone Advantages:**
+            • Perfect hair/edge details
+            • Temporal consistency
+            • Alpha matting quality
+            • No flicker in video
+            """)
+        elif selected_method == 'sam2':
+            st.info("""
+            **SAM2 Advantages:**
+            • Designed for video
+            • Good temporal flow
+            • Automatic prompting
+            """)
+        elif selected_method == 'rembg':
+            st.info("""
+            **Rembg Advantages:**
+            • Fast processing
+            • Good for photos
+            • Easy to use
+            """)
+        
+        st.markdown("---")
+        
+        # System info
+        st.markdown("### 📊 System Information")
+        
+        if CUDA_AVAILABLE:
+            allocated = torch.cuda.memory_allocated() / 1024**3
+            reserved = torch.cuda.memory_reserved() / 1024**3
+            free = GPU_MEMORY - reserved if GPU_MEMORY else 0
+            
+            st.metric("GPU Memory", f"{allocated:.2f} / {GPU_MEMORY:.1f} GB")
+            
+            usage_percent = (allocated / GPU_MEMORY) * 100 if GPU_MEMORY else 0
+            st.progress(min(usage_percent / 100, 1.0))
+            
+            with st.expander("GPU Details"):
+                st.code(f"""
+Device: {GPU_NAME}
+VRAM: {GPU_MEMORY:.1f} GB
+Allocated: {allocated:.2f} GB
+Reserved: {reserved:.2f} GB
+Free: {free:.2f} GB
+PyTorch: {torch.__version__}
+CUDA: {torch.version.cuda if CUDA_AVAILABLE else 'N/A'}
+                """)
+        else:
+            st.info("Running in CPU mode")
+    
+    # Main content
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### 📹 Video Input")
+        
+        uploaded_video = st.file_uploader(
+            "Upload your video",
+            type=['mp4', 'avi', 'mov', 'mkv'],
+            help="Maximum recommended: 30 seconds for best performance"
+        )
+        
         if uploaded_video:
-            # This triggers model download on first use
-            result = process_video_with_sam2(
+            # Save video
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
+                tmp_file.write(uploaded_video.read())
+                video_path = tmp_file.name
+            
+            st.video(uploaded_video)
+            st.success(f"✅ Video ready: {uploaded_video.name}")
+        else:
+            video_path = None
+    
+    with col2:
+        st.markdown("### 🖼️ Background Selection")
+        
+        backgrounds = get_professional_backgrounds()
+        selected_bg_name = st.selectbox(
+            "Choose a background",
+            options=list(backgrounds.keys()),
+            index=0
+        )
+        
+        background_url = backgrounds[selected_bg_name]
+        
+        # Preview
+        try:
+            bg_image = load_background_image(background_url)
+            st.image(bg_image, caption=selected_bg_name, use_container_width=True)
+        except:
+            st.error("Failed to load background preview")
+    
+    # Process button
+    if video_path and st.button("🚀 Process Video", type="primary", use_container_width=True):
+        
+        # Progress tracking
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        def update_progress(progress, message):
+            progress_bar.progress(progress)
+            status_text.text(message)
+        
+        # Process video
+        with st.spinner("Processing video..."):
+            start_time = time.time()
+            
+            result_path = process_video(
                 video_path,
-                background_image,
+                background_url,
+                method=selected_method,
                 progress_callback=update_progress
             )
             
-            if result:
-                st.success("✅ Video processed with SAM2!")
-                st.video(result)
+            processing_time = time.time() - start_time
+        
+        if result_path and os.path.exists(result_path):
+            # Success
+            status_text.text(f"✅ Processing complete in {processing_time:.1f} seconds!")
+            
+            # Load result
+            with open(result_path, 'rb') as f:
+                result_data = f.read()
+            
+            st.markdown("### 🎬 Result")
+            st.video(result_data)
+            
+            # Download
+            st.download_button(
+                label="💾 Download Processed Video",
+                data=result_data,
+                file_name=f"backgroundfx_{uploaded_video.name}",
+                mime="video/mp4",
+                use_container_width=True
+            )
+            
+            # Cleanup
+            os.unlink(result_path)
+            
+            # Stats
+            if CUDA_AVAILABLE:
+                allocated = torch.cuda.memory_allocated() / 1024**3
+                st.info(f"Processing completed using {allocated:.1f}GB GPU memory")
+        else:
+            st.error("❌ Processing failed! Please try again.")
+        
+        # Cleanup temp
+        if video_path and os.path.exists(video_path):
+            os.unlink(video_path)
 
 if __name__ == "__main__":
     main()