Update app.py

app.py

@@ -2,7 +2,7 @@ import gradio as gr
 import cv2
 import numpy as np
 import pandas as pd
-from datetime import datetime, date
+from datetime import datetime, date, timedelta
 import face_recognition
 import pickle
 import os
@@ -10,51 +10,79 @@ from io import BytesIO
 import base64
 from PIL import Image
 import json
+import threading
+import time
+import queue
 
-class AttendanceAnalyzer:
+class AttendanceSystem:
     def __init__(self):
         self.known_face_encodings = []
         self.known_face_names = []
+        self.known_face_ids = []
         self.attendance_records = []
-        self.load_known_faces()
-        
-    def load_known_faces(self):
-        """Load known faces from storage"""
-        if os.path.exists("known_faces.pkl"):
-            try:
-                with open("known_faces.pkl", "rb") as f:
+        self.next_worker_id = 1
+        self.video_capture = None
+        self.is_streaming = False
+        self.frame_queue = queue.Queue(maxsize=2)
+        self.recognition_thread = None
+        self.last_recognition_time = {}
+        self.recognition_cooldown = 5  # seconds between recognitions for same person
+        
+        # Create directories for data storage
+        os.makedirs("data", exist_ok=True)
+        os.makedirs("data/faces", exist_ok=True)
+        
+        self.load_data()
+        
+    def load_data(self):
+        """Load all stored data"""
+        try:
+            # Load face encodings and worker data
+            if os.path.exists("data/workers.pkl"):
+                with open("data/workers.pkl", "rb") as f:
                     data = pickle.load(f)
                     self.known_face_encodings = data.get("encodings", [])
                     self.known_face_names = data.get("names", [])
-            except:
-                self.known_face_encodings = []
-                self.known_face_names = []
-                
-        if os.path.exists("attendance_records.json"):
-            try:
-                with open("attendance_records.json", "r") as f:
+                    self.known_face_ids = data.get("ids", [])
+                    self.next_worker_id = data.get("next_id", 1)
+            
+            # Load attendance records
+            if os.path.exists("data/attendance.json"):
+                with open("data/attendance.json", "r") as f:
                     self.attendance_records = json.load(f)
-            except:
-                self.attendance_records = []
-    
-    def save_known_faces(self):
-        """Save known faces to storage"""
-        data = {
-            "encodings": self.known_face_encodings,
-            "names": self.known_face_names
-        }
-        with open("known_faces.pkl", "wb") as f:
-            pickle.dump(data, f)
+                    
+        except Exception as e:
+            print(f"Error loading data: {e}")
+            self.known_face_encodings = []
+            self.known_face_names = []
+            self.known_face_ids = []
+            self.attendance_records = []
+            self.next_worker_id = 1
     
-    def save_attendance_records(self):
-        """Save attendance records to storage"""
-        with open("attendance_records.json", "w") as f:
-            json.dump(self.attendance_records, f, indent=2)
+    def save_data(self):
+        """Save all data to files"""
+        try:
+            # Save worker data
+            worker_data = {
+                "encodings": self.known_face_encodings,
+                "names": self.known_face_names,
+                "ids": self.known_face_ids,
+                "next_id": self.next_worker_id
+            }
+            with open("data/workers.pkl", "wb") as f:
+                pickle.dump(worker_data, f)
+            
+            # Save attendance records
+            with open("data/attendance.json", "w") as f:
+                json.dump(self.attendance_records, f, indent=2)
+                
+        except Exception as e:
+            print(f"Error saving data: {e}")
     
-    def register_face(self, image, name):
-        """Register a new face for attendance tracking"""
+    def register_worker_manual(self, image, name):
+        """Manual worker registration"""
         if image is None or not name.strip():
-            return "❌ Please provide both image and name!", self.get_registered_faces_info()
+            return "❌ Please provide both image and name!", self.get_registered_workers_info()
         
         # Convert PIL image to RGB array
         if isinstance(image, Image.Image):
@@ -65,102 +93,250 @@ class AttendanceAnalyzer:
         face_encodings = face_recognition.face_encodings(image, face_locations)
         
         if len(face_encodings) == 0:
