Update app.py

app.py

@@ -1,249 +1,83 @@
-import streamlit as st
 import cv2
+import numpy as np
 import face_recognition
 import os
 from datetime import datetime
-import sqlite3
-import pandas as pd
-import numpy as np
-from PIL import Image
-from pathlib import Path
-import logging
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class AttendanceSystem:
-    def __init__(self):
-        """Initialize the attendance system."""
-        self.setup_page_config()
-        self.setup_database()
-        self.load_known_faces()
-
-    def setup_page_config(self):
-        """Configure Streamlit page settings."""
-        st.set_page_config(
-            page_title="Face Recognition Attendance",
-            page_icon="✅",
-            layout="wide"
-        )
-
-    def setup_database(self):
-        """Initialize database connection and create necessary tables."""
-        try:
-            # Use Path to handle paths consistently across platforms
-            db_path = Path("data/attendance.db")
-            db_path.parent.mkdir(exist_ok=True)
-            
-            self.conn = sqlite3.connect(str(db_path))
-            self.cursor = self.conn.cursor()
-            
-            self.cursor.execute('''
-                CREATE TABLE IF NOT EXISTS attendance (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    name TEXT,
-                    roll_no TEXT,
-                    date TEXT,
-                    time TEXT,
-                    status TEXT 
-                )
-            ''')
-            self.conn.commit()
-        except Exception as e:
-            logger.error(f"Database setup error: {e}")
-            st.error("Error setting up database. Please check logs.")
-
-    def load_known_faces(self):
-        """Load and encode known faces from the Photos directory."""
-        try:
-            photos_dir = Path("Photos")
-            photos_dir.mkdir(exist_ok=True)
-            
-            self.images = []
-            self.classnames = []
-            
-            for img_path in photos_dir.glob("*.[jJ][pP][gG]"):
-                img = cv2.imread(str(img_path))
-                if img is not None:
-                    self.images.append(img)
-                    self.classnames.append(img_path.stem)
-            
-            self.encode_known_faces()
-        except Exception as e:
-            logger.error(f"Error loading known faces: {e}")
-            st.error("Error loading known faces. Please check the Photos directory.")
-
-    def encode_known_faces(self):
-        """Encode loaded face images."""
-        try:
-            self.encodings = []
-            for img in self.images:
-                rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                face_encodings = face_recognition.face_encodings(rgb_img)
-                if face_encodings:
-                    self.encodings.append(face_encodings[0])
-                else:
-                    logger.warning("No face found in image")
-        except Exception as e:
-            logger.error(f"Error encoding faces: {e}")
-            st.error("Error encoding faces. Please check image quality.")
-
-    def add_new_face(self):
-        """Add a new face to the system."""
-        st.subheader("Add New Face")
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            new_name = st.text_input("Enter your name:")
-        with col2:
-            roll_no = st.text_input("Enter your roll number:")
-
-        img_file_buffer = st.camera_input("Take a picture")
-        
-        if img_file_buffer and new_name and roll_no:
-            try:
-                image = np.array(Image.open(img_file_buffer))
-                photos_dir = Path("Photos")
-                img_path = photos_dir / f"{new_name}_{roll_no}.jpg"
-                
-                # Save image
-                cv2.imwrite(str(img_path), cv2.cvtColor(image, cv2.COLOR_RGB2BGR))
-                
-                # Update known faces
-                self.load_known_faces()
-                
-                # Record registration
-                self.record_attendance(new_name, roll_no, 'Registered')
-                st.success(f"Successfully registered {new_name}")
-            except Exception as e:
-                logger.error(f"Error adding new face: {e}")
-                st.error("Error adding new face. Please try again.")
-
-    def recognize_face(self):
-        """Perform face recognition and mark attendance."""
-        st.subheader("Face Recognition")
-        img_file_buffer = st.camera_input("Take a picture")
-        
-        if img_file_buffer:
-            try:
-                image = np.array(Image.open(img_file_buffer))
-                small_image = cv2.resize(image, (0, 0), None, 0.25, 0.25)
-                rgb_small_image = cv2.cvtColor(small_image, cv2.COLOR_BGR2RGB)
-                
-                face_locations = face_recognition.face_locations(rgb_small_image)
-                face_encodings = face_recognition.face_encodings(rgb_small_image, face_locations)
-                
-                for encodeFace, faceLoc in zip(face_encodings, face_locations):
-                    matches = face_recognition.compare_faces(self.encodings, encodeFace, tolerance=0.6)
-                    face_distances = face_recognition.face_distance(self.encodings, encodeFace)
-                    
-                    if len(face_distances) > 0:
-                        best_match_index = np.argmin(face_distances)
-                        if matches[best_match_index]:
-                            name, roll_no = self.classnames[best_match_index].split("_")
-                            self.draw_face_box(image, faceLoc, name)
-                            
-                            if not self.check_duplicate_attendance(name):
-                                status = st.radio("Mark Attendance:", ("Present", "Absent"))
-                                if st.button("Confirm Attendance"):
-                                    self.record_attendance(name, roll_no, status)
-                        else:
-                            st.warning("Face not recognized")
-                
-                st.image(image, caption="Recognized Face", use_container_width=True)
-            except Exception as e:
-                logger.error(f"Error in face recognition: {e}")
-                st.error("Error processing image. Please try again.")
-
-    def draw_face_box(self, image, face_location, name):
-        """Draw bounding box and name for recognized face."""
-        y1, x2, y2, x1 = [coord * 4 for coord in face_location]
-        cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
-        cv2.rectangle(image, (x1, y2 - 35), (x2, y2), (0, 255, 0), cv2.FILLED)
-        cv2.putText(image, name, (x1 + 6, y2 - 6), 
-                    cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2)
-
-    def check_duplicate_attendance(self, name):
-        """Check if attendance has already been marked today."""
-        today = datetime.now().strftime('%Y-%m-%d')
-        self.cursor.execute(
-            "SELECT * FROM attendance WHERE name=? AND date=?", 
-            (name, today)
-        )
-        return bool(self.cursor.fetchone())
-
-    def record_attendance(self, name, roll_no, status):
-        """Record attendance in the database."""
-        try:
-            current_time = datetime.now()
-            self.cursor.execute(
-                """INSERT INTO attendance (name, roll_no, date, time, status) 
-                   VALUES (?, ?, ?, ?, ?)""",
-                (name, roll_no, current_time.strftime('%Y-%m-%d'),
-                 current_time.strftime('%H:%M:%S'), status)
-            )
-            self.conn.commit()
-            st.success(f"Attendance recorded for {name}")
-        except Exception as e:
-            logger.error(f"Error recording attendance: {e}")
-            st.error("Error recording attendance. Please try again.")
-
-    def view_attendance_records(self):
-        """Display attendance records."""
-        st.subheader("Attendance Records")
-        try:
-            self.cursor.execute(
-                "SELECT * FROM attendance ORDER BY date DESC, time DESC"
-            )
-            records = self.cursor.fetchall()
-            
-            if records:
-                df = pd.DataFrame(
-                    records, 
-                    columns=["ID", "Name", "Roll No", "Date", "Time", "Status"]
-                )
-                st.dataframe(df)
-            else:
-                st.info("No attendance records found")
-        except Exception as e:
-            logger.error(f"Error viewing records: {e}")
-            st.error("Error loading attendance records")
-
-    def run(self):
-        """Run the main application."""
-        st.title("Face Recognition Attendance System")
-        
-        # Simple authentication
-        if not self.authenticate():
-            return
-        
-        # Navigation
-        app_mode = st.sidebar.selectbox(
-            "Select Mode",
-            ["Recognize", "Add New Face", "View Records"]
-        )
-        
-        # Route to appropriate function
-        if app_mode == "Recognize":
-            self.recognize_face()
-        elif app_mode == "Add New Face":
-            self.add_new_face()
-        elif app_mode == "View Records":
-            self.view_attendance_records()
-
-    def authenticate(self):
-        """Simple authentication system."""
-        password = st.sidebar.text_input("Enter password", type="password")
-        return password == "123"
-
-    def __del__(self):
-        """Cleanup database connection."""
-        try:
-            self.conn.close()
-        except:
-            pass
-
-if __name__ == "__main__":
-    app = AttendanceSystem()
-    app.run()
+
+# from PIL import ImageGrab
+
+path = 'Training_images'
+images = []
+classNames = []
+myList = os.listdir(path)
+print(myList)
+for cl in myList:
+    curImg = cv2.imread(f'{path}/{cl}')
+    images.append(curImg)
+    classNames.append(os.path.splitext(cl)[0])
+print(classNames)
+
+
+def findEncodings(images):
+    encodeList = []
+
+
+    for img in images:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        encode = face_recognition.face_encodings(img)[0]
+        encodeList.append(encode)
+    return encodeList
+
+
+def markAttendance(name):
+    with open('Attendance.csv', 'r+') as f:
+        myDataList = f.readlines()
+
+
+        nameList = []
+        for line in myDataList:
+            entry = line.split(',')
+            nameList.append(entry[0])
+            if name not in nameList:
+                now = datetime.now()
+                dtString = now.strftime('%H:%M:%S')
+                f.writelines(f'\n{name},{dtString}')
+
+#### FOR CAPTURING SCREEN RATHER THAN WEBCAM
+# def captureScreen(bbox=(300,300,690+300,530+300)):
+#     capScr = np.array(ImageGrab.grab(bbox))
+#     capScr = cv2.cvtColor(capScr, cv2.COLOR_RGB2BGR)
+#     return capScr
+
+encodeListKnown = findEncodings(images)
+print('Encoding Complete')
+
+cap = cv2.VideoCapture(0)
+
+while True:
+    success, img = cap.read()
+# img = captureScreen()
+    imgS = cv2.resize(img, (0, 0), None, 0.25, 0.25)
+    imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)
+
+    facesCurFrame = face_recognition.face_locations(imgS)
+    encodesCurFrame = face_recognition.face_encodings(imgS, facesCurFrame)
+
+    for encodeFace, faceLoc in zip(encodesCurFrame, facesCurFrame):
+        matches = face_recognition.compare_faces(encodeListKnown, encodeFace)
+        faceDis = face_recognition.face_distance(encodeListKnown, encodeFace)
+# print(faceDis)
+        matchIndex = np.argmin(faceDis)
+
+        if matches[matchIndex]:
+            name = classNames[matchIndex].upper()
+# print(name)
+            y1, x2, y2, x1 = faceLoc
+            y1, x2, y2, x1 = y1 * 4, x2 * 4, y2 * 4, x1 * 4
+            cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            cv2.rectangle(img, (x1, y2 - 35), (x2, y2), (0, 255, 0), cv2.FILLED)
+            cv2.putText(img, name, (x1 + 6, y2 - 6), cv2.FONT_HERSHEY_COMPLEX, 1, (255, 255, 255), 2)
+            markAttendance(name)
+
+    cv2.imshow('Webcam', img)
+    cv2.waitKey(1)