Spaces:

ArchiMathur
/

faceRecog

Sleeping

File size: 28,473 Bytes

# # import cv2
# # from ultralytics import YOLO
# # import time
# # from datetime import datetime, timedelta
# # import numpy
# # import csv
# #
# # # Load YOLO model
# # model = YOLO("D:\\live attendance\\best(attendance).pt")
# #
# # # Initialize webcam
# # cap = cv2.VideoCapture(0)  # 0 is usually the default camera
# #
# # # Dictionary to store attendance records
# # attendance_records = {}
# #
# # # CSV file to store attendance data
# # csv_file = open(r"D:\\live attendance\\attendance_data.csv", "w", newline="")
# # csv_writer = csv.writer(csv_file)
# # csv_writer.writerow(["Name", "Time"])
# #
# #
# # while True:
# #     # Read a frame from the webcam
# #     ret, frame = cap.read()
# #     if not ret:
# #         print("Failed to capture image")
# #         break
# #
# #     # Detect objects
# #     results = model(frame)
# #
# #     # Iterate through results
# #     for result in results:
# #         boxes = result.boxes
# #         for box in boxes:  # Iterate through detected boxes
# #             x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)  # Extract coordinates
# #             class_id = int(box.cls[0])  # Get the class ID
# #             confidence = box.conf[0]  # Get the confidence score
# #
# #             # Get the class name from YOLO class names
# #             class_name = model.names[class_id]
# #
# #             # Draw rectangle around detected object
# #             cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)  # Draw rectangle
# #             cv2.putText(frame, f"{class_name}: {confidence:.2f}", (x1, y1 - 10),
# #                         cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
# #
# #             # Check if attendance can be marked
# #             current_time = datetime.now()
# #             if class_name not in attendance_records:
# #                 # Mark attendance for the first time
# #                 attendance_records[class_name] = current_time
# #                 print(f"Attendance marked for {class_name} at {current_time}")
# #                 # Write to CSV
# #                 csv_writer.writerow([class_name, current_time.strftime("%Y-%m-%d %H:%M:%S")])
# #             else:
# #                 last_attendance_time = attendance_records[class_name]
# #                 # Check if 24 hours have passed
# #                 if current_time - last_attendance_time >= timedelta(days=1):
# #                     attendance_records[class_name] = current_time
# #                     print(f"Attendance marked for {class_name} at {current_time}")
# #
# #                     # Write to CSV
# #                     csv_writer.writerow([class_name, current_time.strftime("%Y-%m-%d %H:%M:%S")])
# #                     # csv_file.flush()  # Ensure it's saved immediately
# #
# #     # Show the frame with detections
# #     cv2.imshow("Detected Objects", frame)
# #
# #     # Break the loop on 'q' key press
# #     if cv2.waitKey(1) & 0xFF == ord('q'):
# #         break
# #
# # # Release the video capture object and close all OpenCV windows
# # cap.release()
# # cv2.destroyAllWindows()
# #
# # # import cv2
# # # from ultralytics import YOLO
# # # import time
# # # from datetime import datetime, timedelta
# # # import csv
# # #
# # # # Load YOLO model
# # # model = YOLO("D:\\live attendance\\best(attendance).pt")
# # #
# # # # Initialize webcam
# # # cap = cv2.VideoCapture(0)  # 0 is usually the default camera
# # #
# # # # Dictionary to store attendance records
# # # attendance_records = {}
# # #
# # # # CSV file to store attendance data
# # # # csv_file = open("D:\\live attendance\\attendance_data.csv", "w", newline="")
# # # # csv_writer = csv.writer(csv_file)
# # # # csv_writer.writerow(["Name", "Time"])
# # #
# # # with open('D:\\live attendance\\attendance_data.csv', 'w', newline='') as csv_file:
# # #     writer = csv.writer(csv_file)
# # #     writer.writerows(["Name", "Time"])
# # #
# # # while True:
# # #     # Read a frame from the webcam
# # #     ret, frame = cap.read()
# # #     if not ret:
# # #         print("Failed to capture image")
# # #         break
# # #
# # #     # Detect objects
# # #     results = model(frame)
# # #
# # #     # Iterate through results
# # #     for result in results:
# # #         boxes = result.boxes
# # #         for box in boxes:  # Iterate through detected boxes
# # #             x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)  # Extract coordinates
# # #             class_id = int(box.cls[0])  # Get the class ID
# # #             confidence = box.conf[0]  # Get the confidence score
# # #
# # #             # Get the class name from YOLO class names
# # #             class_name = model.names[class_id]
# # #
# # #             # Draw rectangle around detected object
# # #             cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)  # Draw rectangle
# # #             cv2.putText(frame, f"{class_name}: {confidence:.2f}", (x1, y1 - 10),
# # #                         cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
# # #
# # #             # Check if attendance can be marked
# # #             current_time = datetime.now()
# # #             if class_name not in attendance_records:
# # #                 # Mark attendance for the first time
# # #                 attendance_records[class_name] = current_time
# # #                 csv_writer.writerow([class_name, current_time.strftime("%Y-%m-%d %H:%M:%S")])  # Save to CSV
# # #                 print(f"Attendance marked for {class_name} at {current_time}")
# # #             else:
# # #                 last_attendance_time = attendance_records[class_name]
# # #                 # Check if 24 hours have passed
# # #                 if current_time - last_attendance_time >= timedelta(days=1):
# # #                     attendance_records[class_name] = current_time
# # #                     csv_writer.writerow([class_name, current_time.strftime("%Y-%m-%d %H:%M:%S")])  # Save to CSV
# # #                     print(f"Attendance marked for {class_name} at {current_time}")
# # #
# # #     # Show the frame with detections
# # #     cv2.imshow("Detected Objects", frame)
# # #
# # #     # Break the loop on 'q' key press
# # #     if cv2.waitKey(1) & 0xFF == ord('q'):
# # #         break
# # #
# # # # Release the video capture object and close all OpenCV windows
# # # cap.release()
# # # csv_file.close()  # Close the CSV file
# # # cv2.destroyAllWindows()
#
# # import cv2
# # from ultralytics import YOLO
# # from datetime import datetime, timedelta
# # import csv
# #
# # # Load YOLO model
# # model = YOLO("D:\\live attendance\\best(attendance).pt")
# #
# # # Initialize webcam
# # cap = cv2.VideoCapture(0)  # 0 is usually the default camera
# #
# # # Dictionary to store attendance records
# # attendance_records = {}
# #
# # # CSV file to store attendance data
# # csv_file_path = r"D:\\live attendance\\attendance_data.csv"
# # with open(csv_file_path, "a", newline="") as csv_file:#think here
# #     csv_writer = csv.writer(csv_file)
# #
# #
# #     while True:
# #         # Read a frame from the webcam
# #         ret, frame = cap.read()
# #         if not ret:
# #             print("Failed to capture image")
# #             break
# #
# #         # Detect objects
# #         results = model(frame)
# #
# #         # Iterate through results
# #         for result in results:
# #             boxes = result.boxes
# #             for box in boxes:  # Iterate through detected boxes
# #                 x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)  # Extract coordinates
# #                 class_id = int(box.cls[0])  # Get the class ID
# #                 confidence = box.conf[0]  # Get the confidence score
# #
# #                 # Get the class name from YOLO class names
# #                 class_name = model.names[class_id]
# #
# #                 # Draw rectangle around detected object
# #                 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)  # Draw rectangle
# #                 cv2.putText(frame, f"{class_name}: {confidence:.2f}", (x1, y1 - 10),
# #                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
# #
# #                 # Check if attendance can be marked
# #                 current_time = datetime.now()
# #                 if class_name not in attendance_records:
# #                     # Mark attendance for the first time
# #                     attendance_records[class_name] = current_time#think here
# #                     print(f"Attendance marked for {class_name} at {current_time}")
# #                     # Write to CSV
# #                     csv_writer.writerow([class_name, current_time.strftime("%Y-%m-%d %H:%M:%S")])
# #                 else:
# #                     last_attendance_time = attendance_records[class_name]
# #                     # Check if 24 hours have passed
# #                     if current_time - last_attendance_time >= timedelta(days=1):
# #                         attendance_records[class_name] = current_time
# #                         print(f"Attendance marked for {class_name} at {current_time}")
# #                         # Write to CSV
# #                         csv_writer.writerow([class_name, current_time.strftime("%Y-%m-%d %H:%M:%S")])
# #
# #         # Show the frame with detections
# #         cv2.imshow("Detected Objects", frame)
# #
# #         # Break the loop on 'q' key press
# #         if cv2.waitKey(1) & 0xFF == ord('q'):
# #             break
# #
# # # Release the video capture object and close all OpenCV windows
# # cap.release()
# # cv2.destroyAllWindows()
#
#
# # import cv2
# # import pandas as pd
# # from ultralytics import YOLO
# # from datetime import datetime, timedelta
# #
# # # Load the model
# # model = YOLO("D:\\live attendance\\best(attendance).pt")
# #
# # # Open camera (0 for default camera, 1 for external camera)
# # cap = cv2.VideoCapture(0)
# #
# # # Initialize lists to store class names and timestamps
# # class_names_list = []
# # time_list = []
# #
# # # Initialize a list to keep track of last attendance times
# # last_attendance_times = []
# #
# # while True:
# #     # Read a frame from the webcam
# #     ret, frame = cap.read()
# #     if not ret:
# #         print("Failed to capture image")
# #         break
# #
# #     # Detect objects
# #     results = model(frame)
# #
# #     # Iterate through results
# #     for result in results:
# #         boxes = result.boxes
# #         for box in boxes:  # Iterate through detected boxes
# #             x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)  # Extract coordinates
# #             class_id = int(box.cls[0])  # Get the class ID
# #             confidence = box.conf[0]  # Get the confidence score
# #
# #             # Get the class name from YOLO class names
# #             class_name = model.names[class_id]
# #
# #             # Draw rectangle around detected object
# #             cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)  # Draw rectangle
# #             cv2.putText(frame, f"{class_name}: {confidence:.2f}", (x1, y1 - 10),
# #                         cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
# #
# #             # Get the current time
# #             current_time = datetime.now()
# #             current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S")
# #
# #             # Check if the class name is already in the list
# #             if class_name not in class_names_list:
# #                 # Mark attendance for the first time
# #                 class_names_list.append(class_name)
# #                 time_list.append(current_time_str)
# #                 last_attendance_times.append( class_names_list+time_list)  # Store the time of attendance
# #                 print(f"Attendance marked for {class_name} at {current_time_str}")
# #             else:
# #
# #                 # Check if 24 hours have passed since last recorded attendance
# #                 if current_time - last_attendance_times[class_name] >= timedelta(days=1):
# #                     last_attendance_times[class_name] = current_time  # Update the last attendance time
# #                     time_list[class_names_list.index(class_name)] = current_time_str  # Update the time in the list
# #                     print(f"Attendance marked for {class_name} at {current_time_str}")
# #
# #     # Display output
# #     cv2.imshow("Object Detection", frame)
# #
# #     # Exit on 'q' press
# #     if cv2.waitKey(1) & 0xFF == ord('q'):
# #         break
# #
# # # Release camera and close window
# # cap.release()
# # cv2.destroyAllWindows()
# #
# # # Save class names and timestamps to CSV
# # df = pd.DataFrame({
# #     "Class Name": class_names_list,
# #     "Time": time_list
# # })
# # df.to_csv("D:\\live attendance\\attendance_data.csv", index=False)
# #
# # print("Detections saved ")
#
# # import cv2
# # import pandas as pd
# # from ultralytics import YOLO
# # from datetime import datetime
# #
# # # Load the YOLO model
# # model = YOLO("D:\\live attendance\\best(attendance).pt")
# #
# # # Open camera (0 for default camera, 1 for external camera)
# # cap = cv2.VideoCapture(0)
# #
# # # Initialize lists to store class names and timestamps
# # class_names_list = []
# # time_list = []
# #
# # while True:
# #     # Read a frame from the webcam
# #     ret, frame = cap.read()
# #     if not ret:
# #         print("Failed to capture image")
# #         break
# #
# #     # Detect objects
# #     results = model(frame)
# #
# #     # Check if any results are detected
# #     if results:  # Check if results are not empty
# #         for result in results:
# #             boxes = result.boxes
# #             for box in boxes:  # Iterate through detected boxes
# #                 x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)  # Extract coordinates
# #                 class_id = int(box.cls[0])  # Get the class ID
# #                 confidence = box.conf[0]  # Get the confidence score
# #
# #                 # Get the class name from YOLO class names
# #                 class_name = model.names[class_id]
# #
# #                 # Draw rectangle around detected object
# #                 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)  # Draw rectangle
# #                 cv2.putText(frame, f"{class_name}: {confidence:.2f}", (x1, y1 - 10),
# #                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
# #
# #                 # Get the current time
# #                 current_time = datetime.now()
# #                 current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S")
# #
# #                 # Record attendance for every detected class
# #                 if class_name not in class_names_list:
# #                     class_names_list.append(class_name)
# #                     time_list.append(current_time_str)
# #                     print(f"Attendance marked for {class_name} at {current_time_str}")
# #                 else:
# #                     print(f"{class_name} already recorded.")
# #
# #     else:
# #         print("No results detected.")
# #
# #     # Display output
# #     cv2.imshow("Object Detection", frame)
# #
# #     # Exit on 'q' press
# #     if cv2.waitKey(1) & 0xFF == ord('q'):
# #         break
# #
# # # Release camera and close window
# # cap.release()
# # cv2.destroyAllWindows()
# #
# # # Check if lists are populated before saving
# # print("Class Names:", class_names_list)
# # print("Time List:", time_list)
# #
# # # Save class names and timestamps to CSV
# # if class_names_list and time_list:  # Only save if there is data
# #     df = pd.DataFrame({
# #         "Class Name": class_names_list,
# #         "Time": time_list
# #     })
# #     try:
# #         df.to_csv("D:\\live attendance\\attendance_data.csv", index=False)
# #         print("Detections saved to CSV.")
# #     except Exception as e:
# #         print(f"Error saving to CSV: {e}")
# # else:
# #     print("No attendance data to save.")
#
#
# import cv2
# import pandas as pd
# from ultralytics import YOLO
# from datetime import datetime, timedelta
#
# # Load the YOLO model
# model = YOLO("D:\\live attendance\\best(attendance).pt")
#
# # model = YOLO("C:\\Users\\Dell\\Downloads\\best (2).pt")
#
# # Open camera (0 for default camera, 1 for external camera)
# cap = cv2.VideoCapture(0)
#
# # Initialize lists to store class names and timestamps
# class_names_list = []
# time_list = []
#
# while True:
#     # Read a frame from the webcam
#     ret, frame = cap.read()
#     if not ret:
#         print("Failed to capture image")
#         break
#
#     # Detect objects
#     results = model(frame)
#
#     # Check if any results are detected
#     if results:  # Check if results are not empty
#         for result in results:
#             boxes = result.boxes
#             for box in boxes:  # Iterate through detected boxes
#                 x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)  # Extract coordinates
#                 class_id = int(box.cls[0])  # Get the class ID
#                 confidence = box.conf[0]  # Get the confidence score
#
#                 # Get the class name from YOLO class names
#                 class_name = model.names[class_id]
#
#                 # Draw rectangle around detected object
#                 cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)  # Draw rectangle
#                 cv2.putText(frame, f"{class_name}: {confidence:.2f}", (x1, y1 - 10),
#                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
#
#                 # Get the current time
#                 current_time = datetime.now()
#                 current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S")
#
#                 # Check if the class has been recorded and if 24 hours have passed
#                 if class_name in class_names_list:
#                     index = class_names_list.index(class_name)
#                     last_recorded_time = datetime.strptime(time_list[index], "%Y-%m-%d %H:%M:%S")
#
#                     # If less than 24 hours have passed since the last recording
#                     if (current_time - last_recorded_time) < timedelta(hours=24):
#                         print(f"{class_name} already recorded within the last 24 hours.")
#                         continue
#
#                 # Record attendance for the class
#                 class_names_list.append(class_name)
#                 time_list.append(current_time_str)
#                 print(f"Attendance marked for {class_name} at {current_time_str}")
#
#     else:
#         print("No results detected.")
#
#     # Display output
#     cv2.imshow("Object Detection", frame)
#
#     # Exit on 'q' press
#     if cv2.waitKey(1) & 0xFF == ord('q'):
#         break
#
# # Release camera and close window
# cap.release()
# cv2.destroyAllWindows()
#
# # Check if lists are populated before saving
# print("Class Names:", class_names_list)
# print("Time List:", time_list)
#
# # Save class names and timestamps to CSV
# if class_names_list and time_list:  # Only save if there is data
#     df = pd.DataFrame({
#         "Class Name": class_names_list,
#         "Time": time_list
#     })
#     try:
#         df.to_csv("D:\\live attendance\\attendance_data.csv", index=False)
#         print("Detections saved to CSV.")
#     except Exception as e:
#         print(f"Error saving to CSV: {e}")
# else:
#     print("No attendance data to save.")


