Update Dockerfile

Dockerfile

@@ -1,579 +1,100 @@
-#!/usr/bin/env python3
-"""
-High-Quality Video Background Replacement
-Upload video → Choose professional background → Replace with cinema quality
-"""
+# Use Python 3.10 base image optimized for Hugging Face Spaces
+FROM python:3.10-slim
 
-import os
-import sys
-import tempfile
-import cv2
-import numpy as np
-from pathlib import Path
-import gradio as gr
-import torch
-import requests
-from PIL import Image, ImageDraw
-import json
+# Set environment variables to prevent threading issues
+ENV OMP_NUM_THREADS=1
+ENV MKL_NUM_THREADS=1
+ENV OPENBLAS_NUM_THREADS=1
+ENV NUMEXPR_NUM_THREADS=1
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:1024
+ENV CUDA_LAUNCH_BLOCKING=0
 
-# 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'
+# Prevent Python from writing pyc files and buffering stdout/stderr
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
 
-# Global variables for models
-sam2_predictor = None
-matanyone_model = None
-models_loaded = False
+# Set working directory
+WORKDIR /app
 
-# Professional background templates
-PROFESSIONAL_BACKGROUNDS = {
-    "office_modern": {
-        "name": "Modern Office",
-        "type": "gradient", 
-        "colors": ["#f8f9fa", "#e9ecef", "#dee2e6"],
-        "direction": "diagonal"
-    },
-    "office_executive": {
-        "name": "Executive Office",
-        "type": "gradient",
-        "colors": ["#2c3e50", "#34495e", "#5d6d7e"],
-        "direction": "vertical"
-    },
-    "studio_blue": {
-        "name": "Professional Blue",
-        "type": "gradient",
-        "colors": ["#1e3c72", "#2a5298", "#3498db"],
-        "direction": "radial"
-    },
-    "studio_green": {
-        "name": "Broadcast Green",
-        "type": "color",
-        "colors": ["#00b894"],
-        "chroma_key": True
-    },
-    "conference": {
-        "name": "Conference Room",
-        "type": "gradient",
-        "colors": ["#74b9ff", "#0984e3", "#6c5ce7"],
-        "direction": "horizontal"
-    },
-    "minimalist": {
-        "name": "Minimalist White",
-        "type": "gradient",
-        "colors": ["#ffffff", "#f1f2f6", "#ddd"],
-        "direction": "soft_radial"
-    },
-    "warm_gradient": {
-        "name": "Warm Sunset",
-        "type": "gradient",
-        "colors": ["#ff7675", "#fd79a8", "#fdcb6e"],
-        "direction": "diagonal"
-    },
-    "cool_gradient": {
-        "name": "Cool Ocean",
-        "type": "gradient", 
-        "colors": ["#74b9ff", "#0984e3", "#00cec9"],
-        "direction": "vertical"
-    },
-    "corporate": {
-        "name": "Corporate Navy",
-        "type": "gradient",
-        "colors": ["#2d3436", "#636e72", "#74b9ff"],
-        "direction": "radial"
-    },
-    "creative": {
-        "name": "Creative Purple",
-        "type": "gradient",
-        "colors": ["#6c5ce7", "#a29bfe", "#fd79a8"],
-        "direction": "diagonal"
-    }
-}
+# Install system dependencies required for video processing and ML libraries
+RUN apt-get update && apt-get install -y \
+    git \
+    wget \
+    curl \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libglib2.0-0 \
+    libgomp1 \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libfontconfig1 \
+    libxrender1 \
+    libxtst6 \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean
 
