update app v2

app.py

@@ -1,261 +1,303 @@
 import gradio as gr
 import cv2
+import numpy as np
 import pandas as pd
+import matplotlib.pyplot as plt
+from deepface import DeepFace
 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}")
+from PIL import Image
+import io
+import base64
 
-def analyze_video_emotions(video_path, progress=gr.Progress()):
-    """Analyze emotions in video with robust error handling"""
-    global detector
-    
-    if detector is None:
+class EmotionDetector:
+    def __init__(self):
+        self.emotions = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']
+        
+    def detect_emotions_image(self, image):
+        """Detect emotions in a single image"""
         try:
-            detector = load_video_detector()
+            if image is None:
+                return None, "No image provided"
+            
+            # Convert PIL Image to numpy array if needed
+            if isinstance(image, Image.Image):
+                image = np.array(image)
+            
+            # Convert RGB to BGR for OpenCV
+            if len(image.shape) == 3 and image.shape[2] == 3:
+                image_bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+            else:
+                image_bgr = image
+            
+            # Save temporary image for DeepFace
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+                cv2.imwrite(tmp_file.name, image_bgr)
+                temp_path = tmp_file.name
+            
+            try:
+                # Analyze emotions using DeepFace
+                result = DeepFace.analyze(
+                    img_path=temp_path,
+                    actions=['emotion'],
+                    enforce_detection=False,
+                    detector_backend='opencv'
+                )
+                
+                # Handle both single face and multiple faces results
+                if isinstance(result, list):
+                    emotions_data = result[0]['emotion']
+                else:
+                    emotions_data = result['emotion']
+                
+                # Create emotion chart
+                emotion_df = pd.DataFrame(list(emotions_data.items()), 
+                                        columns=['Emotion', 'Confidence'])
+                emotion_df = emotion_df.sort_values('Confidence', ascending=True)
+                
+                # Create matplotlib plot
+                plt.figure(figsize=(10, 6))
+                bars = plt.barh(emotion_df['Emotion'], emotion_df['Confidence'])
+                plt.xlabel('Confidence (%)')
+                plt.title('Emotion Detection Results')
+                plt.grid(axis='x', alpha=0.3)
+                
+                # Color bars based on emotion
+                colors = {
+                    'happy': '#FFD700',
+                    'sad': '#4169E1', 
+                    'angry': '#DC143C',
+                    'fear': '#800080',
+                    'surprise': '#FF8C00',
+                    'disgust': '#228B22',
+                    'neutral': '#708090'
+                }
+                
+                for bar, emotion in zip(bars, emotion_df['Emotion']):
+                    bar.set_color(colors.get(emotion, '#708090'))
+                
+                plt.tight_layout()
+                
+                # Save plot to bytes
+                img_buffer = io.BytesIO()
+                plt.savefig(img_buffer, format='png', dpi=150, bbox_inches='tight')
+                img_buffer.seek(0)
+                plt.close()
+                
+                # Convert to PIL Image
+                chart_image = Image.open(img_buffer)
+                
+                # Get dominant emotion
+                dominant_emotion = max(emotions_data, key=emotions_data.get)
+                confidence = emotions_data[dominant_emotion]
+                
+                result_text = f"**Dominant Emotion:** {dominant_emotion.title()}\n"
+                result_text += f"**Confidence:** {confidence:.1f}%\n\n"
+                result_text += "**All Emotions:**\n"
+                
+                for emotion, conf in sorted(emotions_data.items(), key=lambda x: x[1], reverse=True):
+                    result_text += f"• {emotion.title()}: {conf:.1f}%\n"
+                
+                return chart_image, result_text
+                
+            finally:
+                # Clean up temporary file
+                if os.path.exists(temp_path):
+                    os.unlink(temp_path)
+                    
         except Exception as e:
-            return f"Error loading detector: {str(e)}", None, None, None
+            error_msg = f"Error analyzing image: {str(e)}"
+            print(error_msg)  # For debugging
+            return None, error_msg
     
-    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
+    def detect_emotions_video(self, video_path, sample_rate=30):
+        """Detect emotions in video by sampling frames"""
+        try:
+            if video_path is None:
+                return None, "No video provided"
             
-        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
+            cap = cv2.VideoCapture(video_path)
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            
+            if frame_count == 0:
+                return None, "Invalid video file"
+            
+            # Sample frames every 'sample_rate' frames
+            frame_indices = range(0, frame_count, sample_rate)
+            emotions_over_time = []
+            
+            for frame_idx in frame_indices:
+                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
+                ret, frame = cap.read()
                 
-            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}")
+                if not ret:
+                    continue
                 
                 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)
+                    # Save frame temporarily
+                    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+                        cv2.imwrite(tmp_file.name, frame)
+                        temp_path = tmp_file.name
+                    
+                    # Analyze frame
+                    result = DeepFace.analyze(
+                        img_path=temp_path,
+                        actions=['emotion'],
+                        enforce_detection=False,
+                        detector_backend='opencv'
+                    )
+                    
+                    if isinstance(result, list):
+                        emotions_data = result[0]['emotion']
+                    else:
+                        emotions_data = result['emotion']
+                    
+                    # Add timestamp
+                    timestamp = frame_idx / fps
+                    emotions_data['timestamp'] = timestamp
+                    emotions_over_time.append(emotions_data)
+                    
+                    # Clean up
+                    os.unlink(temp_path)
+                    
                 except Exception as e:
