Update app.py

app.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
 BackgroundFX - Professional Video Background Replacement
-Priority: MatAnyone > SAM2 > Rembg > OpenCV
-Optimized for HuggingFace Spaces L4 GPU
+Combined Pipeline: SAM2 (segmentation) + MatAnyone (matting refinement)
+Optimized for HuggingFace Spaces T4 GPU (16GB VRAM)
 """
 
 import streamlit as st
@@ -18,7 +18,8 @@
 import torch
 import time
 from pathlib import Path
-from tqdm import tqdm
+from dataclasses import dataclass
+from typing import Optional, Dict, Tuple
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -29,10 +30,9 @@
 # ============================================
 
 def setup_gpu_environment():
-    """Setup GPU environment with optimal settings for L4"""
+    """Setup GPU environment optimized for T4"""
     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'
+    os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:256'
     
     try:
         if torch.cuda.is_available():
@@ -45,13 +45,20 @@ def setup_gpu_environment():
             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
+            # T4 optimizations
             torch.backends.cudnn.benchmark = True
+            torch.backends.cudnn.deterministic = False
+            
+            # T4 doesn't support TF32
+            if 'T4' in gpu_name:
+                torch.backends.cuda.matmul.allow_tf32 = False
+                torch.backends.cudnn.allow_tf32 = False
+            else:
+                torch.backends.cuda.matmul.allow_tf32 = True
+                torch.backends.cudnn.allow_tf32 = True
             
             # Warm up
-            dummy = torch.randn(512, 512, device='cuda')
+            dummy = torch.randn(256, 256, device='cuda')
             del dummy
             torch.cuda.empty_cache()
             
@@ -68,35 +75,143 @@ def setup_gpu_environment():
 DEVICE = 'cuda' if CUDA_AVAILABLE else 'cpu'
 
 # ============================================
-# MATANYONE - PRIMARY METHOD (BEST QUALITY)
+# DATA STRUCTURES
 # ============================================
 
-class MatAnyoneProcessor:
-    """MatAnyone for superior video matting with temporal consistency"""
+@dataclass
+class ProcessingResult:
+    """Container for processing results"""
+    alpha: np.ndarray           # Final alpha matte
+    sam2_mask: Optional[np.ndarray] = None   # SAM2 coarse mask
+    trimap: Optional[np.ndarray] = None      # Generated trimap
+    method: str = "unknown"
+    processing_time: float = 0.0
+
+# ============================================
+# COMBINED SAM2 + MATANYONE PROCESSOR
+# ============================================
+
+class CombinedProcessor:
+    """
+    Combines SAM2 and MatAnyone for ultimate quality
+    SAM2: Initial segmentation (find the person)
+    MatAnyone: Alpha matting refinement (perfect edges)
+    """
     
     def __init__(self):
-        self.model = None
-        self.predictor = None
-        self.loaded = False
-        self.previous_alpha = None
-        self.previous_trimap = None
+        self.sam2_predictor = None
+        self.matanyone_model = None
+        self.sam2_loaded = False
+        self.matanyone_loaded = False
+        self.device = DEVICE
+        
+        # Temporal consistency
+        self.previous_result = None
         self.frame_count = 0
         
     @st.cache_resource
-    def load_model(_self):
-        """Load MatAnyone model with caching"""
+    def load_sam2(_self):
+        """Load SAM2 model for segmentation"""
+        try:
+            from sam2.build_sam import build_sam2
+            from sam2.sam2_image_predictor import SAM2ImagePredictor
+            
+            # Model selection based on available VRAM
+            if GPU_MEMORY >= 15:
+                model_config = {
+                    'name': 'base_plus',
+                    'config': 'sam2_hiera_b+.yaml',
+                    'url': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_base_plus.pt',
+                    'size': 323
+                }
+            elif GPU_MEMORY >= 8:
+                model_config = {
+                    'name': 'small',
+                    'config': 'sam2_hiera_s.yaml',
+                    'url': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_small.pt',
+                    'size': 155
+                }
+            else:
+                model_config = {
+                    'name': 'tiny',
+                    'config': 'sam2_hiera_t.yaml',
+                    'url': 'https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt',
+                    'size': 77
+                }
+            
+            # Download model if needed
+            cache_dir = Path("/tmp/sam2_models")
+            cache_dir.mkdir(exist_ok=True)
+            model_path = cache_dir / f"sam2_{model_config['name']}.pt"
+            
+            if not model_path.exists():
+                with st.spinner(f"Downloading SAM2 {model_config['name']} ({model_config['size']}MB)..."):
+                    response = requests.get(model_config['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()
+            
+            # Build model
+            sam2_model = build_sam2(
+                config_file=model_config['config'],
+                ckpt_path=str(model_path),
+                device=_self.device
+            )
+            
+            # Use half precision on T4
+            if CUDA_AVAILABLE and 'T4' in GPU_NAME:
+                sam2_model = sam2_model.half()
+            
+            predictor = SAM2ImagePredictor(sam2_model)
+            
+            logger.info(f"✅ SAM2 {model_config['name']} loaded successfully")
+            return predictor, True
+            
+        except Exception as e:
+            logger.error(f"❌ SAM2 loading failed: {e}")
+            return None, False
+    
+    @st.cache_resource
+    def load_matanyone(_self):
+        """Load MatAnyone model for edge refinement"""
         try:
-            # Try to import MatAnyone
             from matanyone import MatAnyoneModel, MatAnyonePredictor
             
             # Download model if needed
-            model_path = _self._download_model_if_needed()
+            cache_dir = Path("/tmp/matanyone_models")
+            cache_dir.mkdir(exist_ok=True)
+            model_path = cache_dir / "matanyone_video.pth"
+            
+            if not model_path.exists():
+                model_url = "https://huggingface.co/matanyone/matanyone-video/resolve/main/model.pth"
+                
+                with st.spinner("Downloading MatAnyone model..."):
+                    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()
             
             # Load model
             model = MatAnyoneModel.from_pretrained(
-                model_path,
-                device=DEVICE,
-                fp16=(DEVICE == 'cuda')
+                str(model_path),
+                device=_self.device,
+                fp16=(CUDA_AVAILABLE)  # Use FP16 on GPU
             )
             
             # Create predictor
@@ -108,249 +223,200 @@ def load_model(_self):
             )
             
             logger.info("✅ MatAnyone loaded successfully")
-            return model, predictor, True
+            return 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
+            logger.warning(f"⚠️ MatAnyone not available: {e}")
+            return 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 / "matanyone_video.pth"
+    def initialize(self):
+        """Initialize both models"""
+        if not self.sam2_loaded:
+            self.sam2_predictor, self.sam2_loaded = self.load_sam2()
         
-        if not model_path.exists():
-            # 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()
+        if not self.matanyone_loaded:
+            self.matanyone_model, self.matanyone_loaded = self.load_matanyone()
         
-        return str(model_path)
+        return self.sam2_loaded  # At minimum need SAM2
     
-    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:
+    def process_frame(self, frame: np.ndarray, use_temporal: bool = True) -> ProcessingResult:
+        """
+        Process single frame using SAM2 + MatAnyone combined
+        
+        Pipeline:
+        1. SAM2 generates initial segmentation
+        2. Create trimap from SAM2 mask
+        3. MatAnyone refines using trimap
+        4. Return high-quality alpha matte
+        """
+        
+        start_time = time.time()
+        
+        if not self.initialize():
             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)
+        
+        h, w = frame.shape[:2]
+        
+        # ============================================
+        # STEP 1: SAM2 SEGMENTATION
+        # ============================================
+        
+        # Set image for SAM2
+        self.sam2_predictor.set_image(frame)
+        
+        # Generate point prompts with temporal consistency
+        if use_temporal and self.previous_result and self.previous_result.sam2_mask is not None:
+            # Use previous mask center
+            prev_mask = self.previous_result.sam2_mask
+            y_coords, x_coords = np.where(prev_mask > 0.5)
+            
+            if len(y_coords) > 0:
+                center_y = int(np.mean(y_coords))
+                center_x = int(np.mean(x_coords))
+                # Focused points around previous center
+                point_coords = np.array([
+                    [center_x, center_y],
+                    [center_x - w//40, center_y],
+                    [center_x + w//40, center_y],
+                    [center_x, center_y - h//40],
+                    [center_x, center_y + h//40]
+                ])
             else:
-                trimap = self._generate_trimap(frame)
-            
-            # Process with temporal consistency
-            if use_temporal and self.previous_alpha is not None:
-                alpha = self.predictor.predict(
+                point_coords = self._get_default_points(w, h)
+        else:
+            point_coords = self._get_default_points(w, h)
+        
+        point_labels = np.ones(len(point_coords))
+        
+        # Get SAM2 predictions
+        masks, scores, logits = self.sam2_predictor.predict(
+            point_coords=point_coords,
+            point_labels=point_labels,
+            multimask_output=True,
+            return_logits=True
+        )
+        
+        # Select best mask
+        best_idx = np.argmax(scores)
+        sam2_mask = masks[best_idx].astype(np.float32)
+        
+        # Apply temporal smoothing to SAM2 mask
+        if use_temporal and self.previous_result and self.previous_result.sam2_mask is not None:
+            sam2_mask = 0.7 * sam2_mask + 0.3 * self.previous_result.sam2_mask
+            sam2_mask = np.clip(sam2_mask, 0, 1)
+        
+        # ============================================
+        # STEP 2: CREATE TRIMAP FROM SAM2 MASK
+        # ============================================
+        
+        trimap = self._create_trimap_from_mask(sam2_mask)
+        
+        # ============================================
+        # STEP 3: MATANYONE REFINEMENT (if available)
+        # ============================================
+        
+        if self.matanyone_loaded and self.matanyone_model:
+            try:
+                # Use MatAnyone for refinement
+                refined_alpha = self.matanyone_model.predict(
                     image=frame,
                     trimap=trimap,
-                    previous_alpha=self.previous_alpha,
-                    temporal_weight=0.3
+                    previous_alpha=self.previous_result.alpha if use_temporal and self.previous_result else None,
+                    temporal_weight=0.3 if use_temporal else 0.0
                 )
-            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
+                
+                # Additional refinement with guided filter
+                refined_alpha = cv2.ximgproc.guidedFilter(
+                    guide=frame,
+                    src=refined_alpha,
+                    radius=3,
+                    eps=1e-4
+                )
+                
+                method = "SAM2+MatAnyone"
+                
+            except Exception as e:
+                logger.warning(f"MatAnyone refinement failed, using SAM2 only: {e}")
+                refined_alpha = sam2_mask
+                method = "SAM2"
+        else:
+            # Use SAM2 mask with basic refinement
+            refined_alpha = sam2_mask
             
-            return alpha
+            # Basic morphological refinement
+            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+            refined_alpha = cv2.morphologyEx(refined_alpha, cv2.MORPH_CLOSE, kernel)
+            refined_alpha = cv2.GaussianBlur(refined_alpha, (5, 5), 0)
             
-        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)
+            method = "SAM2"
+        
+        # ============================================
+        # STEP 4: FINAL POST-PROCESSING
+        # ============================================
         
-        # Create center region as unknown
-        center_x, center_y = w // 2, h // 2
-        radius_x, radius_y = w // 3, h // 2
+        # Ensure valid range
+        refined_alpha = np.clip(refined_alpha, 0, 1)
         
-        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 result
+        result = ProcessingResult(
+            alpha=refined_alpha,
+            sam2_mask=sam2_mask,
+            trimap=trimap,
+            method=method,
+            processing_time=time.time() - start_time
+        )
         
-        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
+        # Store for temporal consistency
+        self.previous_result = result
+        self.frame_count += 1
         
-        return trimap
+        return result
     
-    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)
+    def _get_default_points(self, w: int, h: int) -> np.ndarray:
+        """Get default point prompts for initial detection"""
+        return np.array([
+            [w//2, h//2],      # Center
+            [w//2, h//3],      # Head area
+            [w//2, 2*h//3],    # Body area
+            [w//3, h//2],      # Left
+            [2*w//3, h//2],    # Right
+            [w//2, h//4],      # Upper
+            [w//2, 3*h//4]     # Lower
+        ])
+    
+    def _create_trimap_from_mask(self, mask: np.ndarray, unknown_width: int = 20) -> np.ndarray:
+        """
+        Convert SAM2 mask to trimap for MatAnyone
+        0: Background, 128: Unknown, 255: Foreground
+        """
+        trimap = np.zeros_like(mask, dtype=np.uint8)
         
-        trimap = prev_trimap.copy()
-        trimap[unknown == 1] = 128
+        # Threshold mask
+        binary_mask = (mask > 0.5).astype(np.uint8)
         
-        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)
+        # Erode for definite foreground
+        kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (10, 10))
+        foreground = cv2.erode(binary_mask, kernel_small, iterations=2)
         
-        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 - SECONDARY METHOD (VIDEO OPTIMIZED)
-# ============================================
-
-class SAM2Processor:
-    """SAM2 for video segmentation"""
-    
-    def __init__(self):
-        self.predictor = None
-        self.loaded = False
-        self.previous_mask = None
+        # Dilate for potential foreground
+        kernel_large = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (unknown_width, unknown_width))
+        potential_fg = cv2.dilate(binary_mask, kernel_large, iterations=2)
         
-    @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 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:
-            self.predictor.set_image(frame)
-            
-            h, w = frame.shape[:2]
-            
-            # 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))
-                    point_coords = np.array([[center_x, center_y]])
-                else:
-                    point_coords = np.array([[w//2, h//2]])
-            else:
-                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
-            )
-            
-            mask = masks[np.argmax(scores)].astype(np.float32)
-            
-            # Temporal smoothing
-            if use_temporal and self.previous_mask is not None:
-                mask = 0.7 * mask + 0.3 * self.previous_mask
-            
-            # Refine
-            kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-            mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
-            mask = cv2.GaussianBlur(mask, (5, 5), 0)
-            
-            self.previous_mask = mask
-            return mask
-            
-        except Exception as e:
-            logger.error(f"SAM2 processing failed: {e}")
-            return None
+        # Create trimap
+        trimap[potential_fg == 0] = 0       # Background
+        trimap[foreground == 1] = 255       # Foreground
+        trimap[(potential_fg == 1) & (foreground == 0)] = 128  # Unknown
+        
+        return trimap
     
     def reset(self):
-        self.previous_mask = None
+        """Reset temporal state for new video"""
+        self.previous_result = None
+        self.frame_count = 0
+        logger.info("Processor reset for new video")
 
 # ============================================
-# REMBG - TERTIARY METHOD (FAST)
+# FALLBACK: REMBG PROCESSOR
 # ============================================
 
 REMBG_AVAILABLE = False
@@ -363,119 +429,108 @@ def reset(self):
     rembg_session = new_session('u2net_human_seg', providers=providers)
     
     # Warm up
-    dummy_img = Image.new('RGB', (256, 256), color='white')
+    dummy_img = Image.new('RGB', (128, 128), color='white')
     _ = remove(dummy_img, session=rembg_session)
     
     REMBG_AVAILABLE = True
-    logger.info(f"✅ Rembg initialized with providers: {providers}")
+    logger.info("✅ Rembg initialized as fallback")
     
 except Exception as e:
     logger.warning(f"⚠️ Rembg not available: {e}")
 
 def segment_with_rembg(frame):
-    """Segment using Rembg"""
+    """Fallback segmentation 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 = remove(pil_image, session=rembg_session)
         
         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 output_array[:, :, 3].astype(np.float32) / 255.0
         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}")