-def download_and_setup_models():
-    """Download and setup SAM2 and MatAnyone models with quality optimizations"""
-    global sam2_predictor, matanyone_model, models_loaded
-    
-    if models_loaded:
-        return "✅ High-quality models already loaded"
-    
-    try:
-        # Download SAM2 if needed
-        sam2_checkpoint = "/tmp/sam2_hiera_large.pt"
-        if not os.path.exists(sam2_checkpoint):
-            print("📥 Downloading SAM2 large model for maximum quality...")
-            url = "https://dl.fbaipublicfiles.com/segment_anything_2/072824/sam2_hiera_large.pt"
-            response = requests.get(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):
-                    f.write(chunk)
-                    downloaded += len(chunk)
-                    if total_size > 0:
-                        percent = (downloaded / total_size) * 100
-                        print(f"Download progress: {percent:.1f}%")
-        
-        # Setup SAM2 with quality settings
-        sys.path.append('/tmp/segment-anything-2')
-        from sam2.build_sam import build_sam2
-        from sam2.sam2_image_predictor import SAM2ImagePredictor
-        
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        print(f"🚀 Loading SAM2 on {device} for maximum quality...")
-        
-        sam2_model = build_sam2("sam2_hiera_large.yaml", sam2_checkpoint, device=device)
-        sam2_predictor = SAM2ImagePredictor(sam2_model)
-        
-        # Setup MatAnyone with quality optimizations
-        sys.path.append('/tmp/MatAnyone')
-        from inference import MatAnyoneInference
-        
-        print("🎨 Loading MatAnyone for cinema-quality matting...")
-        matanyone_model = MatAnyoneInference()
-        
-        models_loaded = True
-        gpu_info = f" (GPU: {torch.cuda.get_device_name(0)})" if torch.cuda.is_available() else " (CPU)"
-        return f"✅ High-quality models loaded successfully!{gpu_info}"
-        
-    except Exception as e:
-        return f"❌ Error loading models: {e}"
+# Upgrade pip and install core Python packages
+RUN pip install --upgrade pip setuptools wheel
 
