app.py

import cv2
import face_recognition
import os
import numpy as np
from datetime import datetime
import pandas as pd
import tkinter as tk
from tkinter import messagebox, Toplevel, Label, Entry, Button
import holidays

EMPLOYEES_FILE = 'employees.xlsx'
ATTENDANCE_FILE = 'attendance.xlsx'
FACES_DIR = 'faces'

os.makedirs(FACES_DIR, exist_ok=True)

# Initialize Excel Files
if not os.path.exists(EMPLOYEES_FILE):
    df = pd.DataFrame(columns=['Employee ID', 'Name'])
    df.to_excel(EMPLOYEES_FILE, index=False)

if not os.path.exists(ATTENDANCE_FILE):
    df = pd.DataFrame(columns=['S.No.', 'Employee ID', 'Name', 'Date', 'Time', 'Attendance', 'Attendance Percentage'])
    df.to_excel(ATTENDANCE_FILE, index=False)

def get_working_days_since_start_of_year():
    import datetime as dt
    today = dt.date.today()
    start_date = dt.date(today.year, 1, 1)
    
    in_holidays = holidays.country_holidays('IN', years=today.year)
    working_days = 0
    current_date = start_date
    while current_date <= today:
        if current_date.weekday() != 6 and current_date not in in_holidays: # 6 is Sunday
            working_days += 1
        current_date += dt.timedelta(days=1)
    return max(1, working_days)

def load_encodings():
    images = []
    classNames = []
    empIds = []
    mylist = os.listdir(FACES_DIR)
    for cl in mylist:
        if cl.endswith(('.png', '.jpg', '.jpeg')):
            curImg = cv2.imread(f'{FACES_DIR}/{cl}')
            images.append(curImg)
            name_ext = os.path.splitext(cl)[0]
            parts = name_ext.split('_', 1)
            if len(parts) == 2:
                emp_id, name = parts
            else:
                emp_id = "Unknown"
                name = name_ext
            classNames.append(name)
            empIds.append(emp_id)
            
    encodeList = []
    for img in images:
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        try:
            encoded_face = face_recognition.face_encodings(img)[0]
            encodeList.append(encoded_face)
        except IndexError:
            encodeList.append(None)
    
    valid_encodings = []
    valid_names = []
    valid_ids = []
    for enc, name, emp_id in zip(encodeList, classNames, empIds):
        if enc is not None:
            valid_encodings.append(enc)
            valid_names.append(name)
            valid_ids.append(emp_id)
            
    return valid_encodings, valid_names, valid_ids

def mark_attendance(emp_id, name):
    try:
        df = pd.read_excel(ATTENDANCE_FILE)
    except:
        df = pd.DataFrame(columns=['S.No.', 'Employee ID', 'Name', 'Date', 'Time', 'Attendance', 'Attendance Percentage'])

    now = datetime.now()
    date_str = now.strftime('%d-%m-%Y')
    time_str = now.strftime('%H:%M:%S')
    
    # Check if already marked today
    df['Employee ID'] = df['Employee ID'].astype(str)
    already_marked = df[(df['Employee ID'] == str(emp_id)) & (df['Date'] == date_str)]
    if not already_marked.empty:
        return False, "Already marked today"
    
    total_present = len(df[df['Employee ID'] == str(emp_id)]) + 1
    total_working_days = get_working_days_since_start_of_year()
    percentage = (total_present / total_working_days) * 100
    
    s_no = len(df) + 1
    
    new_row = {
        'S.No.': s_no,
        'Employee ID': str(emp_id),
        'Name': name,
        'Date': date_str,
        'Time': time_str,
        'Attendance': 'Present',
        'Attendance Percentage': round(percentage, 2)
    }
    
    new_df = pd.DataFrame([new_row])
    df = pd.concat([df, new_df], ignore_index=True)
    df.to_excel(ATTENDANCE_FILE, index=False)
    return True, f"Marked ({round(percentage, 2)}%)"

