app update

app.py

@@ -1,7 +1,5 @@
 import gradio as gr
-import cv2
 import numpy as np
-import librosa
 import pandas as pd
 import plotly.graph_objects as go
 import plotly.express as px
@@ -13,6 +11,22 @@ from collections import deque
 import warnings
 warnings.filterwarnings("ignore")
 
+# Try to import OpenCV with fallback
+try:
+    import cv2
+    CV2_AVAILABLE = True
+except ImportError:
+    CV2_AVAILABLE = False
+    print("OpenCV not available - using PIL for image processing")
+
+# Try to import librosa with fallback
+try:
+    import librosa
+    LIBROSA_AVAILABLE = True
+except ImportError:
+    LIBROSA_AVAILABLE = False
+    print("Librosa not available - using basic audio processing")
+
 # Try to import transformers and torch, with fallbacks
 try:
     from transformers import pipeline
@@ -22,6 +36,13 @@ except ImportError:
     HF_AVAILABLE = False
     print("Transformers not available - using mock emotion detection")
 
+# Additional imports for image processing if OpenCV fails
+try:
+    from PIL import Image, ImageDraw, ImageFont
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+
 class EmotionRecognitionSystem:
     def __init__(self):
         self.emotion_history = deque(maxlen=100)  # Store last 100 emotion readings
@@ -72,8 +93,22 @@ class EmotionRecognitionSystem:
             return dict(zip(emotions, scores))
         
         try:
-            # Convert frame to RGB
-            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            # Handle different image formats
+            if isinstance(frame, np.ndarray):
+                if CV2_AVAILABLE:
+                    # Convert frame to RGB if it's BGR
+                    if len(frame.shape) == 3 and frame.shape[2] == 3:
+                        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    else:
+                        rgb_frame = frame
+                else:
+                    # Use numpy operations for color conversion
+                    if len(frame.shape) == 3 and frame.shape[2] == 3:
+                        rgb_frame = frame[:, :, ::-1]  # BGR to RGB
+                    else:
+                        rgb_frame = frame
+            else:
+                rgb_frame = frame
             
             # Use face emotion model
             results = self.face_emotion_pipeline(rgb_frame)
@@ -113,6 +148,16 @@ class EmotionRecognitionSystem:
     
     def extract_audio_features(self, audio_data, sample_rate):
         """Extract audio features for emotion analysis"""
+        if not LIBROSA_AVAILABLE:
+            # Return mock features if librosa is not available
+            return {
+                'mfcc_mean': np.random.random(),
+                'mfcc_std': np.random.random(),
+                'spectral_centroid_mean': np.random.random(),
+                'zcr_mean': np.random.random(),
+                'spectral_rolloff_mean': np.random.random()
+            }
+        
         try:
             # Extract basic audio features
             mfccs = librosa.feature.mfcc(y=audio_data, sr=sample_rate, n_mfcc=13)
@@ -224,8 +269,14 @@ def process_video_audio(video_frame, audio_data):
     sample_rate = 16000
     if audio_data is not None:
         audio_array, sr = audio_data
-        if sr != sample_rate:
+        if LIBROSA_AVAILABLE and sr != sample_rate:
             audio_array = librosa.resample(audio_array, orig_sr=sr, target_sr=sample_rate)
+        elif not LIBROSA_AVAILABLE:
+            # Simple resampling if librosa not available
+            if sr != sample_rate:
+                # Basic downsampling
+                step = sr // sample_rate
+                audio_array = audio_array[::step] if step > 1 else audio_array
     else:
         audio_array = None
     
@@ -244,22 +295,56 @@ def process_video_audio(video_frame, audio_data):
 
 def create_emotion_overlay(frame, emotion_record):
     """Add emotion information overlay to video frame"""
-    annotated_frame = frame.copy()
-    
-    # Get top emotion
-    clinical_emotions = emotion_record['clinical_emotions']
-    top_emotion = max(clinical_emotions.items(), key=lambda x: x[1])
-    
-    # Add text overlay
-    cv2.putText(annotated_frame, f"Primary: {top_emotion[0]} ({top_emotion[1]:.2f})", 
-                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
-    
-    # Add alert indicator
-    if emotion_record['alerts']:
-        cv2.putText(annotated_frame, "ALERT!", (10, 60), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-    
-    return annotated_frame
+    try:
+        if CV2_AVAILABLE:
+            annotated_frame = frame.copy()
+            
+            # Get top emotion
+            clinical_emotions = emotion_record['clinical_emotions']
+            top_emotion = max(clinical_emotions.items(), key=lambda x: x[1])
+            
+            # Add text overlay
+            cv2.putText(annotated_frame, f"Primary: {top_emotion[0]} ({top_emotion[1]:.2f})", 
+                        (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
+            
+            # Add alert indicator
+            if emotion_record['alerts']:
+                cv2.putText(annotated_frame, "ALERT!", (10, 60), 
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
+            
+            return annotated_frame
+        
+        elif PIL_AVAILABLE:
+            # Use PIL for image annotation
+            pil_image = Image.fromarray(frame)
+            draw = ImageDraw.Draw(pil_image)
+            
+            # Get top emotion
+            clinical_emotions = emotion_record['clinical_emotions']
+            top_emotion = max(clinical_emotions.items(), key=lambda x: x[1])
+            
+            # Add text overlay
+            try:
+                font = ImageFont.load_default()
+            except:
+                font = None
+            
+            text = f"Primary: {top_emotion[0]} ({top_emotion[1]:.2f})"
+            draw.text((10, 10), text, fill=(0, 255, 0), font=font)
+            
+            # Add alert indicator
+            if emotion_record['alerts']:
+                draw.text((10, 40), "ALERT!", fill=(255, 0, 0), font=font)
+            
+            return np.array(pil_image)
+        
+        else:
+            # Return original frame if no image processing available
+            return frame
+            
+    except Exception as e:
+        print(f"Error creating emotion overlay: {e}")
+        return frame
 
 def format_clinical_emotions(clinical_emotions):
     """Format clinical emotions for display"""