import cv2
import pandas as pd
import gradio as gr
from ultralytics import YOLO
from datetime import datetime, timedelta
import os
import numpy as np


class AttendanceSystem:
    def __init__(self, model_path, csv_path):
        self.model_path = model_path
        self.csv_path = csv_path
        self.model = None
        self.class_names_list = []
        self.time_list = []
        self.load_previous_attendance()

    def load_model(self):
        """Load the YOLO model"""
        if self.model is None:
            try:
                self.model = YOLO(self.model_path)
                return True, "Model loaded successfully!"
            except Exception as e:
                return False, f"Error loading model: {str(e)}"
        return True, "Model already loaded"

    def load_previous_attendance(self):
        """Load previous attendance data if CSV exists"""
        if os.path.exists(self.csv_path):
            try:
                df = pd.read_csv(self.csv_path)
                if not df.empty:
                    self.class_names_list = df["Class Name"].tolist()
                    self.time_list = df["Time"].tolist()
                    return True, f"Loaded {len(self.class_names_list)} previous attendance records"
            except Exception as e:
                return False, f"Error loading previous attendance: {str(e)}"
        return False, "No previous attendance data found"

    def process_frame(self, frame):
        """Process a single frame and update attendance"""
        if self.model is None:
            success, message = self.load_model()
            if not success:
                return frame, message, [], []

        # Create a copy of the frame to draw on
        display_frame = frame.copy()

        # Store detected names in this frame
        detected_names = []

        # Detect objects
        results = self.model(frame)

        # Check if any results are detected
        if results:
            for result in results:
                boxes = result.boxes
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy().astype(int)
                    class_id = int(box.cls[0])
                    confidence = float(box.conf[0])

                    # Get the class name from YOLO class names
                    class_name = self.model.names[class_id]
                    detected_names.append(class_name)

                    # Draw rectangle around detected object
                    cv2.rectangle(display_frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                    cv2.putText(display_frame, f"{class_name}: {confidence:.2f}",
                                (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)

                    # Get the current time
                    current_time = datetime.now()
                    current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S")

                    # Check if the class has been recorded already
                    person_already_recorded = False
                    for idx, name in enumerate(self.class_names_list):
                        if name == class_name:
                            last_recorded_time = datetime.strptime(self.time_list[idx], "%Y-%m-%d %H:%M:%S")
                            # If less than 24 hours have passed since the last recording
                            if (current_time - last_recorded_time) < timedelta(hours=24):
                                person_already_recorded = True
                                break

                    # Record attendance if not already recorded in the last 24 hours
                    if not person_already_recorded:
                        self.class_names_list.append(class_name)
                        self.time_list.append(current_time_str)
                        self.save_attendance()

        # Create attendance list for display
        attendance_data = []
        for name, time_str in zip(self.class_names_list, self.time_list):
            attendance_data.append(f"{name} - {time_str}")

        return display_frame, f"Detected: {', '.join(detected_names) if detected_names else 'None'}", attendance_data, detected_names

    def save_attendance(self):
        """Save attendance data to CSV"""
        if self.class_names_list and self.time_list:
            df = pd.DataFrame({
                "Class Name": self.class_names_list,
                "Time": self.time_list
            })
            try:
                df.to_csv(self.csv_path, index=False)
                return True, "Attendance saved to CSV"
            except Exception as e:
                return False, f"Error saving to CSV: {str(e)}"
        return False, "No attendance data to save"

    def clear_attendance(self):
        """Clear attendance records"""
        self.class_names_list = []
        self.time_list = []
        if os.path.exists(self.csv_path):
            try:
                os.remove(self.csv_path)
                return True, "Attendance records cleared"
            except Exception as e:
                return False, f"Error clearing records: {str(e)}"
        return True, "No records to clear"


# Function to capture webcam input
def capture_webcam():
    cap = cv2.VideoCapture(0)
    if not cap.isOpened():
        return None
    ret, frame = cap.read()
    cap.release()
    if ret:
        return frame
    return None


# Function for Gradio interface
def process_webcam(state):
    if state is None:
        # Default paths - update these to match your system
        model_path = "best(attendance).pt"
        csv_path = "attendance_data.csv"
        state = AttendanceSystem(model_path, csv_path)

    # Capture frame from webcam
    frame = capture_webcam()
    if frame is None:
        return None, "Failed to capture webcam frame", "", state

    # Process the frame
    processed_frame, message, attendance_data, detected_names = state.process_frame(frame)

    # Format attendance as HTML table for better display
    if attendance_data:
        attendance_html = "<table style='width:100%; border-collapse: collapse;'>"
        attendance_html += "<tr><th style='border:1px solid black; padding:8px;'>Name</th><th style='border:1px solid black; padding:8px;'>Time</th></tr>"

        for record in attendance_data:
            name, time_str = record.split(" - ", 1)
            attendance_html += f"<tr><td style='border:1px solid black; padding:8px;'>{name}</td><td style='border:1px solid black; padding:8px;'>{time_str}</td></tr>"

        attendance_html += "</table>"
    else:
        attendance_html = "No attendance records."

    return processed_frame, message, attendance_html, state


def clear_attendance_records(state):
    if state is not None:
        success, message = state.clear_attendance()
        return message, "<table></table>", state
    return "System not initialized", "<table></table>", None


def change_model_path(model_path, csv_path, state):
    if not model_path or not csv_path:
        return "Please provide both paths", state

    state = AttendanceSystem(model_path, csv_path)
    success, message = state.load_model()
    return message, state


# Create Gradio interface - compatible with older Gradio versions
with gr.Blocks(title="Attendance System") as app:
    gr.Markdown("# Automated Attendance System")
    gr.Markdown("This system uses YOLO to detect and record attendance of individuals.")

    with gr.Row():
        with gr.Column(scale=2):
            # For older Gradio versions, use a button to capture webcam
            webcam_button = gr.Button("Capture from Webcam")
            output_image = gr.Image(label="Processed Feed")
            status_text = gr.Textbox(label="Status", value="Click 'Capture from Webcam' to start")

        with gr.Column(scale=1):
            # Attendance records and controls
            attendance_display = gr.HTML(label="Attendance Records", value="No records yet.")
            clear_button = gr.Button("Clear Attendance Records")

            # Configuration options
            with gr.Accordion("Configuration", open=False):
                model_path_input = gr.Textbox(label="Model Path", value="best(attendance).pt")
                csv_path_input = gr.Textbox(label="CSV Output Path", value="attendance_data.csv")
                update_paths_button = gr.Button("Update Paths")

    # State for storing the attendance system object
    state = gr.State(None)

    # Set up event handlers
    webcam_button.click(process_webcam, inputs=[state],
                        outputs=[output_image, status_text, attendance_display, state])

    clear_button.click(clear_attendance_records, inputs=[state],
                       outputs=[status_text, attendance_display, state])

    update_paths_button.click(change_model_path, inputs=[model_path_input, csv_path_input, state],
                              outputs=[status_text, state])

# Launch the app
if __name__ == "__main__":
    app.launch(share=True)  # Set share=False if you don't want to create a public link