jbdfbsdf

README.md

@@ -1,20 +1,3 @@
----
-title: FinalProject
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Real-time Facial Emotion Recognition System
-license: mit
----
+Need To adjust things to be able to run in Huggingface
 
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+If you want to run locally, please use the app(for local).py

Video_Presentation.txt

@@ -0,0 +1 @@
+https://www.canva.com/design/DAGoMR6EmvM/Q0SFJu1gnHcW7B6oMkNn5A/watch?utm_content=DAGoMR6EmvM&utm_campaign=share_your_design&utm_medium=link2&utm_source=shareyourdesignpanel

app(for local).py

@@ -0,0 +1,174 @@
+# app.py
+
+import streamlit as st
+import cv2
+import numpy as np
+import tensorflow as tf
+import time
+import os
+
+# --- Streamlit Page Configuration (MUST BE THE FIRST STREAMLIT COMMAND) ---
+st.set_page_config(page_title="Real-time Emotion Recognition", layout="wide")
+
+# --- 1. Load Model and Face Detector (Cached for Performance) ---
+
+@st.cache_resource
+def load_emotion_model():
+    model_path = 'models/emotion_model_best.h5' # Path to your trained model
+    if not os.path.exists(model_path):
+        st.error(f"Error: Model file not found at {model_path}. Please ensure training was successful and the file exists.")
+        st.stop()
+    try:
+        model = tf.keras.models.load_model(model_path)
+        return model
+    except Exception as e:
+        st.error(f"Error loading model from {model_path}: {e}")
+        st.stop()
+
+@st.cache_resource
+def load_face_detector():
+    cascade_path = 'haarcascade_frontalface_default.xml' # Path to your Haar Cascade file
+    if not os.path.exists(cascade_path):
+        st.error(f"Error: Haar Cascade file not found at {cascade_path}.")
+        st.markdown("Please download `haarcascade_frontalface_default.xml` from:")
+        st.markdown("[https://github.com/opencv/opencv/blob/4.x/data/haarcascades/haarcascade_frontalface_default.xml](https://github.com/opencv/opencv/blob/4.x/data/haarcascades/haarcascade_frontalface_default.xml)")
+        st.markdown("And place it in a `cascades` folder next to `app.py`.")
+        st.stop()
+    face_cascade = cv2.CascadeClassifier(cascade_path)
+    if face_cascade.empty():
+        st.error(f"Error: Could not load Haar Cascade classifier from {cascade_path}. Check file integrity.")
+        st.stop()
+    return face_cascade
+
+# Load the model and face detector when the app starts
+model = load_emotion_model()
+face_detector = load_face_detector()
+
+# --- 2. Define Constants and Labels ---
+IMG_HEIGHT = 48
+IMG_WIDTH = 48
+emotion_labels = ['angry', 'disgust', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+label_colors = {
+    'angry': (0, 0, 255),    # BGR Red
+    'disgust': (0, 165, 255), # BGR Orange
+    'fear': (0, 255, 255),   # BGR Yellow
+    'happy': (0, 255, 0),    # BGR Green
+    'neutral': (255, 255, 0), # BGR Cyan
+    'sad': (255, 0, 0),      # BGR Blue
+    'surprise': (255, 0, 255) # BGR Magenta
+}
+
+# --- 3. Streamlit App Layout ---
+st.title("Live Facial Emotion Recognition")
+
+st.markdown("""
+This application uses a deep learning model (trained on FER-2013) to detect emotions from faces in real-time.
+It requires access to your computer's webcam.
+""")
+
+stframe = st.empty()
+st_status = st.empty()
+
+col1, col2 = st.columns([1,1])
+with col1:
+    start_button = st.button("Start Camera", key="start_camera")
+with col2:
+    stop_button = st.button("Stop Camera", key="stop_camera")
+
+# Initialize session state for camera control and performance tracking
+if "camera_started" not in st.session_state:
+    st.session_state.camera_started = False
+if "cap" not in st.session_state:
+    st.session_state.cap = None
+if "last_process_time" not in st.session_state:
+    st.session_state.last_process_time = 0.0
+
+# --- Performance Configuration ---
+DESIRED_FPS = 15 # Aim for 15 frames per second for processing
+FRAME_INTERVAL_SECONDS = 1.0 / DESIRED_FPS
+FACE_DETECTION_DOWNSCALE = 0.5 # Scale factor for face detection (e.g., 0.5 means half size)
+
+# --- 4. Main Camera Loop Logic ---
+
+if start_button:
+    st.session_state.camera_started = True
+
+if stop_button:
+    st.session_state.camera_started = False
+    st_status.info("Camera stopped.")
+    if st.session_state.cap is not None and st.session_state.cap.isOpened():
+        st.session_state.cap.release()
+        st.session_session.cap = None
+    stframe.empty()
+    # Updated: use_container_width instead of use_column_width
+    stframe.image(np.zeros((480, 640, 3), dtype=np.uint8), channels="RGB", use_container_width=True)
+
+if st.session_state.camera_started:
+    st_status.info("Starting camera... Please allow camera access if prompted.")
+
+    if st.session_state.cap is None or not st.session_state.cap.isOpened():
+        st.session_state.cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
+        if not st.session_state.cap.isOpened():
+            st_status.error("Failed to open camera. Please check if it's connected and not in use.")
+            st.session_state.camera_started = False
+            st.stop()
+
+    while st.session_state.camera_started:
+        ret, frame = st.session_state.cap.read()
+        if not ret:
+            st_status.error("Failed to read frame from camera. It might be disconnected or an error occurred.")
+            st.session_state.camera_started = False
+            break
+
+        current_time = time.time()
+        if current_time - st.session_state.last_process_time >= FRAME_INTERVAL_SECONDS:
+            st.session_state.last_process_time = current_time
+
+            gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+            small_frame = cv2.resize(gray_frame, (0, 0), fx=FACE_DETECTION_DOWNSCALE, fy=FACE_DETECTION_DOWNSCALE)
+            
+            faces = face_detector.detectMultiScale(small_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+
+            original_faces = []
+            for (x, y, w, h) in faces:
+                x_orig = int(x / FACE_DETECTION_DOWNSCALE)
+                y_orig = int(y / FACE_DETECTION_DOWNSCALE)
+                w_orig = int(w / FACE_DETECTION_DOWNSCALE)
+                h_orig = int(h / FACE_DETECTION_DOWNSCALE)
+                original_faces.append((x_orig, y_orig, w_orig, h_orig))
+
+            for (x, y, w, h) in original_faces:
+                cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
+
+                face_roi = gray_frame[max(0, y):min(gray_frame.shape[0], y+h), max(0, x):min(gray_frame.shape[1], x+w)]
+
+                if face_roi.size == 0:
+                    continue
+
+                face_roi = cv2.resize(face_roi, (IMG_WIDTH, IMG_HEIGHT))
+                face_roi = np.expand_dims(face_roi, axis=0)
+                face_roi = np.expand_dims(face_roi, axis=-1)
+                face_roi = face_roi / 255.0
+
+                predictions = model.predict(face_roi, verbose=0)[0]
+                emotion_index = np.argmax(predictions)
+                predicted_emotion = emotion_labels[emotion_index]
+                confidence = predictions[emotion_index] * 100
+
+                text_color = label_colors.get(predicted_emotion, (255, 255, 255))
+                text = f"{predicted_emotion} ({confidence:.2f}%)"
+                text_y = y - 10 if y - 10 > 10 else y + h + 20
+                cv2.putText(frame, text, (x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.9, text_color, 2, cv2.LINE_AA)
+
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            # Updated: use_container_width instead of use_column_width
+            stframe.image(frame_rgb, channels="RGB", use_container_width=True)
+
+        time.sleep(0.001) # Small sleep to yield control, can be adjusted or removed
+
+    if st.session_state.cap is not None and st.session_state.cap.isOpened():
+        st.session_state.cap.release()
+        st.session_state.cap = None
+        st_status.info("Camera released.")

requirements.txt

@@ -1,4 +1,7 @@
+# requirements.txt
 streamlit
 opencv-python
+tensorflow # or tensorflow-cpu
 numpy
-tensorflow
+streamlit-webrtc # <-- NEW
+# Add any other libraries your app uses

src/streamlit_app.py

@@ -4,8 +4,9 @@ import streamlit as st
 import cv2
 import numpy as np
 import tensorflow as tf
-import time
 import os
+from streamlit_webrtc import webrtc_streamer, VideoTransformerBase, WebRtcMode
+import av # Part of streamlit-webrtc's dependencies for frame handling
 
 # --- Streamlit Page Configuration (MUST BE THE FIRST STREAMLIT COMMAND) ---
 st.set_page_config(page_title="Real-time Emotion Recognition", layout="wide")
@@ -14,9 +15,14 @@ st.set_page_config(page_title="Real-time Emotion Recognition", layout="wide")
 
 @st.cache_resource
 def load_emotion_model():
-    model_path = 'models/emotion_model_best.h5' # Path to your trained model
+    # Path to your trained model.
+    # In a Docker container, the app's working directory will be /app.
+    # So if your models folder is at /app/models, then 'models/...' is correct.
+    # Ensure your Dockerfile copies the 'models' folder correctly.
+    model_path = 'models/emotion_model_best.h5' 
+    
     if not os.path.exists(model_path):
-        st.error(f"Error: Model file not found at {model_path}. Please ensure training was successful and the file exists.")
+        st.error(f"Error: Model file not found at {model_path}. Please ensure it's copied into the Docker image and path is correct.")
         st.stop()
     try:
         model = tf.keras.models.load_model(model_path)
@@ -27,12 +33,15 @@ def load_emotion_model():
 
 @st.cache_resource
 def load_face_detector():
-    cascade_path = 'haarcascade_frontalface_default.xml' # Path to your Haar Cascade file
+    # Path to your Haar Cascade file.
+    # Ensure 'haarcascade_frontalface_default.xml' is in the root of your project
+    # directory (which is copied to /app in Docker) for this path to be correct.
+    cascade_path = 'haarcascade_frontalface_default.xml'
+
     if not os.path.exists(cascade_path):
         st.error(f"Error: Haar Cascade file not found at {cascade_path}.")
-        st.markdown("Please download `haarcascade_frontalface_default.xml` from:")
-        st.markdown("[https://github.com/opencv/opencv/blob/4.x/data/haarcascades/haarcascade_frontalface_default.xml](https://github.com/opencv/opencv/blob/4.x/data/haarcascades/haarcascade_frontalface_default.xml)")
-        st.markdown("And place it in a `cascades` folder next to `app.py`.")
+        st.markdown("Please ensure `haarcascade_frontalface_default.xml` is in the root of your project directory alongside `src/` and `models/`.")
+        st.markdown("Download from: [https://github.com/opencv/opencv/blob/4.x/data/haarcascades/haarcascade_frontalface_default.xml](https://github.com/opencv/opencv/blob/4.x/data/haarcascades/haarcascade_frontalface_default.xml)")
         st.stop()
     face_cascade = cv2.CascadeClassifier(cascade_path)
     if face_cascade.empty():
@@ -59,116 +68,94 @@ label_colors = {
     'surprise': (255, 0, 255) # BGR Magenta
 }
 
-# --- 3. Streamlit App Layout ---
-st.title("Live Facial Emotion Recognition")
-
-st.markdown("""
-This application uses a deep learning model (trained on FER-2013) to detect emotions from faces in real-time.
-It requires access to your computer's webcam.
-""")
-
-stframe = st.empty()
-st_status = st.empty()
-
-col1, col2 = st.columns([1,1])
-with col1:
-    start_button = st.button("Start Camera", key="start_camera")
-with col2:
-    stop_button = st.button("Stop Camera", key="stop_camera")
-
-# Initialize session state for camera control and performance tracking
-if "camera_started" not in st.session_state:
-    st.session_state.camera_started = False
-if "cap" not in st.session_state:
-    st.session_state.cap = None
-if "last_process_time" not in st.session_state:
-    st.session_state.last_process_time = 0.0
-
-# --- Performance Configuration ---
-DESIRED_FPS = 15 # Aim for 15 frames per second for processing
-FRAME_INTERVAL_SECONDS = 1.0 / DESIRED_FPS
-FACE_DETECTION_DOWNSCALE = 0.5 # Scale factor for face detection (e.g., 0.5 means half size)
-
-# --- 4. Main Camera Loop Logic ---
-
-if start_button:
-    st.session_state.camera_started = True
-
-if stop_button:
-    st.session_state.camera_started = False
-    st_status.info("Camera stopped.")
-    if st.session_state.cap is not None and st.session_state.cap.isOpened():
-        st.session_state.cap.release()
-        st.session_session.cap = None
-    stframe.empty()
-    # Updated: use_container_width instead of use_column_width
-    stframe.image(np.zeros((480, 640, 3), dtype=np.uint8), channels="RGB", use_container_width=True)
-
-if st.session_state.camera_started:
-    st_status.info("Starting camera... Please allow camera access if prompted.")
-
-    if st.session_state.cap is None or not st.session_state.cap.isOpened():
-        st.session_state.cap = cv2.VideoCapture(0, cv2.CAP_DSHOW)
-        if not st.session_state.cap.isOpened():
-            st_status.error("Failed to open camera. Please check if it's connected and not in use.")
-            st.session_state.camera_started = False
-            st.stop()
-
-    while st.session_state.camera_started:
-        ret, frame = st.session_state.cap.read()
-        if not ret:
-            st_status.error("Failed to read frame from camera. It might be disconnected or an error occurred.")
-            st.session_state.camera_started = False
-            break
-
-        current_time = time.time()
-        if current_time - st.session_state.last_process_time >= FRAME_INTERVAL_SECONDS:
-            st.session_state.last_process_time = current_time
-
-            gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-
-            small_frame = cv2.resize(gray_frame, (0, 0), fx=FACE_DETECTION_DOWNSCALE, fy=FACE_DETECTION_DOWNSCALE)
+FACE_DETECTION_DOWNSCALE = 0.5 # Scale factor for face detection
+
+# --- 3. Video Processing Class ---
+# This class will receive frames from the client and process them on the server
+class EmotionDetector(VideoTransformerBase):
+    def __init__(self, model, face_detector):
+        self.model = model
+        self.face_detector = face_detector
+
+    def transform(self, frame: av.VideoFrame) -> np.ndarray:
+        # Convert av.VideoFrame to NumPy array.
+        # Requesting "bgr24" format directly from `av` to align with OpenCV's default.
+        img_bgr = frame.to_ndarray(format="bgr24") # <--- MODIFIED TO BGR24
+
+        # Convert to grayscale for face detection and emotion prediction
+        gray_frame = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+
+        # Scale down for faster face detection
+        small_frame = cv2.resize(gray_frame, (0, 0), fx=FACE_DETECTION_DOWNSCALE, fy=FACE_DETECTION_DOWNSCALE)
+        
+        # Detect faces
+        faces = self.face_detector.detectMultiScale(small_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+
+        # Scale face coordinates back to original frame size
+        original_faces = []
+        for (x, y, w, h) in faces:
+            x_orig = int(x / FACE_DETECTION_DOWNSCALE)
+            y_orig = int(y / FACE_DETECTION_DOWNSCALE)
+            w_orig = int(w / FACE_DETECTION_DOWNSCALE)
+            h_orig = int(h / FACE_DETECTION_DOWNSCALE) # Corrected potential typo here if original was h_orig / h_orig
+            original_faces.append((x_orig, y_orig, w_orig, h_orig))
+
+        # Process each detected face
+        for (x, y, w, h) in original_faces:
+            # Draw rectangle on the BGR image (img_bgr)
+            cv2.rectangle(img_bgr, (x, y), (x+w, y+h), (255, 0, 0), 2)
+
+            # Extract face ROI for emotion prediction
+            # Ensure ROI coordinates are within image bounds
+            face_roi = gray_frame[max(0, y):min(gray_frame.shape[0], y+h), max(0, x):min(gray_frame.shape[1], x+w)]
+
+            if face_roi.size == 0: # Skip if ROI is empty (e.g., face partially out of frame)
+                continue
+
+            face_roi = cv2.resize(face_roi, (IMG_WIDTH, IMG_HEIGHT))
+            face_roi = np.expand_dims(face_roi, axis=0) # Add batch dimension
+            face_roi = np.expand_dims(face_roi, axis=-1) # Add channel dimension (for grayscale)
+            face_roi = face_roi / 255.0 # Normalize pixel values
+
+            predictions = self.model.predict(face_roi, verbose=0)[0]
+            emotion_index = np.argmax(predictions)
+            predicted_emotion = emotion_labels[emotion_index]
+            confidence = predictions[emotion_index] * 100
+
+            text_color = label_colors.get(predicted_emotion, (255, 255, 255))
+            text = f"{predicted_emotion} ({confidence:.2f}%)"
             
-            faces = face_detector.detectMultiScale(small_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
-
-            original_faces = []
-            for (x, y, w, h) in faces:
-                x_orig = int(x / FACE_DETECTION_DOWNSCALE)
-                y_orig = int(y / FACE_DETECTION_DOWNSCALE)
-                w_orig = int(w / FACE_DETECTION_DOWNSCALE)
-                h_orig = int(h / FACE_DETECTION_DOWNSCALE)
-                original_faces.append((x_orig, y_orig, w_orig, h_orig))
-
-            for (x, y, w, h) in original_faces:
-                cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
-
-                face_roi = gray_frame[max(0, y):min(gray_frame.shape[0], y+h), max(0, x):min(gray_frame.shape[1], x+w)]
-
-                if face_roi.size == 0:
-                    continue
-
-                face_roi = cv2.resize(face_roi, (IMG_WIDTH, IMG_HEIGHT))
-                face_roi = np.expand_dims(face_roi, axis=0)
-                face_roi = np.expand_dims(face_roi, axis=-1)
-                face_roi = face_roi / 255.0
+            # Position text above face, or below if not enough space above
+            text_y = y - 10 if y - 10 > 10 else y + h + 20
+            
+            # Draw text on the BGR image (img_bgr)
+            cv2.putText(img_bgr, text, (x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.9, text_color, 2, cv2.LINE_AA)
 
-                predictions = model.predict(face_roi, verbose=0)[0]
-                emotion_index = np.argmax(predictions)
-                predicted_emotion = emotion_labels[emotion_index]
-                confidence = predictions[emotion_index] * 100
+        # Convert the processed BGR image back to RGB for Streamlit/WebRTC display
+        return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
 
-                text_color = label_colors.get(predicted_emotion, (255, 255, 255))
-                text = f"{predicted_emotion} ({confidence:.2f}%)"
-                text_y = y - 10 if y - 10 > 10 else y + h + 20
-                cv2.putText(frame, text, (x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.9, text_color, 2, cv2.LINE_AA)
+# --- 4. Streamlit App Layout and WebRTC Stream ---
+st.title("Live Facial Emotion Recognition")
 
-            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            # Updated: use_container_width instead of use_column_width
-            stframe.image(frame_rgb, channels="RGB", use_container_width=True)
+st.markdown("""
+This application uses a deep learning model to detect emotions from faces in real-time.
+It accesses your webcam directly via your browser (WebRTC) and processes the video frames on the server.
+""")
 
-        time.sleep(0.001) # Small sleep to yield control, can be adjusted or removed
+# Place the webrtc_streamer widget.
+# It automatically renders a video player and "Connect" / "Disconnect" buttons.
+webrtc_ctx = webrtc_streamer(
+    key="emotion_detection_stream",
+    mode=WebRtcMode.SENDRECV, # Send video from client, receive processed video from server
+    video_processor_factory=lambda: EmotionDetector(model, face_detector),
+    media_stream_constraints={"video": True, "audio": False}, # Only video, no audio
+    async_processing=True, # Process frames asynchronously
+    # desired_playing_state={"playing": True}, # Optional: tries to auto-start. Can comment out.
+)
+
+# Provide feedback based on the stream state
+if webrtc_ctx.state.playing:
+    st.success("Webcam stream active. Looking for faces...")
+else:
+    st.info("Webcam stream not active. Click the 'Start' button above to begin, and allow camera access.")
 
-    if st.session_state.cap is not None and st.session_state.cap.isOpened():
-        st.session_state.cap.release()
-        st.session_state.cap = None
-        st_status.info("Camera released.")