Update app.py

app.py

@@ -2,59 +2,63 @@ import gradio as gr
 import cv2
 import mediapipe as mp
 import numpy as np
-from stress_detection import *  # Import your entire code
+import base64
+from io import BytesIO
+from PIL import Image
 
-# Initialize detectors (create once, reuse for all images)
-au01 = AU01Detector()
-au04 = AU04Detector()
-au06 = AU06Detector()
-au07 = AU07Detector()
-au12 = AU12Detector()
-au14 = AU14Detector()
-au17 = AU17Detector()
-au23 = AU23Detector()
-au24 = AU24Detector()
-au26 = AU26Detector()
+# Import your detector classes
+from stress_detection import (
+    AU01Detector, AU04Detector, AU06Detector, AU07Detector,
+    AU12Detector, AU14Detector, AU17Detector, AU23Detector,
+    AU24Detector, AU26Detector, mp_face_mesh
+)
+
+# Initialize all detectors globally
+au01 = AU01Detector(window_size=10)
+au04 = AU04Detector(window_size=10)
+au06 = AU06Detector(window_size=10)
+au07 = AU07Detector(window_size=10)
+au12 = AU12Detector(window_size=10)
+au14 = AU14Detector(window_size=10)
+au17 = AU17Detector(window_size=10)
+au23 = AU23Detector(window_size=10)
+au24 = AU24Detector(window_size=10)
+au26 = AU26Detector(window_size=10)
 
 detectors = [au01, au04, au06, au07, au12, au14, au17, au23, au24, au26]
 
 # Initialize MediaPipe
-mp_face_mesh = mp.solutions.face_mesh
 face_mesh = mp_face_mesh.FaceMesh(
     min_detection_confidence=0.5,
     min_tracking_confidence=0.5,
     refine_landmarks=True
 )
 
-def detect_stress_from_single_image(image):
+def process_frame(frame):
     """
-    Process a single image and return stress prediction
-    
-    Args:
-        image: numpy array (BGR from Gradio)
-    
-    Returns:
-        dict: Stress classification with probabilities
+    Process a single frame from webcam
+    Returns: processed frame with overlays + stress analysis
     """
-    if image is None:
-        return {"Error": "No image provided"}
+    if frame is None:
+        return None, "No frame received"
     
     try:
-        # Get image dimensions
-        frame_height, frame_width = image.shape[:2]
-        
-        # Convert to RGB for MediaPipe
-        rgb_frame = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        # Convert from RGB (Gradio) to BGR (OpenCV)
+        frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+        frame_height, frame_width = frame_bgr.shape[:2]
         
         # Process with MediaPipe
+        rgb_frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
         results = face_mesh.process(rgb_frame)
         
         if not results.multi_face_landmarks:
-            return {"Error": "No face detected in image"}
+            cv2.putText(frame_bgr, "No face detected", (50, 50),
+                       cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
+            return cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB), "⚠️ No face detected"
         
         landmarks = results.multi_face_landmarks[0].landmark
         
-        # Detect all 10 AUs
+        # Detect all AUs
         au01_active, au01_intensity = au01.detect(landmarks, frame_width, frame_height)
         au04_active, au04_intensity = au04.detect(landmarks, frame_width, frame_height)
         au06_active, au06_intensity = au06.detect(landmarks, frame_width, frame_height)
@@ -66,103 +70,159 @@ def detect_stress_from_single_image(image):
         au24_active, au24_intensity = au24.detect(landmarks, frame_width, frame_height)
         au26_active, au26_intensity = au26.detect(landmarks, frame_width, frame_height)
         
