Create app.py

app.py

@@ -0,0 +1,458 @@
+import gradio as gr
+import cv2
+import numpy as np
+import pandas as pd
+from datetime import datetime, date
+import os
+import sqlite3
+import face_recognition
+import io
+from PIL import Image
+import json
+
+# Initialize database
+def init_database():
+    conn = sqlite3.connect('attendance.db')
+    cursor = conn.cursor()
+    
+    # Create users table
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            employee_id TEXT UNIQUE NOT NULL,
+            face_encoding TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    # Create attendance table
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS attendance (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            employee_id TEXT NOT NULL,
+            name TEXT NOT NULL,
+            date DATE NOT NULL,
+            time_in TIME,
+            time_out TIME,
+            status TEXT DEFAULT 'Present',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (employee_id) REFERENCES users (employee_id)
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+# Load known faces from database
+def load_known_faces():
+    conn = sqlite3.connect('attendance.db')
+    cursor = conn.cursor()
+    cursor.execute("SELECT name, employee_id, face_encoding FROM users")
+    users = cursor.fetchall()
+    conn.close()
+    
+    known_faces = []
+    known_names = []
+    known_ids = []
+    
+    for user in users:
+        name, emp_id, encoding_str = user
+        encoding = json.loads(encoding_str)
+        known_faces.append(np.array(encoding))
+        known_names.append(name)
+        known_ids.append(emp_id)
+    
+    return known_faces, known_names, known_ids
+
+# Register new face
+def register_face(image, name, employee_id):
+    if image is None:
+        return "Please upload an image", None
+    
+    if not name or not employee_id:
+        return "Please provide both name and employee ID", None
+    
+    try:
+        # Convert PIL image to RGB array
+        img_array = np.array(image)
+        
+        # Find face encodings
+        face_locations = face_recognition.face_locations(img_array)
+        
+        if len(face_locations) == 0:
+            return "No face detected in the image. Please upload a clear image with a visible face.", None
+        
+        if len(face_locations) > 1:
+            return "Multiple faces detected. Please upload an image with only one face.", None
+        
+        face_encodings = face_recognition.face_encodings(img_array, face_locations)
+        face_encoding = face_encodings[0]
+        
+        # Check if employee ID already exists
+        conn = sqlite3.connect('attendance.db')
+        cursor = conn.cursor()
+        cursor.execute("SELECT * FROM users WHERE employee_id = ?", (employee_id,))
+        existing_user = cursor.fetchone()
+        
+        if existing_user:
+            conn.close()
+            return f"Employee ID {employee_id} already exists!", None
+        
+        # Save to database
+        encoding_str = json.dumps(face_encoding.tolist())
+        cursor.execute(
+            "INSERT INTO users (name, employee_id, face_encoding) VALUES (?, ?, ?)",
+            (name, employee_id, encoding_str)
+        )
+        conn.commit()
+        conn.close()
+        
+        return f"Successfully registered {name} with Employee ID: {employee_id}", get_registered_users()
+        
+    except Exception as e:
+        return f"Error during registration: {str(e)}", None
+
+# Mark attendance
+def mark_attendance(image):
+    if image is None:
+        return "Please upload an image", None, None
+    
+    try:
+        # Convert PIL image to RGB array
+        img_array = np.array(image)
+        
+        # Load known faces
+        known_faces, known_names, known_ids = load_known_faces()
+        
+        if len(known_faces) == 0:
+            return "No registered users found. Please register users first.", None, None
+        
+        # Find faces in the uploaded image
+        face_locations = face_recognition.face_locations(img_array)
+        face_encodings = face_recognition.face_encodings(img_array, face_locations)
+        
+        if len(face_encodings) == 0:
+            return "No face detected in the image.", None, None
+        
+        results = []
+        annotated_image = img_array.copy()
+        
+        for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings):
+            # Compare with known faces
+            matches = face_recognition.compare_faces(known_faces, face_encoding, tolerance=0.6)
+            face_distances = face_recognition.face_distance(known_faces, face_encoding)
+            
+            if len(face_distances) > 0:
+                best_match_index = np.argmin(face_distances)
+                
+                if matches[best_match_index]:
+                    name = known_names[best_match_index]
+                    emp_id = known_ids[best_match_index]
+                    confidence = 1 - face_distances[best_match_index]
+                    
+                    # Mark attendance in database
+                    conn = sqlite3.connect('attendance.db')
+                    cursor = conn.cursor()
+                    
+                    today = date.today()
+                    current_time = datetime.now().strftime("%H:%M:%S")
+                    
+                    # Check if already marked for today
+                    cursor.execute(
+                        "SELECT * FROM attendance WHERE employee_id = ? AND date = ?",
+                        (emp_id, today)
+                    )
+                    existing_record = cursor.fetchone()
+                    
+                    if existing_record:
+                        # Update time_out if time_in exists
+                        if existing_record[4]:  # time_in exists
+                            cursor.execute(
+                                "UPDATE attendance SET time_out = ? WHERE employee_id = ? AND date = ?",
+                                (current_time, emp_id, today)
+                            )
+                            status = "Time Out Updated"
+                        else:
+                            status = "Already marked for today"
+                    else:
+                        # Create new attendance record
+                        cursor.execute(
+                            "INSERT INTO attendance (employee_id, name, date, time_in) VALUES (?, ?, ?, ?)",
+                            (emp_id, name, today, current_time)
+                        )
+                        status = "Attendance Marked"
+                    
+                    conn.commit()
+                    conn.close()
+                    
+                    results.append(f"{name} ({emp_id}) - {status} - Confidence: {confidence:.2f}")
+                    
+                    # Draw rectangle and label on image
+                    cv2.rectangle(annotated_image, (left, top), (right, bottom), (0, 255, 0), 2)
+                    cv2.putText(annotated_image, f"{name} ({confidence:.2f})", 
+                              (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
+                else:
+                    results.append("Unknown person detected")
+                    cv2.rectangle(annotated_image, (left, top), (right, bottom), (0, 0, 255), 2)
+                    cv2.putText(annotated_image, "Unknown", 
+                              (left, top - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+            else:
+                results.append("Unknown person detected")
+        
+        result_text = "\n".join(results)
+        return result_text, Image.fromarray(annotated_image), get_attendance_records()
+        
+    except Exception as e:
+        return f"Error during attendance marking: {str(e)}", None, None
+
+# Get registered users
+def get_registered_users():
+    try:
+        conn = sqlite3.connect('attendance.db')
+        df = pd.read_sql_query("SELECT name, employee_id, created_at FROM users ORDER BY created_at DESC", conn)
+        conn.close()
+        return df
+    except:
+        return pd.DataFrame(columns=['name', 'employee_id', 'created_at'])
+
+# Get attendance records
+def get_attendance_records():
+    try:
+        conn = sqlite3.connect('attendance.db')
+        df = pd.read_sql_query("""
+            SELECT name, employee_id, date, time_in, time_out, status 
+            FROM attendance 
+            ORDER BY date DESC, time_in DESC
+        """, conn)
+        conn.close()
+        return df
+    except:
+        return pd.DataFrame(columns=['name', 'employee_id', 'date', 'time_in', 'time_out', 'status'])
+
+# Get today's attendance
+def get_todays_attendance():
+    try:
+        conn = sqlite3.connect('attendance.db')
+        today = date.today()
+        df = pd.read_sql_query("""
+            SELECT name, employee_id, time_in, time_out, status 
+            FROM attendance 
+            WHERE date = ? 
+            ORDER BY time_in DESC
+        """, conn, params=(today,))
+        conn.close()
+        return df
+    except:
+        return pd.DataFrame(columns=['name', 'employee_id', 'time_in', 'time_out', 'status'])
+
+# Delete user
+def delete_user(employee_id):
+    if not employee_id:
+        return "Please enter an employee ID", get_registered_users()
+    
+    try:
+        conn = sqlite3.connect('attendance.db')
+        cursor = conn.cursor()
+        
+        # Check if user exists
+        cursor.execute("SELECT name FROM users WHERE employee_id = ?", (employee_id,))
+        user = cursor.fetchone()
+        
+        if not user:
+            conn.close()
+            return f"Employee ID {employee_id} not found", get_registered_users()
+        
+        # Delete user and their attendance records
+        cursor.execute("DELETE FROM attendance WHERE employee_id = ?", (employee_id,))
+        cursor.execute("DELETE FROM users WHERE employee_id = ?", (employee_id,))
+        
+        conn.commit()
+        conn.close()
+        
+        return f"Successfully deleted user {user[0]} ({employee_id})", get_registered_users()
+        
+    except Exception as e:
+        return f"Error deleting user: {str(e)}", get_registered_users()
+
+# Initialize database on startup
+init_database()
+
+# Custom CSS
+css = """
+.gradio-container {
+    max-width: 1200px !important;
+}
+.tab-nav {
+    background: linear-gradient(90deg, #667eea 0%, #764ba2 100%) !important;
+}
+.tab-nav button {
+    color: white !important;
+    font-weight: bold !important;
+}
+.tab-nav button.selected {
+    background: rgba(255,255,255,0.2) !important;
+}
+"""
+
+# Create Gradio interface
+with gr.Blocks(css=css, title="Attendance Analyzer - Face Detection", theme=gr.themes.Soft()) as app:
+    gr.Markdown(
+        """
+        # 🎯 Attendance Analyzer Using Face Detection
+        
+        **Advanced AI-powered attendance management system with real-time face recognition**
+        
+        ---
+        """,
+        elem_classes="header"
+    )
+    
+    with gr.Tabs():
+        # Tab 1: Mark Attendance
+        with gr.Tab("📸 Mark Attendance"):
+            gr.Markdown("### Mark attendance by uploading an image or using webcam")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    attendance_image = gr.Image(
+                        type="pil", 
+                        label="Upload Image for Attendance",
+                        height=400
+                    )
+                    mark_btn = gr.Button("Mark Attendance", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    attendance_result = gr.Textbox(
+                        label="Attendance Result",
+                        lines=5,
+                        placeholder="Results will appear here..."
+                    )
+                    annotated_output = gr.Image(
+                        label="Detected Faces",
+                        height=400
+                    )
+            
+            with gr.Row():
+                attendance_df = gr.Dataframe(
+                    label="📊 Today's Attendance Records",
+                    headers=["Name", "Employee ID", "Time In", "Time Out", "Status"],
+                    datatype=["str", "str", "str", "str", "str"],
+                    value=get_todays_attendance()
+                )
+        
+        # Tab 2: Register New User
+        with gr.Tab("👤 Register User"):
+            gr.Markdown("### Register a new user for face recognition")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    register_image = gr.Image(
+                        type="pil",
+                        label="Upload User Photo",
+                        height=400
+                    )
+                    
+                with gr.Column(scale=1):
+                    user_name = gr.Textbox(
+                        label="Full Name",
+                        placeholder="Enter full name..."
+                    )
+                    emp_id = gr.Textbox(
+                        label="Employee ID",
+                        placeholder="Enter unique employee ID..."
+                    )
+                    register_btn = gr.Button("Register User", variant="primary", size="lg")
+                    
+                    register_result = gr.Textbox(
+                        label="Registration Result",
+                        lines=3,
+                        placeholder="Registration status will appear here..."
+                    )
+            
+            with gr.Row():
+                users_df = gr.Dataframe(
+                    label="👥 Registered Users",
+                    headers=["Name", "Employee ID", "Registration Date"],
+                    datatype=["str", "str", "str"],
+                    value=get_registered_users()
+                )
+        
+        # Tab 3: Manage Users
+        with gr.Tab("⚙️ Manage Users"):
+            gr.Markdown("### Manage registered users")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    delete_emp_id = gr.Textbox(
+                        label="Employee ID to Delete",
+                        placeholder="Enter employee ID to delete..."
+                    )
+                    delete_btn = gr.Button("Delete User", variant="stop", size="lg")
+                    delete_result = gr.Textbox(
+                        label="Delete Result",
+                        lines=2,
+                        placeholder="Delete status will appear here..."
+                    )
+                
+                with gr.Column(scale=2):
+                    manage_users_df = gr.Dataframe(
+                        label="👥 All Registered Users",
+                        headers=["Name", "Employee ID", "Registration Date"],
+                        datatype=["str", "str", "str"],
+                        value=get_registered_users()
+                    )
+        
+        # Tab 4: Attendance Reports
+        with gr.Tab("📈 Reports"):
+            gr.Markdown("### View attendance reports and analytics")
+            
+            with gr.Row():
+                refresh_btn = gr.Button("Refresh Reports", variant="secondary")
+            
+            with gr.Row():
+                all_attendance_df = gr.Dataframe(
+                    label="📋 All Attendance Records",
+                    headers=["Name", "Employee ID", "Date", "Time In", "Time Out", "Status"],
+                    datatype=["str", "str", "str", "str", "str", "str"],
+                    value=get_attendance_records(),
+                    height=500
+                )
+    
+    # Event handlers
+    mark_btn.click(
+        fn=mark_attendance,
+        inputs=[attendance_image],
+        outputs=[attendance_result, annotated_output, attendance_df]
+    )
+    
+    register_btn.click(
+        fn=register_face,
+        inputs=[register_image, user_name, emp_id],
+        outputs=[register_result, users_df]
+    )
+    
+    delete_btn.click(
+        fn=delete_user,
+        inputs=[delete_emp_id],
+        outputs=[delete_result, manage_users_df]
+    )
+    
+    refresh_btn.click(
+        fn=lambda: get_attendance_records(),
+        outputs=[all_attendance_df]
+    )
+    
+    # Auto-refresh today's attendance
+    mark_btn.click(
+        fn=lambda: get_todays_attendance(),
+        outputs=[attendance_df]
+    )
+
+if __name__ == "__main__":
+    app.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_api=False
+    )