-def segment_person_hq(image):
-    """High-quality person segmentation using SAM2"""
-    # Set image with quality optimizations
-    sam2_predictor.set_image(image)
-    
-    h, w = image.shape[:2]
-    
-    # Use multiple points for better segmentation
-    points = np.array([
-        [w//2, h//2],           # Center
-        [w//2, h//3],           # Upper body
-        [w//2, 2*h//3],         # Lower body
-        [w//3, h//2],           # Left side
-        [2*w//3, h//2],         # Right side
-    ])
-    labels = np.array([1, 1, 1, 1, 1])  # 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 and apply smoothing
-    best_mask = masks[np.argmax(scores)]
-    
-    # Smooth mask edges for better quality
-    kernel = np.ones((3,3), np.uint8)
-    best_mask = cv2.morphologyEx(best_mask.astype(np.uint8), cv2.MORPH_CLOSE, kernel)
-    best_mask = cv2.GaussianBlur(best_mask.astype(np.float32), (3,3), 1.0)
-    
-    return (best_mask * 255).astype(np.uint8)
+# Copy requirements first for better Docker layer caching
+COPY requirements.txt .
 
-def refine_mask_hq(image, mask):
-    """Cinema-quality mask refinement using MatAnyone"""
-    # Apply edge-preserving filtering before MatAnyone
-    image_filtered = cv2.bilateralFilter(image, 9, 75, 75)
-    
-    # Use MatAnyone for professional matting
-    refined_mask = matanyone_model.infer(image_filtered, mask)
-    
-    # Post-process for smooth edges
-    refined_mask = cv2.medianBlur(refined_mask, 3)
-    
-    return refined_mask
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
 
-def create_professional_background(bg_config, width, height):
-    """Create professional background based on configuration"""
-    if bg_config["type"] == "color":
-        # Solid color
-        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 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)
-    
-    return background
+# Install PyTorch (Hugging Face Spaces handles CUDA automatically)
+RUN pip install torch torchvision torchaudio
 
-def create_gradient_background(bg_config, width, height):
-    """Create high-quality gradient backgrounds"""
-    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('#')
-        rgb = tuple(int(color_hex[i:i+2], 16) for i in (0, 2, 4))
-        rgb_colors.append(rgb)
-    
-    # Create PIL image for high-quality gradients
-    pil_img = Image.new('RGB', (width, height))
-    draw = ImageDraw.Draw(pil_img)
-    
-    if direction == "vertical":
-        # Vertical gradient
-        for y in range(height):
-            # Interpolate between colors
-            progress = y / height
-            if len(rgb_colors) == 2:
-                r = int(rgb_colors[0][0] + (rgb_colors[1][0] - rgb_colors[0][0]) * progress)
-                g = int(rgb_colors[0][1] + (rgb_colors[1][1] - rgb_colors[0][1]) * progress)
-                b = int(rgb_colors[0][2] + (rgb_colors[1][2] - rgb_colors[0][2]) * progress)
-            else:
-                # Multi-color gradient
-                segment = progress * (len(rgb_colors) - 1)
-                idx = int(segment)
-                local_progress = segment - idx
-                
-                if idx >= len(rgb_colors) - 1:
-                    r, g, b = rgb_colors[-1]
-                else:
-                    c1, c2 = rgb_colors[idx], rgb_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)
-            
-            draw.line([(0, y), (width, y)], fill=(r, g, b))
-    
-    elif direction == "horizontal":
-        # Horizontal gradient
-        for x in range(width):
-            progress = x / width
-            if len(rgb_colors) == 2:
-                r = int(rgb_colors[0][0] + (rgb_colors[1][0] - rgb_colors[0][0]) * progress)
-                g = int(rgb_colors[0][1] + (rgb_colors[1][1] - rgb_colors[0][1]) * progress)
-                b = int(rgb_colors[0][2] + (rgb_colors[1][2] - rgb_colors[0][2]) * progress)
-            else:
-                segment = progress * (len(rgb_colors) - 1)
-                idx = int(segment)
-                local_progress = segment - idx
-                
-                if idx >= len(rgb_colors) - 1:
-                    r, g, b = rgb_colors[-1]
-                else:
-                    c1, c2 = rgb_colors[idx], rgb_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)
-            
-            draw.line([(x, 0), (x, height)], fill=(r, g, b))
-    
-    elif direction == "diagonal":
-        # Diagonal gradient
-        for y in range(height):
-            for x in range(width):
-                progress = (x + y) / (width + height)
-                progress = min(1.0, progress)
-                
-                if len(rgb_colors) == 2:
-                    r = int(rgb_colors[0][0] + (rgb_colors[1][0] - rgb_colors[0][0]) * progress)
-                    g = int(rgb_colors[0][1] + (rgb_colors[1][1] - rgb_colors[0][1]) * progress)
-                    b = int(rgb_colors[0][2] + (rgb_colors[1][2] - rgb_colors[0][2]) * progress)
-                else:
-                    segment = progress * (len(rgb_colors) - 1)
-                    idx = int(segment)
-                    local_progress = segment - idx
-                    
-                    if idx >= len(rgb_colors) - 1:
-                        r, g, b = rgb_colors[-1]
-                    else:
-                        c1, c2 = rgb_colors[idx], rgb_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)
-                
-                pil_img.putpixel((x, y), (r, g, b))
-    
-    elif direction in ["radial", "soft_radial"]:
-        # Radial gradient
-        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
-                progress = min(1.0, progress)
-                
-                if direction == "soft_radial":
-                    progress = progress**0.7  # Softer falloff
-                
-                if len(rgb_colors) == 2:
-                    r = int(rgb_colors[0][0] + (rgb_colors[1][0] - rgb_colors[0][0]) * progress)
-                    g = int(rgb_colors[0][1] + (rgb_colors[1][1] - rgb_colors[0][1]) * progress)
-                    b = int(rgb_colors[0][2] + (rgb_colors[1][2] - rgb_colors[0][2]) * progress)
-                else:
-                    segment = progress * (len(rgb_colors) - 1)
-                    idx = int(segment)
-                    local_progress = segment - idx
-                    
-                    if idx >= len(rgb_colors) - 1:
-                        r, g, b = rgb_colors[-1]
-                    else:
-                        c1, c2 = rgb_colors[idx], rgb_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)
-                
-                pil_img.putpixel((x, y), (r, g, b))
-    
-    # Convert PIL to OpenCV format
-    background = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
-    return background
+# Install computer vision and ML dependencies
+RUN pip install opencv-python-headless \
+    transformers \
+    accelerate \
+    huggingface-hub \
+    omegaconf \
+    hydra-core
 
