Update app.py

app.py

@@ -5,6 +5,7 @@ import time
 import os
 from keras.models import load_model
 from PIL import Image
+import mediapipe as mp
 import tempfile
 
 # Larger title
@@ -13,38 +14,40 @@ st.markdown("<h1 style='text-align: center;'>Emotion Detection with Face Recogni
 # Smaller subtitle
 st.markdown("<h3 style='text-align: center;'>angry, fear, happy, neutral, sad, surprise</h3>", unsafe_allow_html=True)
 
+# Start time for measuring performance
 start = time.time()
 
-# Load the emotion model
+# Load the emotion detection model
 @st.cache_resource
 def load_emotion_model():
     model = load_model('CNN_Model_acc_75.h5')  # Ensure this file is in your Space
     return model
 
 model = load_emotion_model()
-print("time taken to load model: ", time.time() - start)
+print("Time taken to load model: ", time.time() - start)
 
 # Emotion labels
 emotion_labels = ['angry', 'fear', 'happy', 'neutral', 'sad', 'surprise']
 
-# Load known faces (from images in a folder)
+# Load known faces and names
 known_faces = []
 known_names = []
 face_recognizer = cv2.face.LBPHFaceRecognizer_create()
 
 def load_known_faces():
-    folder_path = "known_faces"  # Place your folder with known faces here
+    folder_path = "known_faces"  # Folder containing known face images
     for image_name in os.listdir(folder_path):
         if image_name.endswith(('.jpg', '.jpeg', '.png')):
             image_path = os.path.join(folder_path, image_name)
             image = cv2.imread(image_path)
             gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
             # Detect face in the image
-            faces = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml').detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+            faces = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml').detectMultiScale(
+                gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)
+            )
 
             for (x, y, w, h) in faces:
                 roi_gray = gray[y:y+h, x:x+w]
-                # We only need the face, so we crop it and store it for training
                 known_faces.append(roi_gray)
                 known_names.append(image_name.split('.')[0])  # Assuming file name is the person's name
 
@@ -53,47 +56,55 @@ def load_known_faces():
 
 load_known_faces()
 
-# Face detection using OpenCV
-face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-img_shape = 48
+# Mediapipe face detection
+mp_face_detection = mp.solutions.face_detection.FaceDetection(min_detection_confidence=0.5)
 
+# Process a single frame
 def process_frame(frame):
-    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-    faces = face_cascade.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
-
-    result_text = ""  # Initialize the result text for display
-
-    for (x, y, w, h) in faces:
-        roi_gray = gray_frame[y:y+h, x:x+w]
-        roi_color = frame[y:y+h, x:x+w]
-        face_roi = cv2.resize(roi_color, (img_shape, img_shape))  # Resize to 48x48
-        face_roi = cv2.cvtColor(face_roi, cv2.COLOR_BGR2RGB)  # Convert to RGB (3 channels)
-        face_roi = np.expand_dims(face_roi, axis=0)  # Add batch dimension
-        face_roi = face_roi / 255.0  # Normalize the image
-
-        # Emotion detection
-        predictions = model.predict(face_roi)
-        emotion = emotion_labels[np.argmax(predictions[0])]
-
-        # Face recognition using LBPH
-        label, confidence = face_recognizer.predict(roi_gray)
-        name = "Unknown"
-        if confidence < 100:
-            name = known_names[label]
-
-        # Format the result text as "Name is feeling Emotion"
-        result_text = f"{name} is feeling {emotion}"
-
-        # Draw bounding box and label on the frame
-        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
-        cv2.putText(frame, result_text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    results = mp_face_detection.process(rgb_frame)
+
+    result_text = ""  # Initialize result text
+
+    if results.detections:
+        for detection in results.detections:
+            bboxC = detection.location_data.relative_bounding_box
+            h, w, _ = frame.shape
+            bbox = (
+                int(bboxC.xmin * w), int(bboxC.ymin * h),
+                int(bboxC.width * w), int(bboxC.height * h)
+            )
+            x, y, w, h = bbox
+
+            roi_color = frame[y:y+h, x:x+w]
+            roi_gray = cv2.cvtColor(roi_color, cv2.COLOR_BGR2GRAY)
+            face_roi = cv2.resize(roi_color, (48, 48))
+            face_roi = cv2.cvtColor(face_roi, cv2.COLOR_BGR2RGB)
+            face_roi = np.expand_dims(face_roi, axis=0) / 255.0  # Normalize
+
+            # Emotion detection
+            predictions = model.predict(face_roi)
+            emotion = emotion_labels[np.argmax(predictions[0])]
+
+            # Face recognition
+            name = "Unknown"
+            label, confidence = face_recognizer.predict(roi_gray)
+            if confidence < 100:
+                name = known_names[label]
+
+            # Format result text
+            result_text = f"{name} is feeling {emotion}"
+
+            # Draw bounding box and label
+            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+            cv2.putText(frame, result_text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
 
     return frame, result_text
 
-# Video feed
+# Video feed display
 def video_feed(video_source):
-    frame_placeholder = st.empty()  # This placeholder will be used to replace frames in-place
-    text_placeholder = st.empty()  # This placeholder will display the result text
+    frame_placeholder = st.empty()  # Placeholder for displaying video frames
+    text_placeholder = st.empty()  # Placeholder for displaying result text
 
     while True:
         ret, frame = video_source.read()
@@ -102,21 +113,17 @@ def video_feed(video_source):
 
         frame, result_text = process_frame(frame)
 
-        # Display the frame in the placeholder
+        # Display frame and result text
         frame_placeholder.image(frame, channels="BGR", use_column_width=True)
-
-        # Display the result text in the text placeholder
         text_placeholder.markdown(f"<h3 style='text-align: center;'>{result_text}</h3>", unsafe_allow_html=True)
 
-# Sidebar for video or image upload
-upload_choice = st.sidebar.radio("Choose input source", ["Upload Image", "Upload Video", "Camera"])
+# Sidebar for user input source selection
+upload_choice = st.sidebar.radio("Choose Input Source", ["Upload Image", "Upload Video", "Camera"])
 
 if upload_choice == "Camera":
-    # Use Streamlit's built-in camera input widget for capturing images from the webcam
     image = st.camera_input("Take a picture")
 
-    if image is not None:
-        # Convert the image to a numpy array
+    if image:
         frame = np.array(Image.open(image))
         frame, result_text = process_frame(frame)
         st.image(frame, caption='Processed Image', use_column_width=True)
@@ -124,6 +131,7 @@ if upload_choice == "Camera":
 
 elif upload_choice == "Upload Image":
     uploaded_image = st.file_uploader("Upload Image", type=["png", "jpg", "jpeg", "gif"])
+
     if uploaded_image:
         image = Image.open(uploaded_image)
         frame = np.array(image)
@@ -133,11 +141,11 @@ elif upload_choice == "Upload Image":
 
 elif upload_choice == "Upload Video":
     uploaded_video = st.file_uploader("Upload Video", type=["mp4", "mov", "avi", "mkv", "webm"])
+
     if uploaded_video:
-        # Temporarily save the video to disk
         with tempfile.NamedTemporaryFile(delete=False) as tfile:
             tfile.write(uploaded_video.read())
             video_source = cv2.VideoCapture(tfile.name)
             video_feed(video_source)
 
-st.sidebar.write("Emotion Labels: Angry, Fear, Happy, Neutral, Sad, Surprise")
+st.sidebar.write("Emotion Labels: Angry, Fear, Happy, Neutral, Sad, Surprise")