gui_app.py

import multiprocessing as mp
import queue

import tkinter as tk
import tkinter.scrolledtext as st
from tkinter import messagebox

import cv2
from PIL import Image, ImageTk

from recognizer import face_recognition_worker, AttendanceRecognizer


class AttendanceApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Smart Roll Call")
        self.root.geometry("800x600")

        self.video_label = tk.Label(root)
        self.video_label.pack()

        btn_frame = tk.Frame(root)
        btn_frame.pack(pady=10)

        self.start_btn = tk.Button(btn_frame, text="Start Attendance", command=self.start_attendance)
        self.start_btn.grid(row=0, column=0, padx=5)

        self.stop_btn = tk.Button(btn_frame, text="Stop Attendance", command=self.stop_attendance, state=tk.DISABLED)
        self.stop_btn.grid(row=0, column=1, padx=5)

        self.quit_btn = tk.Button(btn_frame, text="Quit", command=self.quit_app)
        self.quit_btn.grid(row=0, column=2, padx=5)

        # text area by bum-head
        self.text_area = st.ScrolledText(btn_frame, width = 50, height = 8, font = ("Times New Roman", 12))
        self.text_area.grid(row=2, column = 0, pady = 5, padx = 5)
        self.text_area.configure(state ='disabled')

        self.cap = None
        self.running = False
        self.frame_queue = None
        self.result_queue = None
        self.worker = None
        self.stop_event = None
        self.latest_results = []

        self.recognizer = AttendanceRecognizer()

    def start_attendance(self):
        self.cap = cv2.VideoCapture(0)
        if not self.cap.isOpened():
            messagebox.showerror("Error", "Cannot access webcam")
            return

        # set camera size for smoothness
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)

        self.frame_queue = mp.Queue(maxsize=1)
        self.result_queue = mp.Queue(maxsize=5)
        self.stop_event = mp.Event()

        self.worker = mp.Process(
            target=face_recognition_worker,
            args=(self.frame_queue, self.result_queue,
                  self.recognizer.known_encodings, self.recognizer.known_names,
                  self.recognizer.known_rollnos, self.recognizer.tolerance,
                  self.stop_event, 0.5)
        )
        self.worker.start()

        self.running = True
        self.start_btn.config(state=tk.DISABLED)
        self.stop_btn.config(state=tk.NORMAL)

        self.update_frame()

    def stop_attendance(self):
        self.running = False
        if self.cap:
            self.cap.release()
            self.cap = None

        if self.stop_event:
            self.stop_event.set()
        if self.worker:
            self.worker.terminate()
            self.worker.join()

        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        self.video_label.config(image="")

    def update_frame(self):
        if self.running and self.cap:
            ret, frame = self.cap.read()
            if ret:
                rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

                # safely clear old frames
                try:
                    while True:
                        self.frame_queue.get_nowait()
                except queue.Empty:
                    pass

                # send new frame
                try:
                    self.frame_queue.put((0, rgb, frame.shape[0], frame.shape[1]), block=False)
                except queue.Full:
                    pass

                # receive from worker
                try:
                    while not self.result_queue.empty():
                        _, recognition_results = self.result_queue.get(block=False)
                        self.latest_results = recognition_results
                        for box, name, roll_no, best_dist in recognition_results:
                            if name != "Unknown":
                                self.display_attended(name, roll_no)
                                self.recognizer.mark_attendance(name, roll_no)
                except queue.Empty:
                    pass

                # draw results
                for box, name, roll_no, best_dist in self.latest_results:
                    top, right, bottom, left = box
                    cv2.rectangle(rgb, (left, top), (right, bottom), (0, 255, 0), 2)
                    cv2.putText(rgb, f"{roll_no}_{name}",
                                (left, top - 10),
                                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)

                # show in tkinter
                img = Image.fromarray(rgb)
                imgtk = ImageTk.PhotoImage(image=img)
                self.video_label.imgtk = imgtk
                self.video_label.configure(image=imgtk)

            self.video_label.after(20, self.update_frame)

    def quit_app(self):
        self.stop_attendance()
        self.root.destroy()

    def display_attended(self, name, roll_no):
        if self.recognizer.is_already_marked_today(roll_no):
            return 

        self.text_area.configure(state=tk.NORMAL)

        # Inserting Text which is read only
        self.text_area.insert(tk.INSERT, f"{roll_no}_{name} present!\n")

if __name__ == "__main__":
    mp.set_start_method("spawn")
    root = tk.Tk()
    app = AttendanceApp(root)
    root.mainloop()