Upload app.py and requirements.txt

app.py

@@ -0,0 +1,261 @@
+import gradio as gr
+import cv2
+import pandas as pd
+import os
+import tempfile
+import traceback
+from pathlib import Path
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Global variables to store detector
+detector = None
+detector_loaded = False
+
+def load_video_detector():
+    """Load FER detector with error handling"""
+    global detector, detector_loaded
+    
+    if detector_loaded:
+        return detector
+    
+    try:
+        from fer import FER
+        detector = FER(mtcnn=True)
+        detector_loaded = True
+        return detector
+    except ImportError as e:
+        raise Exception(f"Failed to import FER: {e}")
+    except Exception as e:
+        raise Exception(f"Failed to initialize FER detector: {e}")
+
+def analyze_video_emotions(video_path, progress=gr.Progress()):
+    """Analyze emotions in video with robust error handling"""
+    global detector
+    
+    if detector is None:
+        try:
+            detector = load_video_detector()
+        except Exception as e:
+            return f"Error loading detector: {str(e)}", None, None, None
+    
+    try:
+        cap = cv2.VideoCapture(str(video_path))
+        
+        # Check if video opened successfully
+        if not cap.isOpened():
+            return "Could not open video file", None, None, None
+        
+        emotions = []
+        frame_rate = int(cap.get(cv2.CAP_PROP_FPS))
+        
+        # Handle cases where frame rate detection fails
+        if frame_rate <= 0:
+            frame_rate = 30
+            
+        frame_interval = max(1, frame_rate * 2)  # analyze every 2 seconds
+        frame_count = 0
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        progress(0, desc="Starting analysis...")
+        
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            if frame_count % frame_interval == 0:
+                progress_val = frame_count / total_frames if total_frames > 0 else 0
+                progress(progress_val, desc=f"Analyzing frame {frame_count}/{total_frames}")
+                
+                try:
+                    results = detector.detect_emotions(frame)
+                    if results and len(results) > 0:
+                        top_emotion = max(results[0]["emotions"], key=results[0]["emotions"].get)
+                        emotions.append(top_emotion)
+                except Exception as e:
+                    print(f"Warning: Error analyzing frame {frame_count}: {e}")
+                    continue
+            
+            frame_count += 1
+        
+        cap.release()
+        
+        if not emotions:
+            return "No faces or emotions detected in the video. Try uploading a video with clear facial expressions.", None, None, None
+        
+        # Process results
+        emotion_counts = pd.Series(emotions).value_counts().to_dict()
+        
+        # Create results text
+        total_detections = sum(emotion_counts.values())
+        results_text = "**Analysis completed!**\n\n**Detected Emotions:**\n\n"
+        
+        for emo, count in emotion_counts.items():
+            percentage = (count / total_detections) * 100
+            results_text += f"- **{emo.title()}**: {count} detections ({percentage:.1f}%)\n"
+        
+        # Dominant emotion
+        dominant_emotion = max(emotion_counts, key=emotion_counts.get)
+        results_text += f"\n**Dominant emotion detected**: {dominant_emotion.title()}"
+        
+        # Create visualization
+        fig, ax = plt.subplots(figsize=(10, 6))
+        emotions_list = list(emotion_counts.keys())
+        counts_list = list(emotion_counts.values())
+        
+        bars = ax.bar(emotions_list, counts_list, color=['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD', '#98D8C8'])
+        ax.set_xlabel('Emotions')
+        ax.set_ylabel('Number of Detections')
+        ax.set_title('Emotion Distribution in Video')
+        
+        # Add value labels on bars
+        for bar in bars:
+            height = bar.get_height()
+            ax.text(bar.get_x() + bar.get_width()/2., height,
+                   f'{int(height)}',
+                   ha='center', va='bottom')
+        
+        plt.xticks(rotation=45)
+        plt.tight_layout()
+        
+        return results_text, fig, emotion_counts, dominant_emotion
+        
+    except Exception as e:
+        error_msg = f"Error during video analysis: {e}\nTraceback: {traceback.format_exc()}"
+        return error_msg, None, None, None
+
+def process_video(video_file):
+    """Main processing function for Gradio interface"""
+    if video_file is None:
+        return "Please upload a video file to analyze facial emotions.", None
+    
+    # Get file info
+    file_size = os.path.getsize(video_file) / (1024 * 1024)  # MB
+    file_info = f"File uploaded successfully: {os.path.basename(video_file)}\nFile size: {file_size:.2f} MB\n\nAnalyzing facial emotions in video... This may take a few minutes.\n\n"
+    
+    try:
+        results_text, plot, emotion_counts, dominant_emotion = analyze_video_emotions(video_file)
+        return file_info + results_text, plot
+        
+    except Exception as e:
+        error_msg = f"Analysis failed: {e}\nPlease try with a different video file or check the file format."
+        return file_info + error_msg, None
+
+def create_interface():
+    """Create the Gradio interface"""
+    
+    # Custom CSS for better styling
+    css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .main-header {
+        text-align: center;
+        color: #2c3e50;
+        margin-bottom: 2rem;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="Video Emotion Detection", theme=gr.themes.Soft()) as iface:
+        
+        # Header
+        gr.HTML("""
+        <div class="main-header">
+            <h1>😊 Video Emotion Detection</h1>
+            <p>Upload a video file to analyze facial emotions using advanced AI</p>
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # File upload
+                video_input = gr.File(
+                    label="Choose a video file", 
+                    file_types=[".mp4", ".avi", ".mov"],
+                    type="filepath"
+                )
+                
+                # Process button
+                process_btn = gr.Button("Analyze Video", variant="primary", size="lg")
+                
+                # Info section
+                with gr.Accordion("ℹ️ About this app", open=False):
+                    gr.Markdown("""
+                    ### How it works:
+                    - **Facial Detection**: Uses MTCNN for face detection
+                    - **Emotion Recognition**: Analyzes facial expressions using FER (Facial Emotion Recognition)
+                    - **Sampling**: Analyzes frames every 2 seconds for efficiency
+                    - **Supported Formats**: MP4, AVI, MOV
+                    
+                    ### Tips for best results:
+                    - Use videos with clear, well-lit faces
+                    - Ensure faces are not too small in the frame
+                    - Videos with multiple people will analyze all detected faces
+                    - Shorter videos (< 5 minutes) process faster
+                    """)
+            
+            with gr.Column(scale=2):
+                # Results section
+                results_output = gr.Textbox(
+                    label="Analysis Results", 
+                    lines=15, 
+                    max_lines=20,
+                    interactive=False,
+                    placeholder="Upload a video and click 'Analyze Video' to see results here..."
+                )
+                
+                # Plot output
+                plot_output = gr.Plot(label="Emotion Distribution Chart")
+        
+        # Event handlers
+        process_btn.click(
+            fn=process_video,
+            inputs=[video_input],
+            outputs=[results_output, plot_output],
+            show_progress=True
+        )
+        
+        # Auto-process when file is uploaded (optional)
+        video_input.change(
+            fn=lambda x: ("Video uploaded successfully! Click 'Analyze Video' to start processing." if x else "", None),
+            inputs=[video_input],
+            outputs=[results_output, plot_output]
+        )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 2rem; padding: 1rem; background-color: #f8f9fa; border-radius: 0.5rem;">
+            <p><strong>Video Emotion Detection App</strong> - Powered by FER and MTCNN</p>
+            <p>Upload your video files and get detailed emotion analysis with visualizations</p>
+        </div>
+        """)
+    
+    return iface
+
+def main():
+    """Main function to launch the app"""
+    # Initialize detector on startup
+    try:
+        print("Loading emotion detection model...")
+        load_video_detector()
+        print("Model loaded successfully!")
+    except Exception as e:
+        print(f"Warning: Could not pre-load detector: {e}")
+        print("Detector will be loaded when first video is processed.")
+    
+    # Create and launch interface
+    iface = create_interface()
+    
+    # Launch the app
+    iface.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7860,       # Default Gradio port
+        share=False,            # Set to True to create public link
+        debug=False,
+        show_error=True,
+        inbrowser=True          # Auto-open in browser
+    )
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,9 @@
+gradio>=4.0.0
+opencv-python-headless==4.8.1.78
+pandas>=1.5.0
+matplotlib>=3.6.0
+fer>=22.5.1
+tensorflow>=2.10.0
+numpy>=1.21.0
+Pillow>=9.0.0
+mtcnn>=0.1.1