-def replace_background_hq(frame, mask, background):
-    """High-quality background replacement with edge feathering"""
-    # Resize background to match frame exactly
-    background = cv2.resize(background, (frame.shape[1], frame.shape[0]), interpolation=cv2.INTER_LANCZOS4)
-    
-    # Apply edge feathering for smooth transitions
-    mask_float = mask.astype(np.float32) / 255.0
-    
-    # Create feathered mask
-    feather_radius = 3
-    mask_feathered = cv2.GaussianBlur(mask_float, (feather_radius*2+1, feather_radius*2+1), feather_radius/3)
-    
-    # Expand mask to 3 channels
-    mask_3channel = np.stack([mask_feathered] * 3, axis=2)
-    
-    # High-quality compositing with gamma correction
-    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 space
-    result_linear = frame_linear * mask_3channel + background_linear * (1 - mask_3channel)
-    
-    # Convert back to sRGB
-    result = np.power(result_linear, 1/2.2) * 255.0
-    result = np.clip(result, 0, 255).astype(np.uint8)
-    
-    return result
+# Install SAM2 from official repository
+RUN pip install git+https://github.com/facebookresearch/segment-anything-2.git
 
-def process_video_hq(video_path, background_choice, custom_background_path, progress=gr.Progress()):
-    """High-quality video processing with professional backgrounds"""
-    if not models_loaded:
-        return None, "❌ Models not loaded. Click 'Load Models' first."
-    
-    try:
-        progress(0, desc="🎬 Initializing high-quality processing...")
-        
-        # Read video with quality settings
-        cap = cv2.VideoCapture(video_path)
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        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))
-        
-        # Prepare background
-        if background_choice == "custom" and custom_background_path:
-            # Use uploaded image
-            background = cv2.imread(custom_background_path)
-            if background is None:
-                return None, "❌ Could not read custom background image"
-            background_name = "Custom Image"
-        else:
-            # Use professional background
-            if background_choice in PROFESSIONAL_BACKGROUNDS:
-                bg_config = PROFESSIONAL_BACKGROUNDS[background_choice]
-                background = create_professional_background(bg_config, frame_width, frame_height)
-                background_name = bg_config["name"]
-            else:
-                return None, "❌ Invalid background selection"
-        
-        # Setup high-quality output video
-        output_path = "/tmp/processed_video_hq.mp4"
-        # Use high-quality codec
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
-        
-        progress(0.1, desc=f"🎨 Using {background_name} background...")
-        
-        # Process each frame with quality optimizations
-        frame_count = 0
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # Update progress
-            progress_pct = 0.1 + (frame_count / total_frames) * 0.8
-            progress(progress_pct, desc=f"✨ Processing frame {frame_count + 1}/{total_frames} (High Quality)")
-            
-            # High-quality person segmentation
-            mask = segment_person_hq(frame)
-            
-            # Cinema-quality mask refinement
-            refined_mask = refine_mask_hq(frame, mask)
-            
-            # High-quality background replacement
-            result_frame = replace_background_hq(frame, refined_mask, background)
-            
-            # Write frame
-            out.write(result_frame)
-            frame_count += 1
-        
-        cap.release()
-        out.release()
-        
-        progress(0.9, desc="🎵 Adding high-quality audio...")
-        
-        # Add audio back with high quality settings
-        final_output = "/tmp/final_output_hq.mp4"
-        audio_cmd = f'ffmpeg -y -i {output_path} -i {video_path} -c:v libx264 -crf 18 -preset slow -c:a aac -b:a 192k -map 0:v:0 -map 1:a:0? -shortest {final_output}'
-        os.system(audio_cmd)
-        
-        # Save to MyAvatar/My Videos
-        myavatar_path = "/tmp/MyAvatar/My_Videos/"
-        os.makedirs(myavatar_path, exist_ok=True)
-        
-        import shutil
-        import time
-        saved_filename = f"hq_background_replaced_{int(time.time())}.mp4"
-        saved_path = os.path.join(myavatar_path, saved_filename)
-        shutil.copy2(final_output, saved_path)
-        
-        progress(1.0, desc="✅ High-quality processing complete!")
-        
-        return final_output, f"✅ High-Quality Success!\n🎬 Background: {background_name}\n📁 Saved: MyAvatar/My Videos/{saved_filename}\n🎯 Quality: Cinema-grade with SAM2 + MatAnyone"
-        
-    except Exception as e:
-        return None, f"❌ Error: {str(e)}"
+# Install MatAnyone from official repository
+RUN pip install git+https://github.com/PeiqingYang/MatAnyone.git
 