-            return "❌ No face detected in the image! Please try again with a clear face image.", self.get_registered_faces_info()
+            return "❌ No face detected in the image! Please try again with a clear face image.", self.get_registered_workers_info()
         
         if len(face_encodings) > 1:
-            return "❌ Multiple faces detected! Please upload an image with only one face.", self.get_registered_faces_info()
+            return "❌ Multiple faces detected! Please upload an image with only one face.", self.get_registered_workers_info()
         
         # Check if person already exists
         name = name.strip().title()
         if name in self.known_face_names:
-            return f"❌ {name} is already registered!", self.get_registered_faces_info()
+            return f"❌ {name} is already registered!", self.get_registered_workers_info()
         
-        # Add the face encoding and name
+        # Generate new worker ID
+        worker_id = f"W{self.next_worker_id:04d}"
+        
+        # Add the face encoding, name, and ID
         self.known_face_encodings.append(face_encodings[0])
         self.known_face_names.append(name)
-        self.save_known_faces()
-        
-        return f"✅ {name} has been successfully registered!", self.get_registered_faces_info()
-    
-    def mark_attendance(self, image):
-        """Mark attendance for detected faces"""
-        if image is None:
-            return "❌ Please provide an image!", self.get_today_attendance()
-        
-        if len(self.known_face_encodings) == 0:
-            return "❌ No registered faces found! Please register faces first.", self.get_today_attendance()
-        
-        # Convert PIL image to RGB array
-        if isinstance(image, Image.Image):
-            image = np.array(image)
+        self.known_face_ids.append(worker_id)
+        self.next_worker_id += 1
         
-        # Find faces in the image
-        face_locations = face_recognition.face_locations(image)
-        face_encodings = face_recognition.face_encodings(image, face_locations)
-        
-        if len(face_encodings) == 0:
-            return "❌ No faces detected in the image!", self.get_today_attendance()
+        # Save face image
+        face_image = Image.fromarray(image)
+        face_image.save(f"data/faces/{worker_id}_{name.replace(' ', '_')}.jpg")
         
-        # Process each face
-        recognized_faces = []
-        unknown_faces = 0
+        self.save_data()
         
-        for face_encoding in face_encodings:
-            # Compare with known faces
-            matches = face_recognition.compare_faces(self.known_face_encodings, face_encoding, tolerance=0.6)
-            face_distances = face_recognition.face_distance(self.known_face_encodings, face_encoding)
+        return f"✅ {name} has been successfully registered with ID: {worker_id}!", self.get_registered_workers_info()
+    
+    def register_worker_auto(self, face_encoding, face_image):
+        """Automatic worker registration for unrecognized faces"""
+        try:
+            # Generate new worker ID and name
+            worker_id = f"W{self.next_worker_id:04d}"
+            worker_name = f"Unknown_Worker_{self.next_worker_id}"
+            
+            # Add to database
+            self.known_face_encodings.append(face_encoding)
+            self.known_face_names.append(worker_name)
+            self.known_face_ids.append(worker_id)
+            self.next_worker_id += 1
+            
+            # Save face image
+            face_pil = Image.fromarray(cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB))
+            face_pil.save(f"data/faces/{worker_id}_{worker_name}.jpg")
+            
+            self.save_data()
+            
+            return worker_id, worker_name
+            
+        except Exception as e:
+            print(f"Error in auto registration: {e}")
+            return None, None
+    
+    def mark_attendance(self, worker_id, worker_name):
+        """Mark attendance for a worker"""
+        try:
+            today = date.today().isoformat()
+            current_time = datetime.now()
+            
+            # Check if already marked today
+            already_marked = any(
+                record["worker_id"] == worker_id and record["date"] == today 
+                for record in self.attendance_records
+            )
+            
+            if not already_marked:
+                # Mark attendance
+                self.attendance_records.append({
+                    "worker_id": worker_id,
+                    "name": worker_name,
+                    "date": today,
+                    "time": current_time.strftime("%H:%M:%S"),
+                    "timestamp": current_time.isoformat(),
+                    "status": "Present",
+                    "method": "Auto"
+                })
+                self.save_data()
+                return True
+            return False
+            
+        except Exception as e:
+            print(f"Error marking attendance: {e}")
+            return False
+    
+    def process_video_frame(self, frame):
+        """Process a single video frame for face recognition"""
+        try:
+            # Resize frame for faster processing
+            small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
+            rgb_small_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)
+            
+            # Find faces in the frame
+            face_locations = face_recognition.face_locations(rgb_small_frame)
+            face_encodings = face_recognition.face_encodings(rgb_small_frame, face_locations)
             
-            if len(face_distances) > 0:
-                best_match_index = np.argmin(face_distances)
+            current_time = time.time()
+            
+            for (face_encoding, face_location) in zip(face_encodings, face_locations):
+                # Scale back up face locations
+                top, right, bottom, left = face_location
+                top *= 4
+                right *= 4
+                bottom *= 4
+                left *= 4
                 
-                if matches[best_match_index] and face_distances[best_match_index] < 0.6:
-                    name = self.known_face_names[best_match_index]
-                    
-                    # Check if already marked today
-                    today = date.today().isoformat()
-                    already_marked = any(
-                        record["name"] == name and record["date"] == today 
-                        for record in self.attendance_records
-                    )
+                # Extract face image
+                face_image = frame[top:bottom, left:right]
+                
+                # Compare with known faces
+                matches = face_recognition.compare_faces(self.known_face_encodings, face_encoding, tolerance=0.6)
+                face_distances = face_recognition.face_distance(self.known_face_encodings, face_encoding)
+                
+                worker_id = None
+                worker_name = "Unknown"
+                color = (0, 0, 255)  # Red for unknown
+                
+                if len(face_distances) > 0:
+                    best_match_index = np.argmin(face_distances)
                     
-                    if not already_marked:
-                        # Mark attendance
-                        self.attendance_records.append({
-                            "name": name,
-                            "date": today,
-                            "time": datetime.now().strftime("%H:%M:%S"),
-                            "status": "Present"
-                        })
-                        recognized_faces.append(name)
+                    if matches[best_match_index] and face_distances[best_match_index] < 0.6:
+                        # Known worker
+                        worker_id = self.known_face_ids[best_match_index]
+                        worker_name = self.known_face_names[best_match_index]
+                        color = (0, 255, 0)  # Green for known
+                        
+                        # Check cooldown period
+                        if worker_id not in self.last_recognition_time or \
+                           current_time - self.last_recognition_time[worker_id] > self.recognition_cooldown:
+                            
+                            # Mark attendance
+                            if self.mark_attendance(worker_id, worker_name):
+                                print(f"✅ Attendance marked for {worker_name} ({worker_id})")
+                            
+                            self.last_recognition_time[worker_id] = current_time
                     else:
