Update app.py

app.py

@@ -1,49 +1,55 @@
 import streamlit as st
 import cv2
-import os
 import numpy as np
+import time
+import os
 from keras.models import load_model
 from PIL import Image
-import sqlite3
+import tempfile
 from huggingface_hub import HfApi
-from datetime import datetime
-from sklearn.preprocessing import LabelEncoder
+
+# Larger title
+st.markdown("<h1 style='text-align: center;'>Emotion Detection with Face Recognition</h1>", unsafe_allow_html=True)
+
+# Smaller subtitle
+st.markdown("<h3 style='text-align: center;'>angry, fear, happy, neutral, sad, surprise</h3>", unsafe_allow_html=True)
+
+start = time.time()
 
 # Constants
 KNOWN_FACES_DIR = "known_faces"  # Directory to save user images
 DATABASE = "students.db"  # SQLite database file to store student information
-EMOTION_MODEL_FILE = "CNN_Model_acc_75.h5"
-EMOTION_LABELS = ["Angry", "Disgust", "Fear", "Happy", "Sad", "Surprise", "Neutral"]
-REPO_NAME = "face_and_emotion_detection"
-REPO_ID = f"LovnishVerma/{REPO_NAME}"
 
-# Ensure the directories exist
+# Ensure the directory exists
 os.makedirs(KNOWN_FACES_DIR, exist_ok=True)
 
-# Retrieve Hugging Face token from environment variable
-hf_token = os.getenv("upload")  # Replace with your actual Hugging Face token
+# Retrieve the Hugging Face token from environment variable
+hf_token = os.getenv("upload")  # The key must match the secret name set in Hugging Face
 if not hf_token:
-    st.error("Hugging Face token not found. Please set the environment variable.")
-    st.stop()
+    raise ValueError("Hugging Face token not found. Ensure it's set as a secret in the Hugging Face Space.")
 
 # Initialize Hugging Face API
 api = HfApi()
+
+# Repository Details on Hugging Face
+REPO_NAME = "face_and_emotion_detection"  # Replace with your Hugging Face repository name
+REPO_ID = "LovnishVerma/" + REPO_NAME  # Replace "LovnishVerma" with your Hugging Face username
+REPO_TYPE = "space"  # 'space' type for Streamlit-based projects
+
+# Ensure the repository exists or create it
 try:
-    api.create_repo(repo_id=REPO_ID, repo_type="space", space_sdk="streamlit", token=hf_token, exist_ok=True)
+    api.create_repo(repo_id=REPO_ID, repo_type=REPO_TYPE, space_sdk="streamlit", token=hf_token, exist_ok=True)
     st.success(f"Repository '{REPO_NAME}' is ready on Hugging Face!")
 except Exception as e:
-    st.error(f"Error creating Hugging Face repository: {e}")
+    st.error(f"Error creating repository: {e}")
 
-# Load the emotion detection model
-try:
-    emotion_model = load_model(EMOTION_MODEL_FILE)
-except Exception as e:
-    st.error(f"Error loading emotion model: {e}")
-    st.stop()
 
-# Database Functions
+# Database setup
 def initialize_database():
-    """ Initializes the SQLite database by creating the students table if it doesn't exist. """
+    """
+    Initializes the SQLite database by creating a table to store student data
+    such as name, roll number, image path, and registration timestamp.
+    """
     conn = sqlite3.connect(DATABASE)
     cursor = conn.cursor()
     cursor.execute("""
@@ -59,7 +65,15 @@ def initialize_database():
     conn.close()
 
 def save_to_database(name, roll_no, image_path):
-    """ Saves the student's data to the database. """
+    """
+    Saves the student's information (name, roll number, image path) to the SQLite database.
+    Ensures roll number is unique.
+
+    Args:
+        name (str): The name of the student.
+        roll_no (str): The roll number of the student.
+        image_path (str): Path to the stored image of the student.
+    """
     conn = sqlite3.connect(DATABASE)
     cursor = conn.cursor()
     try:
@@ -75,17 +89,38 @@ def save_to_database(name, roll_no, image_path):
         conn.close()
 
 def save_image_to_hugging_face(image, name, roll_no):
-    """ Saves the image locally and uploads it to Hugging Face. """
+    """
+    Saves the captured image locally in the 'known_faces' directory and uploads it to Hugging Face.
+    The image is renamed using the format 'UserName_RollNo.jpg'.
+
+    Args:
+        image (PIL Image): The image object captured by the user.
+        name (str): The name of the student.
+        roll_no (str): The roll number of the student.
+
+    Returns:
+        str: The local path where the image is saved.
+    """
+    # Rename the image using the format 'UserName_RollNo.jpg'
     filename = f"{name}_{roll_no}.jpg"
     local_path = os.path.join(KNOWN_FACES_DIR, filename)
-    image.save(local_path)
     
+    # Save the image locally to the known_faces directory
+    image.save(local_path)
+
+    # Try uploading the image to Hugging Face
     try:
-        api.upload_file(path_or_fileobj=local_path, path_in_repo=filename, repo_id=REPO_ID, repo_type="space", token=hf_token)
+        api.upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=filename,
+            repo_id=REPO_ID,
+            repo_type=REPO_TYPE,
+            token=hf_token  # Pass the Hugging Face token directly
+        )
         st.success(f"Image uploaded to Hugging Face: {filename}")
     except Exception as e:
         st.error(f"Error uploading image to Hugging Face: {e}")