-                    print(f"Warning: Error analyzing frame {frame_count}: {e}")
+                    print(f"Error processing frame {frame_idx}: {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
+            cap.release()
+            
+            if not emotions_over_time:
+                return None, "No emotions detected in video"
+            
+            # Create DataFrame for plotting
+            df = pd.DataFrame(emotions_over_time)
+            
+            # Plot emotions over time
+            plt.figure(figsize=(12, 8))
+            
+            for emotion in self.emotions:
+                if emotion in df.columns:
+                    plt.plot(df['timestamp'], df[emotion], label=emotion.title(), linewidth=2)
+            
+            plt.xlabel('Time (seconds)')
+            plt.ylabel('Confidence (%)')
+            plt.title('Emotions Over Time')
+            plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+            plt.grid(True, alpha=0.3)
+            plt.tight_layout()
+            
+            # Save plot
+            img_buffer = io.BytesIO()
+            plt.savefig(img_buffer, format='png', dpi=150, bbox_inches='tight')
+            img_buffer.seek(0)
+            plt.close()
+            
+            chart_image = Image.open(img_buffer)
+            
+            # Calculate average emotions
+            avg_emotions = df[self.emotions].mean().sort_values(ascending=False)
+            
+            result_text = f"**Video Analysis Complete**\n"
+            result_text += f"**Frames Analyzed:** {len(emotions_over_time)}\n"
+            result_text += f"**Duration:** {df['timestamp'].max():.1f} seconds\n\n"
+            result_text += "**Average Emotions:**\n"
+            
+            for emotion, confidence in avg_emotions.items():
+                result_text += f"• {emotion.title()}: {confidence:.1f}%\n"
+            
+            return chart_image, result_text
+            
+        except Exception as e:
+            return None, f"Error processing video: {str(e)}"
 
-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
+# Initialize detector
+detector = EmotionDetector()
 
+# Create Gradio interface
 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.Blocks(title="Emotion Detection App", theme=gr.themes.Soft()) as demo:
+        gr.Markdown(
+            """
+            # 🎭 Emotion Detection App
+            
+            Upload an image or video to detect emotions using AI. This app uses DeepFace for accurate emotion recognition.
+            
+            **Supported emotions:** Happy, Sad, Angry, Fear, Surprise, Disgust, Neutral
+            """
+        )
         
-        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
+        with gr.Tabs():
+            # Image Analysis Tab
+            with gr.Tab("📸 Image Analysis"):
+                with gr.Row():
+                    with gr.Column():
+                        image_input = gr.Image(
+                            label="Upload Image",
+                            type="pil"
+                        )
+                        image_button = gr.Button("Analyze Emotions", variant="primary")
                     
-                    ### 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..."
+                    with gr.Column():
+                        image_chart = gr.Image(label="Emotion Chart")
+                        image_results = gr.Markdown(label="Results")
+                
+                image_button.click(
+                    fn=detector.detect_emotions_image,
+                    inputs=[image_input],
+                    outputs=[image_chart, image_results]
                 )
+            
+            # Video Analysis Tab
+            with gr.Tab("🎥 Video Analysis"):
+                with gr.Row():
+                    with gr.Column():
+                        video_input = gr.Video(label="Upload Video")
+                        with gr.Row():
+                            sample_rate = gr.Slider(
+                                minimum=10,
+                                maximum=60,
+                                value=30,
+                                step=5,
+                                label="Frame Sampling Rate"
+                            )
+                        video_button = gr.Button("Analyze Video", variant="primary")
+                    
+                    with gr.Column():
+                        video_chart = gr.Image(label="Emotions Over Time")
+                        video_results = gr.Markdown(label="Results")
                 
-                # 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
-        )
+                video_button.click(
+                    fn=detector.detect_emotions_video,
+                    inputs=[video_input, sample_rate],
+                    outputs=[video_chart, video_results]
+                )
         
-        # 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]
+        # Examples
+        gr.Markdown("### 📋 Instructions")
+        gr.Markdown(
+            """
+            **For Images:**
+            - Upload any image with visible faces
+            - The app will detect and analyze emotions
+            - Results show confidence percentages for each emotion
+            
+            **For Videos:**
+            - Upload video files (MP4, AVI, MOV, etc.)
+            - Adjust frame sampling rate to balance speed vs accuracy
+            - Lower values = more frames analyzed = more accurate but slower
+            - Higher values = fewer frames analyzed = faster but less detailed
+            
+            **Tips:**
+            - Ensure faces are clearly visible and well-lit
+            - The app works best with front-facing faces
+            - Multiple faces in one image/video are supported
+            """
         )
-        
-        # 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
-    )
+    return demo
 
+# Launch the app
 if __name__ == "__main__":
-    main()
+    demo = create_interface()
+    demo.launch()