Update app.py

app.py

@@ -6,24 +6,24 @@ from keras.models import load_model
 from PIL import Image
 import sqlite3
 from huggingface_hub import HfApi
+from datetime import datetime
 
 # Constants
-DB_FILE = "students.db"
-KNOWN_FACES_DIR = "known_faces"
+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"]
-
-# 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
+REPO_ID = f"LovnishVerma/{REPO_NAME}"
 
-# Ensure Directories
+# Ensure the directories exist
 os.makedirs(KNOWN_FACES_DIR, exist_ok=True)
 
-# Load Hugging Face Token
-hf_token = os.getenv("upload")
+# Retrieve Hugging Face token from environment variable
+hf_token = os.getenv("upload")  # Replace with your actual Hugging Face token
 if not hf_token:
     st.error("Hugging Face token not found. Please set the environment variable.")
+    st.stop()
 
 # Initialize Hugging Face API
 api = HfApi()
@@ -33,143 +33,138 @@ try:
 except Exception as e:
     st.error(f"Error creating Hugging Face repository: {e}")
 
-# Load Emotion 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()
 
 # 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):
+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:
-        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()
+        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.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()
-
-# Face and Emotion Detection
+        st.error("Roll number already exists!")
+    finally:
+        conn.close()
+
+def save_image_to_hugging_face(image, name, roll_no):
+    """ Saves the image locally and uploads it to Hugging Face. """
+    filename = f"{name}_{roll_no}.jpg"
+    local_path = os.path.join(KNOWN_FACES_DIR, filename)
+    image.save(local_path)
+    
+    try:
+        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 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
+initialize_database()
+
+# Streamlit user interface (UI)
+st.title("Student Registration with Hugging Face Image Upload")
+
+# Input fields for student details
+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
+
+# Handle webcam capture
+picture = st.camera_input("Take a picture")  # Capture image using webcam
+
+# 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.")
+    else:
+        try:
+            # Open the image based on capture mode
+            if 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_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)
     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
-        # Convert grayscale to RGB by duplicating the channel
-        rgb_face = cv2.cvtColor(resized_face, cv2.COLOR_GRAY2RGB)  # Convert grayscale to RGB
-        normalized_face = rgb_face / 255.0  # Normalize pixel values to [0, 1]
-        reshaped_face = np.reshape(normalized_face, (1, 48, 48, 3))  # Ensure the input shape is (1, 48, 48, 3)
+        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)  # Get the index of the highest probability
+        emotion_label = np.argmax(emotion_prediction)
         return EMOTION_LABELS[emotion_label]
     return None
 
-# UI Design
-st.title("Student Registration and Emotion Detection")
-create_table()
-
-menu = ["Register Student", "Face Recognition and Emotion Detection", "View Attendance"]
-choice = st.sidebar.selectbox("Menu", menu)
-
-if choice == "Register Student":
-    st.subheader("Register a New Student")
-
-    with st.form("register_form"):
-        name = st.text_input("Name")
-        roll_number = st.text_input("Roll Number")
-        image_file = st.file_uploader("Upload Image", type=["jpg", "jpeg", "png"])
-        use_webcam = st.checkbox("Use Webcam for Face Registration")
-        submitted = st.form_submit_button("Register")
-
-        if submitted:
-            if name and roll_number:
-                if use_webcam:
-                    st.info("Use the camera input widget to capture an image.")
-                    camera_image = st.camera_input("Capture Image")
-                    if camera_image:
-                        try:
-                            img = Image.open(camera_image)
-                            img = img.convert("RGB")
-                            img_path = os.path.join(KNOWN_FACES_DIR, f"{roll_number}.png")
-                            img.save(img_path)
-                            insert_student(name, roll_number, img_path)
-                            st.success(f"Student {name} Registered Successfully!")
-                        except Exception as e:
-                            st.error(f"Error saving webcam image: {e}")
-                elif image_file:
-                    try:
-                        img = Image.open(image_file)
-                        img = img.convert("RGB")
-                        img_path = os.path.join(KNOWN_FACES_DIR, f"{roll_number}.png")
-                        img.save(img_path)
-                        insert_student(name, roll_number, img_path)
-                        st.success(f"Student {name} Registered Successfully!")
-                    except Exception as e:
-                        st.error(f"Error saving uploaded image: {e}")
-                else:
-                    st.warning("Please upload an image or use the webcam to register the face.")
-            else:
-                st.warning("Please fill in all fields.")
-
-elif choice == "Face Recognition and Emotion Detection":
+# 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")
-
-    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:
-            try:
-                img = Image.open(uploaded_file)
-                img_array = np.array(img)
-                emotion_label = detect_faces_and_emotions(img_array)
-                if emotion_label:
-                    st.success(f"Emotion Detected: {emotion_label}")
-                else:
-                    st.warning("No face detected.")
-            except Exception as e:
-                st.error(f"Error: {e}")
-
-    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:
-            try:
-                img = Image.open(camera_image)
-                img_array = np.array(img)
-                emotion_label = detect_faces_and_emotions(img_array)
-                if emotion_label:
-                    st.success(f"Emotion Detected: {emotion_label}")
-                else:
-                    st.warning("No face detected.")
-            except Exception as e:
-                st.error(f"Error: {e}")
-
-elif choice == "View Attendance":
-    st.subheader("View Registered Students (Attendance)")
-
-    students = get_all_students()
-    if students:
-        for student in students:
-            st.write(f"Name: {student[1]}, Roll Number: {student[2]}")
-    else:
-        st.warning("No students registered.")
+    
+    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)
+        if emotion_label:
+            st.success(f"Emotion Detected: {emotion_label}")
+        else:
+            st.warning("No face detected.")