Create app.py

app.py

@@ -0,0 +1,724 @@
+# # 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 = "D:\\live attendance\\best(attendance).pt"
+        csv_path = "D:\\live attendance\\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="D:\\live attendance\\best(attendance).pt")
+                csv_path_input = gr.Textbox(label="CSV Output Path", value="D:\\live attendance\\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