Update app.py

app.py

@@ -1,18 +1,37 @@
-import streamlit as st
-import cv2
 import os
-import numpy as np
-from keras.models import load_model
+import streamlit as st
+from huggingface_hub import HfApi
 from PIL import Image
 import sqlite3
-from datetime import datetime
+import cv2
+import numpy as np
 
 # Constants
-ROOT_DIR = os.getcwd()  # Root directory of the project
-DATABASE = "students.db"  # SQLite database file to store student information
-EMOTION_MODEL_FILE = "CNN_Model_acc_75.h5"
+HOME_DIR = os.getcwd()  # Home directory to save images (root directory)
+DATABASE = "students.db"  # SQLite database to store student information
+REPO_NAME = "face-and-emotion-detection"
+REPO_ID = f"LovnishVerma/{REPO_NAME}"  # Hugging Face Repo
+EMOTION_MODEL_FILE = "CNN_Model_acc_75.h5"  # Emotion detection model file
 EMOTION_LABELS = ["Angry", "Disgust", "Fear", "Happy", "Sad", "Surprise", "Neutral"]
 
+# Ensure home directory exists
+if not os.path.exists(HOME_DIR):
+    os.makedirs(HOME_DIR)
+
+# Retrieve Hugging Face token from environment variable
+hf_token = os.getenv("upload")
+if not hf_token:
+    st.error("Hugging Face token not found. Please set the environment variable.")
+    st.stop()
+
+# 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 the emotion detection model
 try:
     emotion_model = load_model(EMOTION_MODEL_FILE)
@@ -25,7 +44,7 @@ def initialize_database():
     """ Initializes the SQLite database by creating the students table if it doesn't exist. """
     conn = sqlite3.connect(DATABASE)
     cursor = conn.cursor()