-    
+
     return local_path
 
 # Initialize the database when the app starts
@@ -98,22 +133,32 @@ st.title("Student Registration with Hugging Face Image Upload")
 name = st.text_input("Enter your name")
 roll_no = st.text_input("Enter your roll number")
 
-# Choose input method for the image (only webcam now)
-capture_mode = "Use Webcam"  # Only keep the webcam option now
+# Choose input method for the image (webcam or file upload)
+capture_mode = st.radio("Choose an option to upload your image", ["Use Webcam", "Upload File"])
 
-# Handle webcam capture
-picture = st.camera_input("Take a picture")  # Capture image using webcam
+# Handle webcam capture or file upload
+if capture_mode == "Use Webcam":
+    try:
+        picture = st.camera_input("Take a picture")  # Capture image using webcam
+    except Exception as e:
+        st.error(f"Error accessing webcam: {e}")
+        picture = None
+
+elif capture_mode == "Upload File":
+    picture = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])  # Upload image from file system
 
 # Save data and process image on button click
 if st.button("Register"):
     if not name or not roll_no:
         st.error("Please fill in both name and roll number.")
     elif not picture:
-        st.error("Please capture an image using the webcam.")
+        st.error("Please upload or capture an image.")
     else:
         try:
             # Open the image based on capture mode
-            if picture:
+            if capture_mode == "Use Webcam" and picture:
+                image = Image.open(picture)
+            elif capture_mode == "Upload File" and picture:
                 image = Image.open(picture)
             
             # Save the image locally and upload it to Hugging Face
@@ -136,81 +181,186 @@ if st.checkbox("Show registered students"):
         st.write(f"**Name:** {name}, **Roll No:** {roll_no}, **Timestamp:** {timestamp}")
         st.image(image_path, caption=f"{name} ({roll_no})", use_column_width=True)
 
-# Initialize OpenCV's face detector (Haar Cascade)
-face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
-# Initialize LBPH face recognizer
-face_recognizer = cv2.face_LBPHFaceRecognizer_create()
+# Constants
+DB_FILE = "students.db"
+KNOWN_FACES_DIR = "known_faces"
+EMOTION_MODEL_FILE = "CNN_Model_acc_75.h5"
+EMOTION_LABELS = ["Angry", "Disgust", "Fear", "Happy", "Sad", "Surprise", "Neutral"]
+
+# Hugging Face Repository Details
+REPO_NAME = "face_and_emotion_detection"
+REPO_ID = f"LovnishVerma/{REPO_NAME}"  # Replace with your Hugging Face username and repository name
 
-# Function to load and train face recognizer
-def train_face_recognizer():
-    faces = []
-    labels = []
-    label_encoder = LabelEncoder()
+# Ensure Directories
+os.makedirs(KNOWN_FACES_DIR, exist_ok=True)
 