-                        recognized_faces.append(f"{name} (Already marked)")
-                else:
-                    unknown_faces += 1
-            else:
-                unknown_faces += 1
-        
-        # Save attendance records
-        self.save_attendance_records()
-        
-        # Prepare result message
-        result_parts = []
-        if recognized_faces:
-            result_parts.append(f"✅ Attendance marked for: {', '.join(recognized_faces)}")
-        if unknown_faces > 0:
-            result_parts.append(f"❓ {unknown_faces} unknown face(s) detected")
-        
-        result = "\n".join(result_parts) if result_parts else "❌ No faces could be processed!"
-        
-        return result, self.get_today_attendance()
+                        # Unknown face - auto register
+                        if face_image.size > 0:
+                            new_id, new_name = self.register_worker_auto(face_encoding, face_image)
+                            if new_id:
+                                worker_id = new_id
+                                worker_name = new_name
+                                color = (255, 165, 0)  # Orange for newly registered
+                                print(f"🆕 New worker registered: {new_name} ({new_id})")
+                                
+                                # Mark attendance for new worker
+                                self.mark_attendance(worker_id, worker_name)
+                
+                # Draw rectangle and label
+                cv2.rectangle(frame, (left, top), (right, bottom), color, 2)
+                cv2.rectangle(frame, (left, bottom - 35), (right, bottom), color, cv2.FILLED)
+                
+                label = f"{worker_name}"
+                if worker_id:
+                    label += f" ({worker_id})"
+                
+                cv2.putText(frame, label, (left + 6, bottom - 6), 
+                           cv2.FONT_HERSHEY_DUPLEX, 0.6, (255, 255, 255), 1)
+            
+            return frame
+            
+        except Exception as e:
+            print(f"Error processing frame: {e}")
+            return frame
+    
+    def start_video_stream(self, camera_source=0):
+        """Start video streaming and recognition"""
+        try:
+            if self.is_streaming:
+                return "⚠️ Video stream is already running!"
+            
+            self.video_capture = cv2.VideoCapture(camera_source)
+            if not self.video_capture.isOpened():
+                return "❌ Could not open camera/video source!"
+            
+            self.is_streaming = True
+            
+            def video_loop():
+                while self.is_streaming:
+                    ret, frame = self.video_capture.read()
+                    if not ret:
+                        break
+                    
+                    # Process frame for face recognition
+                    processed_frame = self.process_video_frame(frame)
+                    
+                    # Add to queue for display
+                    if not self.frame_queue.full():
+                        try:
+                            self.frame_queue.put_nowait(processed_frame)
+                        except queue.Full:
+                            pass
+                    
+                    time.sleep(0.1)  # Limit processing rate
+            
+            self.recognition_thread = threading.Thread(target=video_loop)
+            self.recognition_thread.daemon = True
+            self.recognition_thread.start()
+            
+            return "✅ Video stream started successfully!"
+            
+        except Exception as e:
+            return f"❌ Error starting video stream: {e}"
+    
+    def stop_video_stream(self):
+        """Stop video streaming"""
+        try:
+            self.is_streaming = False
+            
+            if self.video_capture:
+                self.video_capture.release()
+                self.video_capture = None
+            
+            if self.recognition_thread:
+                self.recognition_thread.join(timeout=2)
+            
+            # Clear frame queue
+            while not self.frame_queue.empty():
+                try:
+                    self.frame_queue.get_nowait()
+                except queue.Empty:
+                    break
+            
+            return "✅ Video stream stopped successfully!"
+            
+        except Exception as e:
+            return f"❌ Error stopping video stream: {e}"
     
-    def get_registered_faces_info(self):
-        """Get information about registered faces"""
+    def get_current_frame(self):
+        """Get current frame for display"""
+        try:
+            if not self.frame_queue.empty():
+                frame = self.frame_queue.get_nowait()
+                return frame
+            return None
+        except queue.Empty:
+            return None
+    
+    def get_registered_workers_info(self):
+        """Get information about registered workers"""
         if not self.known_face_names:
-            return "No faces registered yet."
+            return "No workers registered yet."
         
-        info = f"**Registered Faces ({len(self.known_face_names)}):**\n"
-        for i, name in enumerate(self.known_face_names, 1):
-            info += f"{i}. {name}\n"
+        info = f"**Registered Workers ({len(self.known_face_names)}):**\n\n"
+        for i, (worker_id, name) in enumerate(zip(self.known_face_ids, self.known_face_names), 1):
+            info += f"{i}. **{name}** (ID: {worker_id})\n"
         return info
     
     def get_today_attendance(self):
@@ -169,11 +345,12 @@ class AttendanceAnalyzer:
         today_records = [r for r in self.attendance_records if r["date"] == today]
         
         if not today_records:
-            return f"**Today's Attendance ({today}):**\nNo attendance marked yet."
+            return f"**Today's Attendance ({today}):**\n\nNo attendance marked yet."
         
-        info = f"**Today's Attendance ({today}):**\n"
+        info = f"**Today's Attendance ({today}):**\n\n"
         for record in today_records:
-            info += f"• {record['name']} - {record['time']} ({record['status']})\n"
+            method_icon = "🤖" if record.get("method") == "Auto" else "👤"
+            info += f"{method_icon} **{record['name']}** (ID: {record['worker_id']}) - {record['time']}\n"
         
         return info
     
@@ -182,6 +359,12 @@ class AttendanceAnalyzer:
         if not start_date or not end_date:
             return "Please select both start and end dates."
         
