app

app.py

@@ -1,79 +1,70 @@
-import os
+import gradio as gr
 import cv2
-import tempfile
 import pandas as pd
 import matplotlib.pyplot as plt
 from deepface import DeepFace
-import gradio as gr
+import tempfile
 
-def analyze_video(video_path):
+def analyze_emotions(video_path):
     cap = cv2.VideoCapture(video_path)
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    frames = []
-    count = 0
+    frame_rate = cap.get(cv2.CAP_PROP_FPS)
+    frame_interval = int(frame_rate * 2)  # Analyze every 2 seconds
+
+    emotion_data = []
+    frame_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)
+        if frame_count % frame_interval == 0:
             try:
-                result = DeepFace.analyze(
-                    img_path=tmpfile.name,
-                    actions=['emotion'],
-                    enforce_detection=False,
-                    detector_backend='opencv',
-                    prog_backend='pytorch'
+                analysis = DeepFace.analyze(
+                    frame,
+                    actions=["emotion"],
+                    detector_backend="opencv",  # TensorFlow-free
+                    enforce_detection=False
                 )
-                if isinstance(result, list):
-                    emotions_summary.append(result[0]['emotion'])
-                else:
-                    emotions_summary.append(result['emotion'])
+                emotion_data.append(analysis[0]["emotion"])
             except Exception as e:
-                print(f"Frame {i} skipped: {e}")
-            finally:
-                os.unlink(tmpfile.name)
+                print("Error analyzing frame:", e)
+        frame_count += 1
 
-    df = pd.DataFrame(emotions_summary)
-    emotion_means = df.mean().sort_values(ascending=False)
+    cap.release()
+
+    if not emotion_data:
+        return "No faces detected."
+
+    df = pd.DataFrame(emotion_data)
+    avg_emotions = 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)
+    fig, ax = plt.subplots(figsize=(6, 3))
+    avg_emotions.plot(kind='bar', ax=ax, color='skyblue')
+    ax.set_title("Average Emotions Across Video")
+    ax.set_ylabel("Confidence (%)")
+    ax.set_ylim(0, 100)
     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"
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmpfile:
+        plt.savefig(tmpfile.name)
+        plot_path = tmpfile.name
+
+    summary = f"""
+**Video Analysis Complete**  
+**Frames Analyzed:** {len(df)}  
+**Duration:** {round(frame_count / frame_rate, 1)} seconds  
+
+**Average Emotions:**\n""" + "\n".join([f"• {emotion}: {round(score, 1)}%" for emotion, score in avg_emotions.items()])
+
+    return summary, plot_path
 
-    return "emotion_chart.png", summary
 
-demo = gr.Interface(
-    fn=analyze_video,
+iface = gr.Interface(
+    fn=analyze_emotions,
     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."
+    outputs=[gr.Markdown(), gr.Image(type="filepath", label="Emotion Summary Chart")],
+    title="Emotion Analysis from Video (No TensorFlow)"
 )
 
-if __name__ == "__main__":
-    demo.launch()
+iface.launch()