Update app.py

app.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-High-Quality Video Background Replacement - COMPLETE VERSION
+High-Quality Video Background Replacement - MAIN APPLICATION
 Upload video → Choose professional background → Replace with cinema quality
 Features: SAM2 + MatAnyone with multi-fallback loading, professional backgrounds,
 cinema-quality processing, lazy loading, and enhanced stability
@@ -26,8 +26,8 @@
 from typing import Optional, Tuple, Dict, Any
 import logging
 
-# Import utility functions
-from utils import *
+# Import all utilities
+from utilities import *
 
 # Fix OpenMP threads issue - remove problematic environment variable
 try:
@@ -73,865 +73,6 @@ def patched_get_type(schema):
 models_loaded = False
 loading_lock = threading.Lock()
 
-# Professional background templates - Enhanced collection
-PROFESSIONAL_BACKGROUNDS = {
-    "office_modern": {
-        "name": "Modern Office",
-        "type": "gradient", 
-        "colors": ["#f8f9fa", "#e9ecef", "#dee2e6"],
-        "direction": "diagonal",
-        "description": "Clean, contemporary office environment"
-    },
-    "office_executive": {
-        "name": "Executive Office",
-        "type": "gradient",
-        "colors": ["#2c3e50", "#34495e", "#5d6d7e"],
-        "direction": "vertical",
-        "description": "Professional executive setting"
-    },
-    "studio_blue": {
-        "name": "Professional Blue",
-        "type": "gradient",
-        "colors": ["#1e3c72", "#2a5298", "#3498db"],
-        "direction": "radial",
-        "description": "Broadcast-quality blue studio"
-    },
-    "studio_green": {
-        "name": "Broadcast Green",
-        "type": "color",
-        "colors": ["#00b894"],
-        "chroma_key": True,
-        "description": "Professional green screen replacement"
-    },
-    "conference": {
-        "name": "Conference Room",
-        "type": "gradient",
-        "colors": ["#74b9ff", "#0984e3", "#6c5ce7"],
-        "direction": "horizontal",
-        "description": "Modern conference room setting"
-    },
-    "minimalist": {
-        "name": "Minimalist White",
-        "type": "gradient",
-        "colors": ["#ffffff", "#f1f2f6", "#ddd"],
-        "direction": "soft_radial",
-        "description": "Clean, minimal background"
-    },
-    "warm_gradient": {
-        "name": "Warm Sunset",
-        "type": "gradient",
-        "colors": ["#ff7675", "#fd79a8", "#fdcb6e"],
-        "direction": "diagonal",
-        "description": "Warm, inviting atmosphere"
-    },
-    "cool_gradient": {
-        "name": "Cool Ocean",
-        "type": "gradient", 
-        "colors": ["#74b9ff", "#0984e3", "#00cec9"],
-        "direction": "vertical",
-        "description": "Cool, calming ocean tones"
-    },
-    "corporate": {
-        "name": "Corporate Navy",
-        "type": "gradient",
-        "colors": ["#2d3436", "#636e72", "#74b9ff"],
-        "direction": "radial",
-        "description": "Corporate professional setting"
-    },
-    "creative": {
-        "name": "Creative Purple",
-        "type": "gradient",
-        "colors": ["#6c5ce7", "#a29bfe", "#fd79a8"],
-        "direction": "diagonal",
-        "description": "Creative, artistic environment"
-    },
-    "tech_dark": {
-        "name": "Tech Dark",
-        "type": "gradient",
-        "colors": ["#0c0c0c", "#2d3748", "#4a5568"],
-        "direction": "vertical",
-        "description": "Modern tech/gaming setup"
-    },
-    "nature_green": {
-        "name": "Nature Green",
-        "type": "gradient",
-        "colors": ["#27ae60", "#2ecc71", "#58d68d"],
-        "direction": "soft_radial",
-        "description": "Natural, organic background"
-    },
-    "luxury_gold": {
-        "name": "Luxury Gold",
-        "type": "gradient",
-        "colors": ["#f39c12", "#e67e22", "#d68910"],
-        "direction": "diagonal",
-        "description": "Premium, luxury setting"
-    },
-    "medical_clean": {
-        "name": "Medical Clean",
-        "type": "gradient",
-        "colors": ["#ecf0f1", "#bdc3c7", "#95a5a6"],
-        "direction": "horizontal",
-        "description": "Clean, medical/healthcare setting"
-    },
-    "education_blue": {
-        "name": "Education Blue",
-        "type": "gradient",
-        "colors": ["#3498db", "#5dade2", "#85c1e9"],
-        "direction": "vertical",
-        "description": "Educational, learning environment"
-    }
-}
-
-def download_and_setup_models():
-    """ENHANCED download and setup with multiple fallback methods and lazy loading"""
-    global sam2_predictor, matanyone_model, models_loaded
-    
-    with loading_lock:
-        if models_loaded:
-            return "✅ High-quality models already loaded"
-        
-        try:
-            logger.info("🔄 Starting ENHANCED model loading with multiple fallbacks...")
-            
-            # Check environment and system capabilities
-            is_hf_space = os.getenv("SPACE_ID") is not None
-            is_colab = 'google.colab' in sys.modules
-            is_kaggle = os.environ.get('KAGGLE_KERNEL_RUN_TYPE') is not None
-            
-            env_type = "HuggingFace Space" if is_hf_space else "Google Colab" if is_colab else "Kaggle" if is_kaggle else "Local"
-            logger.info(f"Environment detected: {env_type}")
-            
-            # Load PyTorch and check GPU
-            import torch
-            logger.info(f"✅ PyTorch {torch.__version__} - CUDA: {torch.cuda.is_available()}")
-            
-            if torch.cuda.is_available():
-                try:
-                    gpu_name = torch.cuda.get_device_name(0)
-                    gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1e9
-                    logger.info(f"🎮 GPU: {gpu_name} ({gpu_memory:.1f}GB)")
-                except Exception as e:
-                    logger.info(f"🎮 GPU available but details unavailable: {e}")
-            
-            # === ENHANCED SAM2 LOADING WITH MULTIPLE METHODS ===
-            sam2_loaded = False
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            
-            # Method 1: Try direct import (requirements.txt installation)
-            try:
-                logger.info("🔄 SAM2 Method 1: Direct import from requirements...")
-                from sam2.build_sam import build_sam2
-                from sam2.sam2_image_predictor import SAM2ImagePredictor
-                sam2_loaded = True
-                logger.info("✅ SAM2 imported directly from installed package")
-            except ImportError as e:
-                logger.info(f"❌ SAM2 Method 1 failed: {e}")
-            
-            # Method 2: Add known paths and try again
-            if not sam2_loaded:
-                try:
-                    logger.info("🔄 SAM2 Method 2: Adding SAM2 paths...")
-                    possible_paths = [
-                        '/tmp/segment-anything-2',
-                        './segment-anything-2',
-                        '/opt/ml/code/segment-anything-2',
-                        '/workspace/segment-anything-2',
-                        '/content/segment-anything-2',  # Colab
-                        '/kaggle/working/segment-anything-2',  # Kaggle
-                        os.path.expanduser('~/segment-anything-2'),  # Home directory
-                    ]
-                    
-                    for path in possible_paths:
-                        if os.path.exists(path) and path not in sys.path:
-                            sys.path.insert(0, path)
-                            logger.info(f"✅ Added {path} to Python path")
-                    
-                    from sam2.build_sam import build_sam2
-                    from sam2.sam2_image_predictor import SAM2ImagePredictor
-                    sam2_loaded = True
-                    logger.info("✅ SAM2 imported via path addition")
-                except ImportError as e:
-                    logger.info(f"❌ SAM2 Method 2 failed: {e}")
-            
-            # Method 3: Clone repository if needed
-            if not sam2_loaded:
-                try:
-                    logger.info("🔄 SAM2 Method 3: Cloning repository...")
-                    sam2_dir = "/tmp/segment-anything-2"
-                    
-                    if not os.path.exists(sam2_dir):
-                        logger.info("📥 Cloning SAM2 repository...")
-                        clone_cmd = f"git clone --depth 1 https://github.com/facebookresearch/segment-anything-2.git {sam2_dir}"
-                        result = os.system(clone_cmd)
-                        if result == 0:
-                            logger.info("✅ SAM2 repository cloned successfully")
-                        else:
-                            raise Exception("Git clone failed")
-                    
-                    if sam2_dir not in sys.path:
-                        sys.path.insert(0, sam2_dir)
-                    
-                    from sam2.build_sam import build_sam2
-                    from sam2.sam2_image_predictor import SAM2ImagePredictor
-                    sam2_loaded = True
-                    logger.info("✅ SAM2 imported after cloning")
-                except Exception as e:
-                    logger.info(f"❌ SAM2 Method 3 failed: {e}")
-            
-            # Method 4: Install via pip as last resort
-            if not sam2_loaded:
-                try:
-                    logger.info("🔄 SAM2 Method 4: Installing via pip...")
-                    install_cmd = "pip install git+https://github.com/facebookresearch/segment-anything-2.git"
-                    result = os.system(install_cmd)
-                    if result == 0:
-                        from sam2.build_sam import build_sam2
-                        from sam2.sam2_image_predictor import SAM2ImagePredictor
-                        sam2_loaded = True
-                        logger.info("✅ SAM2 installed and imported via pip")
-                    else:
-                        raise Exception("Pip install failed")
-                except Exception as e:
-                    logger.info(f"❌ SAM2 Method 4 failed: {e}")
-            
-            if not sam2_loaded:
-                logger.warning("❌ All SAM2 loading methods failed, using OpenCV fallback")
-                sam2_predictor = create_opencv_segmentation_fallback()
-            else:
-                # Choose model size based on environment and resources
-                if (is_hf_space and not torch.cuda.is_available()) or device == "cpu":
-                    model_name = "sam2_hiera_tiny"
-                    checkpoint_url = "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_tiny.pt"
-                    logger.info("🔧 Using SAM2 Tiny for CPU/limited resources")
-                else:
-                    model_name = "sam2_hiera_large"
-                    checkpoint_url = "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt"
-                    logger.info("🔧 Using SAM2 Large for maximum quality")
-                
-                # Download checkpoint with progress tracking and caching
-                cache_dir = os.path.expanduser("~/.cache/sam2")
-                os.makedirs(cache_dir, exist_ok=True)
-                sam2_checkpoint = os.path.join(cache_dir, f"{model_name}.pt")
-                
-                if not os.path.exists(sam2_checkpoint):
-                    logger.info(f"📥 Downloading {model_name} checkpoint...")
-                    try:
-                        response = requests.get(checkpoint_url, stream=True)
-                        total_size = int(response.headers.get('content-length', 0))
-                        downloaded = 0
-                        
-                        with open(sam2_checkpoint, 'wb') as f:
-                            for chunk in response.iter_content(chunk_size=8192):
-                                if chunk:
-                                    f.write(chunk)
-                                    downloaded += len(chunk)
-                                    if total_size > 0 and downloaded % (total_size // 20) < 8192:
-                                        percent = (downloaded / total_size) * 100
-                                        logger.info(f"📥 Download progress: {percent:.1f}%")
-                        
-                        logger.info(f"✅ {model_name} downloaded successfully")
-                    except Exception as e:
-                        logger.error(f"❌ Download failed: {e}")
-                        raise
-                else:
-                    logger.info(f"✅ Using cached {model_name}")
-                
-                # Load SAM2 model with comprehensive fallbacks
-                try:
-                    logger.info(f"🚀 Loading SAM2 {model_name} on {device}...")
-                    model_cfg = f"{model_name}.yaml"
-                    
-                    # Create config dynamically if missing
-                    config_path = os.path.join("/tmp/segment-anything-2/sam2_configs", model_cfg)
-                    if not os.path.exists(config_path):
-                        os.makedirs(os.path.dirname(config_path), exist_ok=True)
-                        if "tiny" in model_name:
-                            config_content = """
-model:
-  _target_: sam2.modeling.sam2_base.SAM2Base
-  image_encoder:
-    _target_: sam2.modeling.backbones.hieradet.Hiera
-    embed_dim: 96
-    num_heads: 1
-  memory_encoder:
-    _target_: sam2.modeling.memory_encoder.MemoryEncoder
-    out_dim: 64
-  memory_attention:
-    _target_: sam2.modeling.memory_attention.MemoryAttention
-    d_model: 256
-  sam_mask_decoder:
-    _target_: sam2.modeling.sam.mask_decoder.MaskDecoder
-    transformer_dim: 256
-"""
-                        else:
-                            config_content = """
-model:
-  _target_: sam2.modeling.sam2_base.SAM2Base
-  image_encoder:
-    _target_: sam2.modeling.backbones.hieradet.Hiera
-    embed_dim: 144
-    num_heads: 2
-  memory_encoder:
-    _target_: sam2.modeling.memory_encoder.MemoryEncoder
-    out_dim: 64
-  memory_attention:
-    _target_: sam2.modeling.memory_attention.MemoryAttention
-    d_model: 256
-  sam_mask_decoder:
-    _target_: sam2.modeling.sam.mask_decoder.MaskDecoder
-    transformer_dim: 256
-"""
-                        with open(config_path, 'w') as f:
-                            f.write(config_content)
-                        logger.info(f"✅ Created config: {config_path}")
-                    
-                    # Memory optimization for limited resources
-                    if device == "cpu" or is_hf_space:
-                        torch.set_num_threads(min(4, os.cpu_count() or 1))
-                        if torch.cuda.is_available():
-                            torch.cuda.empty_cache()
-                    
-                    # Try loading on specified device
-                    sam2_model = build_sam2(model_cfg, sam2_checkpoint, device=device)
-                    sam2_predictor = SAM2ImagePredictor(sam2_model)
-                    logger.info(f"✅ SAM2 model loaded successfully on {device}")
-                    
-                except Exception as e:
-                    if device == "cuda":
-                        logger.warning(f"❌ GPU loading failed: {e}")
-                        logger.info("🔄 Trying CPU fallback...")
-                        try:
-                            # Force CPU loading
-                            sam2_model = build_sam2(model_cfg, sam2_checkpoint, device="cpu")
-                            sam2_predictor = SAM2ImagePredictor(sam2_model)
-                            device = "cpu"
-                            logger.info("✅ SAM2 loaded on CPU fallback")
-                        except Exception as e2:
-                            logger.error(f"❌ CPU fallback also failed: {e2}")
-                            logger.info("🔄 Using OpenCV segmentation fallback")
-                            sam2_predictor = create_opencv_segmentation_fallback()
-                    else:
-                        logger.error(f"❌ SAM2 loading failed: {e}")
-                        logger.info("🔄 Using OpenCV segmentation fallback")
-                        sam2_predictor = create_opencv_segmentation_fallback()
-            
-            # === ENHANCED MATANYONE LOADING WITH MULTIPLE METHODS ===
-            matanyone_loaded = False
-            
-            # Method 1: Try HuggingFace Hub integration
-            try:
-                logger.info("🔄 MatAnyone Method 1: HuggingFace Hub...")
-                from huggingface_hub import hf_hub_download
-                from matanyone import InferenceCore
-                matanyone_model = InferenceCore("PeiqingYang/MatAnyone")
-                matanyone_loaded = True
-                logger.info("✅ MatAnyone loaded via HuggingFace Hub")
-            except Exception as e:
-                logger.info(f"❌ MatAnyone Method 1 failed: {e}")
-            
-            # Method 2: Try direct import
-            if not matanyone_loaded:
-                try:
-                    logger.info("🔄 MatAnyone Method 2: Direct import...")
-                    matanyone_paths = [
-                        '/tmp/MatAnyone',
-                        './MatAnyone',
-                        '/content/MatAnyone',
-                        '/kaggle/working/MatAnyone'
-                    ]
-                    
-                    for path in matanyone_paths:
-                        if os.path.exists(path):
-                            sys.path.append(path)
-                            break
-                    
-                    from inference import MatAnyoneInference
-                    matanyone_model = MatAnyoneInference()
-                    matanyone_loaded = True
-                    logger.info("✅ MatAnyone loaded via direct import")
-                except Exception as e:
-                    logger.info(f"❌ MatAnyone Method 2 failed: {e}")
-            
-            # Method 3: Try GitHub installation
-            if not matanyone_loaded:
-                try:
-                    logger.info("🔄 MatAnyone Method 3: Installing from GitHub...")
-                    install_cmd = "pip install git+https://github.com/pq-yang/MatAnyone.git"
-                    result = os.system(install_cmd)
-                    if result == 0:
-                        from matanyone import InferenceCore
-                        matanyone_model = InferenceCore("PeiqingYang/MatAnyone")
-                        matanyone_loaded = True
-                        logger.info("✅ MatAnyone installed and loaded via GitHub")
-                    else:
-                        raise Exception("GitHub install failed")
-                except Exception as e:
-                    logger.info(f"❌ MatAnyone Method 3 failed: {e}")
-            
-            # Method 4: Enhanced OpenCV fallback (CINEMA QUALITY)
-            if not matanyone_loaded:
-                logger.info("🎨 Using ENHANCED OpenCV fallback for cinema-quality matting...")
-                matanyone_model = create_enhanced_matting_fallback()
-                matanyone_loaded = True
-            
-            # Memory cleanup
-            gc.collect()
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-            
-            models_loaded = True
-            gpu_info = ""
-            if torch.cuda.is_available() and device == "cuda":
-                try:
-                    gpu_info = f" (GPU: {torch.cuda.get_device_name(0)})"
-                except:
-                    gpu_info = " (GPU)"
-            else:
-                gpu_info = " (CPU)"
-            
-            success_msg = f"✅ ENHANCED high-quality models loaded successfully!{gpu_info}"
-            logger.info(success_msg)
-            return success_msg
-            
-        except Exception as e:
-            error_msg = f"❌ Enhanced loading failed: {str(e)}"
-            logger.error(error_msg)
-            logger.error(f"Full traceback: {traceback.format_exc()}")
-            return error_msg
-
-def create_opencv_segmentation_fallback():
-    """Create comprehensive OpenCV-based segmentation fallback"""
-    class OpenCVSegmentationFallback:
-        def __init__(self):
-            logger.info("🔧 Initializing OpenCV segmentation fallback")
-            # Initialize background subtractor for better segmentation
-            self.bg_subtractor = cv2.createBackgroundSubtractorMOG2(detectShadows=True)
-            self.image = None
-        
-        def set_image(self, image):
-            self.image = image.copy()
-        
-        def predict(self, point_coords, point_labels, multimask_output=True):
-            """Advanced OpenCV-based person segmentation with multiple techniques"""
-            if self.image is None:
-                raise ValueError("No image set")
-            
-            h, w = self.image.shape[:2]
-            
-            try:
-                # Multi-method segmentation approach
-                masks = []
-                
-                # Method 1: Skin tone detection
-                hsv = cv2.cvtColor(self.image, cv2.COLOR_BGR2HSV)
-                
-                # Enhanced skin tone ranges
-                lower_skin1 = np.array([0, 20, 70], dtype=np.uint8)
-                upper_skin1 = np.array([20, 255, 255], dtype=np.uint8)
-                lower_skin2 = np.array([0, 20, 70], dtype=np.uint8)
-                upper_skin2 = np.array([25, 255, 255], dtype=np.uint8)
-                
-                skin_mask1 = cv2.inRange(hsv, lower_skin1, upper_skin1)
-                skin_mask2 = cv2.inRange(hsv, lower_skin2, upper_skin2)
-                skin_mask = cv2.bitwise_or(skin_mask1, skin_mask2)
-                
-                # Method 2: Edge detection for person outline
-                gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)
-                edges = cv2.Canny(gray, 50, 150)
-                
-                # Method 3: Color-based segmentation
-                lab = cv2.cvtColor(self.image, cv2.COLOR_BGR2LAB)
-                
-                # Method 4: Focus on center region with point guidance
-                center_x, center_y = w//2, h//2
-                if len(point_coords) > 0:
-                    # Use provided points as guidance
-                    center_x = int(np.mean(point_coords[:, 0]))
-                    center_y = int(np.mean(point_coords[:, 1]))
-                
-                # Create center-biased mask
-                center_mask = np.zeros((h, w), dtype=np.uint8)
-                roi_width = w // 3
-                roi_height = h // 2
-                cv2.ellipse(center_mask, (center_x, center_y), (roi_width, roi_height), 0, 0, 360, 255, -1)
-                
-                # Combine different segmentation methods
-                combined_mask = cv2.bitwise_or(skin_mask, edges // 4)
-                combined_mask = cv2.bitwise_and(combined_mask, center_mask)
-                
-                # Morphological operations for cleanup
-                kernel_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
-                kernel_open = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-                
-                combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel_close)
-                combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel_open)
-                
-                # Fill holes using contour detection
-                contours, _ = cv2.findContours(combined_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-                
-                if contours:
-                    # Find largest contour (likely person)
-                    largest_contour = max(contours, key=cv2.contourArea)
-                    
-                    # Create mask from largest contour
-                    mask = np.zeros((h, w), dtype=np.uint8)
-                    cv2.fillPoly(mask, [largest_contour], 255)
-                    
-                    # Smooth the mask
-                    mask = cv2.GaussianBlur(mask, (5, 5), 2.0)
-                    mask = (mask > 127).astype(np.uint8)
-                else:
-                    # Fallback: use center region
-                    mask = center_mask
-                
-                # Additional refinement
-                mask = cv2.medianBlur(mask, 5)
-                
-                # Return in SAM2-compatible format
-                masks.append(mask)
-                scores = [1.0]
-                
-                return masks, scores, None
-                
-            except Exception as e:
-                logger.warning(f"OpenCV segmentation error: {e}")
-                # Ultimate fallback: center rectangle
-                mask = np.zeros((h, w), dtype=np.uint8)
-                x1, y1 = w//4, h//6
-                x2, y2 = 3*w//4, 5*h//6
-                mask[y1:y2, x1:x2] = 255
-                return [mask], [1.0], None
-    
-    return OpenCVSegmentationFallback()
-
-def create_enhanced_matting_fallback():
-    """Create enhanced matting fallback with advanced OpenCV techniques"""
-    class EnhancedMattingFallback:
-        def __init__(self):
-            logger.info("🎨 Initializing enhanced matting fallback")
-        
-        def infer(self, image, mask):
-            """Enhanced mask refinement using advanced OpenCV techniques"""
-            try:
-                # Ensure proper format
-                if len(mask.shape) == 3:
-                    mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-                
-                # Multi-stage refinement process
-                
-                # Stage 1: Bilateral filter for edge-preserving smoothing
-                refined_mask = cv2.bilateralFilter(mask, 9, 75, 75)
-                
-                # Stage 2: Morphological operations for structure cleanup
-                kernel_ellipse = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
-                refined_mask = cv2.morphologyEx(refined_mask, cv2.MORPH_CLOSE, kernel_ellipse)
-                refined_mask = cv2.morphologyEx(refined_mask, cv2.MORPH_OPEN, kernel_ellipse)
-                
-                # Stage 3: Gaussian blur for smooth edges
-                refined_mask = cv2.GaussianBlur(refined_mask, (3, 3), 1.0)
-                
-                # Stage 4: Edge enhancement for cinema quality
-                edges = cv2.Canny(refined_mask, 50, 150)
-                edge_enhancement = cv2.dilate(edges, np.ones((2, 2), np.uint8), iterations=1)
-                refined_mask = cv2.bitwise_or(refined_mask, edge_enhancement // 4)
-                
-                # Stage 5: Distance transform for smooth transitions
-                dist_transform = cv2.distanceTransform(refined_mask, cv2.DIST_L2, 5)
-                dist_transform = cv2.normalize(dist_transform, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
-                
-                # Combine distance transform with original mask
-                alpha = 0.7
-                refined_mask = cv2.addWeighted(refined_mask, alpha, dist_transform, 1-alpha, 0)
-                
-                # Stage 6: Final smoothing and cleanup
-                refined_mask = cv2.medianBlur(refined_mask, 3)
-                
-                # Stage 7: Ensure smooth gradients at edges
-                refined_mask = cv2.GaussianBlur(refined_mask, (1, 1), 0.5)
-                
-                return refined_mask
-                
-            except Exception as e:
-                logger.warning(f"Enhanced matting error: {e}")
-                return mask if len(mask.shape) == 2 else cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-    
-    return EnhancedMattingFallback()
-
-def segment_person_hq(image):
-    """High-quality person segmentation using SAM2 or fallback with optimized points"""
-    try:
-        # Set image for segmentation
-        sam2_predictor.set_image(image)
-        
-        h, w = image.shape[:2]
-        
-        # Enhanced point selection (covers head, torso, limbs, and edges)
-        points = np.array([
-            [w//2, h//4],    # Top-center (head)
-            [w//2, h//2],    # Center (torso)
-            [w//2, 3*h//4],  # Bottom-center (legs)
-            [w//4, h//2],    # Left-side (arm)
-            [3*w//4, h//2],  # Right-side (arm)
-            [w//5, h//5],    # Top-left (hair/accessories)
-            [4*w//5, h//5]   # Top-right (hair/accessories)
-        ])
-        labels = np.ones(len(points))  # All positive points
-        
-        # Predict with high quality settings
-        masks, scores, _ = sam2_predictor.predict(
-            point_coords=points,
-            point_labels=labels,
-            multimask_output=True
-        )
-        
-        # Select best mask based on score and size
-        best_idx = np.argmax(scores)
-        best_mask = masks[best_idx]
-        
-        # Post-processing for better quality
-        if len(best_mask.shape) > 2:
-            best_mask = best_mask.squeeze()
-        
-        # Ensure binary mask
-        if best_mask.dtype != np.uint8:
-            best_mask = (best_mask * 255).astype(np.uint8)
-        
-        # Sharper edges (reduced blur)
-        kernel = np.ones((3, 3), np.uint8)
-        best_mask = cv2.morphologyEx(best_mask, cv2.MORPH_CLOSE, kernel)
-        
-        # Apply reduced Gaussian smoothing for sharper edges
-        best_mask = cv2.GaussianBlur(best_mask.astype(np.float32), (3, 3), 0.8)  # Reduced from 1.0
-        
-        return (best_mask * 255).astype(np.uint8) if best_mask.max() <= 1.0 else best_mask.astype(np.uint8)
-        
-    except Exception as e:
-        logger.error(f"Segmentation error: {e}")
-        # Return center region as fallback
-        h, w = image.shape[:2]
-        fallback_mask = np.zeros((h, w), dtype=np.uint8)
-        x1, y1 = w//4, h//6
-        x2, y2 = 3*w//4, 5*h//6
-        fallback_mask[y1:y2, x1:x2] = 255
-        return fallback_mask
-
-def refine_mask_hq(image, mask):
-    """Cinema-quality mask refinement with stronger edge preservation"""
-    try:
-        # Apply pre-processing to image for better matting
-        image_filtered = cv2.bilateralFilter(image, 10, 75, 75)  # Increased from 9 to 10
-        
-        # Use MatAnyone or fallback for professional matting
-        refined_mask = matanyone_model.infer(image_filtered, mask)
-        
-        # Ensure proper format
-        if len(refined_mask.shape) == 3:
-            refined_mask = cv2.cvtColor(refined_mask, cv2.COLOR_BGR2GRAY)
-        
-        # Stronger edge preservation with bilateral filter
-        refined_mask = cv2.bilateralFilter(refined_mask, 10, 75, 75)  # Increased from default
-        
-        # Post-process for smooth edges
-        refined_mask = cv2.medianBlur(refined_mask, 3)
-        
-        return refined_mask
-        
-    except Exception as e:
-        logger.error(f"Mask refinement error: {e}")
-        # Return original mask if refinement fails
-        return mask if len(mask.shape) == 2 else cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-
-def create_green_screen_background(frame):
-    """Create green screen background (Stage 1 of two-stage process)"""
-    h, w = frame.shape[:2]
-    green_screen = np.full((h, w, 3), (0, 177, 64), dtype=np.uint8)  # Professional green screen color
-    return green_screen
-
-def create_professional_background(bg_config, width, height):
-    """Create professional background based on configuration"""
-    try:
-        if bg_config["type"] == "color":
-            # Solid color background
-            color_hex = bg_config["colors"][0].lstrip('#')
-            color_rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
-            color_bgr = color_rgb[::-1]  # Convert RGB to BGR
-            background = np.full((height, width, 3), color_bgr, dtype=np.uint8)
-            
-        elif bg_config["type"] == "gradient":
-            background = create_gradient_background(bg_config, width, height)
-        
-        else:
-            # Fallback to solid color
-            background = np.full((height, width, 3), (128, 128, 128), dtype=np.uint8)
-        
-        return background
-        
-    except Exception as e:
-        logger.error(f"Background creation error: {e}")
-        # Return neutral gray background as fallback
-        return np.full((height, width, 3), (128, 128, 128), dtype=np.uint8)
-
-def create_gradient_background(bg_config, width, height):
-    """Create high-quality gradient backgrounds with comprehensive direction support"""
-    try:
-        colors = bg_config["colors"]
-        direction = bg_config.get("direction", "vertical")
-        
-        # Convert hex colors to RGB
-        rgb_colors = []
-        for color_hex in colors:
-            color_hex = color_hex.lstrip('#')
-            try:
-                rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
-                rgb_colors.append(rgb)
-            except ValueError:
-                # Fallback for invalid color
-                rgb_colors.append((128, 128, 128))
-        
-        if not rgb_colors:
-            rgb_colors = [(128, 128, 128)]  # Fallback color
-        
-        # Create PIL image for high-quality gradients
-        pil_img = Image.new('RGB', (width, height))
-        draw = ImageDraw.Draw(pil_img)
-        
-        # Helper function for color interpolation
-        def interpolate_color(colors, progress):
-            if len(colors) == 1:
-                return colors[0]
-            elif len(colors) == 2:
-                r = int(colors[0][0] + (colors[1][0] - colors[0][0]) * progress)
-                g = int(colors[0][1] + (colors[1][1] - colors[0][1]) * progress)
-                b = int(colors[0][2] + (colors[1][2] - colors[0][2]) * progress)
-                return (r, g, b)
-            else:
-                # Multi-color gradient
-                segment = progress * (len(colors) - 1)
-                idx = int(segment)
-                local_progress = segment - idx
-                
-                if idx >= len(colors) - 1:
-                    return colors[-1]
-                else:
-                    c1, c2 = colors[idx], colors[idx + 1]
-                    r = int(c1[0] + (c2[0] - c1[0]) * local_progress)
-                    g = int(c1[1] + (c2[1] - c1[1]) * local_progress)
-                    b = int(c1[2] + (c2[2] - c1[2]) * local_progress)
-                    return (r, g, b)
-        
-        if direction == "vertical":
-            # Vertical gradient - optimized line drawing
-            for y in range(height):
-                progress = y / height if height > 0 else 0
-                color = interpolate_color(rgb_colors, progress)
-                draw.line([(0, y), (width, y)], fill=color)
-        
-        elif direction == "horizontal":
-            # Horizontal gradient - optimized line drawing
-            for x in range(width):
-                progress = x / width if width > 0 else 0
-                color = interpolate_color(rgb_colors, progress)
-                draw.line([(x, 0), (x, height)], fill=color)
-        
-        elif direction == "diagonal":
-            # Diagonal gradient - optimized pixel setting
-            max_distance = width + height
-            for y in range(height):
-                for x in range(width):
-                    progress = (x + y) / max_distance if max_distance > 0 else 0
-                    progress = min(1.0, progress)
-                    color = interpolate_color(rgb_colors, progress)
-                    pil_img.putpixel((x, y), color)
-        
-        elif direction in ["radial", "soft_radial"]:
-            # Radial gradient - optimized with center calculation
-            center_x, center_y = width // 2, height // 2
-            max_distance = np.sqrt(center_x**2 + center_y**2)
-            
-            for y in range(height):
-                for x in range(width):
-                    distance = np.sqrt((x - center_x)**2 + (y - center_y)**2)
-                    progress = distance / max_distance if max_distance > 0 else 0
-                    progress = min(1.0, progress)
-                    
-                    if direction == "soft_radial":
-                        progress = progress**0.7  # Softer falloff
-                    
-                    color = interpolate_color(rgb_colors, progress)
-                    pil_img.putpixel((x, y), color)
-        
-        else:
-            # Default to vertical gradient for unknown directions
-            for y in range(height):
-                progress = y / height if height > 0 else 0
-                color = interpolate_color(rgb_colors, progress)
-                draw.line([(0, y), (width, y)], fill=color)
-        
-        # Convert PIL to OpenCV format (RGB to BGR)
-        background = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
-        return background
-        
-    except Exception as e:
-        logger.error(f"Gradient creation error: {e}")
-        # Return simple gradient fallback
-        background = np.zeros((height, width, 3), dtype=np.uint8)
-        for y in range(height):
-            intensity = int(255 * (y / height)) if height > 0 else 128
-            background[y, :] = [intensity, intensity, intensity]
-        return background
-
-def replace_background_hq(frame, mask, background):
-    """High-quality background replacement with advanced compositing"""
-    try:
-        # Resize background to match frame exactly with high-quality interpolation
-        background = cv2.resize(background, (frame.shape[1], frame.shape[0]), 
-                              interpolation=cv2.INTER_LANCZOS4)
-        
-        # Ensure mask is single channel
-        if len(mask.shape) == 3:
-            mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-        
-        # Convert mask to float and normalize
-        mask_float = mask.astype(np.float32) / 255.0
-        
-        # Apply edge feathering for smooth transitions
-        feather_radius = 3
-        kernel_size = feather_radius * 2 + 1
-        mask_feathered = cv2.GaussianBlur(mask_float, (kernel_size, kernel_size), feather_radius/3)
-        
-        # Create 3-channel mask
-        mask_3channel = np.stack([mask_feathered] * 3, axis=2)
-        
-        # High-quality compositing with gamma correction for realistic lighting
-        frame_linear = np.power(frame.astype(np.float32) / 255.0, 2.2)
-        background_linear = np.power(background.astype(np.float32) / 255.0, 2.2)
-        
-        # Composite in linear color space for accurate blending
-        result_linear = frame_linear * mask_3channel + background_linear * (1 - mask_3channel)
-        
-        # Convert back to sRGB color space
-        result = np.power(result_linear, 1/2.2) * 255.0
-        result = np.clip(result, 0, 255).astype(np.uint8)
-        
-        return result
-        
-    except Exception as e:
-        logger.error(f"Background replacement error: {e}")
-        # Simple fallback compositing
-        try:
-            if len(mask.shape) == 3:
-                mask = cv2.cvtColor(mask, cv2.COLOR_BGR2GRAY)
-            
-            background = cv2.resize(background, (frame.shape[1], frame.shape[0]))
-            mask_normalized = mask.astype(np.float32) / 255.0
-            mask_3channel = np.stack([mask_normalized] * 3, axis=2)
-            
-            result = frame * mask_3channel + background * (1 - mask_3channel)
-            return result.astype(np.uint8)
-        except:
-            # Ultimate fallback - return original frame
-            return frame
-
 def process_video_hq(video_path, background_choice, custom_background_path, progress=gr.Progress()):
     """TWO-STAGE High-quality video processing: Original → Green Screen → Final Background"""
     if not models_loaded:
@@ -1168,27 +309,6 @@ def process_video_hq(video_path, background_choice, custom_background_path, prog
         logger.error(f"Video processing error: {traceback.format_exc()}")
         return None, error_msg
 
-def get_model_status():
-    """Get current model loading status with detailed information"""
-    if models_loaded:
-        try:
-            gpu_info = ""
-            if torch.cuda.is_available():
-                try:
-                    gpu_name = torch.cuda.get_device_name(0)
-                    gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1e9
-                    gpu_info = f" (GPU: {gpu_name[:20]}{'...' if len(gpu_name) > 20 else ''} - {gpu_memory:.1f}GB)"
-                except:
-                    gpu_info = " (GPU Available)"
-            else:
-                gpu_info = " (CPU Mode)"
-            
-            return f"✅ ENHANCED high-quality models loaded{gpu_info}"
-        except:
-            return "✅ ENHANCED high-quality models loaded"
-    else:
-        return "⏳ Models not loaded. Click 'Load Models' for ENHANCED cinema-quality processing."
-
 def create_interface():
     """Create enhanced Gradio interface with comprehensive features and 4-method background system"""
     
@@ -1366,4 +486,230 @@ def switch_background_method(method):
                         padding: 12px 8px; 
                         border: 1px solid #ddd; 
                         border-radius: 6px; 
-                        text-align: center;
+                        text-align: center; 
+                        background: {gradient};
+                        min-height: 60px;
+                        display: flex;
+                        align-items: center;
+                        justify-content: center;
+                    '>
+                        <div>
+                            <strong style='color: white; text-shadow: 1px 1px 2px rgba(0,0,0,0.8); font-size: 12px; display: block;'>{config["name"]}</strong>
+                            <small style='color: rgba(255,255,255,0.9); text-shadow: 1px 1px 1px rgba(0,0,0,0.6); font-size: 10px;'>{config.get("description", "")[:30]}...</small>
+                        </div>
+                    </div>
+                    """
+                
+                bg_preview_html += "</div>"
+                gr.HTML(bg_preview_html)
+        
+        # AI Background Generation Function
+        def generate_ai_background(prompt, style):
+            """Generate AI background using procedural methods"""
+            if not prompt or not prompt.strip():
+                return None, "❌ Please enter a prompt"
+            
+            try:
+                # Create procedural background based on prompt
+                bg_image = create_procedural_background(prompt, style, 1920, 1080)
+                
+                if bg_image is not None:
+                    # Save generated image
+                    import tempfile
+                    with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
+                        cv2.imwrite(tmp.name, bg_image)
+                        return tmp.name, f"✅ Background generated: {prompt[:50]}..."
+                else:
+                    return None, "❌ Generation failed, try different prompt"
+            except Exception as e:
+                logger.error(f"AI generation error: {e}")
+                return None, f"❌ Generation error: {str(e)}"
+        
+        # Enhanced video processing function that handles all 4 methods
+        def process_video_enhanced(video_path, bg_method, custom_img, prof_choice, grad_type, 
+                                 color1, color2, color3, use_third, ai_prompt, ai_style, ai_img, 
+                                 progress=gr.Progress()):
+            """Process video with any of the 4 background methods using TWO-STAGE approach"""
+            
+            if not models_loaded:
+                return None, "❌ Models not loaded. Click 'Load Models' first."
+            
+            if not video_path:
+                return None, "❌ No video file provided."
+            
+            try:
+                progress(0, desc="🎬 Preparing background...")
+                
+                # Determine which background to use based on method
+                if bg_method == "upload":
+                    if custom_img and os.path.exists(custom_img):
+                        return process_video_hq(video_path, "custom", custom_img, progress)
+                    else:
+                        return None, "❌ No image uploaded. Please upload a background image."
+                
+                elif bg_method == "professional":
+                    if prof_choice and prof_choice in PROFESSIONAL_BACKGROUNDS:
+                        return process_video_hq(video_path, prof_choice, None, progress)
+                    else:
+                        return None, f"❌ Invalid professional background: {prof_choice}"
+                
+                elif bg_method == "colors":
+                    # Create custom gradient as temporary image
+                    try:
+                        colors = [color1 or "#3498db", color2 or "#2ecc71"]
+                        if use_third and color3:
+                            colors.append(color3)
+                        
+                        bg_config = {
+                            "type": "gradient" if grad_type != "solid" else "color",
+                            "colors": colors,
+                            "direction": grad_type if grad_type != "solid" else "vertical"
+                        }
+                        
+                        if grad_type == "solid":
+                            bg_config["colors"] = [colors[0]]
+                        
+                        # Create temporary image for gradient
+                        gradient_bg = create_professional_background(bg_config, 1920, 1080)
+                        temp_path = f"/tmp/gradient_{int(time.time())}.png"
+                        cv2.imwrite(temp_path, gradient_bg)
+                        
+                        return process_video_hq(video_path, "custom", temp_path, progress)
+                    except Exception as e:
+                        return None, f"❌ Error creating gradient: {str(e)}"
+                
+                elif bg_method == "ai":
+                    if ai_img and os.path.exists(ai_img):
+                        return process_video_hq(video_path, "custom", ai_img, progress)
+                    else:
+                        return None, "❌ No AI background generated. Click 'Generate Background' first."
+                
+                else:
+                    return None, f"❌ Unknown background method: {bg_method}"
+                
+            except Exception as e:
+                logger.error(f"Enhanced processing error: {e}")
+                return None, f"❌ Processing error: {str(e)}"
+        
+        # Connect all the functions
+        load_models_btn.click(
+            fn=download_and_setup_models,
+            outputs=status_text
+        )
+        
+        generate_ai_btn.click(
+            fn=generate_ai_background,
+            inputs=[ai_prompt, ai_style],
+            outputs=[ai_generated_image, status_text]
+        )
+        
+        process_btn.click(
+            fn=process_video_enhanced,
+            inputs=[
+                video_input,           # video_path
+                background_method,     # bg_method  
+                custom_background,     # custom_img
+                professional_choice,   # prof_choice
+                gradient_type,         # grad_type
+                color1, color2, color3, use_third_color,  # colors
+                ai_prompt, ai_style, ai_generated_image   # AI
+            ],
+            outputs=[video_output, result_text]
+        )
+        
+        # Comprehensive info section
+        with gr.Accordion("ℹ️ ENHANCED Quality & Features", open=False):
+            gr.Markdown("""
+            ### 🏆 TWO-STAGE Cinema-Quality Features:
+            
+            **🎬 Two-Stage Processing:**
+            - **Stage 1**: Original Video → Green Screen Video (SAM2 + MatAnyone segmentation)
+            - **Stage 2**: Green Screen Video → Final Background (Professional chroma key replacement)
+            - **Why Two-Stage?**: Better edge quality, cleaner separation, professional results
+            
+            **🤖 Advanced AI Models:**
+            - **SAM2**: State-of-the-art segmentation (Large/Tiny auto-selection)
+            - **MatAnyone**: CVPR 2025 professional matting technology
+            - **Multi-Fallback Loading**: 4+ methods each for maximum reliability
+            - **OpenCV Fallbacks**: Enhanced backup systems for compatibility
+            
+            **🎨 4 Background Methods:**
+            - **A) Upload Image**: Use any custom image as background
+            - **B) Professional Presets**: 15+ high-quality professional backgrounds
+            - **C) Colors/Gradients**: Custom color combinations with 6 gradient types
+            - **D) AI Generated**: Procedural backgrounds from text prompts
+            
+            **🎬 Professional Quality:**
+            - **✨ Edge Feathering**: Smooth, natural transitions
+            - **🎬 Gamma Correction**: Professional color compositing
+            - **🔍 Multi-Point Segmentation**: 7-point strategic person detection
+            - **🧹 Morphological Processing**: Advanced mask cleanup
+            - **🟢 Green Screen Intermediate**: Professional chroma key workflow
+            
+            **🎵 Audio & Video:**
+            - **High-Quality Audio**: 192kbps AAC preservation
+            - **📺 H.264 Codec**: CRF 18 for broadcast quality
+            - **🎞️ Frame Processing**: Advanced error handling
+            - **💾 Smart Caching**: Optimized memory management
+            
+            ### 💡 Usage Tips:
+            - Upload videos in common formats (MP4, MOV, AVI)
+            - For best results, ensure good lighting in original video
+            - Custom backgrounds work best with high resolution images
+            - AI prompts: Try "modern office", "sunset mountain", "abstract tech"
+            - GPU processing is faster but CPU fallback always available
+            - Two-stage processing gives cinema-quality results
+            """)
+        
+        # Footer
+        gr.Markdown("---")
+        gr.Markdown(
+            "*🎬 Cinema-Quality Video Background Replacement - "
+            "Enhanced with TWO-STAGE processing and 4-method background system*"
+        )
+    
+    return demo
+
+def main():
+    """Main application entry point"""
+    try:
+        print("🎬 Cinema-Quality Video Background Replacement")
+        print("=" * 50)
+        
+        # Initialize application
+        os.makedirs("/tmp/MyAvatar/My_Videos/", exist_ok=True)
+        os.makedirs(os.path.expanduser("~/.cache/sam2"), exist_ok=True)
+        
+        print("🚀 Features:")
+        print("  • SAM2 + MatAnyone AI models")
+        print("  • TWO-STAGE processing (Original → Green Screen → Final)")
+        print("  • 4 background methods (Upload/Professional/Colors/AI)")
+        print("  • Multi-fallback loading system")
+        print("  • Cinema-quality processing")
+        print("  • Enhanced stability & error handling")
+        print("=" * 50)
+        
+        # Create and launch interface
+        logger.info("🌐 Creating Gradio interface...")
+        demo = create_interface()
+        
+        logger.info("🚀 Launching application...")
+        
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=True,
+            show_error=True
+        )
+        
+    except KeyboardInterrupt:
+        logger.info("🛑 Application stopped by user")
+        print("\n🛑 Application stopped by user")
+    except Exception as e:
+        logger.error(f"❌ Application failed to start: {e}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        print(f"❌ Application failed to start: {e}")
+        print("Check logs for detailed error information.")
+
+if __name__ == "__main__":
+    main()