app.py update

app.py

@@ -1,108 +1,79 @@
 import os
 import cv2
-import io
 import tempfile
 import pandas as pd
 import matplotlib.pyplot as plt
-from PIL import Image
-from deepface import DeepFace 
+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):
-        try:
-            if video_path is None:
-                return None, "No video provided"
-
-            file_size_mb = os.path.getsize(video_path) / (1024 * 1024)
-            if file_size_mb > max_size_mb:
-                return None, f"Video too large ({file_size_mb:.2f} MB). Limit: {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 video"
-
-            emotions_over_time = []
-            for i in range(0, frame_count, sample_rate):
-                cap.set(cv2.CAP_PROP_POS_FRAMES, i)
-                ret, frame = cap.read()
-                if not ret:
-                    continue
-                rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                pil_img = Image.fromarray(rgb)
-
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmpfile:
-                    pil_img.save(tmpfile.name)
-                    result = DeepFace.analyze(
-                        img_path=tmpfile.name,
-                        actions=['emotion'],
-                        enforce_detection=False,
-                        detector_backend='opencv',
-                        prog_backend='pytorch'
-                    )
-                    emotions = result[0]['emotion'] if isinstance(result, list) else result['emotion']
-                    emotions['timestamp'] = i / fps
-                    emotions_over_time.append(emotions)
-
-                    os.unlink(tmpfile.name)
-
-            cap.release()
-
-            if not emotions_over_time:
-                return None, "No emotions detected."
-
-            df = pd.DataFrame(emotions_over_time)
-            plt.figure(figsize=(12, 6))
-            for emotion in self.emotions:
-                if emotion in df.columns:
-                    plt.plot(df['timestamp'], df[emotion], label=emotion)
-            plt.xlabel("Time (s)")
-            plt.ylabel("Emotion Confidence")
-            plt.title("Emotion Trends Over Time")
-            plt.legend()
-            plt.grid(True)
-
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png')
-            buf.seek(0)
-            chart = Image.open(buf)
-            plt.close()
-
-            avg = df[self.emotions].mean().sort_values(ascending=False)
-            summary = "**Video Analysis Complete**\n"
-            summary += f"**Frames Analyzed:** {len(df)}\n"
-            summary += f"**Duration:** {df['timestamp'].max():.1f} seconds\n\n"
-            summary += "**Average Emotions:**\n"
-            for e, v in avg.items():
-                summary += f"• {e.title()}: {v:.1f}%\n"
-
-            return chart, summary
-
-        except Exception as e:
-            return None, f"Error: {str(e)}"
-
-def create_interface():
-    detector = EmotionDetector()
-    def process(video, rate): return detector.detect_emotions_video(video, rate)
-
-    return gr.Interface(
-        fn=process,
-        inputs=[
-            gr.Video(label="Upload Video"),
-            gr.Slider(minimum=1, maximum=60, step=1, value=30, label="Sample Rate")
-        ],
-        outputs=[
-            gr.Image(type="pil", label="Emotion Chart"),
-            gr.Textbox(label="Summary")
-        ],
-        title="Emotion Detection from Video",
-        description="Upload a video to analyze facial emotions using DeepFace."
-    )
+def analyze_video(video_path):
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    frames = []
+    count = 0
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        if count % int(fps * 2) == 0:  # sample every 2 seconds
+            frames.append(frame)
+        count += 1
+    cap.release()
+
+    emotions_summary = []
+    for i, frame in enumerate(frames):
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmpfile:
+            cv2.imwrite(tmpfile.name, frame)
+            try:
+                result = DeepFace.analyze(
+                    img_path=tmpfile.name,
+                    actions=['emotion'],
+                    enforce_detection=False,
+                    detector_backend='opencv',
+                    prog_backend='pytorch'
+                )
+                if isinstance(result, list):
+                    emotions_summary.append(result[0]['emotion'])
+                else:
+                    emotions_summary.append(result['emotion'])
+            except Exception as e:
+                print(f"Frame {i} skipped: {e}")
+            finally:
+                os.unlink(tmpfile.name)
+
+    df = pd.DataFrame(emotions_summary)
+    emotion_means = df.mean().sort_values(ascending=False)
+
+    # Plot
+    plt.figure(figsize=(10, 5))
+    emotion_means.plot(kind='bar', color='skyblue')
+    plt.title("Average Emotions in Video")
+    plt.ylabel("Probability")
+    plt.xticks(rotation=45)
+    plt.tight_layout()
+    plt.savefig("emotion_chart.png")
+    plt.close()
+
+    summary = "**Video Analysis Complete**\n"
+    summary += f"**Frames Analyzed:** {len(frames)}\n"
+    summary += f"**Duration:** {round(len(frames) * 2.0, 1)} seconds\n\n"
+    summary += "**Average Emotions:**\n"
+    for emotion, value in emotion_means.items():
+        summary += f"• {emotion.capitalize()}: {value:.1f}%\n"
+
+    return "emotion_chart.png", summary
+
+demo = gr.Interface(
+    fn=analyze_video,
+    inputs=gr.Video(label="Upload a Video"),
+    outputs=[
+        gr.Image(label="Emotion Chart"),
+        gr.Markdown(label="Emotion Summary")
+    ],
+    title="Emotion Recognition from Video",
+    description="Upload a short video. The app analyzes emotions every 2 seconds using DeepFace and PyTorch."
+)
 
 if __name__ == "__main__":
-    create_interface().launch()
+    demo.launch()