Update app.py

app.py

@@ -1,170 +1,98 @@
-import sqlite3
-import streamlit as st
-import cv2
-import numpy as np
-import time
 import os
-from keras.models import load_model
-from PIL import Image
-import tempfile
-
-# 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)
-
-# Database setup
-DATABASE_NAME = "emotion_recognition.db"
-
-def init_db():
-    conn = sqlite3.connect(DATABASE_NAME)
-    cursor = conn.cursor()
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS registered_faces (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            image BLOB NOT NULL
-        )
-    ''')
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS attendance_log (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            emotion TEXT NOT NULL,
-            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-        )
-    ''')
-    conn.commit()
-    conn.close()
-
-init_db()
-
-def register_face(name, image):
-    conn = sqlite3.connect(DATABASE_NAME)
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO registered_faces (name, image) VALUES (?, ?)", (name, image))
-    conn.commit()
-    conn.close()
-
-def fetch_registered_faces():
-    conn = sqlite3.connect(DATABASE_NAME)
-    cursor = conn.cursor()
-    cursor.execute("SELECT id, name FROM registered_faces")
-    rows = cursor.fetchall()
-    conn.close()
-    return rows
-
-def log_attendance(name, emotion):
-    conn = sqlite3.connect(DATABASE_NAME)
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO attendance_log (name, emotion) VALUES (?, ?)", (name, emotion))
-    conn.commit()
-    conn.close()
-
-def fetch_recent_activity():
-    conn = sqlite3.connect(DATABASE_NAME)
-    cursor = conn.cursor()
-    cursor.execute("SELECT name, emotion, timestamp FROM attendance_log ORDER BY timestamp DESC LIMIT 10")
-    rows = cursor.fetchall()
-    conn.close()
-    return rows
-
-# Load the emotion model
-@st.cache_resource
-def load_emotion_model():
-    model = load_model('CNN_Model_acc_75.h5')
-    return model
-
-model = load_emotion_model()
-
-# Emotion labels
-emotion_labels = ['angry', 'fear', 'happy', 'neutral', 'sad', 'surprise']
-
-# Sidebar options
-sidebar_choice = st.sidebar.selectbox("Choose an option", ["Emotion Detection", "Register New Face", "View Registered Faces", "Recent Activity"])
-
-if sidebar_choice == "Register New Face":
-    st.header("Register New Face")
-    name = st.text_input("Enter Name")
-    uploaded_image = st.file_uploader("Upload Face Image", type=["png", "jpg", "jpeg"])
-    if name and uploaded_image:
-        image = np.array(Image.open(uploaded_image))
-        _, buffer = cv2.imencode('.jpg', image)
-        register_face(name, buffer.tobytes())
-        st.success(f"Successfully registered {name}!")
-
-elif sidebar_choice == "View Registered Faces":
-    st.header("Registered Faces")
-    faces = fetch_registered_faces()
-    if faces:
-        for face_id, name in faces:
-            st.write(f"ID: {face_id}, Name: {name}")
-    else:
-        st.write("No faces registered yet.")
-
-elif sidebar_choice == "Recent Activity":
-    st.header("Recent Activity (Attendance Log)")
-    logs = fetch_recent_activity()
-    if logs:
-        for name, emotion, timestamp in logs:
-            st.write(f"Name: {name}, Emotion: {emotion}, Timestamp: {timestamp}")
-    else:
-        st.write("No recent activity found.")
+import cv2
+import streamlit as st
+from datetime import datetime
+
+# Constants
+KNOWN_FACES_DIR = "known_faces"
+os.makedirs(KNOWN_FACES_DIR, exist_ok=True)
+
+# Global State
+if "activity_log" not in st.session_state:
+    st.session_state.activity_log = []
+
+# Streamlit App Title
+st.title("Face Detection and Registration App")
+
+st.sidebar.header("Navigation")
+page = st.sidebar.radio("Choose an option:", ["Real-time Face Detection", "Register New Face", "View Registered Faces", "Recent Activity"])
 
