update app

app.py

@@ -1,90 +1,128 @@
-def detect_emotions_video(self, video_path, sample_rate=30, max_size_mb=50):
-    """Detect emotions in video by sampling frames"""
-    try:
-        if video_path is None:
-            return None, "No video provided"
-        
-        # Check file size
-        file_size_mb = os.path.getsize(video_path) / (1024 * 1024)
-        if file_size_mb > max_size_mb:
-            return None, f"Video file too large ({file_size_mb:.2f} MB). Max allowed: {max_size_mb} MB."
-
-        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 or unreadable video file"
-
-        # Sample every Nth frame
-        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 not ret:
-                continue
-
-            try:
-                with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
-                    cv2.imwrite(tmp_file.name, frame)
-                    temp_path = tmp_file.name
-
-                result = DeepFace.analyze(
-                    img_path=temp_path,
-                    actions=['emotion'],
-                    enforce_detection=False,
-                    detector_backend='opencv'
-                )
-
-                emotions_data = result[0]['emotion'] if isinstance(result, list) else result['emotion']
-                emotions_data['timestamp'] = frame_idx / fps
-                emotions_over_time.append(emotions_data)
-
-                os.unlink(temp_path)
-            except Exception as e:
-                print(f"Error processing frame {frame_idx}: {e}")
-                continue
-
-        cap.release()
-
-        if not emotions_over_time:
-            return None, "No emotions detected in video."
-
-        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()
-
-        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)
-        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)}"
+import os
+import cv2
+import tempfile
+import io
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+from deepface import DeepFace
+import gradio as gr
+
+class EmotionDetector:
+    def __init__(self):
+        self.emotions = ['angry', 'disgust', 'fear', 'happy', 'sad', 'surprise', 'neutral']
+
+    def detect_emotions_video(self, video_path, sample_rate=30, max_size_mb=50):
+        """Detect emotions in video by sampling frames"""
+        try:
+            if video_path is None:
+                return None, "No video provided"
+            
+            # Check file size
+            file_size_mb = os.path.getsize(video_path) / (1024 * 1024)
+            if file_size_mb > max_size_mb:
+                return None, f"Video file too large ({file_size_mb:.2f} MB). Max allowed: {max_size_mb} MB."
+
+            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 or unreadable video file"
+
+            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 not ret:
+                    continue
+
+                try:
+                    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+                        cv2.imwrite(tmp_file.name, frame)
+                        temp_path = tmp_file.name
+
+                    result = DeepFace.analyze(
+                        img_path=temp_path,
+                        actions=['emotion'],
+                        enforce_detection=False,
+                        detector_backend='opencv'
+                    )
+
+                    emotions_data = result[0]['emotion'] if isinstance(result, list) else result['emotion']
+                    emotions_data['timestamp'] = frame_idx / fps
+                    emotions_over_time.append(emotions_data)
+
+                    os.unlink(temp_path)
+                except Exception as e:
+                    print(f"Error processing frame {frame_idx}: {e}")
+                    continue
+
+            cap.release()
+
+            if not emotions_over_time:
+                return None, "No emotions detected in video."
+
+            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()
+
+            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)
+            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 create_interface():
+    detector = EmotionDetector()
+
+    def process(video, sample_rate):
+        if video is None:
+            return None, "Please upload a video."
+        return detector.detect_emotions_video(video, sample_rate)
+
+    iface = gr.Interface(
+        fn=process,
+        inputs=[
+            gr.Video(label="Upload Video"),
+            gr.Slider(minimum=1, maximum=60, step=1, value=30, label="Sample Rate (Frames)")
+        ],
+        outputs=[
+            gr.Image(type="pil", label="Emotion Chart"),
+            gr.Textbox(label="Analysis Summary")
+        ],
+        title="Emotion Detection from Video",
+        description="Upload a video to analyze facial emotions over time."
+    )
+
+    return iface
+
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch()