Update app.py

app.py

@@ -26,6 +26,9 @@
 from typing import Optional, Tuple, Dict, Any
 import logging
 
+# Import utility functions
+from utils import *
+
 # Fix OpenMP threads issue - remove problematic environment variable
 try:
     if 'OMP_NUM_THREADS' in os.environ:
@@ -737,6 +740,7 @@ def refine_mask_hq(image, mask):
         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]
@@ -1185,261 +1189,6 @@ def get_model_status():
     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
-
-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
-
 def create_interface():
     """Create enhanced Gradio interface with comprehensive features and 4-method background system"""
     
@@ -1617,1474 +1366,4 @@ def switch_background_method(method):
                         padding: 12px 8px; 
                         border: 1px solid #ddd; 
                         border-radius: 6px; 
-                        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 create_advanced_procedural_background(prompt, style, width, height):
-    """Create advanced procedural background with more sophisticated algorithms"""
-    try:
-        # This is an enhanced version of procedural generation
-        base_bg = create_procedural_background(prompt, style, width, height)
-        
-        if base_bg is None:
-            return None
-        
-        # Add noise texture for realism
-        noise = np.random.normal(0, 10, (height, width, 3)).astype(np.int16)
-        enhanced_bg = base_bg.astype(np.int16) + noise
-        enhanced_bg = np.clip(enhanced_bg, 0, 255).astype(np.uint8)
-        
-        # Slight blur for smoothness
-        enhanced_bg = cv2.GaussianBlur(enhanced_bg, (3, 3), 1.0)
-        
-        return enhanced_bg
-    
-    except Exception as e:
-        logger.error(f"Advanced procedural background creation failed: {e}")
-        return create_procedural_background(prompt, style, width, height)
-
-def generate_textured_background(primary_color, texture_type="noise", width=1920, height=1080):
-    """Generate textured background with different patterns"""
-    try:
-        # Convert hex color to BGR
-        if primary_color.startswith('#'):
-            color_hex = primary_color.lstrip('#')
-            color_rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
-            color_bgr = color_rgb[::-1]
-        else:
-            # Default color if invalid
-            color_bgr = (64, 64, 128)
-        
-        # Create base background
-        background = np.full((height, width, 3), color_bgr, dtype=np.uint8)
-        
-        # Apply texture based on type
-        if texture_type == "noise":
-            # Apply random noise
-            noise = np.random.randint(0, 40, (height, width, 3), dtype=np.int16)
-            noise -= 20  # Center around zero to both add and subtract
-            textured = background.astype(np.int16) + noise
-            textured = np.clip(textured, 0, 255).astype(np.uint8)
-            background = textured
-            
-        elif texture_type == "dots":
-            # Create dot pattern
-            overlay = background.copy()
-            dot_color = tuple(min(255, c + 30) for c in color_bgr)
-            
-            for y in range(0, height, 20):
-                for x in range(0, width, 20):
-                    cv2.circle(overlay, (x, y), 3, dot_color, -1)
-            
-            cv2.addWeighted(background, 0.8, overlay, 0.2, 0, background)
-            
-        elif texture_type == "lines":
-            # Create line pattern
-            overlay = background.copy()
-            line_color = tuple(max(0, c - 30) for c in color_bgr)
-            
-            for y in range(0, height, 15):
-                cv2.line(overlay, (0, y), (width, y), line_color, 1)
-            
-            cv2.addWeighted(background, 0.9, overlay, 0.1, 0, background)
-            
-        elif texture_type == "fabric":
-            # Create fabric-like texture
-            texture = np.zeros((height, width, 3), dtype=np.uint8)
-            
-            # Create weave pattern
-            for y in range(height):
-                for x in range(width):
-                    # Weave pattern
-                    pattern_val = (np.sin(x/5) * 10 + np.sin(y/5) * 10)
-                    pattern_val = int(pattern_val) % 20
-                    
-                    # Adjust color based on pattern
-                    adjusted_color = tuple(
-                        max(0, min(255, c + pattern_val - 10)) for c in color_bgr
-                    )
-                    texture[y, x] = adjusted_color
-            
-            # Blend with base
-            cv2.addWeighted(background, 0.7, texture, 0.3, 0, background)
-            
-        # Apply final blur for smoothness
-        background = cv2.GaussianBlur(background, (3, 3), 0.5)
-        
-        return background
-        
-    except Exception as e:
-        logger.error(f"Textured background generation failed: {e}")
-        # Return simple colored background as fallback
-        return np.full((height, width, 3), (64, 64, 128), dtype=np.uint8)
-
-def create_pattern_background(pattern_type, colors, width=1920, height=1080):
-    """Create background with specific patterns"""
-    try:
-        if not colors or len(colors) == 0:
-            colors = ["#3498db", "#2ecc71"]
-        
-        # Convert hex colors to BGR
-        bgr_colors = []
-        for color in colors:
-            if color.startswith('#'):
-                hex_color = color.lstrip('#')
-                rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
-                bgr_colors.append(rgb[::-1])
-            else:
-                bgr_colors.append((64, 64, 128))  # Default fallback
-        
-        # Initialize background
-        background = np.zeros((height, width, 3), dtype=np.uint8)
-        
-        if pattern_type == "stripes":
-            # Create striped background
-            stripe_width = height // len(bgr_colors)
-            if stripe_width == 0:
-                stripe_width = 1
-            
-            for i, color in enumerate(bgr_colors):
-                start_y = i * stripe_width
-                end_y = min(start_y + stripe_width, height)
-                background[start_y:end_y, :] = color
-        
-        elif pattern_type == "checkered":
-            # Create checkered background
-            cell_size = min(width, height) // 10
-            for y in range(0, height, cell_size):
-                for x in range(0, width, cell_size):
-                    color_idx = ((y // cell_size) + (x // cell_size)) % len(bgr_colors)
-                    y_end = min(y + cell_size, height)
-                    x_end = min(x + cell_size, width)
-                    background[y:y_end, x:x_end] = bgr_colors[color_idx]
-        
-        elif pattern_type == "radial":
-            # Create radial pattern
-            center_x, center_y = width // 2, height // 2
-            max_dist = np.sqrt(center_x**2 + center_y**2)
-            
-            for y in range(height):
-                for x in range(width):
-                    dist = np.sqrt((x - center_x)**2 + (y - center_y)**2)
-                    color_idx = int((dist / max_dist) * len(bgr_colors)) % len(bgr_colors)
-                    background[y, x] = bgr_colors[color_idx]
-        
-        elif pattern_type == "waves":
-            # Create wave pattern
-            for y in range(height):
-                for x in range(width):
-                    wave_value = np.sin(x/30) + np.sin(y/30)
-                    color_idx = int((wave_value + 2) / 4 * len(bgr_colors)) % len(bgr_colors)
-                    background[y, x] = bgr_colors[color_idx]
-        
-        else:  # Default to gradient
-            # Create simple gradient
-            for y in range(height):
-                progress = y / height
-                for x in range(width):
-                    if len(bgr_colors) >= 2:
-                        r = int(bgr_colors[0][0] + progress * (bgr_colors[1][0] - bgr_colors[0][0]))
-                        g = int(bgr_colors[0][1] + progress * (bgr_colors[1][1] - bgr_colors[0][1]))
-                        b = int(bgr_colors[0][2] + progress * (bgr_colors[1][2] - bgr_colors[0][2]))
-                        background[y, x] = (r, g, b)
-                    else:
-                        background[y, x] = bgr_colors[0]
-        
-        # Apply slight blur for smoothness
-        background = cv2.GaussianBlur(background, (3, 3), 0.5)
-        
-        return background
-        
-    except Exception as e:
-        logger.error(f"Pattern background creation failed: {e}")
-        # Return simple fallback
-        return np.zeros((height, width, 3), dtype=np.uint8)
-
-def create_dynamic_background(base_color, intensity=0.5, width=1920, height=1080):
-    """Create dynamic-looking background with motion-like elements"""
-    try:
-        # Convert hex color to BGR
-        if base_color.startswith('#'):
-            color_hex = base_color.lstrip('#')
-            color_rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
-            base_bgr = color_rgb[::-1]
-        else:
-            # Default color if invalid
-            base_bgr = (64, 64, 128)
-        
-        # Create base background
-        background = np.full((height, width, 3), base_bgr, dtype=np.uint8)
-        
-        # Create dynamic elements
-        overlay = np.zeros_like(background)
-        
-        # Scale intensity
-        intensity = max(0.1, min(1.0, intensity))
-        
-        # Create motion streaks
-        import random
-        random.seed(42)  # For reproducibility
-        
-        for _ in range(int(50 * intensity)):
-            start_x = random.randint(0, width)
-            start_y = random.randint(0, height)
-            end_x = start_x + random.randint(-width//3, width//3)
-            end_y = start_y + random.randint(-height//3, height//3)
-            
-            # Randomize color slightly
-            color_variation = random.randint(-20, 20)
-            streak_color = tuple(
-                max(0, min(255, c + color_variation)) for c in base_bgr
-            )
-            
-            # Draw streak
-            cv2.line(overlay, (start_x, start_y), (end_x, end_y), 
-                     streak_color, thickness=random.randint(1, 5))
-        
-        # Add some glow effect
-        overlay_blurred = cv2.GaussianBlur(overlay, (21, 21), 11.0)
-        
-        # Blend with base
-        alpha = 0.7 * intensity
-        cv2.addWeighted(background, 1.0-alpha, overlay_blurred, alpha, 0, background)
-        
-        # Add subtle texture
-        texture = np.random.randint(0, 15, (height, width, 3), dtype=np.int16)
-        texture -= 7  # Center around zero
-        textured = background.astype(np.int16) + texture
-        background = np.clip(textured, 0, 255).astype(np.uint8)
-        
-        return background
-        
-    except Exception as e:
-        logger.error(f"Dynamic background creation failed: {e}")
-        # Return simple colored background as fallback
-        return np.full((height, width, 3), (64, 64, 128), dtype=np.uint8)
-
-def create_themed_background(theme, width=1920, height=1080):
-    """Create themed background based on specific categories"""
-    try:
-        theme_lower = theme.lower()
-        
-        # Business/Professional themes
-        if theme_lower in ["business", "professional", "corporate", "office"]:
-            colors = ["#2c3e50", "#34495e", "#3498db"]
-            bg_config = {
-                "type": "gradient",
-                "colors": colors,
-                "direction": "diagonal"
-            }
-            background = create_gradient_background(bg_config, width, height)
-            
-            # Add subtle grid for professional look
-            overlay = background.copy()
-            grid_color = tuple(max(0, c - 30) for c in (41, 128, 185))  # Darker blue
-            
-            grid_spacing = width // 40
-            for x in range(0, width, grid_spacing):
-                cv2.line(overlay, (x, 0), (x, height), grid_color, 1)
-            
-            for y in range(0, height, grid_spacing):
-                cv2.line(overlay, (0, y), (width, y), grid_color, 1)
-            
-            cv2.addWeighted(background, 0.9, overlay, 0.1, 0, background)
-            
-        # Creative/Artistic themes
-        elif theme_lower in ["creative", "artistic", "design", "art"]:
-            colors = ["#8e44ad", "#9b59b6", "#e74c3c", "#f1c40f"]
-            
-            # Create colorful base
-            background = np.zeros((height, width, 3), dtype=np.uint8)
-            
-            # 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])
-            
-            # Add colorful elements
-            import random
-            random.seed(42)
-            
-            for _ in range(15):
-                center_x = random.randint(width//10, width-width//10)
-                center_y = random.randint(height//10, height-height//10)
-                radius = random.randint(width//20, width//5)
-                color = bgr_colors[random.randint(0, len(bgr_colors)-1)]
-                
-                cv2.circle(background, (center_x, center_y), radius, color, -1)
-            
-            # Blur for artistic look
-            background = cv2.GaussianBlur(background, (51, 51), 25.0)
-            
-        # Nature/Outdoor themes
-        elif theme_lower in ["nature", "outdoor", "forest", "garden"]:
-            colors = ["#27ae60", "#2ecc71", "#1abc9c"]
-            bg_config = {
-                "type": "gradient",
-                "colors": colors,
-                "direction": "vertical"
-            }
-            background = create_gradient_background(bg_config, width, height)
-            
-            # Add natural texture
-            overlay = background.copy()
-            
-            # Create organic shapes
-            import random
-            random.seed(42)
-            
-            for _ in range(10):
-                points = []
-                for i in range(6):
-                    angle = i * (2 * np.pi / 6)
-                    radius = random.randint(width//15, width//8)
-                    x = int(width/2 + radius * np.cos(angle) + random.randint(-width//10, width//10))
-                    y = int(height/2 + radius * np.sin(angle) + random.randint(-height//10, height//10))
-                    points.append([x, y])
-                
-                points = np.array(points, dtype=np.int32)
-                color = (random.randint(30, 60), random.randint(100, 150), random.randint(30, 60))
-                cv2.fillPoly(overlay, [points], color)
-            
-            cv2.addWeighted(background, 0.7, overlay, 0.3, 0, background)
-            
-        # Technology/Digital themes
-        elif theme_lower in ["tech", "digital", "technology", "futuristic"]:
-            colors = ["#0a0a0a", "#1a1a1a", "#2980b9"]
-            bg_config = {
-                "type": "gradient",
-                "colors": colors,
-                "direction": "radial"
-            }
-            background = create_gradient_background(bg_config, width, height)
-            
-            # Add tech elements
-            overlay = background.copy()
-            
-            # Grid lines
-            line_color = (0, 120, 215)  # Blue
-            grid_spacing = width // 30
-            
-            for x in range(0, width, grid_spacing):
-                cv2.line(overlay, (x, 0), (x, height), line_color, 1)
-            
-            for y in range(0, height, grid_spacing):
-                cv2.line(overlay, (0, y), (width, y), line_color, 1)
-            
-            # Digital circuits
-            import random
-            random.seed(42)
-            
-            for _ in range(20):
-                start_x = random.randint(0, width)
-                start_y = random.randint(0, height)
-                
-                # Create circuit path
-                points = [(start_x, start_y)]
-                current_x, current_y = start_x, start_y
-                
-                for _ in range(5):
-                    # Horizontal or vertical movement only
-                    if random.choice([True, False]):
-                        current_x += random.randint(-width//10, width//10)
-                    else:
-                        current_y += random.randint(-height//10, height//10)
-                    
-                    current_x = max(0, min(width-1, current_x))
-                    current_y = max(0, min(height-1, current_y))
-                    points.append((current_x, current_y))
-                
-                # Draw circuit
-                for i in range(len(points)-1):
-                    cv2.line(overlay, points[i], points[i+1], (0, 200, 255), 2)
-            
-            cv2.addWeighted(background, 0.8, overlay, 0.2, 0, background)
-            
-        # Default/Generic theme
-        else:
-            # Create simple gradient background
-            colors = ["#3498db", "#2ecc71", "#e74c3c"]
-            bg_config = {
-                "type": "gradient",
-                "colors": colors[:2],
-                "direction": "diagonal"
-            }
-            background = create_gradient_background(bg_config, width, height)
-        
-        return background
-        
-    except Exception as e:
-        logger.error(f"Themed background creation failed: {e}")
-        # Return simple colored background as fallback
-        return np.full((height, width, 3), (64, 64, 128), dtype=np.uint8)
-
-def enhance_background_quality(background):
-    """Apply post-processing enhancements to improve background quality"""
-    try:
-        if background is None:
-            return None
-        
-        # Convert to float for better precision
-        bg_float = background.astype(np.float32)
-        
-        # Adjust contrast slightly
-        mean_val = np.mean(bg_float)
-        contrast_enhanced = bg_float + (bg_float - mean_val) * 0.2
-        
-        # Ensure valid range
-        contrast_enhanced = np.clip(contrast_enhanced, 0, 255)
-        
-        # Convert to PIL for higher quality enhancements
-        img_pil = Image.fromarray(contrast_enhanced.astype(np.uint8))
-        
-        # Enhance saturation slightly
-        enhancer = ImageEnhance.Color(img_pil)
-        img_pil = enhancer.enhance(1.1)
-        
-        # Enhance sharpness
-        enhancer = ImageEnhance.Sharpness(img_pil)
-        img_pil = enhancer.enhance(1.2)
-        
-        # Convert back to OpenCV format
-        enhanced_bg = np.array(img_pil)
-        
-        # Apply slight noise reduction
-        enhanced_bg = cv2.fastNlMeansDenoisingColored(enhanced_bg, None, 3, 3, 7, 21)
-        
-        return enhanced_bg
-    
-    except Exception as e:
-        logger.error(f"Background enhancement failed: {e}")
-        return background  # Return original if enhancement fails
-
-def add_vignette_effect(image, intensity=0.3):
-    """Add subtle vignette effect to background for professional look"""
-    try:
-        if image is None:
-            return None
-        
-        # Make a copy to avoid modifying original
-        result = image.copy()
-        h, w = result.shape[:2]
-        
-        # Create radial gradient mask
-        center_x, center_y = w // 2, h // 2
-        radius = min(center_x, center_y)
-        
-        mask = np.zeros((h, w), dtype=np.float32)
-        y, x = np.ogrid[:h, :w]
-        mask_squared = (x - center_x)**2 + (y - center_y)**2
-        
-        # Normalize distances
-        mask = mask_squared / (4 * radius**2)
-        mask = np.clip(mask, 0, 1)
-        
-        # Adjust vignette intensity
-        mask = intensity * mask
-        
-        # Apply vignette
-        mask = cv2.merge([mask, mask, mask])
-        result = result * (1 - mask)
-        result = result.astype(np.uint8)
-        
-        return result
-    
-    except Exception as e:
-        logger.error(f"Vignette effect failed: {e}")
-        return image  # Return original if vignette fails
-
-def analyze_video_for_optimal_background(video_path, frame_samples=10):
-    """Analyze video to determine optimal background color and style"""
-    try:
-        if not os.path.exists(video_path):
-            return None, "Video file not found"
-        
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return None, "Cannot open video file"
-        
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        
-        if total_frames == 0:
-            return None, "Video appears to be empty"
-        
-        # Sample frames evenly throughout video
-        frame_indices = [int(i * total_frames / frame_samples) for i in range(frame_samples)]
-        
-        dominant_colors = []
-        brightness_values = []
-        saturation_values = []
-        
-        for frame_idx in frame_indices:
-            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
-            ret, frame = cap.read()
-            
-            if not ret:
-                continue
-            
-            # Convert to HSV for better color analysis
-            hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
-            
-            # Calculate average HSV values
-            avg_h = np.mean(hsv_frame[:, :, 0])
-            avg_s = np.mean(hsv_frame[:, :, 1])
-            avg_v = np.mean(hsv_frame[:, :, 2])
-            
-            brightness_values.append(avg_v)
-            saturation_values.append(avg_s)
-            
-            # Find dominant color (simple approach)
-            small_frame = cv2.resize(frame, (32, 32))
-            pixels = small_frame.reshape(-1, 3)
-            from sklearn.cluster import KMeans
-            kmeans = KMeans(n_clusters=1)
-            kmeans.fit(pixels)
-            dominant_color = kmeans.cluster_centers_[0].astype(int)
-            dominant_colors.append(dominant_color)
-        
-        cap.release()
-        
-        # Average dominant colors across frames
-        if dominant_colors:
-            avg_dominant = np.mean(dominant_colors, axis=0).astype(int)
-            
-            # Convert BGR to hex
-            hex_color = '#{:02x}{:02x}{:02x}'.format(
-                avg_dominant[2], avg_dominant[1], avg_dominant[0]
-            )
-            
-            # Determine complementary color for background
-            r, g, b = avg_dominant[2], avg_dominant[1], avg_dominant[0]
-            complementary = '#{:02x}{:02x}{:02x}'.format(255-r, 255-g, 255-b)
-            
-            avg_brightness = np.mean(brightness_values)
-            avg_saturation = np.mean(saturation_values)
-            
-            # Recommend background based on analysis
-            if avg_brightness > 200:  # Very bright video
-                background_style = "dark"
-                background_colors = ["#1a1a1a", "#2c3e50", "#34495e"]
-            elif avg_brightness < 50:  # Very dark video
-                background_style = "light"
-                background_colors = ["#ecf0f1", "#f5f5f5", "#e0e0e0"]
-            else:
-                # Use complementary color scheme
-                background_style = "complementary"
-                background_colors = [complementary, hex_color]
-            
-            # Recommend gradient direction based on video aspect ratio
-            if frame_width > frame_height:
-                direction = "horizontal"
-            else:
-                direction = "vertical"
-            
-            result = {
-                "dominant_color": hex_color,
-                "complementary_color": complementary,
-                "recommended_style": background_style,
-                "recommended_colors": background_colors,
-                "recommended_direction": direction,
-                "video_brightness": float(avg_brightness),
-                "video_saturation": float(avg_saturation),
-                "video_dimensions": (frame_width, frame_height)
-            }
-            
-            return result, "Analysis successful"
-        
-        return None, "Failed to analyze video colors"
-        
-    except Exception as e:
-        logger.error(f"Video analysis error: {str(e)}")
-        return None, f"Analysis error: {str(e)}"
-def apply_cinematic_color_grading(frame):
-    """Apply professional color grading to video frames"""
-    try:
-        # Convert to float for better precision
-        frame_float = frame.astype(np.float32) / 255.0
-        
-        # Split channels
-        b, g, r = cv2.split(frame_float)
-        
-        # Adjust shadows, midtones and highlights for each channel
-        # Red channel - Enhance reds slightly
-        r = np.power(r, 0.95)  # Raise shadows
-        r = r * 1.05  # Boost overall
-        
-        # Green channel - Natural look
-        g = np.power(g, 1.0)  # Keep natural
-        
-        # Blue channel - Slight coolness in shadows
-        b = np.power(b, 0.98)  # Enhance shadows slightly
-        
-        # Merge channels
-        graded = cv2.merge([b, g, r])
-        
-        # Increase overall contrast slightly
-        contrast = 1.1
-        brightness = 0.0
-        graded = graded * contrast + brightness
-        
-        # Apply slight S-curve for cinematic look
-        graded = 0.5 + (graded - 0.5) * 1.15
-        
-        # Clip values to valid range
-        graded = np.clip(graded, 0.0, 1.0)
-        
-        # Convert back to 8-bit
-        graded_8bit = (graded * 255.0).astype(np.uint8)
-        
-        return graded_8bit
-    
-    except Exception as e:
-        logger.error(f"Color grading error: {e}")
-        return frame
-
-def enhance_video_quality(input_path, output_path, enhance_level=1):
-    """Enhance video quality with professional processing"""
-    try:
-        if not os.path.exists(input_path):
-            return False, "Input video not found"
-        
-        cap = cv2.VideoCapture(input_path)
-        if not cap.isOpened():
-            return False, "Cannot open input video"
-        
-        # Get video properties
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        
-        # Create output video
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-        
-        if not out.isOpened():
-            return False, "Cannot create output video"
-        
-        frame_count = 0
-        
-        # Process frames
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # Progress tracking
-            if frame_count % 100 == 0:
-                logger.info(f"Enhancing: {frame_count}/{total_frames} frames")
-            
-            # Apply enhancements based on level
-            if enhance_level >= 1:
-                # Basic enhancements
-                frame = cv2.bilateralFilter(frame, 5, 50, 50)  # Preserve edges while reducing noise
-            
-            if enhance_level >= 2:
-                # Intermediate enhancements
-                frame = apply_cinematic_color_grading(frame)
-            
-            if enhance_level >= 3:
-                # Advanced enhancements (more processing intensive)
-                hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
-                hsv[:, :, 1] = hsv[:, :, 1] * 1.2  # Increase saturation
-                hsv[:, :, 1] = np.clip(hsv[:, :, 1], 0, 255)
-                frame = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
-                
-                # Sharpen the image
-                kernel = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
-                frame = cv2.filter2D(frame, -1, kernel)
-            
-            # Write enhanced frame
-            out.write(frame)
-            frame_count += 1
-        
-        # Release resources
-        cap.release()
-        out.release()
-        
-        return True, f"Enhanced {frame_count} frames successfully"
-        
-    except Exception as e:
-        logger.error(f"Video enhancement error: {str(e)}")
-        return False, f"Enhancement error: {str(e)}"
-
-def extract_best_frame_for_thumbnail(video_path, output_path=None):
-    """Extract the best frame from video for thumbnail or preview"""
-    try:
-        if not os.path.exists(video_path):
-            return None, "Video file not found"
-        
-        cap = cv2.VideoCapture(video_path)
-        if not cap.isOpened():
-            return None, "Cannot open video file"
-        
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        
-        if total_frames == 0:
-            return None, "Video appears to be empty"
-        
-        # Sample frames every few seconds
-        sample_interval = int(fps * 2)  # Every 2 seconds
-        frame_indices = list(range(0, total_frames, sample_interval))
-        
-        # Limit to a reasonable number of samples
-        if len(frame_indices) > 20:
-            frame_indices = frame_indices[:20]
-        
-        best_frame = None
-        best_score = -1
-        
-        for idx in frame_indices:
-            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
-            ret, frame = cap.read()
-            
-            if not ret:
-                continue
-            
-            # Calculate frame quality score
-            score = calculate_frame_quality(frame)
-            
-            if score > best_score:
-                best_score = score
-                best_frame = frame.copy()
-        
-        cap.release()
-        
-        if best_frame is None:
-            return None, "Could not extract good frame"
-        
-        # Save if output path provided
-        if output_path:
-            cv2.imwrite(output_path, best_frame)
-            return output_path, f"Best frame saved with score {best_score:.2f}"
-        
-        return best_frame, f"Best frame extracted with score {best_score:.2f}"
-        
-    except Exception as e:
-        logger.error(f"Frame extraction error: {str(e)}")
-        return None, f"Extraction error: {str(e)}"
-
-def calculate_frame_quality(frame):
-    """Calculate quality score for a video frame"""
-    try:
-        # Convert to grayscale for some calculations
-        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        
-        # Calculate sharpness using Laplacian
-        laplacian = cv2.Laplacian(gray, cv2.CV_64F)
-        sharpness = np.var(laplacian)
-        
-        # Calculate brightness
-        brightness = np.mean(gray)
-        
-        # Calculate contrast
-        contrast = np.std(gray)
-        
-        # Calculate saturation from original frame
-        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
-        saturation = np.mean(hsv[:, :, 1])
-        
-        # Penalize extreme brightness (too dark or too bright)
-        brightness_score = 1.0 - abs(brightness - 127.5) / 127.5
-        
-        # Combine factors with weights
-        score = (
-            sharpness * 0.4 +  # Sharpness is important
-            brightness_score * 0.2 +  # Moderate brightness
-            contrast * 0.2 +  # Good contrast
-            saturation * 0.2   # Vibrant colors
-        )
-        
-        return score
-    
-    except Exception as e:
-        logger.error(f"Frame quality calculation error: {e}")
-        return 0.0
-def optimize_video_for_web(input_path, output_path, target_size_mb=10, preserve_quality=True):
-    """Optimize video file size for web sharing while maintaining quality"""
-    try:
-        if not os.path.exists(input_path):
-            return False, "Input video not found"
-        
-        # Get original file size in MB
-        original_size = os.path.getsize(input_path) / (1024 * 1024)
-        logger.info(f"Original video size: {original_size:.2f} MB")
-        
-        # Calculate target bitrate
-        if original_size <= target_size_mb:
-            logger.info("Video already smaller than target size")
-            shutil.copy2(input_path, output_path)
-            return True, f"Video already optimized at {original_size:.2f} MB"
-        
-        # Get video duration
-        cap = cv2.VideoCapture(input_path)
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        duration_sec = frame_count / fps if fps > 0 else 0
-        cap.release()
-        
-        if duration_sec <= 0:
-            return False, "Could not determine video duration"
-        
-        # Calculate target bitrate in kbps
-        target_bitrate = int((target_size_mb * 8 * 1024) / duration_sec)
-        
-        # Set CRF value based on preserve_quality flag
-        crf = 23 if preserve_quality else 28
-        
-        # Use ffmpeg for high-quality compression
-        cmd = [
-            "ffmpeg", "-y",
-            "-i", input_path,
-            "-c:v", "libx264",
-            "-preset", "medium",
-            "-crf", str(crf),
-            "-maxrate", f"{target_bitrate}k",
-            "-bufsize", f"{target_bitrate*2}k",
-            "-c:a", "aac",
-            "-b:a", "128k",
-            output_path
-        ]
-        
-        logger.info(f"Running optimization command: {' '.join(cmd)}")
-        
-        import subprocess
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode != 0:
-            logger.error(f"FFMPEG error: {result.stderr}")
-            return False, f"Optimization failed: {result.stderr[:100]}..."
-        
-        # Verify output file exists and has reasonable size
-        if not os.path.exists(output_path):
-            return False, "Output file was not created"
-        
-        new_size = os.path.getsize(output_path) / (1024 * 1024)
-        logger.info(f"Optimized video size: {new_size:.2f} MB")
-        
-        size_reduction = ((original_size - new_size) / original_size) * 100
-        
-        return True, f"Optimized from {original_size:.2f} MB to {new_size:.2f} MB ({size_reduction:.1f}% reduction)"
-        
-    except Exception as e:
-        logger.error(f"Video optimization error: {str(e)}")
-        return False, f"Optimization error: {str(e)}"
-
-def generate_report(video_path, background_choice, processing_time, output_path):
-    """Generate comprehensive processing report"""
-    try:
-        if not os.path.exists(video_path) or not os.path.exists(output_path):
-            return "Could not generate report - missing files"
-        
-        # Get video properties
-        input_cap = cv2.VideoCapture(video_path)
-        input_fps = input_cap.get(cv2.CAP_PROP_FPS)
-        input_frames = int(input_cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        input_width = int(input_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        input_height = int(input_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        input_size = os.path.getsize(video_path) / (1024 * 1024)  # MB
-        input_cap.release()
-        
-        # Get output properties
-        output_cap = cv2.VideoCapture(output_path)
-        output_fps = output_cap.get(cv2.CAP_PROP_FPS)
-        output_frames = int(output_cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        output_width = int(output_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        output_height = int(output_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        output_size = os.path.getsize(output_path) / (1024 * 1024)  # MB
-        output_cap.release()
-        
-        # Background info
-        if background_choice in PROFESSIONAL_BACKGROUNDS:
-            bg_name = PROFESSIONAL_BACKGROUNDS[background_choice]["name"]
-            bg_type = PROFESSIONAL_BACKGROUNDS[background_choice]["type"]
-        else:
-            bg_name = background_choice
-            bg_type = "custom"
-        
-        # Format report
-        report = f"""
-📊 Video Processing Report
-======================================
-
-📹 Input Video:
-   - Resolution: {input_width}x{input_height}
-   - Frames: {input_frames}
-   - FPS: {input_fps:.2f}
-   - Size: {input_size:.2f} MB
-
-🎬 Output Video:
-   - Resolution: {output_width}x{output_height}
-   - Frames: {output_frames}
-   - FPS: {output_fps:.2f}
-   - Size: {output_size:.2f} MB
-
-🎨 Background:
-   - Choice: {bg_name}
-   - Type: {bg_type}
-
-⏱️ Processing:
-   - Total time: {processing_time:.2f} seconds
-   - Frames per second: {output_frames/processing_time if processing_time > 0 else 0:.2f}
-
-💾 Efficiency:
-   - Size reduction: {(input_size - output_size)/input_size*100:.2f}%
-   - Storage saved: {input_size - output_size:.2f} MB
-
-🔍 Quality Analysis:
-   - Preservation: High (TWO-STAGE processing)
-   - Method: SAM2 + MatAnyone segmentation
-   - Edge quality: Enhanced (bilateral filtering)
-
-Report generated: {time.strftime("%Y-%m-%d %H:%M:%S")}
-        """
-        
-        return report
-        
-    except Exception as e:
-        logger.error(f"Report generation error: {str(e)}")
-        return f"Error generating report: {str(e)}"
-
-def get_memory_usage():
-    """Get current memory usage for monitoring"""
-    try:
-        import psutil
-        process = psutil.Process(os.getpid())
-        memory_info = process.memory_info()
-        
-        # Convert to MB
-        rss_mb = memory_info.rss / (1024 * 1024)
-        vms_mb = memory_info.vms / (1024 * 1024)
-        
-        # Get GPU memory if available
-        gpu_memory = None
-        if torch.cuda.is_available():
-            try:
-                gpu_memory = torch.cuda.memory_allocated() / (1024 * 1024)
-            except:
-                pass
-        
-        memory_data = {
-            "rss_mb": rss_mb,
-            "vms_mb": vms_mb,
-            "gpu_mb": gpu_memory,
-            "percent": process.memory_percent(),
-        }
-        
-        return memory_data
-    
-    except Exception as e:
-        logger.warning(f"Could not get memory usage: {e}")
-        return {"error": str(e)}
-
-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
-
-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 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_system_info():
-    """Get system information for debugging"""
-    try:
-        import platform
-        try:
-            import psutil
-            memory_gb = psutil.virtual_memory().total / (1024**3)
-        except ImportError:
-            memory_gb = "Unknown (psutil not available)"
-        
-        info = {
-            "platform": platform.platform(),
-            "python": platform.python_version(),
-            "cpu_count": os.cpu_count(),
-            "memory_gb": memory_gb,
-            "cuda_available": torch.cuda.is_available(),
-        }
-        
-        if torch.cuda.is_available():
-            try:
-                info["gpu_name"] = torch.cuda.get_device_name(0)
-                info["gpu_memory_gb"] = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            except:
-                info["gpu_name"] = "GPU Available"
-                info["gpu_memory_gb"] = "Unknown"
-        
-        return info
-    except Exception as e:
-        logger.warning(f"Could not get system info: {e}")
-        return {"error": str(e)}
-
-def check_dependencies():
-    """Check if all required dependencies are available"""
-    try:
-        required_packages = [
-            ('cv2', 'opencv-python'),
-            ('PIL', 'Pillow'),
-            ('numpy', 'numpy'),
-            ('torch', 'torch'),
-            ('gradio', 'gradio'),
-            ('requests', 'requests')
-        ]
-        
-        missing_packages = []
-        for import_name, package_name in required_packages:
-            try:
-                __import__(import_name)
-                logger.info(f"✅ {package_name} available")
-            except ImportError:
-                missing_packages.append(package_name)
-                logger.warning(f"❌ {package_name} missing")
-        
-        if missing_packages:
-            logger.error(f"Missing required packages: {', '.join(missing_packages)}")
-            return False, missing_packages
-        
-        return True, []
-    except Exception as e:
-        logger.error(f"Error checking dependencies: {e}")
-        return False, [str(e)]
-
-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 initialize_application():
-    """Initialize the application with all necessary setup"""
-    try:
-        logger.info("🔧 Initializing application...")
-        
-        # Check dependencies
-        deps_ok, missing = check_dependencies()
-        if not deps_ok:
-            logger.error(f"❌ Missing dependencies: {missing}")
-            return False
-        
-        # Create directories
-        if not create_directories():
-            logger.error("❌ Failed to create necessary directories")
-            return False
-        
-        # Log system information
-        try:
-            sys_info = get_system_info()
-            logger.info(f"🖥️ System: {sys_info}")
-        except Exception as e:
-            logger.warning(f"Could not log system information: {e}")
-        
-        # Clean up old temporary files
-        cleanup_temp_files()
-        
-        logger.info("✅ Application initialized successfully")
-        return True
-        
-    except Exception as e:
-        logger.error(f"❌ Application initialization failed: {e}")
-        return False
-
-# Additional utility functions for advanced users
-def batch_process_videos(video_dir, output_dir, background_choice="office_modern"):
-    """
-    Batch process multiple videos (for advanced users)
-    This function is not connected to the UI but can be used programmatically
-    """
-    try:
-        if not models_loaded:
-            logger.error("Models not loaded. Call download_and_setup_models() first.")
-            return False
-        
-        video_files = []
-        for ext in ['*.mp4', '*.mov', '*.avi']:
-            video_files.extend(Path(video_dir).glob(ext))
-        
-        if not video_files:
-            logger.warning(f"No video files found in {video_dir}")
-            return False
-        
-        os.makedirs(output_dir, exist_ok=True)
-        
-        for i, video_path in enumerate(video_files):
-            try:
-                logger.info(f"Processing {i+1}/{len(video_files)}: {video_path.name}")
-                
-                # Process video (simplified version without Gradio progress)
-                result_path, message = process_video_hq(str(video_path), background_choice, None)
-                
-                if result_path:
-                    # Copy to output directory
-                    output_path = Path(output_dir) / f"processed_{video_path.name}"
-                    shutil.copy2(result_path, output_path)
-                    logger.info(f"✅ Saved: {output_path}")
-                else:
-                    logger.error(f"❌ Failed to process {video_path.name}: {message}")
-                    
-            except Exception as e:
-                logger.error(f"Error processing {video_path.name}: {e}")
-        
-        return True
-        
-    except Exception as e:
-        logger.error(f"Batch processing error: {e}")
-        return False
-
-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 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.")
-
-# Export main functions for external use
-__all__ = [
-    'download_and_setup_models',
-    'process_video_hq', 
-    'create_professional_background',
-    'get_available_backgrounds',
-    'create_custom_gradient',
-    'batch_process_videos',
-    'validate_video_file',
-    'create_procedural_background',
-    'create_abstract_background',
-    'create_minimalist_background',
-    'create_corporate_background',
-    'create_nature_background',
-    'create_artistic_background',
-    'create_green_screen_background'
-]
-
-if __name__ == "__main__":
-    main()
+                        text-align: center;