-else:  # Emotion Detection
-    st.sidebar.write("Emotion Labels: Angry, Fear, Happy, Neutral, Sad, Surprise")
+# Initialize Cascade Classifier
+face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")
 
-    upload_choice = st.radio("Choose input source", ["Upload Image", "Upload Video", "Camera"])
+# Helper Function for Real-time Face Detection
+def start_camera(register_mode=False, face_name=None):
+    cap = cv2.VideoCapture(0)  # Open the camera
 
-    def process_frame(frame):
-        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-        faces = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml').detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))
+    if not cap.isOpened():
+        st.error("Unable to access the camera. Please check your webcam or permissions.")
+        return
+
+    stframe = st.empty()  # Streamlit placeholder for video frames
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            st.error("Failed to grab frame from camera.")
+            break
+
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(50, 50))
 
-        result_text = ""
         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]
-            face_roi = cv2.resize(roi_color, (48, 48))
-            face_roi = cv2.cvtColor(face_roi, cv2.COLOR_BGR2RGB) / 255.0
-            face_roi = np.expand_dims(face_roi, axis=0)
-
-            predictions = model.predict(face_roi)
-            emotion = emotion_labels[np.argmax(predictions[0])]
-
-            label = "Unknown"  # Placeholder for face recognition (add later)
-            log_attendance(label, emotion)
-
-            result_text = f"{label} is feeling {emotion}"
-            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
-
-    if upload_choice == "Upload Image":
-        uploaded_image = st.file_uploader("Upload Image", type=["png", "jpg", "jpeg"])
-        if uploaded_image:
-            image = np.array(Image.open(uploaded_image))
-            frame, result_text = process_frame(image)
-            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", "avi", "mkv"])
-        if uploaded_video:
-            with tempfile.NamedTemporaryFile(delete=False) as tfile:
-                tfile.write(uploaded_video.read())
-                video_source = cv2.VideoCapture(tfile.name)
-                while True:
-                    ret, frame = video_source.read()
-                    if not ret:
-                        break
-                    frame, result_text = process_frame(frame)
-                    st.image(frame, channels="BGR", use_column_width=True)
-
-    elif upload_choice == "Camera":
-        image = st.camera_input("Take a picture")
-        if image:
-            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)
+            # Draw rectangle
+            cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
+
+            if register_mode and face_name:
+                # Save the cropped face image
+                face_img = frame[y:y + h, x:x + w]
+                face_filename = f"{face_name}_{datetime.now().strftime('%Y%m%d%H%M%S')}.jpg"
+                face_path = os.path.join(KNOWN_FACES_DIR, face_filename)
+                cv2.imwrite(face_path, face_img)
+
+                st.session_state.activity_log.append(
+                    f"Registered face: {face_name} at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+                )
+                st.success(f"Face registered successfully as {face_name}!")
+                return  # Stop after registering
+
+        stframe.image(frame, channels="BGR", use_column_width=True)
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+# Pages
+if page == "Real-time Face Detection":
+    st.header("Real-time Face Detection")
+    if st.button("Start Camera"):
+        start_camera()
+
+elif page == "Register New Face":
+    st.header("Register New Face")
+    name = st.text_input("Enter a name for the face:")
+
+    if st.button("Start Registration"):
+        if name.strip():
+            st.info(f"Looking for face to register as '{name}'...")
+            start_camera(register_mode=True, face_name=name)
+        else:
+            st.error("Please enter a valid name!")
+
+elif page == "View Registered Faces":
+    st.header("Registered Faces")
+    faces = os.listdir(KNOWN_FACES_DIR)
+
+    if faces:
+        st.write(f"*Total Registered Faces: {len(faces)}*")
+        for face_file in faces:
+            st.write(face_file)
+    else:
+        st.write("No registered faces found.")
+
+elif page == "Recent Activity":
+    st.header("Recent Activity Log")
+    if st.session_state.activity_log:
+        for log in reversed(st.session_state.activity_log):
+            st.write(log)
+    else:
+        st.write("No recent activity to display.")