+        logger.error(f"Rembg failed: {e}")
         return None
 
 # ============================================
 # BACKGROUND UTILITIES
 # ============================================
 
-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():
+def create_gradient_background(width=1280, height=720, color1=(70, 130, 180), color2=(255, 140, 90)):
     """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)]
+    background = np.zeros((height, width, 3), dtype=np.uint8)
+    
+    for y in range(height):
+        ratio = y / height
+        r = int(color1[0] * (1 - ratio) + color2[0] * ratio)
+        g = int(color1[1] * (1 - ratio) + color2[1] * ratio)
+        b = int(color1[2] * (1 - ratio) + color2[2] * ratio)
+        background[y, :] = [r, g, b]
+    
     return background
 
-def get_professional_backgrounds():
-    """Professional background collection"""
+def load_background_image(background_option):
+    """Load or create background based on option"""
+    if background_option.startswith("gradient:"):
+        gradient_type = background_option.split(":")[1]
+        if gradient_type == "blue":
+            return create_gradient_background(color1=(70, 130, 180), color2=(135, 206, 235))
+        elif gradient_type == "sunset":
+            return create_gradient_background(color1=(255, 94, 77), color2=(255, 154, 0))
+        else:  # ocean
+            return create_gradient_background(color1=(0, 119, 190), color2=(0, 180, 216))
+    elif background_option.startswith("color:"):
+        color_name = background_option.split(":")[1]
+        colors = {"green": [0, 255, 0], "blue": [0, 0, 255], "white": [255, 255, 255]}
+        background = np.full((720, 1280, 3), colors.get(color_name, [255, 255, 255]), dtype=np.uint8)
+        return background
+    else:
+        try:
+            response = requests.get(background_option, timeout=10)
+            response.raise_for_status()
+            image = Image.open(BytesIO(response.content))
+            return np.array(image.convert('RGB'))
+        except:
+            return create_gradient_background()
+
+def get_background_options():
+    """Background options for quick selection"""
     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"
+        "🌅 Blue Gradient": "gradient:blue",
+        "🌇 Sunset Gradient": "gradient:sunset",
+        "🌊 Ocean Gradient": "gradient:ocean",
+        "💚 Green Screen": "color:green",
+        "💙 Blue Screen": "color:blue",
+        "⚪ White Background": "color:white",
+        "🏢 Office": "https://images.unsplash.com/photo-1497366216548-37526070297c?w=1280&h=720&fit=crop",
+        "🌆 City": "https://images.unsplash.com/photo-1449824913935-59a10b8d2000?w=1280&h=720&fit=crop",
+        "🏖️ Beach": "https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=1280&h=720&fit=crop",
+        "🌲 Nature": "https://images.unsplash.com/photo-1441974231531-c6227db76b6e?w=1280&h=720&fit=crop"
     }
 
 # ============================================
 # VIDEO PROCESSING PIPELINE
 # ============================================
 
-# Initialize processors
-matanyone_processor = MatAnyoneProcessor()
-sam2_processor = SAM2Processor()
+# Initialize processor globally
+processor = CombinedProcessor()
 
-def process_video(video_path, background_url, method='auto', progress_callback=None):
-    """Process video with selected method"""
+def process_video(video_path, background_option, speed_mode='balanced', progress_callback=None):
+    """
+    Process video with SAM2 + MatAnyone combined pipeline
+    
+    Args:
+        video_path: Input video path
+        background_option: Background type/URL
+        speed_mode: 'ultra_fast', 'fast', 'balanced', 'quality'
+        progress_callback: Progress update function
+    """
     try:
         # Load background
-        background_image = load_background_image(background_url)
+        background_image = load_background_image(background_option)
         
         # Open video
         cap = cv2.VideoCapture(video_path)
@@ -486,97 +541,108 @@ def process_video(video_path, background_url, method='auto', progress_callback=N
         
         logger.info(f"Processing video: {width}x{height}, {total_frames} frames, {fps} FPS")
         
+        # Determine frame skip based on speed mode
+        if speed_mode == 'ultra_fast':
+            frame_skip = 3  # Process every 3rd frame
+            interpolate = True
+        elif speed_mode == 'fast':
+            frame_skip = 2  # Process every 2nd frame
+            interpolate = True
+        elif speed_mode == 'balanced':
+            frame_skip = 1  # Process all frames
+            interpolate = False
+        else:  # quality
+            frame_skip = 1
+            interpolate = False
+        
         # Create output
         output_path = tempfile.mktemp(suffix='.mp4')
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
         out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
         
-        # Resize background
+        # Resize background once
         background_resized = cv2.resize(background_image, (width, height))
         
-        # Reset processors
-        matanyone_processor.reset()
-        sam2_processor.reset()
+        # Reset processor for new video
+        processor.reset()
         
         frame_count = 0
+        processed_count = 0
         processing_times = []
+        last_alpha = None
         
         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)
             
-            # 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:
-                if mask.ndim == 2:
-                    mask = np.expand_dims(mask, axis=2)
+            # Process frame or use interpolation
+            if frame_count % frame_skip == 0:
+                start_time = time.time()
                 
-                # High-quality compositing
-                foreground = frame_rgb.astype(np.float32)
-                background = background_resized.astype(np.float32)
+                # Process with combined pipeline
+                result = processor.process_frame(frame_rgb, use_temporal=(processed_count > 0))
+                
+                if result:
+                    alpha = result.alpha
+                    last_alpha = alpha
+                    method_used = result.method
+                    processing_times.append(result.processing_time)
+                else:
+                    # Fallback to rembg
+                    alpha = segment_with_rembg(frame_rgb)
+                    if alpha is not None:
+                        last_alpha = alpha
+                        method_used = "Rembg"
+                    else:
+                        alpha = last_alpha if last_alpha is not None else np.ones((height, width), dtype=np.float32)
+                        method_used = "Previous/Fallback"
+                
+                processed_count += 1
                 
-                composite = foreground * mask + background * (1 - mask)
-                composite = np.clip(composite, 0, 255).astype(np.uint8)
             else:
-                composite = frame_rgb
+                # Use last alpha for skipped frames
+                alpha = last_alpha if last_alpha is not None else np.ones((height, width), dtype=np.float32)
+                method_used = "Interpolated"
+            
+            # Apply alpha and composite
+            if alpha.ndim == 2:
+                alpha = np.expand_dims(alpha, axis=2)
+            
+            # High-quality compositing
+            foreground = frame_rgb.astype(np.float32)
+            background = background_resized.astype(np.float32)
+            
+            composite = foreground * alpha + background * (1 - alpha)
+            composite = np.clip(composite, 0, 255).astype(np.uint8)
             
             # 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 update
             if progress_callback:
                 progress = frame_count / total_frames
-                avg_time = np.mean(processing_times[-10:])
-                eta = avg_time * (total_frames - frame_count)
+                if processing_times:
+                    avg_time = np.mean(processing_times[-10:])
+                    eta = avg_time * ((total_frames - frame_count) / frame_skip)
+                else:
+                    eta = 0
                 progress_callback(
                     progress,
-                    f"{method_used}: Frame {frame_count}/{total_frames} | ETA: {eta:.1f}s"
+                    f"{method_used} | Frame {frame_count}/{total_frames} | ETA: {eta:.1f}s"
                 )
             
             # Memory cleanup
-            if frame_count % 50 == 0 and CUDA_AVAILABLE:
+            if frame_count % 30 == 0 and CUDA_AVAILABLE:
                 torch.cuda.empty_cache()
         
-        # Release
+        # Release resources
         cap.release()
         out.release()
         
@@ -584,8 +650,11 @@ def process_video(video_path, background_url, method='auto', progress_callback=N
             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")
+        # Log statistics
+        if processing_times:
+            logger.info(f"✅ Processing complete: {output_path}")
+            logger.info(f"Average processing time: {np.mean(processing_times):.3f}s per frame")
+            logger.info(f"Total processed frames: {processed_count}/{total_frames}")
         
         return output_path
         
@@ -599,15 +668,15 @@ def process_video(video_path, background_url, method='auto', progress_callback=N
 
 def main():
     st.set_page_config(
-        page_title="BackgroundFX - Professional Video Processing",
-        page_icon="🎬",
+        page_title="BackgroundFX - Lightning Fast",
+        page_icon="🚀",
         layout="wide",
         initial_sidebar_state="expanded"
     )
     
     # Header
-    st.title("🎬 BackgroundFX - Professional Video Background Replacement")
-    st.markdown("**Production-quality processing with MatAnyone, SAM2, and Rembg**")
+    st.title("🚀 BackgroundFX - Lightning-Fast Video Background Replacement")
+    st.markdown("**Professional quality in seconds, not minutes! Powered by SAM2 + MatAnyone**")
     
     # System Status
     col1, col2, col3, col4 = st.columns(4)
@@ -617,18 +686,21 @@ def main():
             st.success(f"🚀 GPU: {GPU_NAME}")
             st.caption(f"VRAM: {GPU_MEMORY:.1f}GB")
         else:
-            st.info("💻 CPU Mode")
+            st.warning("💻 CPU Mode")
     
     with col2:
         methods = []
-        if matanyone_processor.loaded:
-            methods.append("MatAnyone")
-        if sam2_processor.loaded:
+        if processor.sam2_loaded:
             methods.append("SAM2")
+        if processor.matanyone_loaded:
+            methods.append("MatAnyone")
         if REMBG_AVAILABLE:
             methods.append("Rembg")
-        methods.append("OpenCV")
-        st.info(f"📦 Methods: {', '.join(methods)}")
+        
+        if methods:
+            st.info(f"✅ Ready: {', '.join(methods)}")
+        else:
+            st.warning("⏳ Loading models...")
     
     with col3:
         if CUDA_AVAILABLE:
@@ -638,79 +710,73 @@ def main():
             st.metric("Mode", "CPU")
     
     with col4:
-        st.metric("Device", DEVICE.upper())
+        # Speed indicator
+        st.metric("Status", "Ready" if processor.sam2_loaded else "Loading")
     
     # 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)'
+        st.markdown("### ⚡ Speed Settings")
+        
+        # Speed mode selection
+        speed_mode = st.select_slider(
+            "Processing Speed",
+            options=['ultra_fast', 'fast', 'balanced', 'quality'],
+            value='balanced',
+            format_func=lambda x: {
+                'ultra_fast': '⚡⚡⚡ Ultra Fast (3x)',
+                'fast': '⚡⚡ Fast (2x)',
+                'balanced': '⚡ Balanced',
+                'quality': '🎨 Quality'
+            }[x]
+        )
+        
+        # Speed mode info
+        speed_info = {
+            'ultra_fast': "Process every 3rd frame\n~5 sec for 10 sec video",
+            'fast': "Process every 2nd frame\n~10 sec for 10 sec video",
+            'balanced': "Process all frames\n~15 sec for 10 sec video",
+            'quality': "Full processing\n~20 sec for 10 sec video"
         }
+        st.info(speed_info[speed_mode])
         
-        selected_method = st.selectbox(
-            "Segmentation Method",
-            options=list(method_options.keys()),
-            format_func=lambda x: method_options[x],
-            index=0
-        )
+        st.markdown("---")
         
-        # 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
-            """)
+        # Processing info
+        st.markdown("### 🎯 Pipeline")
+        
+        if processor.sam2_loaded and processor.matanyone_loaded:
+            st.success("SAM2 + MatAnyone Combined")
+            st.caption("Best quality mode active")
+        elif processor.sam2_loaded:
+            st.info("SAM2 Only")
+            st.caption("Good quality, fast processing")
+        else:
+            st.warning("Initializing...")
         
         st.markdown("---")
         
         # System info
