Update app.py

app.py

@@ -1,9 +1,13 @@
 import os
 import sqlite3
-from huggingface_hub import HfApi
+import cv2
 import streamlit as st
 from datetime import datetime
 from PIL import Image
+import numpy as np
+from keras.models import load_model
+from huggingface_hub import HfApi
+import time
 
 # Constants
 KNOWN_FACES_DIR = "known_faces"  # Directory to save user images
@@ -12,12 +16,10 @@ DATABASE = "students.db"  # SQLite database file to store student information
 # Ensure the directory exists
 os.makedirs(KNOWN_FACES_DIR, exist_ok=True)
 
-# Retrieve the Hugging Face token from environment variable
+# Initialize Hugging Face API
 hf_token = os.getenv("upload")  # The key must match the secret name set in Hugging Face
 if not hf_token:
-    raise ValueError("Hugging Face token not found. Ensure it's set as a secret in the Hugging Face Space.")
-
-# Initialize Hugging Face API
+    raise ValueError("Hugging Face token not found. Ensure it's set as a secret in Hugging Face")
 api = HfApi()
 
 # Repository Details on Hugging Face
@@ -25,19 +27,13 @@ REPO_NAME = "face_and_emotion_detection"  # Replace with your Hugging Face repos
 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=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 repository: {e}")
+# Load emotion detection model
+model = load_model('CNN_Model_acc_75.h5')
+emotion_labels = ['angry', 'fear', 'happy', 'neutral', 'sad', 'surprise']
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
 
-# Database setup
+# Initialize the SQLite database
 def initialize_database():
-    """
-    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("""
@@ -52,16 +48,8 @@ def initialize_database():
     conn.commit()
     conn.close()
 
+# Save student information in the SQLite database
 def save_to_database(name, roll_no, image_path):
-    """
-    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:
@@ -76,34 +64,19 @@ def save_to_database(name, roll_no, image_path):
     finally:
         conn.close()
 
+# Save the captured image to Hugging Face and return the local path
 def save_image_to_hugging_face(image, name, roll_no):
-    """
-    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)
-    
-    # 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=REPO_TYPE,
-            token=hf_token  # Pass the Hugging Face token directly
+            token=hf_token
         )
         st.success(f"Image uploaded to Hugging Face: {filename}")
     except Exception as e:
@@ -111,31 +84,54 @@ def save_image_to_hugging_face(image, name, roll_no):
 
     return local_path
 
-# Initialize the database when the app starts
-initialize_database()
+# Process each frame for emotion detection
+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))
 
-# Streamlit user interface (UI)
-st.title("Student Registration with Hugging Face Image Upload")
+    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]
 
-# Input fields for student details
-name = st.text_input("Enter your name")
-roll_no = st.text_input("Enter your roll number")
+        face_roi = cv2.resize(roi_color, (48, 48))
+        face_roi = np.expand_dims(face_roi, axis=0)
+        face_roi = face_roi / float(48)
+        predictions = model.predict(face_roi)
+        emotion = emotion_labels[np.argmax(predictions[0])]
+
+        # Display emotion text on face
+        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+        cv2.putText(frame, emotion, (x, y+h), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
+
+    return frame
+
+# Attendance recording
+def record_attendance(name, roll_no, emotion):
+    conn = sqlite3.connect(DATABASE)
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT INTO students (name, roll_no, image_path, timestamp)
+        VALUES (?, ?, ?, ?)
+    """, (name, roll_no, f"known_faces/{name}_{roll_no}.jpg", datetime.now()))
+    conn.commit()
+    conn.close()
+
+# User Interface
+st.title("Student Registration and Attendance")
 
 # 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 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
-
+    picture = st.camera_input("Take a picture")  # Capture image using webcam
 elif capture_mode == "Upload File":
-    picture = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])  # Upload image from file system
+    picture = st.file_uploader("Upload an image", type=["jpg", "jpeg", "png"])
+
+# Input fields for student details
+name = st.text_input("Enter your name")
+roll_no = st.text_input("Enter your roll number")
 
-# Save data and process image on button click
+# Handle image upload or webcam capture
 if st.button("Register"):
     if not name or not roll_no:
         st.error("Please fill in both name and roll number.")
@@ -148,21 +144,38 @@ if st.button("Register"):
                 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
             image_path = save_image_to_hugging_face(image, name, roll_no)
+
+            # Save user data to the database
             save_to_database(name, roll_no, image_path)
+
+            # Detect faces and emotions
+            cap = cv2.VideoCapture(0)
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+
+                frame = process_frame(frame)
+                st.image(frame, channels="BGR", use_column_width=True)
+                record_attendance(name, roll_no, emotion)
+                break  # Stop after capturing one frame
+
+            cap.release()
+
         except Exception as e:
             st.error(f"An error occurred: {e}")
 
-# Display registered student data
+# Display registered students
 if st.checkbox("Show registered students"):
     conn = sqlite3.connect(DATABASE)
     cursor = conn.cursor()
     cursor.execute("SELECT name, roll_no, image_path, timestamp FROM students")
     rows = cursor.fetchall()
     conn.close()
-    
+
     st.write("### Registered Students")
     for row in rows:
         name, roll_no, image_path, timestamp = row