-    # Load known faces
-    for filename in os.listdir(KNOWN_FACES_DIR):
-        if filename.endswith(".jpg"):
-            image_path = os.path.join(KNOWN_FACES_DIR, filename)
+# Load Hugging Face Token
+hf_token = os.getenv("upload")
+if not hf_token:
+    st.error("Hugging Face token not found. Please set the environment variable.")
+
+# Initialize Hugging Face API
+api = HfApi()
+try:
+    api.create_repo(repo_id=REPO_ID, repo_type="space", space_sdk="streamlit", token=hf_token, exist_ok=True)
+    st.success(f"Repository '{REPO_NAME}' is ready on Hugging Face!")
+except Exception as e:
+    st.error(f"Error creating Hugging Face repository: {e}")
+
+# Load Emotion Model
+try:
+    emotion_model = load_model(EMOTION_MODEL_FILE)
+except Exception as e:
+    st.error(f"Error loading emotion model: {e}")
+
+# Database Functions
+def create_table():
+    with sqlite3.connect(DB_FILE) as conn:
+        conn.execute("""CREATE TABLE IF NOT EXISTS students (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        name TEXT NOT NULL,
+                        roll_number TEXT NOT NULL UNIQUE,
+                        image_path TEXT NOT NULL)""")
+        conn.commit()
+
+def insert_student(name, roll_number, image_path):
+    try:
+        with sqlite3.connect(DB_FILE) as conn:
+            conn.execute("INSERT INTO students (name, roll_number, image_path) VALUES (?, ?, ?)",
+                         (name, roll_number, image_path))
+            conn.commit()
+    except sqlite3.IntegrityError:
+        st.warning("Roll number already exists!")
+
+def get_all_students():
+    with sqlite3.connect(DB_FILE) as conn:
+        cursor = conn.execute("SELECT * FROM students")
+        return cursor.fetchall()
+
+# Load the emotion 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)
+
+# Emotion labels
+emotion_labels = ['angry', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+
+# Load known faces (from images in a folder)
+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
+    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_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-
-            # Detect face(s)
-            faces_detected = face_cascade.detectMultiScale(gray_image, 1.3, 5)
-            for (x, y, w, h) in faces_detected:
-                face = gray_image[y:y+h, x:x+w]
-                faces.append(face)
-                labels.append(filename.split('_')[0])  # Assuming name is in the filename
-            
-    labels = label_encoder.fit_transform(labels)
-    face_recognizer.train(faces, np.array(labels))
-    st.success("Face recognizer trained successfully!")
+            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))
 
-train_face_recognizer()
+            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
 
-# Face and Emotion Detection Function
-def detect_faces_and_emotions(image):
-    # Convert the image to grayscale for face detection
-    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    # Train the recognizer with the known faces
+    face_recognizer.train(known_faces, np.array([i for i in range(len(known_faces))]))
 
-    # Detect faces using OpenCV's Haar Cascade
-    faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.3, minNeighbors=5)
+load_known_faces()
+
+# Face detection using OpenCV
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+img_shape = 48
+
+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
 
-    # If faces are detected, predict emotions and recognize faces
     for (x, y, w, h) in faces:
-        face = gray_image[y:y+h, x:x+w]
-        resized_face = cv2.resize(face, (48, 48))  # Resize face to 48x48
-        rgb_face = cv2.cvtColor(resized_face, cv2.COLOR_BGR2RGB)
-        normalized_face = rgb_face / 255.0
-        reshaped_face = np.reshape(normalized_face, (1, 48, 48, 3))
-        
-        # Predict the emotion
-        emotion_prediction = emotion_model.predict(reshaped_face)
-        emotion_label = np.argmax(emotion_prediction)
-        
-        # Recognize the face
-        label, confidence = face_recognizer.predict(face)
-        recognized_label = label_encoder.inverse_transform([label])[0]
-        
-        return EMOTION_LABELS[emotion_label], recognized_label
-    
-    return None, None
+        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
 
-# UI for Emotion Detection (Only using webcam now)
-if st.sidebar.selectbox("Menu", ["Register Student", "Face Recognition and Emotion Detection", "View Attendance"]) == "Face Recognition and Emotion Detection":
-    st.subheader("Recognize Faces and Detect Emotions")
-    
-    st.info("Use the camera input widget to capture an image.")
-    camera_image = st.camera_input("Take a picture")
-    if camera_image:
-        img = Image.open(camera_image)
-        img_array = np.array(img)
-
-        # Detect emotion and recognize face in the captured image
-        emotion_label, recognized_label = detect_faces_and_emotions(img_array)
-        
-        if emotion_label:
-            st.success(f"Emotion Detected: {emotion_label}")
-            st.success(f"Face Recognized as: {recognized_label}")
-        else:
-            st.warning("No face detected.")
+        # 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)
+
+    return frame, result_text
+
+# Video feed
+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
+
+    while True:
+        ret, frame = video_source.read()
+        if not ret:
+            break
+
+        frame, result_text = process_frame(frame)
+
+        # Display the frame in the placeholder
+        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"])
+
+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
+        frame = np.array(Image.open(image))
+        frame, result_text = process_frame(frame)
+        st.image(frame, caption='Processed Image', use_column_width=True)
+        st.markdown(f"<h3 style='text-align: center;'>{result_text}</h3>", unsafe_allow_html=True)
+
+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)
+        frame, result_text = process_frame(frame)
+        st.image(frame, caption='Processed Image', use_column_width=True)
+        st.markdown(f"<h3 style='text-align: center;'>{result_text}</h3>", unsafe_allow_html=True)
+
+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")