-def get_model_status():
-    """Get current model loading status"""
-    if models_loaded:
-        gpu_info = f" (GPU: {torch.cuda.get_device_name(0)})" if torch.cuda.is_available() else " (CPU)"
-        return f"✅ High-quality models loaded{gpu_info}"
-    else:
-        return "⏳ Models not loaded. Click 'Load Models' for cinema-quality processing."
+# Create necessary directories with proper permissions
+RUN mkdir -p /app/checkpoints \
+    && mkdir -p /app/Configs \
+    && mkdir -p /tmp/MyAvatar/My_Videos \
+    && chmod 755 /app/checkpoints \
+    && chmod 755 /app/Configs \
+    && chmod 755 /tmp/MyAvatar/My_Videos
 
-def create_interface():
-    """Create enhanced Gradio interface with professional backgrounds"""
-    
-    # Create background choices
-    bg_choices = ["custom"] + list(PROFESSIONAL_BACKGROUNDS.keys())
-    bg_labels = ["📷 Custom Image"] + [f"🎨 {config['name']}" for config in PROFESSIONAL_BACKGROUNDS.values()]
-    bg_dropdown_choices = list(zip(bg_labels, bg_choices))
-    
-    with gr.Blocks(title="High-Quality Video Background Replacement", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🎬 Cinema-Quality Video Background Replacement")
-        gr.Markdown("**Professional background replacement using SAM2 + MatAnyone AI models**")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📥 Input")
-                video_input = gr.Video(label="🎥 Upload Video (MP4, MOV, AVI)")
-                
-                gr.Markdown("### 🎨 Background Selection")
-                background_choice = gr.Dropdown(
-                    choices=bg_dropdown_choices,
-                    value="office_modern",
-                    label="Choose Background Type",
-                    info="Select professional background or upload custom image"
-                )
-                
-                custom_background = gr.Image(
-                    label="📷 Custom Background Image", 
-                    type="filepath",
-                    visible=False,
-                    info="Upload your own background image (will be resized to match video)"
-                )
-                
-                # Show/hide custom background based on selection
-                def toggle_custom_bg(choice):
-                    return gr.update(visible=(choice == "custom"))
-                
-                background_choice.change(
-                    fn=toggle_custom_bg,
-                    inputs=background_choice,
-                    outputs=custom_background
-                )
-                
-                with gr.Row():
-                    load_models_btn = gr.Button("🚀 Load High-Quality Models", variant="secondary", size="lg")
-                    process_btn = gr.Button("✨ Process with Cinema Quality", variant="primary", size="lg")
-                
-                status_text = gr.Textbox(
-                    label="🔧 System Status", 
-                    value=get_model_status(), 
-                    interactive=False,
-                    lines=2
-                )
-            
-            with gr.Column(scale=1):
-                gr.Markdown("### 📤 High-Quality Output")
-                video_output = gr.Video(label="🎬 Processed Video", height=400)
-                result_text = gr.Textbox(
-                    label="📊 Processing Results", 
-                    interactive=False,
-                    lines=4
-                )
-                
-                gr.Markdown("### 🎨 Professional Backgrounds Available")
-                bg_preview_html = "<div style='display: grid; grid-template-columns: repeat(2, 1fr); gap: 10px; padding: 10px;'>"
-                for key, config in PROFESSIONAL_BACKGROUNDS.items():
-                    colors_display = " → ".join(config["colors"][:2])
-                    bg_preview_html += f"""
-                    <div style='padding: 8px; border: 1px solid #ddd; border-radius: 8px; text-align: center; background: linear-gradient(45deg, {config["colors"][0]}, {config["colors"][-1]});'>
-                        <strong style='color: white; text-shadow: 1px 1px 2px rgba(0,0,0,0.7);'>{config["name"]}</strong>
-                    </div>
-                    """
-                bg_preview_html += "</div>"
-                gr.HTML(bg_preview_html)
-        
-        # Event handlers
-        load_models_btn.click(
-            fn=download_and_setup_models,
-            outputs=status_text
-        )
-        
-        process_btn.click(
-            fn=process_video_hq,
-            inputs=[video_input, background_choice, custom_background],
-            outputs=[video_output, result_text]
-        )
-        
-        # Info section
-        with gr.Accordion("ℹ️ Quality & Features", open=False):
-            gr.Markdown("""
-            ### 🏆 Cinema-Quality Features:
-            - **🤖 SAM2 Large Model**: Meta's most advanced segmentation
-            - **🎨 MatAnyone**: CVPR 2025 professional matting
-            - **✨ Edge Feathering**: Smooth, natural transitions  
-            - **🎬 Gamma Correction**: Professional color compositing
-            - **🎵 High-Quality Audio**: 192kbps AAC preservation
-            - **📺 H.264 Codec**: CRF 18 for broadcast quality
-            
-            ### 🎨 Professional Backgrounds:
-            - **Office Environments**: Modern, Executive styles
-            - **Studio Backdrops**: Broadcast-quality gradients
-            - **Creative Themes**: Artistic color combinations
-            - **Custom Images**: Upload your own backgrounds
-            
-            ### 💾 Output:
-            - Saved to: **MyAvatar/My Videos/**
-            - Format: **MP4 (H.264)**
-            - Quality: **Cinema-grade**
-            """)
-    
-    return demo
+# Copy application files
+COPY . .
 
-if __name__ == "__main__":
-    print("🎬 Starting Cinema-Quality Video Background Replacement...")
-    
-    # Create and launch interface
-    demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_error=True
-    )
+# Download SAM2 configuration files if not present
+RUN if [ ! -d "Configs" ] || [ -z "$(ls -A Configs)" ]; then \
+    echo "Downloading SAM2 configs..." && \
+    git clone --depth 1 https://github.com/facebookresearch/segment-anything-2.git temp_sam2 && \
+    cp -r temp_sam2/sam2_configs/* Configs/ 2>/dev/null || \
+    cp -r temp_sam2/configs/* Configs/ 2>/dev/null || \
+    echo "Config copy failed, will use defaults" && \
+    rm -rf temp_sam2; \
+    fi
+
+# Ensure all Python files are executable
+RUN find /app -name "*.py" -exec chmod +x {} \;
+
+# Create a non-root user for security (optional but recommended)
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app /tmp/MyAvatar
+USER appuser
+
+# Expose the port that Gradio will run on
+EXPOSE 7860
+
+# Health check to ensure the application is running
+HEALTHCHECK --interval=30s --timeout=30s --start-period=120s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Set the default command to run the application
+CMD ["python", "app.py"]