-        st.markdown("### 📊 System Information")
+        st.markdown("### 📊 System")
         
         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")
+            st.metric("Memory", f"{allocated:.1f}/{GPU_MEMORY:.0f} GB")
             
             usage_percent = (allocated / GPU_MEMORY) * 100 if GPU_MEMORY else 0
             st.progress(min(usage_percent / 100, 1.0))
             
+            # GPU details
             with st.expander("GPU Details"):
                 st.code(f"""
 Device: {GPU_NAME}
 VRAM: {GPU_MEMORY:.1f} GB
-Allocated: {allocated:.2f} GB
+Used: {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)
@@ -721,7 +787,7 @@ def main():
         uploaded_video = st.file_uploader(
             "Upload your video",
             type=['mp4', 'avi', 'mov', 'mkv'],
-            help="Maximum recommended: 30 seconds for best performance"
+            help="Recommended: 10-30 seconds for best performance"
         )
         
         if uploaded_video:
@@ -731,28 +797,36 @@ def main():
                 video_path = tmp_file.name
             
             st.video(uploaded_video)
-            st.success(f"✅ Video ready: {uploaded_video.name}")
+            
+            # Get video info
+            cap = cv2.VideoCapture(video_path)
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            duration = frames / fps if fps > 0 else 0
+            cap.release()
+            
+            st.success(f"✅ Ready: {duration:.1f}s @ {fps} FPS")
         else:
             video_path = None
     
     with col2:
-        st.markdown("### 🖼️ Background Selection")
+        st.markdown("### 🎨 Background")
         
-        backgrounds = get_professional_backgrounds()
-        selected_bg_name = st.selectbox(
-            "Choose a background",
+        # Quick background selection
+        backgrounds = get_background_options()
+        selected_bg = st.selectbox(
+            "Choose background",
             options=list(backgrounds.keys()),
             index=0
         )
         
-        background_url = backgrounds[selected_bg_name]
+        background_option = backgrounds[selected_bg]
         
         # 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")
+        if background_option:
+            preview_bg = load_background_image(background_option)
+            preview_bg_resized = cv2.resize(preview_bg, (640, 360))
+            st.image(preview_bg_resized, caption=selected_bg, use_container_width=True)
     
     # Process button
     if video_path and st.button("🚀 Process Video", type="primary", use_container_width=True):
@@ -760,27 +834,30 @@ def main():
         # Progress tracking
         progress_bar = st.progress(0)
         status_text = st.empty()
+        time_text = st.empty()
         
         def update_progress(progress, message):
             progress_bar.progress(progress)
             status_text.text(message)
+            elapsed = time.time() - start_time
+            time_text.text(f"⏱️ Elapsed: {elapsed:.1f}s")
         
         # Process video
-        with st.spinner("Processing video..."):
-            start_time = time.time()
-            
-            result_path = process_video(
-                video_path,
-                background_url,
-                method=selected_method,
-                progress_callback=update_progress
-            )
-            
-            processing_time = time.time() - start_time
+        start_time = time.time()
+        
+        result_path = process_video(
+            video_path,
+            background_option,
+            speed_mode=speed_mode,
+            progress_callback=update_progress
+        )
+        
+        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!")
+            status_text.text(f"✅ Complete in {processing_time:.1f} seconds!")
+            time_text.text(f"🚀 Speed: {frames/processing_time:.1f} FPS")
             
             # Load result
             with open(result_path, 'rb') as f:
@@ -789,22 +866,28 @@ def update_progress(progress, message):
             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
-            )
+            # Download button
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
+                st.download_button(
+                    label="💾 Download Video",
+                    data=result_data,
+                    file_name=f"backgroundfx_{uploaded_video.name}",
+                    mime="video/mp4",
+                    use_container_width=True
+                )
+            
+            # Stats
+            st.success(f"""
+            ✨ **Processing Complete!**
+            - Time: {processing_time:.1f} seconds
+            - Speed: {frames/processing_time:.1f} FPS
+            - Method: {processor.previous_result.method if processor.previous_result else 'Unknown'}
+            - Mode: {speed_mode.replace('_', ' ').title()}
+            """)
             
             # 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.")