-        # Calculate simple stress score from single frame
-        stress_aus_intensity = (au01_intensity + au04_intensity + au07_intensity + 
-                                au17_intensity + au23_intensity + au24_intensity) / 6
+        # Draw overlays (like your original code)
+        overlay = frame_bgr.copy()
+        
+        # Create semi-transparent overlay panels
+        cv2.rectangle(overlay, (5, 5), (300, 200), (50, 50, 50), -1)
+        cv2.rectangle(overlay, (frame_width - 305, 5), (frame_width - 5, 150), (50, 50, 50), -1)
+        frame_bgr = cv2.addWeighted(overlay, 0.7, frame_bgr, 0.3, 0)
+        
+        # Left panel: Stress Indicators
+        y_offset = 25
+        cv2.putText(frame_bgr, "STRESS INDICATORS:", (10, y_offset),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
+        y_offset += 25
+        
+        stress_aus = [
+            (au01_active, au01_intensity, "AU01-BrowRaise"),
+            (au04_active, au04_intensity, "AU04-BrowLower"),
+            (au07_active, au07_intensity, "AU07-LidTight"),
+            (au17_active, au17_intensity, "AU17-ChinRaise"),
+            (au23_active, au23_intensity, "AU23-LipTight"),
+            (au24_active, au24_intensity, "AU24-LipPress")
+        ]
+        
+        stress_count = 0
+        for active, intensity, name in stress_aus:
+            if active:
+                stress_count += 1
+            color = (0, 0, 255) if active else (150, 150, 150)
+            cv2.putText(frame_bgr, f"{name}: {intensity:.0f}%",
+                       (15, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
+            y_offset += 22
         
-        positive_aus_intensity = (au06_intensity + au12_intensity + au14_intensity) / 3
+        # Right panel: Positive Indicators
+        y_offset = 25
+        x_right = frame_width - 300
+        cv2.putText(frame_bgr, "POSITIVE:", (x_right, y_offset),
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        y_offset += 25
         
-        # Simple scoring for single frame
-        stress_score = stress_aus_intensity - (positive_aus_intensity * 0.3)
-        stress_score = min(100, max(0, stress_score))
+        positive_aus = [
+            (au06_active, au06_intensity, "AU06-Cheek"),
+            (au12_active, au12_intensity, "AU12-Smile"),
+            (au14_active, au14_intensity, "AU14-Dimple"),
+            (au26_active, au26_intensity, "AU26-Jaw")
+        ]
         
-        # Classification
-        if stress_score < 30:
-            return {
-                "Not Stressed 😊": float(100 - stress_score) / 100,
-                "Stressed 😰": float(stress_score) / 100
-            }
+        positive_count = 0
+        for active, intensity, name in positive_aus:
+            if active:
+                positive_count += 1
+            color = (0, 255, 0) if active else (150, 150, 150)
+            cv2.putText(frame_bgr, f"{name}: {intensity:.0f}%",
+                       (x_right, y_offset), cv2.FONT_HERSHEY_SIMPLEX, 0.4, color, 1)
+            y_offset += 22
+        
+        # Bottom status bar
+        cv2.rectangle(frame_bgr, (0, frame_height - 40), (frame_width, frame_height), (40, 40, 40), -1)
+        
+        # Simple stress calculation
+        stress_score = (au01_intensity + au04_intensity + au07_intensity + 
+                       au17_intensity + au23_intensity + au24_intensity) / 6
+        
+        if stress_score > 50:
+            status = "🔴 STRESSED"
+            status_color = (0, 0, 255)
+        elif stress_score > 25:
+            status = "🟡 POSSIBLY STRESSED"
+            status_color = (0, 165, 255)
         else:
-            return {
-                "Stressed 😰": float(stress_score) / 100,
-                "Not Stressed 😊": float(100 - stress_score) / 100
-            }
+            status = "🟢 NOT STRESSED"
+            status_color = (0, 255, 0)
+        
+        cv2.putText(frame_bgr, f"{status} | Score: {stress_score:.1f}/100 | Stress AUs: {stress_count}/6 | Positive: {positive_count}/4",
+                   (10, frame_height - 12), cv2.FONT_HERSHEY_SIMPLEX, 0.6, status_color, 2)
+        
+        # Convert back to RGB for Gradio
+        output_frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+        
+        # Create detailed text output
+        analysis_text = f"""
+🎯 CURRENT ANALYSIS:
+
+{status}
+Stress Score: {stress_score:.1f}/100
+
+📊 STRESS INDICATORS:
+- AU01 (Inner Brow): {au01_intensity:.0f}% {'✓ ACTIVE' if au01_active else ''}
+- AU04 (Brow Lower): {au04_intensity:.0f}% {'✓ ACTIVE' if au04_active else ''}
+- AU07 (Lid Tighten): {au07_intensity:.0f}% {'✓ ACTIVE' if au07_active else ''}
+- AU17 (Chin Raise): {au17_intensity:.0f}% {'✓ ACTIVE' if au17_active else ''}
+- AU23 (Lip Tighten): {au23_intensity:.0f}% {'✓ ACTIVE' if au23_active else ''}
+- AU24 (Lip Press): {au24_intensity:.0f}% {'✓ ACTIVE' if au24_active else ''}
+
+😊 POSITIVE INDICATORS:
+- AU06 (Cheek Raise): {au06_intensity:.0f}% {'✓ ACTIVE' if au06_active else ''}
+- AU12 (Smile): {au12_intensity:.0f}% {'✓ ACTIVE' if au12_active else ''}
+- AU14 (Dimpler): {au14_intensity:.0f}% {'✓ ACTIVE' if au14_active else ''}
+- AU26 (Jaw Drop): {au26_intensity:.0f}% {'✓ ACTIVE' if au26_active else ''}
+        """
+        
+        return output_frame, analysis_text
         
     except Exception as e:
-        return {"Error": f"Processing failed: {str(e)}"}
+        return frame, f"❌ Error: {str(e)}"
 
 
-# Create Gradio interface
-with gr.Blocks(title="Stress Detection System", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🧠 Stress Detection System")
-    gr.Markdown("### AI-Powered Facial Expression Analysis using 10 Action Units (FACS)")
-    gr.Markdown("*Based on Facial Action Coding System - Ekman & Friesen*")
+# Create Gradio Interface
+with gr.Blocks(title="Real-Time Stress Detection", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🧠 Real-Time 10-AU Stress Detection System")
+    gr.Markdown("### Live Facial Expression Analysis - Based on FACS")
+    gr.Markdown("*Research Guide: Prof. Anup Nandy*")
     
     with gr.Row():
-        with gr.Column():
-            image_input = gr.Image(
+        with gr.Column(scale=2):
+            webcam = gr.Image(
                 sources=["webcam"],
-                type="numpy",
-                label="📹 Capture Your Face"
+                streaming=True,
+                label="📹 Live Webcam Feed"
             )
-            analyze_btn = gr.Button("🔍 Analyze Stress Level", variant="primary", size="lg")
             
             gr.Markdown("""
-            ### 📝 How to use:
-            1. Click the **webcam icon** above
-            2. Allow camera access
-            3. Position your face clearly in frame
-            4. Click **Analyze Stress Level**
+            ### 📝 Instructions:
+            1. **Allow camera access** when prompted
+            2. **Position your face** clearly in the frame
+            3. **Analysis runs automatically** in real-time
+            4. Watch the overlay for instant AU detection
             """)
-            
-        with gr.Column():
-            output_label = gr.Label(
-                num_top_classes=2,
-                label="📊 Stress Analysis Results"
+        
+        with gr.Column(scale=1):
+            analysis_output = gr.Textbox(
+                label="📊 Real-Time Analysis",
+                lines=20,
+                value="Waiting for camera..."
             )
-            
-            gr.Markdown("""
-            ### 🔬 Action Units Detected:
-            **Stress Indicators:**
-            - AU01: Inner Brow Raise
-            - AU04: Brow Lowerer  
-            - AU07: Lid Tightener
-            - AU17: Chin Raiser
-            - AU23: Lip Tightener
-            - AU24: Lip Pressor
-            
-            **Positive Indicators:**
-            - AU06: Cheek Raiser
-            - AU12: Lip Corner Puller
-            - AU14: Dimpler
-            - AU26: Jaw Drop
-            """)
-    
-    # Connect button
-    analyze_btn.click(
-        fn=detect_stress_from_single_image,
-        inputs=image_input,
-        outputs=output_label
-    )
     
     gr.Markdown("""
     ---
-    ### ℹ️ About
-    This system uses **10 Facial Action Units** based on the Facial Action Coding System (FACS) 
-    to detect stress through micro-expressions. Developed under the guidance of **Prof. Anup Nandy**.
+    ### 🔬 Action Units Being Tracked:
+    
+    **Stress Indicators:** AU01, AU04, AU07, AU17, AU23, AU24  
+    **Positive Indicators:** AU06, AU12, AU14, AU26
+    
+    The system analyzes your facial expressions in real-time and provides instant feedback 
+    on stress levels based on the Facial Action Coding System (FACS).
     """)
+    
+    # Process streaming webcam
+    webcam.stream(
+        fn=process_frame,
+        inputs=[webcam],
+        outputs=[webcam, analysis_output],
+        stream_every=0.1  # Process every 100ms (10 FPS)
+    )
 
-# Launch
 if __name__ == "__main__":
-    demo.launch()
-```
-
----
-
-## Final File Structure in Your Space:
-```
-your-space/
-├── app.py                  # ← Gradio interface (code above)
-├── stress_detection.py     # ← Your complete code (paste as-is)
-├── requirements.txt        # ← 6 packages listed above
-└── README.md              # ← Update with proper metadata
+    demo.launch()