class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Face Recognition Attendance System")
        self.geometry("400x300")
        
        Label(self, text="Attendance System", font=("Helvetica", 16)).pack(pady=20)
        
        Button(self, text="Login (Face Recognition)", width=30, height=2, command=self.login).pack(pady=10)
        Button(self, text="New User Registration", width=30, height=2, command=self.new_user_registration).pack(pady=10)
        
    def new_user_registration(self):
        reg_win = Toplevel(self)
        reg_win.title("Register New User")
        reg_win.geometry("300x250")
        
        Label(reg_win, text="Employee ID:").pack(pady=5)
        emp_id_entry = Entry(reg_win)
        emp_id_entry.pack(pady=5)
        
        Label(reg_win, text="Name:").pack(pady=5)
        name_entry = Entry(reg_win)
        name_entry.pack(pady=5)
        
        def capture_and_register():
            emp_id = emp_id_entry.get().strip()
            name = name_entry.get().strip()
            
            if not emp_id or not name:
                messagebox.showerror("Error", "Please enter both fields")
                return
            
            # Check if emp_id exists
            try:
                emp_df = pd.read_excel(EMPLOYEES_FILE)
                if str(emp_id) in emp_df['Employee ID'].astype(str).values:
                    messagebox.showerror("Error", "Employee ID already exists!")
                    return
            except:
                pass
            
            messagebox.showinfo("Instructions", "Look at the camera. Press 'SPACE' to capture your face, or 'ESC' to cancel.")
            
            cap = cv2.VideoCapture(0)
            img_path = os.path.join(FACES_DIR, f"{emp_id}_{name}.jpg")
            
            while True:
                success, img = cap.read()
                if not success:
                    break
                
                # Draw instructions
                cv2.putText(img, "Press SPACE to Capture, ESC to Cancel", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
                cv2.imshow('Registration - Capture Face', img)
                
                key = cv2.waitKey(1) & 0xFF
                if key == 32: # SPACE
                    cv2.imwrite(img_path, img)
                    break
                elif key == 27: # ESC
                    cap.release()
                    cv2.destroyAllWindows()
                    return
            
            cap.release()
            cv2.destroyAllWindows()
            
            # Save to Excel
            try:
                emp_df = pd.read_excel(EMPLOYEES_FILE)
            except:
                emp_df = pd.DataFrame(columns=['Employee ID', 'Name'])
                
            new_row = {'Employee ID': emp_id, 'Name': name}
            emp_df = pd.concat([emp_df, pd.DataFrame([new_row])], ignore_index=True)
            emp_df.to_excel(EMPLOYEES_FILE, index=False)
            
            messagebox.showinfo("Success", "User Registered successfully!")
            reg_win.destroy()
            
        Button(reg_win, text="Register and Capture Face", command=capture_and_register).pack(pady=20)
        
    def login(self):
        encodings, names, emp_ids = load_encodings()
        if not encodings:
            messagebox.showerror("Error", "No users registered yet.")
            return
            
        cap = cv2.VideoCapture(0)
        
        while True:
            success, img = cap.read()
            if not success:
                break
                
            imgS = cv2.resize(img, (0,0), None, 0.25, 0.25)
            imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)
            
            faces_in_frame = face_recognition.face_locations(imgS)
            encoded_faces = face_recognition.face_encodings(imgS, faces_in_frame)
            
            for encode_face, faceloc in zip(encoded_faces, faces_in_frame):
                matches = face_recognition.compare_faces(encodings, encode_face)
                faceDist = face_recognition.face_distance(encodings, encode_face)
                
                if len(faceDist) > 0:
                    matchIndex = np.argmin(faceDist)
                    
                    if matches[matchIndex]:
                        name = names[matchIndex]
                        emp_id = emp_ids[matchIndex]
                        
                        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)
                        
                        success_mark, msg = mark_attendance(emp_id, name)
                        display_text = f"{name}: {msg}"
                        cv2.putText(img, display_text, (x1, y2+25), cv2.FONT_HERSHEY_COMPLEX, 0.7, (255,0,0), 2)
                        
                        cv2.imshow('Login - Face Recognition', img)
                        cv2.waitKey(2000)
                        cap.release()
                        cv2.destroyAllWindows()
                        if success_mark:
                            messagebox.showinfo("Success", f"Welcome {name}! Attendance marked.\n{msg}")
                        else:
                            messagebox.showwarning("Warning", f"{name}, {msg}")
                        return
                    else:
                        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, 0, 255), 2)
                        cv2.putText(img, "Unknown", (x1, y2+25), cv2.FONT_HERSHEY_COMPLEX, 1, (0,0,255), 2)

            cv2.putText(img, "Press ESC to Cancel", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
            cv2.imshow('Login - Face Recognition', img)
            if cv2.waitKey(1) & 0xFF == 27:
                break
                
        cap.release()
        cv2.destroyAllWindows()

if __name__ == "__main__":
    app = App()
    app.mainloop()