Update ui_components.py

ui_components.py

@@ -3,6 +3,7 @@
 FIXED UI Components for Video Background Replacement
 Updated to use the fixed core processing functions with working SAM2 + MatAnyone
 Now includes TWO-STAGE processing option
+ENHANCED: Added debug logging and cancel functionality
 """
 
 import gradio as gr
@@ -11,6 +12,7 @@
 import os
 import time
 import logging
+import traceback
 from typing import Optional
 
 # Import FIXED core processing functions
@@ -27,6 +29,10 @@
 
 logger = logging.getLogger(__name__)
 
+# Global debug log storage
+DEBUG_LOG = []
+MAX_DEBUG_LINES = 100
+
 # ============================================================================ #
 # GRADIO MONKEY PATCH (BUG FIX for gradio>=4.44.0)
 # ============================================================================ #
@@ -44,26 +50,54 @@ def patched_get_type(schema):
 except (ImportError, AttributeError) as e:
     logger.warning(f"Could not apply Gradio monkey patch: {e}")
 
+# ============================================================================ #
+# DEBUG LOGGING FUNCTIONS
+# ============================================================================ #
+def add_debug_log(message):
+    """Add message to debug log"""
+    global DEBUG_LOG
+    timestamp = time.strftime("%H:%M:%S")
+    log_entry = f"[{timestamp}] {message}"
+    DEBUG_LOG.append(log_entry)
+    if len(DEBUG_LOG) > MAX_DEBUG_LINES:
+        DEBUG_LOG = DEBUG_LOG[-MAX_DEBUG_LINES:]
+    logger.info(message)
+    return "\n".join(DEBUG_LOG)
+
+def clear_debug_log():
+    """Clear the debug log"""
+    global DEBUG_LOG
+    DEBUG_LOG = []
+    return "Debug log cleared"
+
+def get_debug_log():
+    """Get current debug log as string"""
+    return "\n".join(DEBUG_LOG)
+
 # ============================================================================ #
 # UI HELPER FUNCTIONS
 # ============================================================================ #
 def generate_ai_background(prompt, style):
     """Generate AI background from prompt"""
     if not prompt or not prompt.strip():
-        return None, "Please enter a prompt"
+        return None, "Please enter a prompt", get_debug_log()
     try:
+        add_debug_log(f"Generating AI background: {prompt[:50]}...")
         bg_image = create_procedural_background(prompt, style, 1920, 1080)
         if bg_image is not None:
             with tempfile.NamedTemporaryFile(suffix='.png', delete=False) as tmp:
                 cv2.imwrite(tmp.name, bg_image)
-                return tmp.name, f"Background generated: {prompt[:50]}..."
-        return None, "Generation failed, try different prompt"
+                add_debug_log(f"AI background saved to: {tmp.name}")
+                return tmp.name, f"Background generated: {prompt[:50]}...", get_debug_log()
+        return None, "Generation failed, try different prompt", get_debug_log()
     except Exception as e:
-        logger.error(f"AI generation error: {e}")
-        return None, f"Generation error: {str(e)}"
+        error_msg = f"AI generation error: {str(e)}"
+        add_debug_log(error_msg)
+        return None, error_msg, get_debug_log()
 
 def switch_background_method(method):
     """Switch between background method UI groups"""
+    add_debug_log(f"Switched to background method: {method}")
     return (
         gr.update(visible=(method == "upload")),
         gr.update(visible=(method == "professional")),
@@ -72,20 +106,11 @@ def switch_background_method(method):
     )
 
 def update_cache_status():
-    """Update cache status display with actual model state - FIXED"""
+    """Update cache status display - Simplified to remove misleading info"""
     try:
-        status = get_model_status()
         cache = get_cache_status()
-        
-        sam2_status = f"✅ Loaded & Validated" if status['sam2'] == 'Ready' else "❌ Not loaded"
-        matanyone_status = f"✅ Loaded & Validated" if status['matanyone'] == 'Ready' else "❌ Not loaded"
-        models_status = "✅ Models Validated" if status['validated'] else "❌ Not validated"
         two_stage_status = "✅ Available" if cache.get('two_stage_available', False) else "❌ Not available"
-        
-        return (f"SAM2: {sam2_status}\n"
-                f"MatAnyone: {matanyone_status}\n"
-                f"Two-Stage: {two_stage_status}\n"
-                f"Status: {models_status}")
+        return f"Two-Stage Mode: {two_stage_status}"
     except Exception as e:
         return f"Status check error: {str(e)}"
 
@@ -97,49 +122,62 @@ def gradio_progress_wrapper(progress_obj, pct, desc):
     try:
         if progress_obj is not None:
             progress_obj(pct, desc=desc)
+            add_debug_log(f"Progress: {pct:.1%} - {desc}")
     except Exception:
         pass
 
 # ============================================================================ #
-# MAIN PROCESSING FUNCTION FOR UI (FIXED WITH TWO-STAGE)
+# MAIN PROCESSING FUNCTION WITH ENHANCED ERROR HANDLING
 # ============================================================================ #
 def process_video_enhanced_fixed(
     video_path, bg_method, custom_img, prof_choice, grad_type,
     color1, color2, color3, use_third, ai_prompt, ai_style, ai_img,
-    use_two_stage, chroma_preset,  # NEW PARAMETERS
+    use_two_stage, chroma_preset,
     progress: Optional[gr.Progress] = None
 ):
-    """FIXED enhanced video processing function with two-stage option"""
+    """Enhanced video processing with comprehensive error logging"""
     if not video_path:
-        return None, "No video file provided."
+        add_debug_log("ERROR: No video file provided")
+        return None, "No video file provided.", get_debug_log()
     
     def progress_callback(pct, desc):
         gradio_progress_wrapper(progress, pct, desc)
     
     try:
-        # Determine the processing mode message
+        # Clear old logs for new processing
+        add_debug_log("="*50)
+        add_debug_log("Starting new video processing...")
+        add_debug_log(f"Video: {video_path}")
+        add_debug_log(f"Background method: {bg_method}")
+        add_debug_log(f"Two-stage mode: {use_two_stage}")
+        
         mode_msg = "TWO-STAGE Green Screen" if use_two_stage else "Single-Stage"
-        logger.info(f"Processing with {mode_msg} mode")
+        add_debug_log(f"Processing mode: {mode_msg}")
         
         if bg_method == "upload":
             if custom_img and os.path.exists(custom_img):
-                return process_video_fixed(video_path, "custom", custom_img, 
+                add_debug_log(f"Using uploaded image: {custom_img}")
+                result = process_video_fixed(video_path, "custom", custom_img, 
                                          progress_callback, use_two_stage=use_two_stage,
                                          chroma_preset=chroma_preset)
-            return None, "No image uploaded. Please upload a background image."
+                return result[0], result[1], get_debug_log()
+            return None, "No image uploaded. Please upload a background image.", get_debug_log()
             
         elif bg_method == "professional":
             if prof_choice and prof_choice in PROFESSIONAL_BACKGROUNDS:
-                return process_video_fixed(video_path, prof_choice, None, 
+                add_debug_log(f"Using professional background: {prof_choice}")
+                result = process_video_fixed(video_path, prof_choice, None, 
                                          progress_callback, use_two_stage=use_two_stage,
                                          chroma_preset=chroma_preset)
-            return None, f"Invalid professional background: {prof_choice}"
+                return result[0], result[1], get_debug_log()
+            return None, f"Invalid professional background: {prof_choice}", get_debug_log()
             
         elif bg_method == "colors":
             try:
                 colors = [color1 or "#3498db", color2 or "#2ecc71"]
                 if use_third and color3:
                     colors.append(color3)
+                add_debug_log(f"Creating gradient with colors: {colors}")
                     
                 from utilities import create_professional_background
                 bg_config = {
@@ -150,38 +188,49 @@ def progress_callback(pct, desc):
                 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_fixed(video_path, "custom", temp_path, 
+                add_debug_log(f"Gradient saved to: {temp_path}")
+                
+                result = process_video_fixed(video_path, "custom", temp_path, 
                                          progress_callback, use_two_stage=use_two_stage,
                                          chroma_preset=chroma_preset)
+                return result[0], result[1], get_debug_log()
             except Exception as e:
-                return None, f"Error creating gradient: {str(e)}"
+                error_msg = f"Error creating gradient: {str(e)}"
+                add_debug_log(f"ERROR: {error_msg}")
+                return None, error_msg, get_debug_log()
                 
         elif bg_method == "ai":
             if ai_img and os.path.exists(ai_img):
-                return process_video_fixed(video_path, "custom", ai_img, 
+                add_debug_log(f"Using AI generated image: {ai_img}")
+                result = process_video_fixed(video_path, "custom", ai_img, 
                                          progress_callback, use_two_stage=use_two_stage,
                                          chroma_preset=chroma_preset)
-            return None, "No AI background generated. Click 'Generate Background' first."
+                return result[0], result[1], get_debug_log()
+            return None, "No AI background generated. Click 'Generate Background' first.", get_debug_log()
             
         else:
-            return None, f"Unknown background method: {bg_method}"
+            return None, f"Unknown background method: {bg_method}", get_debug_log()
             
     except Exception as e:
-        logger.error(f"Enhanced processing error: {e}")
-        return None, f"Processing error: {str(e)}"
+        error_msg = f"Processing error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        add_debug_log(f"CRITICAL ERROR: {error_msg}")
+        return None, error_msg, get_debug_log()
 
 def load_models_with_progress_fixed(progress: Optional[gr.Progress] = None):
-    """FIXED model loading with Gradio progress updates and validation"""
+    """Model loading with debug logging"""
     def progress_callback(pct, desc):
         gradio_progress_wrapper(progress, pct, desc)
     
-    return load_models_with_validation(progress_callback)
+    add_debug_log("Starting model loading...")
+    result = load_models_with_validation(progress_callback)
+    add_debug_log(f"Model loading result: {result}")
+    return result, get_debug_log()
 
 # ============================================================================ #
-# MAIN INTERFACE CREATION (FIXED WITH TWO-STAGE)
+# MAIN INTERFACE CREATION WITH DEBUG PANEL
 # ============================================================================ #
 def create_interface():
-    """Create the complete Gradio interface with FIXED processing and TWO-STAGE option"""
+    """Create the complete Gradio interface with debug capabilities"""
     
     with gr.Blocks(
         title="FIXED High-Quality Video Background Replacement",
@@ -190,6 +239,14 @@ def create_interface():
         .gradio-container { max-width: 1200px !important; }
         .progress-bar { background: linear-gradient(90deg, #3498db, #2ecc71) !important; }
         .status-box { background-color: #f8f9fa; border: 1px solid #dee2e6; border-radius: 6px; }
+        .debug-box { 
+            background-color: #1e1e1e; 
+            color: #00ff00; 
+            font-family: monospace;
+            font-size: 12px;
+            padding: 10px;
+            border-radius: 4px;
+        }
         .two-stage-box { 
             background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
             color: white;
@@ -201,7 +258,6 @@ def create_interface():
     ) as demo:
         gr.Markdown("# FIXED Cinema-Quality Video Background Replacement")
         gr.Markdown("**Upload a video → Choose a background → Get professional results with VALIDATED AI**")
-        gr.Markdown("*Powered by PROPERLY INTEGRATED SAM2 + MatAnyone with comprehensive validation*")
         
         # Two-stage mode banner if available
         if TWO_STAGE_AVAILABLE:
@@ -227,12 +283,6 @@ def create_interface():
                     value="professional",
                     label="Background Method"
                 )
-                gr.Markdown(
-                    "- **upload** = Upload Image  \n"
-                    "- **professional** = Professional Presets  \n"
-                    "- **colors** = Colors/Gradients  \n"
-                    "- **ai** = AI Generated"
-                )
 
                 with gr.Group(visible=False) as upload_group:
                     gr.Markdown("**Upload Your Background Image**")
@@ -264,7 +314,7 @@ def create_interface():
                     gr.Markdown("**AI Generated Background**")
                     ai_prompt = gr.Textbox(
                         label="Describe your background",
-                        placeholder="e.g., 'modern office with plants', 'sunset over mountains', 'abstract tech pattern'",
+                        placeholder="e.g., 'modern office with plants', 'sunset over mountains'",
                         lines=2
                     )
                     ai_style = gr.Dropdown(
@@ -300,7 +350,6 @@ def create_interface():
                         visible=False
                     )
                     
-                    # Show/hide chroma preset based on two-stage checkbox
                     use_two_stage.change(
                         fn=lambda x: gr.update(visible=x),
                         inputs=use_two_stage,
@@ -308,82 +357,93 @@ def create_interface():
                     )
 
                 gr.Markdown("### Processing Controls")
-                gr.Markdown("*First load and validate the AI models, then process your video*")
                 with gr.Row():
-                    load_models_btn = gr.Button("Step 1: Load & Validate AI Models", variant="secondary")
+                    load_models_btn = gr.Button("Step 1: Load Models", variant="secondary")
                     process_btn = gr.Button("Step 2: Process Video", variant="primary")
+                    cancel_btn = gr.Button("Cancel", variant="stop")
 
                 status_text = gr.Textbox(
                     label="System Status", 
-                    value="Ready - click 'Load & Validate AI Models' to start",
+                    value="Ready - click 'Load Models' to start",
                     interactive=False, 
-                    lines=4,
+                    lines=3,
                     elem_classes=["status-box"]
                 )
 
-                # Enhanced cache/validation status indicator
                 validation_status = gr.Textbox(
-                    label="AI Models Validation Status",
+                    label="Processing Mode",
                     value=update_cache_status(),
                     interactive=False,
-                    lines=4,
+                    lines=1,
                     elem_classes=["status-box"]
                 )
 
             with gr.Column(scale=1):
                 gr.Markdown("### Your Results")
-                gr.Markdown("*Processed video with validated SAM2 + MatAnyone will appear here*")
                 video_output = gr.Video(label="Your Processed Video", height=400)
                 result_text = gr.Textbox(
                     label="Processing Results",
                     interactive=False,
-                    lines=10,
-                    placeholder="Processing status and detailed results will appear here...",
+                    lines=8,
+                    placeholder="Processing status will appear here...",
                     elem_classes=["status-box"]
                 )
+                
+                # Debug panel
+                with gr.Accordion("🔧 Debug Log", open=False):
+                    debug_output = gr.Textbox(
+                        label="Debug Output",
+                        value=get_debug_log(),
+                        lines=15,
+                        max_lines=20,
+                        interactive=False,
+                        elem_classes=["debug-box"]
+                    )
+                    with gr.Row():
+                        refresh_debug_btn = gr.Button("Refresh Log", size="sm")
+                        clear_debug_btn = gr.Button("Clear Log", size="sm")
 
-                gr.Markdown("### Professional Backgrounds Available")
-                bg_preview_html = """
-                <div style='display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; padding: 10px; max-height: 400px; overflow-y: auto; border: 1px solid #ddd; border-radius: 8px;'>
-                """
-                for key, config in PROFESSIONAL_BACKGROUNDS.items():
-                    colors = config["colors"]
-                    gradient = f"linear-gradient(45deg, {colors[0]}, {colors[-1]})" if len(colors) >= 2 else colors[0]
-                    bg_preview_html += f"""
-                    <div style='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)
-
-        # Event handlers with FIXED functions
-        load_models_btn.click(
+        # Event handlers
+        load_event = load_models_btn.click(
             fn=load_models_with_progress_fixed, 
-            outputs=[status_text]
+            outputs=[status_text, debug_output]
         )
         
         generate_ai_btn.click(
             fn=generate_ai_background, 
             inputs=[ai_prompt, ai_style], 
-            outputs=[ai_generated_image, status_text]
+            outputs=[ai_generated_image, status_text, debug_output]
         )
         
-        # Updated process button with two-stage parameters
-        process_btn.click(
+        # Process with cancel capability
+        process_event = process_btn.click(
             fn=process_video_enhanced_fixed,
             inputs=[video_input, background_method, custom_background, professional_choice,
                     gradient_type, color1, color2, color3, use_third_color,
                     ai_prompt, ai_style, ai_generated_image,
-                    use_two_stage, chroma_preset],  # Added two-stage parameters
-            outputs=[video_output, result_text]
+                    use_two_stage, chroma_preset],
+            outputs=[video_output, result_text, debug_output]
+        )
+        
+        # Cancel button
+        cancel_btn.click(
+            fn=lambda: (add_debug_log("Processing cancelled by user"), "Processing cancelled")[1],
+            outputs=[status_text],
+            cancels=[process_event, load_event]
+        )
+        
+        # Debug controls
+        refresh_debug_btn.click(
+            fn=get_debug_log,
+            outputs=[debug_output]
+        )
+        
+        clear_debug_btn.click(
+            fn=clear_debug_log,
+            outputs=[debug_output]
         )
 
-        # Auto-update validation status when models are loaded
+        # Auto-update validation status
         load_models_btn.click(
             fn=update_cache_status,
             outputs=[validation_status]
@@ -391,29 +451,12 @@ def create_interface():
 
         with gr.Accordion("Quality & Features", open=False):
             gr.Markdown("""
-            ### Cinema-Quality Features:
-            
-            **Single-Stage Mode (Default):**
-            - Original → Final Background
-            - Fast processing with good quality
-            - Edge threshold: 140, feather: 1px
-            - Morphological edge cleaning
-            
-            **Two-Stage Mode (Professional):**
-            - Stage 1: Original → Green Screen
-            - Stage 2: Green Screen → Final (Chroma Key)
-            - Perfect edges with spill suppression
-            - Adjustable tolerance and softness
-            - Cinema-grade quality
-            
-            **Core Technology:**
-            - SAM2 with multi-point strategy
-            - MatAnyone refinement every 3 frames
-            - Enhanced OpenCV fallbacks
-            - H.264 CRF 18, AAC 192kbps audio
+            ### Features:
+            - Single-Stage: Fast processing with good quality
+            - Two-Stage: Cinema-grade green screen processing
+            - Debug logging for troubleshooting
+            - Cancel button to stop long processes
+            - SAM2 + MatAnyone AI models
             """)
 
-        gr.Markdown("---")
-        gr.Markdown("*Cinema-Quality Video Background Replacement — Validated SAM2 + MatAnyone pipeline*")
-
     return demo