commiting

app.py

@@ -53,13 +53,11 @@ selected_model = st.sidebar.selectbox(
     list(model_options.keys())
 )
 
-# Input method selection with addition of video upload and simulation
 input_method = st.sidebar.radio(
     "Choose Input Method",
     ["Real-time Webcam", "Upload an Image", "Capture Image"]
 )
 
-# Confidence threshold
 confidence_threshold = st.sidebar.slider(
     "Confidence Threshold",
     min_value=0.0,
@@ -68,11 +66,8 @@ confidence_threshold = st.sidebar.slider(
     step=0.05
 )
 
-# Face detection toggle
 use_face_detection = st.sidebar.checkbox("Enable Face Detection", value=True)
 
-
-# History length for real-time tracking
 if input_method in ["Real-time Webcam", "Upload Video", "Simulation Mode"]:
     history_length = st.sidebar.slider(
         "Emotion History Length (seconds)",
@@ -89,10 +84,9 @@ face_detector = load_face_detector()
 # --- Utility Functions ---
 def detect_faces(image):
     """Detect faces in an image using OpenCV."""
-    # Convert PIL Image to OpenCV format
     if isinstance(image, Image.Image):
         opencv_image = np.array(image)
-        opencv_image = opencv_image[:, :, ::-1].copy()  # Convert RGB to BGR
+        opencv_image = opencv_image[:, :, ::-1].copy()  
     else:
         opencv_image = image
     
@@ -136,7 +130,6 @@ def draw_faces_with_emotions(image, faces, emotions):
     """Draw rectangles around faces and label with emotions."""
     img = image.copy()
     
-    # Define colors for different emotions (BGR format)
     emotion_colors = {
         "happy": (0, 255, 0),      # Green
         "sad": (255, 0, 0),        # Blue
@@ -147,15 +140,14 @@ def draw_faces_with_emotions(image, faces, emotions):
         "disgust": (0, 128, 128)   # Brown
     }
     
-    # Default color for unknown emotions
-    default_color = (255, 255, 255)  # White
+    default_color = (255, 255, 255)  
     
     for (x, y, w, h), emotion in zip(faces, emotions):
-        # Get color based on emotion (lowercase and remove any prefix)
+       
         emotion_key = emotion["label"].lower().split("_")[-1]
         color = emotion_colors.get(emotion_key, default_color)
         
-        # Draw rectangle around face
+        
         cv2.rectangle(img, (x, y), (x+w, y+h), color, 2)
         
         # Add emotion label and confidence
@@ -190,7 +182,7 @@ def generate_simulated_face(frame_num, canvas_size=(640, 480)):
     eye_size = max(5, face_radius // 8)
     
     # Blink occasionally
-    if frame_num % 50 > 45:  # Blink every 50 frames for 5 frames
+    if frame_num % 50 > 45:  
         cv2.ellipse(canvas, (left_eye_x, eye_y), (eye_size, 1), 0, 0, 360, (30, 30, 30), -1)
         cv2.ellipse(canvas, (right_eye_x, eye_y), (eye_size, 1), 0, 0, 360, (30, 30, 30), -1)
     else:
@@ -199,12 +191,12 @@ def generate_simulated_face(frame_num, canvas_size=(640, 480)):
         cv2.circle(canvas, (left_eye_x, eye_y), eye_size-2, (70, 70, 70), -1)
         cv2.circle(canvas, (right_eye_x, eye_y), eye_size-2, (70, 70, 70), -1)
     
-    # Draw mouth - change shape based on frame number to simulate different emotions
+   
     mouth_y = face_y + int(face_radius * 0.3)
     mouth_width = int(face_radius * 0.6)
     mouth_height = int(face_radius * 0.2)
     
-    # Cycle through different emotions based on frame number
+ 
     emotion_cycle = (frame_num // 100) % 4
     
     if emotion_cycle == 0:  # Happy
@@ -223,7 +215,7 @@ def generate_simulated_face(frame_num, canvas_size=(640, 480)):
         cv2.line(canvas, (face_x - mouth_width//2, mouth_y), 
                 (face_x + mouth_width//2, mouth_y), (50, 50, 50), 2)
     
-    # Add some text showing what emotion is being simulated
+    
     emotions = ["Happy", "Sad", "Surprised", "Neutral"]
     cv2.putText(canvas, f"Simulating: {emotions[emotion_cycle]}", 
                 (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (50, 50, 50), 2)
@@ -234,12 +226,12 @@ def generate_simulated_face(frame_num, canvas_size=(640, 480)):
 
 def process_video_feed(feed_source, is_simulation=False):
     """Process video feed (webcam, video file, or simulation)."""
-    # Create placeholders
+    
     video_placeholder = st.empty()
     metrics_placeholder = st.empty()
     chart_placeholder = st.empty()
     
-    # Initialize session state for tracking emotions over time
+    
     if 'emotion_history' not in st.session_state:
         st.session_state.emotion_history = {}
         st.session_state.last_update_time = time.time()
@@ -270,12 +262,12 @@ def process_video_feed(feed_source, is_simulation=False):
             
             # Create deques for tracking emotions
             emotion_deques = {}
-            timestamp_deque = deque(maxlen=30*history_length)  # Store timestamps for X seconds at 30fps
+            timestamp_deque = deque(maxlen=30*history_length)  
             
             while st.session_state.get('running', False):
                 # Get frame
                 if is_simulation:
-                    # Generate a simulated frame
+                
                     frame = generate_simulated_face(st.session_state.simulation_frame)
                     st.session_state.simulation_frame += 1
                     ret = True
@@ -287,18 +279,18 @@ def process_video_feed(feed_source, is_simulation=False):
                     if is_simulation:
                         st.error("Simulation error")
                     elif input_method == "Upload Video":
-                        # For video files, loop back to the beginning
+                        
                         cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
                         continue
                     else:
                         st.error("Failed to capture frame from video source")
                     break
                 
-                # For webcam, flip horizontally for a more natural view
+                
                 if input_method == "Real-time Webcam" and not is_simulation:
                     frame = cv2.flip(frame, 1)
                 
-                # Increment frame count for FPS calculation
+                
                 st.session_state.frame_count += 1
                 
                 # Detect faces
@@ -349,7 +341,7 @@ def process_video_feed(feed_source, is_simulation=False):
                         2
                     )
                     
-                    # Update emotion history
+                   
                     current_time = time.time()
                     timestamp_deque.append(current_time)
                     
@@ -362,34 +354,33 @@ def process_video_feed(feed_source, is_simulation=False):
                         "time": current_time
                     })
                 
-                # Calculate FPS
+                
                 current_time = time.time()
                 time_diff = current_time - st.session_state.last_update_time
-                if time_diff >= 1.0:  # Update every second
+                if time_diff >= 1.0:  
                     fps = st.session_state.frame_count / time_diff
                     st.session_state.last_update_time = current_time
                     st.session_state.frame_count = 0
                     
-                    # Update metrics
+                    
                     with metrics_placeholder.container():
                         cols = st.columns(3)
                         cols[0].metric("FPS", f"{fps:.1f}")
                         cols[1].metric("Faces Detected", len(faces) if use_face_detection else "N/A")
                 
-                # Display the frame
                 video_placeholder.image(frame, channels="BGR", use_column_width=True)
                 
-                # Update emotion history chart periodically
-                if len(timestamp_deque) > 0 and time_diff >= 0.5:  # Update chart every 0.5 seconds
+               
+                if len(timestamp_deque) > 0 and time_diff >= 0.5:
                     with chart_placeholder.container():
-                        # Create tabs for each face
+                        
                         if len(emotion_deques) > 0:
                             tabs = st.tabs(list(emotion_deques.keys()))
                             
                             for i, (face_id, emotion_data) in enumerate(emotion_deques.items()):
                                 with tabs[i]:
                                     if len(emotion_data) > 0:
-                                        # Count occurrences of each emotion
+                                        
                                         emotion_counts = {}
                                         for entry in emotion_data:
                                             emotion = entry["emotion"]
@@ -397,7 +388,7 @@ def process_video_feed(feed_source, is_simulation=False):
                                                 emotion_counts[emotion] = 0
                                             emotion_counts[emotion] += 1
                                         
-                                        # Create pie chart for emotion distribution
+                                        
                                         fig = go.Figure(data=[go.Pie(
                                             labels=list(emotion_counts.keys()),
                                             values=list(emotion_counts.values()),
@@ -406,8 +397,8 @@ def process_video_feed(feed_source, is_simulation=False):
                                         fig.update_layout(title=f"Emotion Distribution - {face_id}")
                                         st.plotly_chart(fig, use_container_width=True)
                                         
-                                        # Create line chart for emotion confidence over time
-                                        emotions = list(emotion_data)[-20:]  # Get the last 20 entries
+                                    
+                                        emotions = list(emotion_data)[-20:]  
                                         times = [(e["time"] - emotions[0]["time"]) for e in emotions]
                                         confidences = [e["confidence"] for e in emotions]
                                         emotion_labels = [e["emotion"] for e in emotions]
@@ -432,11 +423,11 @@ def process_video_feed(feed_source, is_simulation=False):
                         else:
                             st.info("No emotion data available yet.")
                 
-                # Control processing speed for videos and simulation
+                
                 if input_method in ["Upload Video", "Simulation Mode"]:
-                    time.sleep(0.03 / processing_speed)  # Adjust delay based on processing_speed
+                    time.sleep(0.03 / processing_speed)  
+            
             
-            # Release resources when done
             if not is_simulation and cap.isOpened():
                 cap.release()
         
@@ -444,7 +435,6 @@ def process_video_feed(feed_source, is_simulation=False):
             st.error(f"Error during processing: {str(e)}")
             st.session_state.running = False
     else:
-        # Display a placeholder image when not running
         placeholder_img = np.zeros((300, 500, 3), dtype=np.uint8)
         cv2.putText(
             placeholder_img,
@@ -479,7 +469,6 @@ def process_static_image(image):
             with col2:
                 st.image(result_image, caption="Detected Emotions", channels="BGR", use_column_width=True)
             
-            # Display predictions
             st.subheader("Detected Emotions:")
             for i, (emotion, face) in enumerate(zip(emotions, faces)):
                 if emotion["score"] >= confidence_threshold:
@@ -505,7 +494,6 @@ def process_static_image(image):
         else:
             st.warning("No faces detected in the image. Try another image or disable face detection.")
     else:
-        # Process the whole image
         prediction = predict_emotion(image)
         st.subheader("Prediction:")
         st.write(f"**Emotion:** {prediction['label']}")
@@ -516,7 +504,6 @@ if input_method == "Upload an Image":
     uploaded_file = st.file_uploader("Choose an image file", type=["jpg", "jpeg", "png"])
     
     if uploaded_file is not None:
-        # Load and display image
         image = Image.open(uploaded_file).convert("RGB")
         process_static_image(image)
 
@@ -531,17 +518,13 @@ elif input_method == "Upload Video":
     uploaded_video = st.file_uploader("Upload a video file", type=["mp4", "avi", "mov", "mkv"])
     
     if uploaded_video is not None:
-        # Save the uploaded video to a temporary file
         tfile = tempfile.NamedTemporaryFile(delete=False)
         tfile.write(uploaded_video.read())
         
-        # Open the video file
         cap = cv2.VideoCapture(tfile.name)
         
-        # Process the video
         process_video_feed(cap)
         
-        # Clean up the temporary file
         os.unlink(tfile.name)
 
 elif input_method == "Simulation Mode":
@@ -556,15 +539,6 @@ elif input_method == "Real-time Webcam":
             st.error("Could not open webcam. Please try the Simulation Mode instead.")
             st.info("If you're using Streamlit in a browser, make sure you've granted camera permissions.")
             
-            # Show troubleshooting tips
-            with st.expander("Webcam Troubleshooting Tips"):
-                st.markdown("""
-                1. **Check Browser Permissions**: Make sure your browser has permission to access your camera.
-                2. **Close Other Applications**: Other applications might be using your webcam.
-                3. **Refresh the Page**: Sometimes simply refreshing can resolve the issue.
-                4. **Try a Different Browser**: Some browsers handle webcam access better than others.
-                5. **Use Simulation Mode**: If you cannot get the webcam working, use the Simulation Mode.
-                """)
         else:
             # Webcam available, process it
             process_video_feed(cap)