+        # Convert to string format if needed
+        if hasattr(start_date, 'strftime'):
+            start_date = start_date.strftime('%Y-%m-%d')
+        if hasattr(end_date, 'strftime'):
+            end_date = end_date.strftime('%Y-%m-%d')
+        
         # Filter records by date range
         filtered_records = [
             r for r in self.attendance_records 
@@ -191,148 +374,183 @@ class AttendanceAnalyzer:
         if not filtered_records:
             return f"No attendance records found between {start_date} and {end_date}."
         
-        # Create DataFrame for better presentation
+        # Create DataFrame for analysis
         df = pd.DataFrame(filtered_records)
         
         # Summary statistics
         total_days = (pd.to_datetime(end_date) - pd.to_datetime(start_date)).days + 1
-        unique_people = df['name'].nunique()
+        unique_workers = df['worker_id'].nunique()
         total_attendances = len(df)
+        auto_registrations = len(df[df['method'] == 'Auto'])
         
-        report = f"**Attendance Report ({start_date} to {end_date})**\n\n"
-        report += f"📊 **Summary:**\n"
+        report = f"**📊 Attendance Report ({start_date} to {end_date})**\n\n"
+        report += f"**Summary:**\n"
         report += f"• Total Days: {total_days}\n"
-        report += f"• Unique People: {unique_people}\n"
-        report += f"• Total Attendances: {total_attendances}\n\n"
+        report += f"• Unique Workers: {unique_workers}\n"
+        report += f"• Total Attendances: {total_attendances}\n"
+        report += f"• Auto Detections: {auto_registrations}\n\n"
         
         # Individual attendance counts
         if not df.empty:
-            attendance_counts = df['name'].value_counts()
-            report += f"👥 **Individual Attendance:**\n"
-            for name, count in attendance_counts.items():
-                percentage = (count / total_days) * 100
-                report += f"• {name}: {count} days ({percentage:.1f}%)\n"
+            attendance_counts = df.groupby(['worker_id', 'name']).size().reset_index(name='count')
+            report += f"**👥 Individual Attendance:**\n"
+            for _, row in attendance_counts.iterrows():
+                percentage = (row['count'] / total_days) * 100
+                report += f"• **{row['name']}** ({row['worker_id']}): {row['count']} days ({percentage:.1f}%)\n"
         
         return report
     
     def export_attendance_csv(self):
         """Export attendance records to CSV"""
-        if not self.attendance_records:
-            return None, "No attendance records to export."
-        
-        df = pd.DataFrame(self.attendance_records)
-        csv_file = f"attendance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-        df.to_csv(csv_file, index=False)
-        
-        return csv_file, f"✅ Attendance exported to {csv_file}"
+        try:
+            if not self.attendance_records:
+                return None, "No attendance records to export."
+            
+            df = pd.DataFrame(self.attendance_records)
+            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+            csv_file = f"attendance_report_{timestamp}.csv"
+            df.to_csv(csv_file, index=False)
+            
+            return csv_file, f"✅ Attendance exported to {csv_file}"
+            
+        except Exception as e:
+            return None, f"❌ Error exporting data: {e}"
 
-# Initialize the attendance analyzer
-analyzer = AttendanceAnalyzer()
+# Initialize the attendance system
+attendance_system = AttendanceSystem()
 
-# Create Gradio interface
 def create_interface():
     with gr.Blocks(
-        title="Attendance Analyzer Using Face Detection",
+        title="🎯 Advanced Attendance System with Live Recognition",
         theme=gr.themes.Soft(),
         css="""
         .gradio-container {
-            max-width: 1200px !important;
+            max-width: 1400px !important;
         }
         .tab-nav {
             font-weight: bold;
         }
+        .status-box {
+            padding: 10px;
+            border-radius: 5px;
+            margin: 5px 0;
+        }
         """
     ) as demo:
         
         gr.Markdown(
             """
-            # 👤 Attendance Analyzer Using Face Detection
+            # 🎯 Advanced Attendance System with Live Face Recognition
             
-            **A comprehensive face recognition system for attendance management**
+            **Comprehensive facial recognition system with automatic worker registration and attendance tracking**
             
-            📋 **Features:**
-            - Register new faces for attendance tracking
-            - Automatic attendance marking via face detection
-            - Real-time attendance reports and analytics
-            - Export attendance data to CSV
+            ## 🚀 **Key Features:**
+            - **🎥 Live Video Stream Recognition** - Real-time face detection from camera/CCTV
+            - **🤖 Automatic Worker Registration** - Auto-register unknown faces with unique IDs
+            - **👤 Manual Registration** - Register workers manually with photos
+            - **📅 24-Hour Attendance Rule** - One attendance mark per worker per day
+            - **📊 Advanced Analytics** - Detailed reports and data export
+            - **💾 Persistent Data Storage** - All data saved locally in `/data` folder
+            
+            ## 📁 **Data Storage Location:**
+            - **Worker Database:** `/data/workers.pkl`
+            - **Attendance Records:** `/data/attendance.json` 
+            - **Face Images:** `/data/faces/` folder
             """
         )
         
         with gr.Tabs():
-            # Face Registration Tab
-            with gr.Tab("👥 Register Face", elem_classes="tab-nav"):
-                gr.Markdown("### Register New Person for Attendance Tracking")
+            # Live Recognition Tab
+            with gr.Tab("🎥 Live Recognition", elem_classes="tab-nav"):
+                gr.Markdown("### Real-time Face Recognition and Attendance")
                 
                 with gr.Row():
                     with gr.Column(scale=1):
-                        register_image = gr.Image(
-                            label="Upload Person's Photo",
-                            type="pil",
-                            height=300
+                        camera_source = gr.Number(
+                            label="Camera Source (0 for default camera, or RTSP URL)",
+                            value=0,
+                            precision=0
                         )
-                        register_name = gr.Textbox(
-                            label="Person's Name",
-                            placeholder="Enter full name...",
-                            lines=1
+                        
+                        with gr.Row():
+                            start_stream_btn = gr.Button(
+                                "🎥 Start Live Recognition",
+                                variant="primary",
+                                size="lg"
+                            )
+                            stop_stream_btn = gr.Button(
+                                "⏹️ Stop Stream",
+                                variant="secondary",
+                                size="lg"
+                            )
+                        
+                        stream_status = gr.Textbox(
+                            label="Stream Status",
+                            value="Ready to start...",
+                            interactive=False,
+                            lines=2
                         )
-                        register_btn = gr.Button(
-                            "🔐 Register Face",
-                            variant="primary",
-                            size="lg"
+                        
+                        gr.Markdown(
+                            """
+                            **📋 Instructions:**
+                            1. Click "Start Live Recognition" to begin
+                            2. System will automatically detect and register new faces
+                            3. Known workers will be marked present (once per day)
+                            4. New workers get auto-assigned IDs (W0001, W0002, etc.)
+                            
+                            **🎨 Color Coding:**
+                            - 🟢 **Green:** Known worker (attendance marked)
+                            - 🟠 **Orange:** New worker (auto-registered)
+                            - 🔴 **Red:** Face detected but processing
+                            """
                         )
                     
                     with gr.Column(scale=1):
-                        register_output = gr.Textbox(
-                            label="Registration Status",
-                            lines=3,
-                            interactive=False
+                        live_attendance_display = gr.Markdown(
+                            value=attendance_system.get_today_attendance(),
+                            label="Live Attendance Updates"
                         )
-                        registered_faces_info = gr.Markdown(
-                            value=analyzer.get_registered_faces_info(),
-                            label="Registered Faces"
+                        
+                        refresh_attendance_btn = gr.Button(
+                            "🔄 Refresh Attendance",
+                            variant="secondary"
                         )
-                
-                register_btn.click(
-                    fn=analyzer.register_face,
-                    inputs=[register_image, register_name],
-                    outputs=[register_output, registered_faces_info]
-                )
             
-            # Attendance Marking Tab
-            with gr.Tab("✅ Mark Attendance", elem_classes="tab-nav"):
-                gr.Markdown("### Mark Attendance via Face Recognition")
+            # Manual Registration Tab
+            with gr.Tab("👤 Manual Registration", elem_classes="tab-nav"):
+                gr.Markdown("### Register Workers Manually")
                 
                 with gr.Row():
                     with gr.Column(scale=1):
-                        attendance_image = gr.Image(
-                            label="Upload Photo for Attendance",
+                        register_image = gr.Image(
+                            label="Upload Worker's Photo",
                             type="pil",
                             height=300
                         )
-                        mark_attendance_btn = gr.Button(
-                            "📋 Mark Attendance",
+                        register_name = gr.Textbox(
+                            label="Worker's Full Name",
+                            placeholder="Enter full name...",
+                            lines=1
+                        )
+                        register_btn = gr.Button(
+                            "👤 Register Worker",
                             variant="primary",
                             size="lg"
                         )
                     
                     with gr.Column(scale=1):
-                        attendance_output = gr.Textbox(
-                            label="Attendance Status",
-                            lines=4,
+                        register_output = gr.Textbox(
+                            label="Registration Status",
+                            lines=3,
                             interactive=False
                         )
-                        today_attendance = gr.Markdown(
-                            value=analyzer.get_today_attendance(),
-                            label="Today's Attendance"
+                        registered_workers_info = gr.Markdown(
+                            value=attendance_system.get_registered_workers_info(),
+                            label="Registered Workers Database"
                         )
-                
-                mark_attendance_btn.click(
-                    fn=analyzer.mark_attendance,
-                    inputs=[attendance_image],
-                    outputs=[attendance_output, today_attendance]
-                )
             
-            # Reports Tab
+            # Reports & Analytics Tab
             with gr.Tab("📊 Reports & Analytics", elem_classes="tab-nav"):
                 gr.Markdown("### Attendance Reports and Data Export")
                 
@@ -341,11 +559,11 @@ def create_interface():
                         gr.Markdown("#### 📅 Generate Report")
                         start_date = gr.Date(
                             label="Start Date",
-                            value=date.today().replace(day=1).isoformat()
+                            value=date.today().replace(day=1)
                         )
                         end_date = gr.Date(
                             label="End Date",
-                            value=date.today().isoformat()
+                            value=date.today()
                         )
                         generate_report_btn = gr.Button(
                             "📊 Generate Report",
@@ -372,77 +590,107 @@ def create_interface():
                             value="Select date range and click 'Generate Report' to view attendance analytics.",
                             label="Attendance Report"
                         )
-                
-                generate_report_btn.click(
-                    fn=analyzer.get_attendance_report,
-                    inputs=[start_date, end_date],
-                    outputs=[report_output]
-                )
-                
-                def export_and_show(analyzer=analyzer):
-                    file_path, status = analyzer.export_attendance_csv()
-                    if file_path:
-                        return status, gr.update(visible=True, value=file_path)
-                    else:
-                        return status, gr.update(visible=False)
-                
-                export_btn.click(
-                    fn=export_and_show,
-                    outputs=[export_status, export_file]
-                )
             
-            # Instructions Tab
-            with gr.Tab("ℹ️ Instructions", elem_classes="tab-nav"):
+            # System Info Tab
+            with gr.Tab("ℹ️ System Information", elem_classes="tab-nav"):
                 gr.Markdown(
                     """
-                    ## 📖 How to Use the Attendance Analyzer
+                    ## 📖 System Guide
                     
-                    ### 1. 👥 Register Faces
-                    - Go to the **"Register Face"** tab
-                    - Upload a clear photo of the person (one face per image)
-                    - Enter the person's full name
-                    - Click **"Register Face"** to add them to the system
+                    ### 🎥 Live Recognition System
+                    - **Camera Setup:** Use camera index (0, 1, 2...) or RTSP URL for IP cameras
+                    - **Auto Registration:** Unknown faces automatically get worker IDs (W0001, W0002...)
+                    - **24-Hour Rule:** Each worker can only be marked present once per day
+                    - **Real-time Processing:** Continuous face detection and recognition
                     
-                    ### 2. ✅ Mark Attendance
-                    - Go to the **"Mark Attendance"** tab
-                    - Upload a photo containing one or more registered faces
-                    - Click **"Mark Attendance"** to automatically detect and mark attendance
-                    - The system will show which people were recognized and marked present
+                    ### 👤 Manual Registration
+                    - Upload clear, front-facing photos for best results
+                    - One face per image for registration
+                    - Workers get unique IDs automatically assigned
                     
-                    ### 3. 📊 View Reports
-                    - Go to the **"Reports & Analytics"** tab
-                    - Select a date range to generate attendance reports
-                    - Export attendance data to CSV for external analysis
+                    ### 📁 Data Storage Structure
+                    ```
+                    /data/
+                    ├── workers.pkl          # Worker database (encodings, names, IDs)
+                    ├── attendance.json      # All attendance records
+                    └── faces/              # Saved face images
+                        ├── W0001_John_Doe.jpg
+                        ├── W0002_Jane_Smith.jpg
+                        └── ...
+                    ```
                     
-                    ### 💡 Tips for Best Results:
-                    - Use high-quality, well-lit photos
-                    - Ensure faces are clearly visible and not obscured
-                    - For registration, use photos with the person looking directly at camera
-                    - The system works best with front-facing photos
-                    - Multiple people can be detected in a single attendance photo
+                    ### 🔧 Technical Features
+                    - **Face Recognition:** Uses state-of-the-art face_recognition library
+                    - **Tolerance:** 0.6 threshold for face matching accuracy
+                    - **Threading:** Separate threads for video processing and UI
+                    - **Queue Management:** Efficient frame processing with queue system
+                    - **Error Handling:** Robust error handling and recovery
                     
-                    ### 🔧 Technical Features:
-                    - **Face Detection**: Automatically locates faces in images
-                    - **Face Recognition**: Matches detected faces with registered users
-                    - **Duplicate Prevention**: Prevents multiple attendance marks for the same person on the same day
-                    - **Data Persistence**: All data is saved and persists between sessions
-                    - **Export Capability**: Generate CSV reports for external analysis
+                    ### 🚨 Troubleshooting
+                    - **Camera Issues:** Check camera permissions and connections
+                    - **Poor Recognition:** Ensure good lighting and clear face visibility
+                    - **Performance:** Reduce video resolution for better performance
+                    - **Storage:** Check disk space for face image storage
                     
-                    ### 🚨 Troubleshooting:
-                    - **"No face detected"**: Ensure the image contains a clear, visible face
-                    - **"Multiple faces detected"** (during registration): Use images with only one person
-                    - **"Unknown face"**: The person needs to be registered first
-                    - **Poor recognition**: Try re-registering with a clearer photo
+                    ### 🔒 Privacy & Security
+                    - All data stored locally in `/data` folder
+                    - No external API calls or data transmission
+                    - Face images saved securely with worker IDs
+                    - Attendance records in JSON format for easy backup
                     """
                 )
         
-        # Footer
-        gr.Markdown(
-            """
-            ---
-            **🔒 Privacy Note:** All face data is processed locally and securely stored. 
-            No personal data is transmitted to external servers.
-            """
+        # Event handlers
+        start_stream_btn.click(
+            fn=attendance_system.start_video_stream,
+            inputs=[camera_source],
+            outputs=[stream_status]
+        )
+        
+        stop_stream_btn.click(
+            fn=attendance_system.stop_video_stream,
+            outputs=[stream_status]
+        )
+        
+        refresh_attendance_btn.click(
+            fn=attendance_system.get_today_attendance,
+            outputs=[live_attendance_display]
+        )
+        
+        register_btn.click(
+            fn=attendance_system.register_worker_manual,
+            inputs=[register_image, register_name],
+            outputs=[register_output, registered_workers_info]
+        )
+        
+        generate_report_btn.click(
+            fn=attendance_system.get_attendance_report,
+            inputs=[start_date, end_date],
+            outputs=[report_output]
+        )
+        
+        def export_and_show():
+            file_path, status = attendance_system.export_attendance_csv()
+            if file_path:
+                return status, gr.update(visible=True, value=file_path)
+            else:
+                return status, gr.update(visible=False)
+        
+        export_btn.click(
+            fn=export_and_show,
+            outputs=[export_status, export_file]
+        )
+        
+        # Auto-refresh attendance every 10 seconds when streaming
+        def auto_refresh():
+            if attendance_system.is_streaming:
+                return attendance_system.get_today_attendance()
+            return gr.update()
+        
+        demo.load(
+            fn=auto_refresh,
+            outputs=[live_attendance_display],
+            every=10
         )
     
     return demo
@@ -454,5 +702,6 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        show_error=True,
+        debug=True
     )