Create utilities.py

utilities.py

@@ -0,0 +1,1276 @@
+#!/usr/bin/env python3
+"""
+utilities.py - Helper functions and utilities for Video Background Replacement
+Contains all the utility functions, model loading, and background creation functions
+"""
+
+import os
+import sys
+import tempfile
+import cv2
+import numpy as np
+from pathlib import Path
+import torch
+import requests
+from PIL import Image, ImageDraw, ImageFilter, ImageEnhance
+import json
+import traceback
+import time
+import shutil
+import gc
+import threading
+import queue
+from typing import Optional, Tuple, Dict, Any
+import logging
+
+# Fix OpenMP threads issue - remove problematic environment variable
+try:
+    if 'OMP_NUM_THREADS' in os.environ:
+        del os.environ['OMP_NUM_THREADS']
+except:
+    pass
+
+# Suppress warnings and optimize for quality
+import warnings
+warnings.filterwarnings("ignore")
+os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:1024'
+os.environ['CUDA_LAUNCH_BLOCKING'] = '0'
+
+# Setup logging for debugging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global variables for models (lazy loading)
+sam2_predictor = None
+matanyone_model = None
+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 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_procedural_background(prompt, style, width, height):
+    """Create procedural background based on text prompt and style"""
+    try:
+        # Analyze prompt for colors and patterns
+        prompt_lower = prompt.lower()
+        
+        # Color mapping based on prompt keywords
+        color_map = {
+            'blue': ['#1e3c72', '#2a5298', '#3498db'],
+            'ocean': ['#74b9ff', '#0984e3', '#00cec9'], 
+            'sky': ['#87CEEB', '#4682B4', '#1E90FF'],
+            'green': ['#27ae60', '#2ecc71', '#58d68d'],
+            'nature': ['#2d5016', '#3c6e1f', '#4caf50'],
+            'forest': ['#1B4332', '#2D5A36', '#40916C'],
+            'red': ['#e74c3c', '#c0392b', '#ff7675'],
+            'sunset': ['#ff7675', '#fd79a8', '#fdcb6e'],
+            'orange': ['#e67e22', '#f39c12', '#ff9f43'],
+            'purple': ['#6c5ce7', '#a29bfe', '#fd79a8'],
+            'pink': ['#fd79a8', '#fdcb6e', '#ff7675'],
+            'yellow': ['#f1c40f', '#f39c12', '#fdcb6e'],
+            'tech': ['#2c3e50', '#34495e', '#74b9ff'],
+            'space': ['#0c0c0c', '#2d3748', '#4a5568'],
+            'dark': ['#1a1a1a', '#2d2d2d', '#404040'],
+            'office': ['#f8f9fa', '#e9ecef', '#74b9ff'],
+            'corporate': ['#2c3e50', '#34495e', '#74b9ff'],
+            'warm': ['#ff7675', '#fd79a8', '#fdcb6e'],
+            'cool': ['#74b9ff', '#0984e3', '#00cec9'],
+            'minimal': ['#ffffff', '#f1f2f6', '#ddd'],
+            'abstract': ['#6c5ce7', '#a29bfe', '#fd79a8']
+        }
+        
+        # Find matching colors
+        selected_colors = ['#3498db', '#2ecc71', '#e74c3c']  # Default
+        for keyword, colors in color_map.items():
+            if keyword in prompt_lower:
+                selected_colors = colors
+                break
+        
+        # Create background based on style
+        if style == "abstract":
+            return create_abstract_background(selected_colors, width, height)
+        elif style == "minimalist":
+            return create_minimalist_background(selected_colors, width, height)
+        elif style == "corporate":
+            return create_corporate_background(selected_colors, width, height)
+        elif style == "nature":
+            return create_nature_background(selected_colors, width, height)
+        elif style == "artistic":
+            return create_artistic_background(selected_colors, width, height)
+        else:
+            # Default: photorealistic gradient
+            bg_config = {
+                "type": "gradient",
+                "colors": selected_colors[:2],
+                "direction": "diagonal"
+            }
+            return create_gradient_background(bg_config, width, height)
+    
+    except Exception as e:
+        logger.error(f"Procedural background creation failed: {e}")
+        return None
+
+def create_abstract_background(colors, width, height):
+    """Create abstract geometric background"""
+    try:
+        background = np.zeros((height, width, 3), dtype=np.uint8)
+        
+        # Convert hex colors to BGR
+        bgr_colors = []
+        for color in colors:
+            hex_color = color.lstrip('#')
+            rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+            bgr = rgb[::-1]
+            bgr_colors.append(bgr)
+        
+        # Base gradient
+        for y in range(height):
+            progress = y / height
+            color = [
+                int(bgr_colors[0][i] + (bgr_colors[1][i] - bgr_colors[0][i]) * progress)
+                for i in range(3)
+            ]
+            background[y, :] = color
+        
+        # Add geometric shapes
+        import random
+        random.seed(42)  # Reproducible
+        
+        for _ in range(8):
+            center_x = random.randint(width//4, 3*width//4)
+            center_y = random.randint(height//4, 3*height//4)
+            radius = random.randint(width//20, width//8)
+            color = bgr_colors[random.randint(0, len(bgr_colors)-1)]
+            
+            overlay = background.copy()
+            cv2.circle(overlay, (center_x, center_y), radius, color, -1)
+            cv2.addWeighted(background, 0.7, overlay, 0.3, 0, background)
+        
+        return background
+    
+    except Exception as e:
+        logger.error(f"Abstract background creation failed: {e}")
+        return None
+
+def create_minimalist_background(colors, width, height):
+    """Create minimalist background"""
+    try:
+        bg_config = {
+            "type": "gradient",
+            "colors": colors[:2],
+            "direction": "soft_radial"
+        }
+        background = create_gradient_background(bg_config, width, height)
+        
+        # Add subtle element
+        overlay = background.copy()
+        center_x, center_y = width//2, height//2
+        
+        hex_color = colors[0].lstrip('#')
+        rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+        bgr = rgb[::-1]
+        
+        cv2.circle(overlay, (center_x, center_y), min(width, height)//3, bgr, -1)
+        cv2.addWeighted(background, 0.95, overlay, 0.05, 0, background)
+        
+        return background
+    
+    except Exception as e:
+        logger.error(f"Minimalist background creation failed: {e}")
+        return None
+
+def create_corporate_background(colors, width, height):
+    """Create corporate background"""
+    try:
+        bg_config = {
+            "type": "gradient", 
+            "colors": ['#2c3e50', '#34495e', '#74b9ff'],
+            "direction": "diagonal"
+        }
+        background = create_gradient_background(bg_config, width, height)
+        
+        # Add subtle grid
+        grid_color = (80, 80, 80)
+        grid_spacing = width // 20
+        
+        for x in range(0, width, grid_spacing):
+            cv2.line(background, (x, 0), (x, height), grid_color, 1)
+        
+        for y in range(0, height, grid_spacing):
+            cv2.line(background, (0, y), (width, y), grid_color, 1)
+        
+        background = cv2.GaussianBlur(background, (3, 3), 1.0)
+        return background
+    
+    except Exception as e:
+        logger.error(f"Corporate background creation failed: {e}")
+        return None
+
+def create_nature_background(colors, width, height):
+    """Create nature background"""
+    try:
+        bg_config = {
+            "type": "gradient",
+            "colors": ['#2d5016', '#3c6e1f', '#4caf50'],
+            "direction": "vertical"
+        }
+        background = create_gradient_background(bg_config, width, height)
+        
+        # Add organic shapes
+        import random
+        random.seed(42)
+        
+        overlay = background.copy()
+        
+        for _ in range(5):
+            center_x = random.randint(width//6, 5*width//6)
+            center_y = random.randint(height//6, 5*height//6)
+            
+            axes_x = random.randint(width//20, width//6)
+            axes_y = random.randint(height//20, height//6)
+            angle = random.randint(0, 180)
+            
+            color = (random.randint(40, 80), random.randint(120, 160), random.randint(30, 70))
+            cv2.ellipse(overlay, (center_x, center_y), (axes_x, axes_y), angle, 0, 360, color, -1)
+        
+        cv2.addWeighted(background, 0.8, overlay, 0.2, 0, background)
+        background = cv2.GaussianBlur(background, (5, 5), 2.0)
+        
+        return background
+    
+    except Exception as e:
+        logger.error(f"Nature background creation failed: {e}")
+        return None
+
+def create_artistic_background(colors, width, height):
+    """Create artistic background with creative elements"""
+    try:
+        # Start with base gradient
+        bg_config = {
+            "type": "gradient",
+            "colors": colors,
+            "direction": "diagonal"
+        }
+        background = create_gradient_background(bg_config, width, height)
+        
+        # Add artistic elements
+        import random
+        random.seed(42)
+        
+        # Convert colors to BGR
+        bgr_colors = []
+        for color in colors:
+            hex_color = color.lstrip('#')
+            rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+            bgr_colors.append(rgb[::-1])
+        
+        overlay = background.copy()
+        
+        # Add flowing curves
+        for i in range(3):
+            pts = []
+            for x in range(0, width, width//10):
+                y = int(height//2 + (height//4) * np.sin(2 * np.pi * x / width + i))
+                pts.append([x, y])
+            
+            pts = np.array(pts, np.int32)
+            color = bgr_colors[i % len(bgr_colors)]
+            cv2.polylines(overlay, [pts], False, color, thickness=width//50)
+        
+        # Blend with base
+        cv2.addWeighted(background, 0.7, overlay, 0.3, 0, background)
+        
+        # Add texture
+        background = cv2.GaussianBlur(background, (3, 3), 1.0)
+        
+        return background
+    
+    except Exception as e:
+        logger.error(f"Artistic background creation failed: {e}")
+        return None
+
+# Utility functions for validation and cleanup
+def validate_video_file(video_path):
+    """Validate video file format and basic properties"""
+    if not video_path or not os.path.exists(video_path):
+        return False, "Video file not found"
+    
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            return False, "Cannot open video file"
+        
+        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        if frame_count == 0:
+            return False, "Video appears to be empty"
+        
+        cap.release()
+        return True, "Video file valid"
+    except Exception as e:
+        return False, f"Error validating video: {str(e)}"
+
+def cleanup_temp_files():
+    """Clean up temporary files to free disk space"""
+    try:
+        temp_patterns = [
+            "/tmp/processed_video_*.mp4",
+            "/tmp/final_output_*.mp4",
+            "/tmp/greenscreen_*.mp4",
+            "/tmp/gradient_*.png",
+            "/tmp/*.pt",  # Model checkpoints
+        ]
+        
+        import glob
+        for pattern in temp_patterns:
+            for file_path in glob.glob(pattern):
+                try:
+                    if os.path.exists(file_path):
+                        # Only delete files older than 1 hour
+                        if time.time() - os.path.getmtime(file_path) > 3600:
+                            os.remove(file_path)
+                            logger.info(f"Cleaned up: {file_path}")
+                except Exception as e:
+                    logger.warning(f"Could not clean up {file_path}: {e}")
+    except Exception as e:
+        logger.warning(f"Cleanup error: {e}")
+
+def get_available_backgrounds():
+    """Get list of available professional backgrounds"""
+    return {key: config["name"] for key, config in PROFESSIONAL_BACKGROUNDS.items()}
+
+def create_custom_gradient(colors, direction="vertical", width=1920, height=1080):
+    """
+    Create a custom gradient background
+    
+    Args:
+        colors: List of hex colors (e.g., ["#ff0000", "#00ff00"])
+        direction: "vertical", "horizontal", "diagonal", "radial"
+        width, height: Dimensions
+    
+    Returns:
+        numpy array of the generated background
+    """
+    try:
+        bg_config = {
+            "type": "gradient",
+            "colors": colors,
+            "direction": direction
+        }
+        return create_gradient_background(bg_config, width, height)
+    except Exception as e:
+        logger.error(f"Error creating custom gradient: {e}")
+        return None
+
+def create_directories():
+    """Create necessary directories for the application"""
+    try:
+        directories = [
+            "/tmp/MyAvatar",
+            "/tmp/MyAvatar/My_Videos",
+            os.path.expanduser("~/.cache/sam2"),
+        ]
+        
+        for directory in directories:
+            os.makedirs(directory, exist_ok=True)
+            logger.info(f"📁 Created/verified directory: {directory}")
+        
+        return True
+    except Exception as e:
+        logger.error(f"Error creating directories: {e}")
+        return False
+
+def optimize_memory_usage():
+    """Optimize memory usage by cleaning up unused resources"""
+    try:
+        # Clear PyTorch cache
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        # Run garbage collector
+        gc.collect()
+        
+        # Clear OpenCV cache
+        cv2.ocl.setUseOpenCL(False)
+        
+        return True
+    except Exception as e:
+        logger.warning(f"Memory optimization failed: {e}")
+        return False