-    cursor.execute(""" 
+    cursor.execute("""
         CREATE TABLE IF NOT EXISTS students (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             name TEXT NOT NULL,
@@ -53,22 +72,31 @@ def save_to_database(name, roll_no, image_path):
     finally:
         conn.close()
 
-def save_image_to_root_directory(image, name, roll_no):
-    """ Saves the image locally in the root directory. """
+def save_image_to_hugging_face(image, name, roll_no):
+    """ Saves the image locally to the HOME_DIR and uploads it to Hugging Face. """
     # Construct the local file path
-    filename = f"{name}_{roll_no}.jpg"
-    local_path = os.path.join(ROOT_DIR, filename)
+    filename = f"{name}_{roll_no}_{datetime.now().strftime('%Y%m%d%H%M%S')}.jpg"
+    local_path = os.path.join(HOME_DIR, filename)
     
     try:
         # Convert image to RGB if necessary
         if image.mode != "RGB":
             image = image.convert("RGB")
         
-        # Save the image to the root directory
+        # Save the image to the home directory
         image.save(local_path)
-        st.success(f"Image saved to {local_path}.")
+        
+        # Upload the saved file to Hugging Face
+        api.upload_file(
+            path_or_fileobj=local_path,
+            path_in_repo=filename,
+            repo_id=REPO_ID,
+            repo_type="space",
+            token=hf_token,
+        )
+        st.success(f"Image saved to {HOME_DIR} and uploaded to Hugging Face as {filename}.")
     except Exception as e:
-        st.error(f"Error saving image: {e}")
+        st.error(f"Error saving or uploading image: {e}")
     
     return local_path
 
@@ -76,7 +104,7 @@ def save_image_to_root_directory(image, name, roll_no):
 initialize_database()
 
 # Streamlit user interface (UI)
-st.title("Student Registration with Image Upload and Face Recognition")
+st.title("Student Registration with Hugging Face Image Upload")
 
 # Input fields for student details
 name = st.text_input("Enter your name")
@@ -105,12 +133,26 @@ if st.button("Register"):
             elif capture_mode == "Upload File" and picture:
                 image = Image.open(picture)
             
-            # Save the image locally in the root directory
-            image_path = save_image_to_root_directory(image, name, roll_no)
+            # Save the image locally and upload it to Hugging Face
+            image_path = save_image_to_hugging_face(image, name, roll_no)
             save_to_database(name, roll_no, image_path)
         except Exception as e:
             st.error(f"An error occurred: {e}")
 
+# Display registered student data
+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
+        st.write(f"**Name:** {name}, **Roll No:** {roll_no}, **Timestamp:** {timestamp}")
+        st.image(image_path, caption=f"{name} ({roll_no})", use_column_width=True)
+
 # Face and Emotion Detection Function
 def detect_faces_and_emotions(image):
     gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
@@ -130,37 +172,8 @@ def detect_faces_and_emotions(image):
         return EMOTION_LABELS[emotion_label]
     return None
 
-# Face Recognition: Compare uploaded image with all images in the root directory
-def recognize_face(image_path):
-    """ Compares the uploaded image with all images in the root directory """
-    img = cv2.imread(image_path)
-    gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
-    faces = face_cascade.detectMultiScale(gray_image, scaleFactor=1.3, minNeighbors=5)
-    
-    recognized_name = None
-    for (x, y, w, h) in faces:
-        face = gray_image[y:y+h, x:x+w]
-        for filename in os.listdir(ROOT_DIR):
-            if filename.endswith(('.jpg', '.jpeg', '.png')):
-                stored_image = cv2.imread(os.path.join(ROOT_DIR, filename))
-                stored_gray = cv2.cvtColor(stored_image, cv2.COLOR_BGR2GRAY)
-                stored_faces = face_cascade.detectMultiScale(stored_gray)
-                for (sx, sy, sw, sh) in stored_faces:
-                    stored_face = stored_gray[sy:sy+sh, sx:sx+sw]
-                    resized_stored_face = cv2.resize(stored_face, (48, 48))
-                    rgb_stored_face = cv2.cvtColor(resized_stored_face, cv2.COLOR_GRAY2RGB)
-                    stored_normalized_face = rgb_stored_face / 255.0
-                    stored_reshaped_face = np.reshape(stored_normalized_face, (1, 48, 48, 3))
-
-                    # Compare the faces (you can use a more advanced method like facial embeddings, but for simplicity, this is just basic comparison)
-                    if np.allclose(stored_reshaped_face, face):
-                        recognized_name = filename.split('_')[0]  # Extract the name from the file name
-                        break
-    return recognized_name
-
-# UI for Emotion and Face Detection
-if st.sidebar.selectbox("Menu", ["Register Student", "Face Recognition and Emotion Detection"]) == "Face Recognition and Emotion Detection":
+# UI for Emotion Detection
+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")
     action = st.radio("Choose Action", ["Upload Image", "Use Webcam"])
 
@@ -170,11 +183,8 @@ if st.sidebar.selectbox("Menu", ["Register Student", "Face Recognition and Emoti
             img = Image.open(uploaded_file)
             img_array = np.array(img)
             emotion_label = detect_faces_and_emotions(img_array)
-            recognized_name = recognize_face(uploaded_file)
             if emotion_label:
                 st.success(f"Emotion Detected: {emotion_label}")
-            if recognized_name:
-                st.success(f"Face Recognized: {recognized_name}")
             else:
                 st.warning("No face detected.")
 
@@ -185,10 +195,7 @@ if st.sidebar.selectbox("Menu", ["Register Student", "Face Recognition and Emoti
             img = Image.open(camera_image)
             img_array = np.array(img)
             emotion_label = detect_faces_and_emotions(img_array)
-            recognized_name = recognize_face(camera_image)
             if emotion_label:
                 st.success(f"Emotion Detected: {emotion_label}")
-            if recognized_name:
-                st.success(f"Face Recognized: {recognized_name}")
             else:
                 st.warning("No face detected.")