Update app.py

app.py

@@ -4,90 +4,79 @@ import os
 import numpy as np
 from keras.models import load_model
 from PIL import Image
-from huggingface_hub import HfApi
+import sqlite3
 from datetime import datetime
 
 # Constants
-KNOWN_FACES_DIR = "known_faces"  # Directory to save user images
+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"
 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
-os.makedirs(KNOWN_FACES_DIR, exist_ok=True)
-
-# Initialize Hugging Face API
-hf_token = os.getenv("upload")  # Replace with your actual Hugging Face token
-api = HfApi()
-
-# Load emotion detection model
+# 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()
 
-# Face and Emotion Detection Function
-def detect_faces_and_emotions(image):
-    """Detect faces and emotions in the image"""
-    gray_image = cv2.cvtColor(image, 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)
+# Database Functions
+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(""" 
+        CREATE TABLE IF NOT EXISTS students (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            roll_no TEXT NOT NULL UNIQUE,
+            image_path TEXT NOT NULL,
+            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+def save_to_database(name, roll_no, image_path):
+    """ Saves the student's data to the database. """
+    conn = sqlite3.connect(DATABASE)
+    cursor = conn.cursor()
+    try:
+        cursor.execute("""
+            INSERT INTO students (name, roll_no, image_path)
+            VALUES (?, ?, ?)
+        """, (name, roll_no, image_path))
+        conn.commit()
+        st.success("Data saved successfully!")
+    except sqlite3.IntegrityError:
+        st.error("Roll number already exists!")
+    finally:
+        conn.close()
+
+def save_image_to_root_directory(image, name, roll_no):
+    """ Saves the image locally in the root directory. """
+    # Construct the local file path
+    filename = f"{name}_{roll_no}.jpg"
+    local_path = os.path.join(ROOT_DIR, filename)
     
-    emotion_label = None
-    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_GRAY2RGB)
-        normalized_face = rgb_face / 255.0
-        reshaped_face = np.reshape(normalized_face, (1, 48, 48, 3))
+    try:
+        # Convert image to RGB if necessary
+        if image.mode != "RGB":
+            image = image.convert("RGB")
         
-        # Predict the emotion
-        emotion_prediction = emotion_model.predict(reshaped_face)
-        emotion_label = np.argmax(emotion_prediction)
+        # Save the image to the root directory
+        image.save(local_path)
+        st.success(f"Image saved to {local_path}.")
+    except Exception as e:
+        st.error(f"Error saving image: {e}")
     
-    return faces, EMOTION_LABELS[emotion_label] if emotion_label else None
+    return local_path
 
-# Face Recognition Function
-def recognize_face(image):
-    """Recognize the face in the uploaded image by comparing with known faces"""
-    recognizer = cv2.face.LBPHFaceRecognizer_create()
-    
-    known_faces = []
-    labels = []
-    
-    # Load known faces from the directory
-    for filename in os.listdir(KNOWN_FACES_DIR):
-        if filename.endswith(".jpg"):
-            image_path = os.path.join(KNOWN_FACES_DIR, filename)
-            known_image = cv2.imread(image_path)
-            gray_image = cv2.cvtColor(known_image, cv2.COLOR_BGR2GRAY)
-            faces = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml').detectMultiScale(gray_image, scaleFactor=1.3, minNeighbors=5)
-            
-            for (x, y, w, h) in faces:
-                face = gray_image[y:y+h, x:x+w]
-                known_faces.append(face)
-                labels.append(filename.split(".")[0])  # Use image name as label
-    
-    if known_faces:
-        recognizer.train(known_faces, np.array(range(len(labels))))  # Train recognizer with known faces
-    
-    # Detect faces in the uploaded image
-    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    faces = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml').detectMultiScale(gray_image, scaleFactor=1.3, minNeighbors=5)
-    
-    recognized_name = "Unknown"
-    for (x, y, w, h) in faces:
-        face = gray_image[y:y+h, x:x+w]
-        label, confidence = recognizer.predict(face)
-        if confidence < 100:  # Confidence threshold
-            recognized_name = labels[label]  # Get the name from labels
-    
-    return recognized_name
+# Initialize the database when the app starts
+initialize_database()
 
-# Streamlit UI
-st.title("Student Registration with Face Recognition and Emotion Detection")
+# Streamlit user interface (UI)
+st.title("Student Registration with Image Upload and Face Recognition")
 
 # Input fields for student details
 name = st.text_input("Enter your name")
@@ -116,19 +105,90 @@ if st.button("Register"):
             elif capture_mode == "Upload File" and picture:
                 image = Image.open(picture)
             
-            # Convert the image to numpy array for processing
-            img_array = np.array(image)
-            
-            # Detect faces and emotions
-            faces, emotion_label = detect_faces_and_emotions(img_array)
-            if faces:
+            # Save the image locally in the root directory
+            image_path = save_image_to_root_directory(image, name, roll_no)
+            save_to_database(name, roll_no, image_path)
+        except Exception as e:
+            st.error(f"An error occurred: {e}")
+
+# Face and Emotion Detection Function
+def detect_faces_and_emotions(image):
+    gray_image = cv2.cvtColor(image, 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)
+    
+    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_GRAY2RGB)
+        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)
+        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":
+    st.subheader("Recognize Faces and Detect Emotions")
+    action = st.radio("Choose Action", ["Upload Image", "Use Webcam"])
+
+    if action == "Upload Image":
+        uploaded_file = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"])
+        if uploaded_file:
+            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.")
+
+    elif action == "Use Webcam":
+        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)
+            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.")
-            
-            # Perform face recognition
-            recognized_name = recognize_face(img_array)
-            st.success(f"Face Recognized as: {recognized_name}")
-        
-        except Exception as e:
-            st.error(f"An error occurred: {e}")