Update app.py

app.py

@@ -1,8 +1,6 @@
 # Suppress TensorFlow oneDNN warnings
 import os
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-os.environ['CUDA_VISIBLE_DEVICES'] = '-1'  # Force CPU usage to avoid GPU issues
 
 # Standard Library Imports
 import base64
@@ -11,55 +9,31 @@ import logging
 import queue
 import threading
 import time
+import hashlib
+import uuid
 from datetime import datetime, date
 from io import BytesIO
-from typing import Tuple, Optional, List, Dict, Any
+from typing import Tuple, Optional, List, Dict
 import pickle
-import sqlite3
-from pathlib import Path
 
-# Setup logging first before any other imports that might use it
-logging.basicConfig(
-    level=logging.INFO, 
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[
-        logging.FileHandler("attendance_system.log"),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# Third-Party Imports - with error handling
-try:
-    import cv2
-    import gradio as gr
-    import numpy as np
-    import pandas as pd
-    from PIL import Image
-    import requests
-    from dotenv import load_dotenv
-    from retrying import retry
-    from simple_salesforce import Salesforce
-    
-    # Import DeepFace with fallback
-    try:
-        from deepface import DeepFace
-        DEEPFACE_AVAILABLE = True
-        logger.info("✅ DeepFace loaded successfully")
-    except ImportError as e:
-        logger.warning(f"⚠️ DeepFace not available: {e}")
-        DEEPFACE_AVAILABLE = False
-    except Exception as e:
-        logger.error(f"❌ DeepFace import error: {e}")
-        DEEPFACE_AVAILABLE = False
-        
-except ImportError as e:
-    logger.error(f"Missing dependency: {e}")
-    logger.error("Please install required packages using: pip install -r requirements.txt")
-    exit(1)
+# Third-Party Imports
+import cv2
+import gradio as gr
+import numpy as np
+import pandas as pd
+from PIL import Image
+import requests
+from dotenv import load_dotenv
+from deepface import DeepFace
+from retrying import retry
+from simple_salesforce import Salesforce
 
 # --- CONFIGURATION ---
 
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
 # Load environment variables from .env file
 load_dotenv()
 
@@ -75,149 +49,6 @@ SF_CREDENTIALS = {
     "domain": os.getenv("SF_DOMAIN", "login")
 }
 
-# System configuration
-FACE_RECOGNITION_THRESHOLD = float(os.getenv("FACE_THRESHOLD", "10.0"))
-CONFIDENCE_THRESHOLD = float(os.getenv("CONFIDENCE_THRESHOLD", "0.95"))
-RECOGNITION_COOLDOWN = int(os.getenv("RECOGNITION_COOLDOWN", "5"))
-
-# --- DATABASE SETUP ---
-
-class LocalDatabase:
-    """Local SQLite database for offline functionality and backup."""
-    
-    def __init__(self, db_path: str = "data/attendance.db"):
-        self.db_path = db_path
-        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
-        self._init_database()
-    
-    def _init_database(self):
-        """Initialize database tables."""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                
-                # Workers table
-                cursor.execute('''
-                    CREATE TABLE IF NOT EXISTS workers (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        worker_id TEXT UNIQUE NOT NULL,
-                        name TEXT NOT NULL,
-                        face_embedding TEXT NOT NULL,
-                        image_path TEXT,
-                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        synced_to_sf BOOLEAN DEFAULT FALSE
-                    )
-                ''')
-                
-                # Attendance table
-                cursor.execute('''
-                    CREATE TABLE IF NOT EXISTS attendance (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        worker_id TEXT NOT NULL,
-                        worker_name TEXT NOT NULL,
-                        date TEXT NOT NULL,
-                        timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                        status TEXT DEFAULT 'Present',
-                        synced_to_sf BOOLEAN DEFAULT FALSE,
-                        UNIQUE(worker_id, date)
-                    )
-                ''')
-                
-                conn.commit()
-                logger.info("Database initialized successfully")
-        except Exception as e:
-            logger.error(f"Database initialization error: {e}")
-    
-    def add_worker(self, worker_id: str, name: str, embedding: List[float], image_path: str = None) -> bool:
-        """Add a new worker to the database."""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute('''
-                    INSERT INTO workers (worker_id, name, face_embedding, image_path)
-                    VALUES (?, ?, ?, ?)
-                ''', (worker_id, name, json.dumps(embedding), image_path))
-                conn.commit()
-                return True
-        except sqlite3.IntegrityError:
-            logger.warning(f"Worker {worker_id} already exists in database")
-            return False
-        except Exception as e:
-            logger.error(f"Error adding worker to database: {e}")
-            return False
-    
-    def get_all_workers(self) -> List[Dict[str, Any]]:
-        """Get all workers from the database."""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute('SELECT worker_id, name, face_embedding, image_path FROM workers')
-                workers = []
-                for row in cursor.fetchall():
-                    workers.append({
-                        'worker_id': row[0],
-                        'name': row[1],
-                        'embedding': json.loads(row[2]),
-                        'image_path': row[3]
-                    })
-                return workers
-        except Exception as e:
-            logger.error(f"Error fetching workers from database: {e}")
-            return []
-    
-    def mark_attendance(self, worker_id: str, worker_name: str, date_str: str) -> bool:
-        """Mark attendance for a worker."""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute('''
-                    INSERT OR IGNORE INTO attendance (worker_id, worker_name, date)
-                    VALUES (?, ?, ?)
-                ''', (worker_id, worker_name, date_str))
-                conn.commit()
-                return cursor.rowcount > 0
-        except Exception as e:
-            logger.error(f"Error marking attendance: {e}")
-            return False
-    
-    def has_attended_today(self, worker_id: str, date_str: str) -> bool:
-        """Check if worker has already attended today."""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute('''
-                    SELECT COUNT(*) FROM attendance 
-                    WHERE worker_id = ? AND date = ?
-                ''', (worker_id, date_str))
-                return cursor.fetchone()[0] > 0
-        except Exception as e:
-            logger.error(f"Error checking attendance: {e}")
-            return False
-    
-    def get_attendance_report(self, start_date: str = None, end_date: str = None) -> pd.DataFrame:
-        """Get attendance report as pandas DataFrame."""
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                query = 'SELECT * FROM attendance'
-                params = []
-                
-                if start_date and end_date:
-                    query += ' WHERE date BETWEEN ? AND ?'
-                    params = [start_date, end_date]
-                elif start_date:
-                    query += ' WHERE date >= ?'
-                    params = [start_date]
-                elif end_date:
-                    query += ' WHERE date <= ?'
-                    params = [end_date]
-                
-                query += ' ORDER BY timestamp DESC'
-                
-                return pd.read_sql_query(query, conn, params=params)
-        except Exception as e:
-            logger.error(f"Error generating attendance report: {e}")
-            return pd.DataFrame()
-
 # --- SALESFORCE CONNECTION ---
 
 @retry(stop_max_attempt_number=3, wait_fixed=2000)
@@ -230,13 +61,59 @@ def connect_to_salesforce() -> Optional[Salesforce]:
         return sf
     except Exception as e:
         logger.error(f"❌ Salesforce connection failed: {e}")
-        return None  # Don't raise, allow offline mode
+        raise
+
+# --- FACE QUALITY ASSESSMENT ---
+
+def assess_face_quality(face_image: np.ndarray, facial_area: Dict) -> Tuple[bool, Dict]:
+    """
+    Assess the quality of a detected face for registration/recognition.
+    Returns (is_good_quality, quality_metrics)
+    """
+    h, w = face_image.shape[:2]
+    
+    # 1. Face size check (minimum 80x80 pixels)
+    min_face_size = 80
+    size_check = min(w, h) >= min_face_size
+    
+    # 2. Blur detection using Laplacian variance
+    gray = cv2.cvtColor(face_image, cv2.COLOR_BGR2GRAY) if len(face_image.shape) == 3 else face_image
+    blur_score = cv2.Laplacian(gray, cv2.CV_64F).var()
+    blur_threshold = 100  # Higher values = less blur
+    blur_check = blur_score > blur_threshold
+    
+    # 3. Brightness check
+    brightness = np.mean(gray)
+    brightness_check = 50 < brightness < 200  # Not too dark or too bright
+    
+    # 4. Face detection confidence (from facial_area if available)
+    confidence_check = facial_area.get('confidence', 0) > 0.98
+    
+    # 5. Face area ratio (face should take reasonable portion of the detection area)
+    face_area = w * h
+    detection_area = facial_area.get('w', w) * facial_area.get('h', h)
+    area_ratio = face_area / max(detection_area, 1)
+    area_check = area_ratio > 0.6
+    
+    quality_metrics = {
+        'size_score': min(w, h),
+        'blur_score': blur_score,
+        'brightness_score': brightness,
+        'confidence_score': facial_area.get('confidence', 0),
+        'area_ratio': area_ratio
+    }
+    
+    # All checks must pass for good quality
+    is_good_quality = all([size_check, blur_check, brightness_check, confidence_check, area_check])
+    
+    return is_good_quality, quality_metrics
 
 # --- CORE LOGIC ---
 
 class AttendanceSystem:
-    """Enhanced attendance system with improved error handling and offline support."""
-    
+    """
+    Manages all backend logic for the face recognition attendance system.
+    """
     def __init__(self):
         # State Management
         self.processing_thread = None
@@ -245,374 +122,450 @@ class AttendanceSystem:
         self.error_message = None 
         self.last_processed_frame = None
         self.final_log = None
-        self.processing_stats = {
-            'frames_processed': 0,
-            'faces_detected': 0,
-            'workers_recognized': 0,
-            'new_registrations': 0
-        }
 
-        # Data Storage
-        self.known_face_embeddings: List[np.ndarray] = []
+        # Data Storage with improved structure
+        self.known_face_embeddings: List[List[np.ndarray]] = []  # Multiple embeddings per person
         self.known_face_names: List[str] = []
         self.known_face_ids: List[str] = []
+        self.worker_metadata: Dict[str, Dict] = {}  # Store additional info per worker
         self.next_worker_id: int = 1
         
-        # Session Tracking
+        # Session Tracking with improvements
         self.last_recognition_time = {}
-        self.recognition_cooldown = RECOGNITION_COOLDOWN
+        self.recognition_cooldown = 5
         self.session_log: List[str] = []
+        self.daily_attendance: set = set()  # Track who attended today
+        self.session_attendees: set = set()  # Track who attended this session
+        
+        # Processing optimization
+        self.frame_skip_count = 0
+        self.frame_skip_rate = 2  # Process every 3rd frame for speed
+        self.processing_resolution = (640, 480)  # Reduce resolution for speed
 
-        # Initialize components
-        try:
-            self.db = LocalDatabase()
-            self.sf = connect_to_salesforce()
-            self._create_directories()
-            self.load_worker_data()
-            logger.info("✅ Attendance system initialized successfully")
-        except Exception as e:
-            logger.error(f"❌ System initialization error: {e}")
-            self.error_message = f"System initialization failed: {str(e)}"
+        # Initialize
+        self.sf = connect_to_salesforce()
+        self._create_directories()
+        self.load_worker_data()
+        self._load_daily_attendance()
 
     def _create_directories(self):
-        """Create necessary directories."""
-        directories = ["data/faces", "data/reports", "data/backups"]
-        for directory in directories:
-            os.makedirs(directory, exist_ok=True)
-
-    def load_worker_data(self):
-        """Load worker data with improved error handling and offline support."""
-        logger.info("Loading worker data...")
+        os.makedirs("data/faces", exist_ok=True)
+        os.makedirs("data/embeddings", exist_ok=True)
+
+    def _generate_unique_worker_id(self) -> str:
+        """Generate a truly unique worker ID with timestamp and UUID components."""
+        timestamp = datetime.now().strftime("%y%m%d")
+        unique_suffix = str(uuid.uuid4())[:8].upper()
+        worker_id = f"W{self.next_worker_id:04d}-{timestamp}-{unique_suffix}"
         
-        try:
-            # First try to load from local database
-            local_workers = self.db.get_all_workers()
-            if local_workers:
-                self._load_workers_from_list(local_workers)
-                logger.info(f"✅ Loaded {len(local_workers)} workers from local database.")
-            
-            # Then sync with Salesforce if available
-            if self.sf:
-                try:
-                    self._sync_with_salesforce()
-                except Exception as e:
-                    logger.error(f"❌ Error syncing with Salesforce: {e}")
-            else:
-                logger.warning("Salesforce not connected. Running in offline mode.")
-        except Exception as e:
-            logger.error(f"Error loading worker data: {e}")
+        # Ensure uniqueness by checking against existing IDs
+        while worker_id in self.known_face_ids:
+            self.next_worker_id += 1
+            worker_id = f"W{self.next_worker_id:04d}-{timestamp}-{unique_suffix}"
+        
+        return worker_id
 
-    def _load_workers_from_list(self, workers: List[Dict[str, Any]]):
-        """Load workers from a list of worker dictionaries."""
-        temp_embeddings, temp_names, temp_ids, max_id = [], [], [], 0
+    def _load_daily_attendance(self):
+        """Load today's attendance records to prevent duplicates."""
+        today_str = date.today().isoformat()
+        self.daily_attendance.clear()
         
-        for worker in workers:
+        if self.sf:
+            try:
+                records = self.sf.query_all(f"SELECT Worker_ID__c FROM Attendance__c WHERE Date__c = {today_str}")['records']
+                self.daily_attendance.update([record['Worker_ID__c'] for record in records])
+                logger.info(f"✅ Loaded {len(self.daily_attendance)} attendance records for today.")
+            except Exception as e:
+                logger.error(f"❌ Error loading daily attendance: {e}")
+
+    def load_worker_data(self):
+        logger.info("Loading worker data...")
+        if self.sf:
             try:
-                temp_embeddings.append(np.array(worker['embedding']))
-                temp_names.append(worker['name'])
-                temp_ids.append(worker['worker_id'])
+                workers = self.sf.query_all("SELECT Worker_ID__c, Name, Face_Embedding__c FROM Worker__c")['records']
+                if not workers:
+                    self._load_local_worker_data()
+                    return
+
+                temp_embeddings, temp_names, temp_ids, max_id = [], [], [], 0
+                for worker in workers:
+                    if worker.get('Face_Embedding__c'):
+                        # Support multiple embeddings per worker (stored as JSON array)
+                        embedding_data = json.loads(worker['Face_Embedding__c'])
+                        if isinstance(embedding_data[0], list):
+                            # Multiple embeddings
+                            temp_embeddings.append([np.array(emb) for emb in embedding_data])
+                        else:
+                            # Single embedding - wrap in list for consistency
+                            temp_embeddings.append([np.array(embedding_data)])
+                        
+                        temp_names.append(worker['Name'])
+                        temp_ids.append(worker['Worker_ID__c'])
+                        
+                        # Extract numeric part for next ID
+                        try:
+                            worker_num = int(worker['Worker_ID__c'].split('-')[0][1:])
+                            if worker_num > max_id:
+                                max_id = worker_num
+                        except (ValueError, TypeError, IndexError):
+                            continue
                 
-                worker_num = int(worker['worker_id'][1:])
-                if worker_num > max_id:
-                    max_id = worker_num
-            except (ValueError, TypeError, KeyError) as e:
-                logger.warning(f"Error processing worker data: {e}")
-                continue
-        
-        self.known_face_embeddings = temp_embeddings
-        self.known_face_names = temp_names
-        self.known_face_ids = temp_ids
-        self.next_worker_id = max_id + 1
+                self.known_face_embeddings = temp_embeddings
+                self.known_face_names = temp_names
+                self.known_face_ids = temp_ids
+                self.next_worker_id = max_id + 1
+                self.save_local_worker_data()
+                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from Salesforce.")
+            except Exception as e:
+                logger.error(f"❌ Error loading from Salesforce: {e}. Attempting local load.")
+                self._load_local_worker_data()
+        else:
+            logger.warning("Salesforce not connected. Loading from local cache.")
+            self._load_local_worker_data()
 
-    def _sync_with_salesforce(self):
-        """Sync data with Salesforce."""
+    def _load_local_worker_data(self):
         try:
-            workers = self.sf.query_all("SELECT Worker_ID__c, Name, Face_Embedding__c FROM Worker__c")['records']
-            
-            for worker in workers:
-                if worker.get('Face_Embedding__c'):
-                    # Add to local database if not exists
-                    self.db.add_worker(
-                        worker['Worker_ID__c'],
-                        worker['Name'],
-                        json.loads(worker['Face_Embedding__c'])
-                    )
-            
-            logger.info(f"✅ Synced {len(workers)} workers from Salesforce.")
+            if os.path.exists("data/workers.pkl"):
+                with open("data/workers.pkl", "rb") as f: 
+                    data = pickle.load(f)
+                self.known_face_embeddings = data.get("embeddings", [])
+                self.known_face_names = data.get("names", [])
+                self.known_face_ids = data.get("ids", [])
+                self.next_worker_id = data.get("next_id", 1)
+                self.worker_metadata = data.get("metadata", {})
+                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from local cache.")
         except Exception as e:
-            logger.error(f"❌ Salesforce sync error: {e}")
+            logger.error(f"❌ Error loading local data: {e}")
 
+    def save_local_worker_data(self):
+        try:
+            worker_data = {
+                "embeddings": self.known_face_embeddings, 
+                "names": self.known_face_names, 
+                "ids": self.known_face_ids, 
+                "next_id": self.next_worker_id,
+                "metadata": self.worker_metadata
+            }
+            with open("data/workers.pkl", "wb") as f: 
+                pickle.dump(worker_data, f)
+        except Exception as e:
+            logger.error(f"❌ Error saving local worker data: {e}")
+    
+    # --- Registration and Attendance ---
     def register_worker_manual(self, image: Image.Image, name: str) -> Tuple[str, str]:
-        """Register a worker manually with enhanced validation."""
         if image is None or not name.strip():
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
         
-        if not DEEPFACE_AVAILABLE:
-            return "❌ Face recognition is not available. The system is running in limited mode.", self.get_registered_workers_info()
-        
         try:
-            # Validate image quality
             image_array = np.array(image)
-            if image_array.shape[0] < 100 or image_array.shape[1] < 100:
-                return "❌ Image resolution too low. Please use a higher quality image!", self.get_registered_workers_info()
             
-            # Detect face
-            face_analysis = DeepFace.analyze(
-                img_path=image_array, 
-                actions=['emotion'], 
-                enforce_detection=True
-            )
+            # Extract face with quality assessment
+            face_objs = DeepFace.extract_faces(img_path=image_array, detector_backend='opencv', enforce_detection=True)
+            
+            if not face_objs:
+                return "❌ No face detected in the image!", self.get_registered_workers_info()
+            
+            # Use the best quality face
+            best_face = None
+            best_quality_score = 0
+            
+            for face_obj in face_objs:
+                facial_area = face_obj['facial_area']
+                face_region = image_array[facial_area['y']:facial_area['y']+facial_area['h'], 
+                                        facial_area['x']:facial_area['x']+facial_area['w']]
+                
+                is_good_quality, quality_metrics = assess_face_quality(face_region, facial_area)
+                quality_score = (quality_metrics['blur_score'] + quality_metrics['confidence_score'] * 1000 + 
+                               quality_metrics['size_score'] + quality_metrics['brightness_score']) / 4
+                
+                if is_good_quality and quality_score > best_quality_score:
+                    best_quality_score = quality_score
+                    best_face = (face_region, facial_area)
+            
+            if best_face is None:
+                return "❌ Face quality too low! Please provide a clearer image with good lighting.", self.get_registered_workers_info()
             
-            # Get embedding
-            embedding = DeepFace.represent(
-                img_path=image_array, 
-                model_name='Facenet'
-            )[0]['embedding']
+            face_image, facial_area = best_face
+            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet')[0]['embedding']
             
-            # Check for duplicates
-            if self._is_duplicate_face(embedding):
-                return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
+            # Enhanced duplicate checking
+            if self._is_duplicate_face_enhanced(embedding):
+                return f"❌ Face matches an existing worker! Please check the registered workers list.", self.get_registered_workers_info()
 
-            worker_id = f"W{self.next_worker_id:04d}"
+            worker_id = self._generate_unique_worker_id()
             name = name.strip().title()
+            self._add_worker_to_system(worker_id, name, [embedding], face_image, quality_metrics)
+            self.save_local_worker_data()
+            
+            return f"✅ {name} registered successfully with ID: {worker_id}!", self.get_registered_workers_info()
             
-            # Add to system
-            success = self._add_worker_to_system(worker_id, name, embedding, image_array)
-            if success:
-                return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
-            else:
-                return f"❌ Failed to register worker!", self.get_registered_workers_info()
-                
         except ValueError as e:
-            return "❌ No face detected in the image! Please ensure the face is clearly visible.", self.get_registered_workers_info()
+            return f"❌ Face detection failed: {str(e)}", self.get_registered_workers_info()
         except Exception as e:
-            logger.error(f"Registration error: {e}")
-            return f"❌ Registration error: {str(e)}", self.get_registered_workers_info()
+            return f"❌ Registration error: {e}", self.get_registered_workers_info()
 
-    def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
-        """Auto-register a new worker with improved validation."""
-        if not DEEPFACE_AVAILABLE:
-            return None
-            
+    def _register_worker_auto(self, face_image: np.ndarray, facial_area: Dict) -> Optional[Tuple[str, str]]:
+        """Auto-register with enhanced quality and duplicate checking."""
         try:
-            # Skip very small faces
-            if face_image.shape[0] < 50 or face_image.shape[1] < 50:
-                return None
-            
-            embedding = DeepFace.represent(
-                img_path=face_image, 
-                model_name='Facenet', 
-                enforce_detection=False
-            )[0]['embedding']
+            # Quality assessment for auto-registration
+            is_good_quality, quality_metrics = assess_face_quality(face_image, facial_area)
             
-            if self._is_duplicate_face(embedding): 
+            # Higher standards for auto-registration
+            if not is_good_quality or quality_metrics['blur_score'] < 150 or quality_metrics['confidence_score'] < 0.99:
+                logger.info(f"Face quality insufficient for auto-registration: {quality_metrics}")
                 return None
             
-            worker_id = f"W{self.next_worker_id:04d}"
-            worker_name = f"Unknown Worker {self.next_worker_id}"
+            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
             
-            success = self._add_worker_to_system(worker_id, worker_name, embedding, face_image)
-            if success:
-                log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
-                self.session_log.append(log_msg)
-                logger.info(log_msg)
-                self.processing_stats['new_registrations'] += 1
-                return worker_id, worker_name
-            
-        except Exception as e:
-            logger.error(f"❌ Auto-registration error: {e}")
-        
-        return None
-
-    def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray) -> bool:
-        """Add worker to system with improved error handling."""
-        try:
-            # Add to memory
-            self.known_face_embeddings.append(np.array(embedding))
-            self.known_face_names.append(name)
-            self.known_face_ids.append(worker_id)
-            self.next_worker_id += 1
+            # Enhanced duplicate checking with stricter threshold for auto-registration
+            if self._is_duplicate_face_enhanced(embedding, threshold=8.0):
+                logger.info("Face matches existing worker - skipping auto-registration")
+                return None
             
-            # Save face image
-            face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
-            image_path = f"data/faces/{worker_id}.jpg"
-            face_pil.save(image_path)
+            worker_id = self._generate_unique_worker_id()
+            worker_name = f"Auto-Worker-{self.next_worker_id}"
             
-            # Add to local database
-            db_success = self.db.add_worker(worker_id, name, embedding, image_path)
+            self._add_worker_to_system(worker_id, worker_name, [embedding], face_image, quality_metrics)
+            self.save_local_worker_data()
             
-            # Sync to Salesforce if available
-            if self.sf:
-                try:
-                    caption = self._get_image_caption(face_pil)
-                    worker_record = self.sf.Worker__c.create({
-                        'Name': name, 
-                        'Worker_ID__c': worker_id, 
-                        'Face_Embedding__c': json.dumps(embedding), 
-                        'Image_Caption__c': caption
-                    })
-                    
-                    image_url = self._upload_image_to_salesforce(face_pil, worker_record['id'], worker_id)
-                    if image_url: 
-                        self.sf.Worker__c.update(worker_record['id'], {'Image_URL__c': image_url})
-                    
-                    logger.info(f"✅ Worker {worker_id} synced to Salesforce.")
-                except Exception as e:
-                    logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
+            log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} (ID: {worker_id})"
+            self.session_log.append(log_msg)
+            logger.info(log_msg)
             
-            return db_success
+            return worker_id, worker_name
             
         except Exception as e:
-            logger.error(f"❌ Error adding worker to system: {e}")
-            return False
+            logger.error(f"❌ Auto-registration error: {e}")
+            return None
 
-    def _is_duplicate_face(self, embedding: List[float], threshold: float = None) -> bool:
-        """Check for duplicate faces with configurable threshold."""
+    def _add_worker_to_system(self, worker_id: str, name: str, embeddings: List[np.ndarray], 
+                             image_array: np.ndarray, quality_metrics: Dict = None):
+        """Add worker with multiple embeddings support."""
+        self.known_face_embeddings.append(embeddings)
+        self.known_face_names.append(name)
+        self.known_face_ids.append(worker_id)
+        self.worker_metadata[worker_id] = {
+            'registration_time': datetime.now().isoformat(),
+            'quality_metrics': quality_metrics or {},
+            'embedding_count': len(embeddings)
+        }
+        self.next_worker_id += 1
+        
+        # Save face image
+        face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
+        face_pil.save(f"data/faces/{worker_id}.jpg")
+        
+        # Sync to Salesforce
+        if self.sf:
+            try:
+                # Store first embedding for Salesforce compatibility
+                embedding_data = embeddings[0].tolist() if len(embeddings) == 1 else [emb.tolist() for emb in embeddings]
+                caption = self._get_image_caption(face_pil)
+                
+                worker_record = self.sf.Worker__c.create({
+                    'Name': name, 
+                    'Worker_ID__c': worker_id, 
+                    'Face_Embedding__c': json.dumps(embedding_data), 
+                    'Image_Caption__c': caption,
+                    'Registration_Timestamp__c': datetime.now().isoformat()
+                })
+                
+                image_url = self._upload_image_to_salesforce(face_pil, worker_record['id'], worker_id)
+                if image_url: 
+                    self.sf.Worker__c.update(worker_record['id'], {'Image_URL__c': image_url})
+                
+                logger.info(f"✅ Worker {worker_id} synced to Salesforce.")
+            except Exception as e:
+                logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
+
+    def _is_duplicate_face_enhanced(self, embedding: List[float], threshold: float = 10.0) -> bool:
+        """Enhanced duplicate detection with multiple embeddings per worker."""
         if not self.known_face_embeddings: 
             return False
         
-        threshold = threshold or FACE_RECOGNITION_THRESHOLD
-        try:
-            distances = [
-                np.linalg.norm(np.array(embedding) - known_embedding) 
-                for known_embedding in self.known_face_embeddings
-            ]
-            return min(distances) < threshold
-        except Exception as e:
-            logger.error(f"Error checking duplicate face: {e}")
-            return False
+        embedding_array = np.array(embedding)
+        
+        for worker_embeddings in self.known_face_embeddings:
+            # Check against all embeddings for this worker
+            for known_embedding in worker_embeddings:
+                distance = np.linalg.norm(embedding_array - known_embedding)
+                if distance < threshold:
+                    return True
+        
+        return False
+
+    def _find_best_match(self, embedding: np.ndarray) -> Tuple[int, float]:
+        """Find the best matching worker with minimum distance."""
+        if not self.known_face_embeddings:
+            return -1, float('inf')
+        
+        best_match_index = -1
+        min_distance = float('inf')
+        
+        for worker_idx, worker_embeddings in enumerate(self.known_face_embeddings):
+            for known_embedding in worker_embeddings:
+                distance = np.linalg.norm(embedding - known_embedding)
+                if distance < min_distance:
+                    min_distance = distance
+                    best_match_index = worker_idx
+        
+        return best_match_index, min_distance
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
-        """Mark attendance with improved tracking."""
-        today_str = date.today().isoformat()
+        """Mark attendance with duplicate prevention."""
+        # Check if already marked today
+        if worker_id in self.daily_attendance:
+            logger.info(f"Worker {worker_id} already marked present today")
+            return False
         
-        # Check cooldown period
-        last_seen = self.last_recognition_time.get(worker_id)
-        if last_seen and (time.time() - last_seen < self.recognition_cooldown):
+        # Check session cooldown
+        current_time = time.time()
+        last_seen = self.last_recognition_time.get(worker_id, 0)
+        if current_time - last_seen < self.recognition_cooldown:
             return False
         
-        # Check if already attended today
-        if self.db.has_attended_today(worker_id, today_str):
+        # Check if already marked in this session
+        if worker_id in self.session_attendees:
+            logger.info(f"Worker {worker_id} already marked in this session")
             return False
         
-        # Mark attendance in local database
-        db_success = self.db.mark_attendance(worker_id, worker_name, today_str)
+        today_str = date.today().isoformat()
+        current_datetime = datetime.now()
         
-        # Sync to Salesforce if available
+        # Mark in Salesforce
         if self.sf:
             try:
-                current_time = datetime.now()
                 self.sf.Attendance__c.create({
                     'Worker_ID__c': worker_id, 
                     'Name__c': worker_name, 
                     'Date__c': today_str, 
-                    'Timestamp__c': current_time.isoformat(), 
+                    'Timestamp__c': current_datetime.isoformat(), 
                     'Status__c': "Present"
                 })
             except Exception as e:
                 logger.error(f"❌ Error saving attendance to Salesforce: {e}")
         
-        if db_success:
-            current_time = datetime.now()
-            log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
-            self.session_log.append(log_msg)
-            self.processing_stats['workers_recognized'] += 1
+        # Update tracking sets
+        self.daily_attendance.add(worker_id)
+        self.session_attendees.add(worker_id)
+        self.last_recognition_time[worker_id] = current_time
         
-        return db_success
+        log_msg = f"✅ [{current_datetime.strftime('%H:%M:%S')}] Marked Present: {worker_name} (ID: {worker_id})"
+        self.session_log.append(log_msg)
+        logger.info(log_msg)
+        
+        return True
 
+    # --- Video Processing with Speed Optimizations ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
-        """Enhanced frame processing with better error handling."""
-        if not DEEPFACE_AVAILABLE:
-            # Add overlay for limited mode
-            overlay = frame.copy()
-            cv2.rectangle(overlay, (0, 0), (frame.shape[1], 120), (0, 0, 0), -1)
-            cv2.addWeighted(overlay, 0.7, frame, 0.3, 0, frame)
-            
-            # Draw messages
-            cv2.putText(frame, "SYSTEM RUNNING IN LIMITED MODE", (10, 30), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
-            cv2.putText(frame, "Face recognition is not available", (10, 60), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-            cv2.putText(frame, "System can still manage workers and generate reports", (10, 90), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
-            
-            # Add timestamp
-            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            cv2.putText(frame, f"Time: {timestamp}", (10, frame.shape[0] - 20), 
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        """
+        Optimized frame processing with speed improvements and quality checks.
+        """
+        try:
+            # Frame skipping for speed
+            self.frame_skip_count += 1
+            if self.frame_skip_count % self.frame_skip_rate != 0:
+                return frame
             
-            # Log limited mode activity
-            if not hasattr(self, '_limited_mode_logged'):
-                log_msg = f"🔄 [{datetime.now().strftime('%H:%M:%S')}] System running in limited mode - Face recognition unavailable"
-                self.session_log.append(log_msg)
-                logger.info(log_msg)
-                self._limited_mode_logged = True
+            # Resize frame for faster processing
+            original_height, original_width = frame.shape[:2]
+            target_width, target_height = self.processing_resolution
             
-            return frame
-            
-        try:
-            self.processing_stats['frames_processed'] += 1
+            if original_width > target_width:
+                scale_factor = target_width / original_width
+                new_width = target_width
+                new_height = int(original_height * scale_factor)
+                resized_frame = cv2.resize(frame, (new_width, new_height))
+            else:
+                resized_frame = frame
+                scale_factor = 1.0
             
-            # Extract faces with improved error handling
-            try:
-                face_objs = DeepFace.extract_faces(
-                    img_path=frame, 
-                    detector_backend='opencv', 
-                    enforce_detection=False
-                )
-            except Exception as e:
-                logger.warning(f"Face extraction error: {e}")
-                return frame
+            # Extract faces
+            face_objs = DeepFace.extract_faces(img_path=resized_frame, detector_backend='opencv', enforce_detection=False)
 
             if face_objs:
-                self.processing_stats['faces_detected'] += len(face_objs)
+                logger.debug(f"Found {len(face_objs)} faces in frame")
 
             for i, face_obj in enumerate(face_objs):
-                try:
-                    confidence = face_obj.get('confidence', 0)
-                    
-                    if confidence < CONFIDENCE_THRESHOLD:
-                        continue
+                facial_area = face_obj['facial_area']
+                confidence = facial_area.get('confidence', 0)
+                
+                # Higher confidence threshold
+                if confidence < 0.98:
+                    continue
 
-                    # Extract facial area coordinates - FIXED
-                    facial_area = face_obj['facial_area']
-                    x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
-                    
-                    # Validate coordinates
-                    if x < 0 or y < 0 or w <= 0 or h <= 0:
-                        continue
-                    
-                    face_image = frame[y:y+h, x:x+w]
-                    
-                    if face_image.size == 0: 
-                        continue
+                # Scale coordinates back to original frame
+                x = int(facial_area['x'] / scale_factor)
+                y = int(facial_area['y'] / scale_factor)
+                w = int(facial_area['w'] / scale_factor)
+                h = int(facial_area['h'] / scale_factor)
+                
+                # Extract face from original frame
+                face_image = frame[y:y+h, x:x+w]
+                
+                if face_image.size == 0: 
+                    continue
 
-                    # Get face embedding
-                    try:
-                        embedding = DeepFace.represent(
-                            img_path=face_image, 
-                            model_name='Facenet', 
-                            enforce_detection=False
-                        )[0]['embedding']
-                    except Exception as e:
-                        logger.warning(f"Embedding extraction error: {e}")
-                        continue
+                # Quality assessment
+                is_good_quality, quality_metrics = assess_face_quality(face_image, facial_area)
+                
+                if not is_good_quality:
+                    # Draw red box for poor quality faces
+                    cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 2)
+                    cv2.putText(frame, "Poor Quality", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+                    continue
+
+                # Generate embedding for recognition
+                embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
+                embedding_array = np.array(embedding)
+                
+                # Find best match
+                match_index, min_distance = self._find_best_match(embedding_array)
+                
+                # Recognition threshold
+                recognition_threshold = 9.0  # Slightly stricter threshold
+                
+                if match_index != -1 and min_distance < recognition_threshold:
+                    # Known worker
+                    worker_id = self.known_face_ids[match_index]
+                    worker_name = self.known_face_names[match_index]
+                    color = (0, 255, 0)  # Green
                     
-                    # Face recognition
-                    color, worker_id, worker_name = self._recognize_face(embedding, face_image)
+                    logger.debug(f"Recognized {worker_name} with distance {min_distance:.4f}")
                     
-                    # Draw bounding box and label
-                    label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
-                    cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
+                    # Try to mark attendance (will handle duplicates internally)
+                    attendance_marked = self.mark_attendance(worker_id, worker_name)
+                    if attendance_marked:
+                        label = f"{worker_name} ✓"
+                    else:
+                        label = f"{worker_name} (Already Present)"
+                
+                else:
+                    # Unknown face - attempt auto-registration with strict quality requirements
+                    color = (0, 165, 255)  # Orange
+                    label = "Unknown"
                     
-                    # Add background for text
-                    label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
-                    cv2.rectangle(frame, (x, y-30), (x + label_size[0], y), color, -1)
-                    cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+                    logger.debug(f"Unknown face with min distance {min_distance:.4f}")
                     
-                except Exception as e:
-                    logger.warning(f"Error processing face {i}: {e}")
-                    continue
+                    # Only auto-register high-quality faces
+                    if (quality_metrics['blur_score'] > 200 and 
+                        quality_metrics['confidence_score'] > 0.99 and 
+                        quality_metrics['size_score'] > 100):
+                        
+                        new_worker = self._register_worker_auto(face_image, facial_area)
+                        if new_worker:
+                            worker_id, worker_name = new_worker
+                            self.mark_attendance(worker_id, worker_name)
+                            label = f"{worker_name} (New)"
+                            color = (255, 165, 0)  # Orange for new registration
+                
+                # Draw bounding box and label
+                cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
+                
+                # Add quality indicator
+                quality_text = f"Q:{quality_metrics.get('blur_score', 0):.0f}"
+                cv2.putText(frame, label, (x, y-30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
+                cv2.putText(frame, quality_text, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
 
             return frame
             
@@ -620,481 +573,336 @@ class AttendanceSystem:
             logger.error(f"ERROR in process_frame: {e}")
             return frame
 
-    def _recognize_face(self, embedding: List[float], face_image: np.ndarray) -> Tuple[Tuple[int, int, int], Optional[str], str]:
-        """Recognize face and return color, worker_id, and worker_name."""
-        if not self.known_face_embeddings:
-            return (0, 0, 255), None, "Unknown"  # Red for unknown
-
-        try:
-            distances = [
-                np.linalg.norm(np.array(embedding) - known) 
-                for known in self.known_face_embeddings
-            ]
-            min_dist = min(distances)
-            match_index = distances.index(min_dist) if min_dist < FACE_RECOGNITION_THRESHOLD else -1
-
-            if match_index != -1:
-                worker_id = self.known_face_ids[match_index]
-                worker_name = self.known_face_names[match_index]
-                
-                # Mark attendance
-                if self.mark_attendance(worker_id, worker_name):
-                    self.last_recognition_time[worker_id] = time.time()
-                
-                return (0, 255, 0), worker_id, worker_name  # Green for recognized
-            else:
-                # Try auto-registration
-                new_worker = self._register_worker_auto(face_image)
-                if new_worker:
-                    worker_id, worker_name = new_worker[0], new_worker[1]
-                    if self.mark_attendance(worker_id, worker_name):
-                        self.last_recognition_time[worker_id] = time.time()
-                    return (0, 165, 255), worker_id, worker_name  # Orange for new
-                
-                return (0, 0, 255), None, "Unknown"  # Red for unknown
-        except Exception as e:
-            logger.error(f"Face recognition error: {e}")
-            return (0, 0, 255), None, "Error"
-
     def _processing_loop(self, source):
-        """Enhanced processing loop with better error handling."""
-        video_capture = None
-        try:
-            video_capture = cv2.VideoCapture(source)
-            if not video_capture.isOpened():
-                err_msg = f"❌ **Error:** Could not open video source. Please check the source and try again."
-                self.error_message = err_msg
-                self.is_processing.clear()
-                return
-
-            # Reset statistics
-            self.processing_stats = {
-                'frames_processed': 0,
-                'faces_detected': 0,
-                'workers_recognized': 0,
-                'new_registrations': 0
-            }
+        """Optimized processing loop with better error handling."""
+        video_capture = cv2.VideoCapture(source)
+        
+        if not video_capture.isOpened():
+            err_msg = f"❌ **Error:** Could not open video source. Please check the source and try again."
+            self.error_message = err_msg
+            self.is_processing.clear()
+            return
+        
+        # Set camera properties for speed
+        if isinstance(source, int):  # Camera source
+            video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
+            video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
+            video_capture.set(cv2.CAP_PROP_FPS, 30)
+            video_capture.set(cv2.CAP_PROP_BUFFERSIZE, 1)
+        
+        frame_count = 0
+        start_time = time.time()
+        
+        while self.is_processing.is_set():
+            ret, frame = video_capture.read()
+            if not ret: 
+                logger.info("End of video stream or camera disconnected")
+                break
             
-            # Add initial log entry
-            start_msg = f"🚀 [{datetime.now().strftime('%H:%M:%S')}] Processing started"
-            if not DEEPFACE_AVAILABLE:
-                start_msg += " (Limited Mode)"
-            self.session_log.append(start_msg)
-            logger.info(start_msg)
-
-            while self.is_processing.is_set():
-                ret, frame = video_capture.read()
-                if not ret: 
-                    break
-                
-                processed_frame = self.process_frame(frame)
-                
-                if not self.frame_queue.full(): 
-                    self.frame_queue.put(processed_frame)
-                
-                self.last_processed_frame = processed_frame
-                time.sleep(0.05)  # Control frame rate
-                
-                # Add periodic activity log in limited mode
-                if not DEEPFACE_AVAILABLE and self.processing_stats['frames_processed'] % 100 == 0:
-                    activity_msg = f"📹 [{datetime.now().strftime('%H:%M:%S')}] Processed {self.processing_stats['frames_processed']} frames"
-                    self.session_log.append(activity_msg)
-                
-        except Exception as e:
-            logger.error(f"Processing loop error: {e}")
-            self.error_message = f"❌ Processing error: {str(e)}"
-        finally:
-            if video_capture:
-                video_capture.release()
+            frame_count += 1
             
-            # Add final log entry
-            end_msg = f"⏹️ [{datetime.now().strftime('%H:%M:%S')}] Processing stopped"
-            self.session_log.append(end_msg)
-            logger.info(end_msg)
+            # Process frame
+            processed_frame = self.process_frame(frame)
             
-            self.final_log = self.session_log.copy()
-            self.is_processing.clear()
+            # Update frame queue (non-blocking)
+            try:
+                if not self.frame_queue.full():
+                    self.frame_queue.put(processed_frame, block=False)
+            except queue.Full:
+                pass  # Skip frame if queue is full
+            
+            self.last_processed_frame = processed_frame
+            
+            # Dynamic frame rate control
+            if frame_count % 30 == 0:  # Every 30 frames, check performance
+                elapsed = time.time() - start_time
+                fps = frame_count / elapsed
+                if fps < 10:  # If too slow, increase frame skipping
+                    self.frame_skip_rate = min(5, self.frame_skip_rate + 1)
+                elif fps > 20:  # If fast enough, reduce frame skipping
+                    self.frame_skip_rate = max(1, self.frame_skip_rate - 1)
+            
+            # Small delay to prevent overwhelming the system
+            time.sleep(0.03)
+        
+        # Cleanup
+        self.final_log = self.session_log.copy()
+        video_capture.release()
+        self.is_processing.clear()
+        logger.info(f"Processing stopped. Processed {frame_count} frames.")
 
     def start_processing(self, source) -> str:
-        """Start processing with enhanced validation."""
+        """Start processing with session reset."""
         if self.is_processing.is_set(): 
             return "⚠️ Processing is already active."
         
-        if source is None:
-            return "❌ Please provide a valid input source."
-        
-        # Reset states for the new session
+        # Reset states for new session
         self.session_log.clear()
+        self.session_attendees.clear()
         self.last_recognition_time.clear()
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
-        self._limited_mode_logged = False  # Reset limited mode logging flag
+        self.frame_skip_count = 0
+        
+        # Reload daily attendance to get latest data
+        self._load_daily_attendance()
         
         self.is_processing.set()
         self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,))
         self.processing_thread.daemon = True
         self.processing_thread.start()
         
+        return f"✅ Started processing with optimized speed settings..."
 
     def stop_processing(self) -> str:
-        """Stop processing and generate summary."""
-        if not self.is_processing.is_set():
-            return "⚠️ No processing is currently active."
-        
+        """Stop processing and clean up."""
         self.is_processing.clear()
+        self.error_message = None
         
-        # Generate processing summary
-        stats = self.processing_stats
-        summary = f"""✅ Processing stopped.
-📊 Session Summary:
-- Frames processed: {stats['frames_processed']}
-- Faces detected: {stats['faces_detected']}
-- Workers recognized: {stats['workers_recognized']}
-- New registrations: {stats['new_registrations']}"""
+        # Generate session summary
+        if self.session_attendees:
+            summary = f"📊 Session Summary: {len(self.session_attendees)} unique attendees marked present"
+            self.session_log.append(summary)
         
-        return summary
-
-    def get_processing_stats(self) -> str:
-        """Get current processing statistics."""
-        stats = self.processing_stats
-        return f"""📊 **Processing Statistics:**
-- Frames processed: {stats['frames_processed']}
-- Faces detected: {stats['faces_detected']}
-- Workers recognized: {stats['workers_recognized']}
-- New registrations: {stats['new_registrations']}"""
-
-    def generate_attendance_report(self, start_date: str = None, end_date: str = None) -> pd.DataFrame:
-        """Generate attendance report."""
-        return self.db.get_attendance_report(start_date, end_date)
-
-    def export_attendance_csv(self, start_date: str = None, end_date: str = None) -> str:
-        """Export attendance data to CSV."""
-        try:
-            df = self.generate_attendance_report(start_date, end_date)
-            if df.empty:
-                return "❌ No attendance data found for the specified period."
-            
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"data/reports/attendance_report_{timestamp}.csv"
-            df.to_csv(filename, index=False)
-            
-            return f"✅ Attendance report exported to: {filename}"
-        except Exception as e:
-            logger.error(f"Error exporting attendance report: {e}")
-            return f"❌ Error exporting report: {str(e)}"
+        return "✅ Processing stopped. Session summary generated."
 
     # --- Helper & Reporting ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        """Generate image caption using Hugging Face API."""
         if not HF_API_TOKEN: 
             return "Hugging Face API token not configured."
-        
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             img_data = buffered.getvalue()
             headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-            
-            response = requests.post(HF_API_URL, headers=headers, data=img_data, timeout=30)
+            response = requests.post(HF_API_URL, headers=headers, data=img_data, timeout=10)
             response.raise_for_status()
             result = response.json()
-            
             return result[0].get("generated_text", "No caption found.")
-        except requests.exceptions.Timeout:
-            return "Caption generation timed out."
         except Exception as e:
             logger.error(f"Hugging Face API error: {e}")
             return "Caption generation failed."
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        """Upload image to Salesforce with error handling."""
         if not self.sf: 
             return None
-        
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
-            
             cv = self.sf.ContentVersion.create({
                 'Title': f'Image_{worker_id}', 
                 'PathOnClient': f'{worker_id}.jpg', 
                 'VersionData': encoded_image, 
                 'FirstPublishLocationId': record_id
             })
-            
-            return f"/{cv['id']}"  # Relative URL
+            return f"/{cv['id']}"
         except Exception as e:
             logger.error(f"Salesforce image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        """Get information about registered workers."""
+        """Get formatted info about registered workers."""
+        if not self.known_face_ids:
+            return "No workers registered yet."
+        
         try:
-            workers = self.db.get_all_workers()
-            if not workers: 
-                return "No workers registered."
+            info_lines = [f"**👥 Registered Workers ({len(self.known_face_ids)})**\n"]
             
-            worker_list = "\n".join([
-                f"- **{w['name']}** (ID: {w['worker_id']})" 
-                for w in workers
-            ])
+            for i, (worker_id, name) in enumerate(zip(self.known_face_ids, self.known_face_names)):
+                status = "✅ Present Today" if worker_id in self.daily_attendance else "⏳ Not Marked"
+                embedding_count = len(self.known_face_embeddings[i])
+                info_lines.append(f"- **{name}** (ID: `{worker_id}`) - {status} - {embedding_count} face(s)")
             
-            return f"**👥 Registered Workers ({len(workers)})**\n{worker_list}"
-        except Exception as e: 
-            return f"Error: {e}"
+            return "\n".join(info_lines)
+            
+        except Exception as e:
+            return f"Error loading worker info: {e}"
 
-    def get_system_status(self) -> str:
-        """Get comprehensive system status."""
-        sf_status = "✅ Connected" if self.sf else "❌ Offline"
-        deepface_status = "✅ Available" if DEEPFACE_AVAILABLE else "❌ Not Available (Limited Mode)"
-        db_workers = len(self.db.get_all_workers())
+    def get_attendance_stats(self) -> str:
+        """Get attendance statistics for today."""
+        today_str = date.today().isoformat()
+        total_workers = len(self.known_face_ids)
+        present_today = len(self.daily_attendance)
+        attendance_rate = (present_today / max(total_workers, 1)) * 100
         
-        status = f"""🔧 **System Status:**
-- Salesforce: {sf_status}
-- Face Recognition: {deepface_status}
-- Registered Workers: {db_workers}
-- Recognition Threshold: {FACE_RECOGNITION_THRESHOLD}
-- Confidence Threshold: {CONFIDENCE_THRESHOLD}
-- Processing: {'✅ Active' if self.is_processing.is_set() else '⏹️ Stopped'}
-
-{'⚠️ **Note:** Face recognition is disabled. System running in limited mode.' if not DEEPFACE_AVAILABLE else ''}"""
+        return f"""
+**📊 Today's Attendance Statistics**
+- **Date**: {today_str}
+- **Total Workers**: {total_workers}
+- **Present Today**: {present_today}
+- **Attendance Rate**: {attendance_rate:.1f}%
+- **Session Attendees**: {len(self.session_attendees)}
+"""
         
-        return status
-
 # --- GRADIO UI ---
+attendance_system = AttendanceSystem()
 
 def create_interface():
-    """Create enhanced Gradio interface with better error handling."""
-    try:
-        attendance_system = AttendanceSystem()
-        
-        # Check if system is in limited mode
-        limited_mode = not DEEPFACE_AVAILABLE
+    with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Attendance System") as demo:
+        gr.Markdown("# 🎯 Advanced Face Recognition Attendance System v2.0")
         
-        with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Attendance System") as demo:
-            gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
-            if limited_mode:
-                gr.Markdown("⚠️ **RUNNING IN LIMITED MODE** - Face recognition is not available")
-                gr.Markdown("*Some features may be disabled. Please check system requirements.*")
-            else:
-                gr.Markdown("*Enhanced with offline support, statistics, and reporting features*")
-            
-            with gr.Tabs():
-                # Main Controls Tab
-                with gr.Tab("⚙️ Controls & Status"):
-                    gr.Markdown("### 1. Choose Input Source & Start Processing")
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            selected_tab_index = gr.Number(value=0, visible=False)
-                            with gr.Tabs() as video_tabs:
-                                with gr.Tab("Live Camera", id=0):
-                                    camera_source = gr.Number(label="Camera Source", value=0, precision=0)
-                                with gr.Tab("Upload Video", id=1):
-                                    video_file = gr.Video(label="Upload Video File", sources=["upload"])
-                        with gr.Column(scale=1):
-                            start_btn = gr.Button("▶️ Start Processing", variant="primary")
-                            stop_btn = gr.Button("⏹️ Stop Processing", variant="stop")
-                            status_box = gr.Textbox(label="Status", interactive=False, value="System Ready.")
-                    
-                    gr.Markdown("### 2. System Information")
-                    with gr.Row():
-                        system_status = gr.Markdown(value=attendance_system.get_system_status())
-                        processing_stats = gr.Markdown(value="📊 **Processing Statistics:** Not started")
-                        refresh_status_btn = gr.Button("🔄 Refresh Status")
-                    
-                    gr.Markdown("### 3. View Results in the 'Output & Log' Tab")
-                    gr.Markdown("**🎨 Color Coding:** <font color='green'>Green</font> = Known, <font color='orange'>Orange</font> = New, <font color='red'>Red</font> = Unknown")
+        with gr.Tabs():
+            with gr.Tab("⚙️ Controls & Status"):
+                gr.Markdown("### 1. Choose Input Source & Start Processing")
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        selected_tab_index = gr.Number(value=0, visible=False)
+                        with gr.Tabs() as video_tabs:
+                            with gr.Tab("Live Camera", id=0):
+                                camera_source = gr.Number(label="Camera Source", value=0, precision=0)
+                            with gr.Tab("Upload Video", id=1):
+                                video_file = gr.Video(label="Upload Video File", sources=["upload"])
+                    with gr.Column(scale=1):
+                        start_btn = gr.Button("▶️ Start Processing", variant="primary", size="lg")
+                        stop_btn = gr.Button("⏹️ Stop Processing", variant="stop", size="lg")
+                        status_box = gr.Textbox(label="Status", interactive=False, value="System Ready - Enhanced with Quality Control")
                 
-                # Output Tab
-                with gr.Tab("📊 Output & Log"):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            video_output = gr.Image(label="Recognition Output", interactive=False)
-                        with gr.Column(scale=1):
-                            session_log_display = gr.Markdown(label="📋 Session Log", value="System is ready.")
-
-                # Worker Management Tab
-                with gr.Tab("👤 Worker Management"):
-                    with gr.Row():
-                        with gr.Column():
-                            register_image = gr.Image(label="Upload Worker's Photo", type="pil")
-                            register_name = gr.Textbox(label="Worker's Full Name")
-                            register_btn = gr.Button("Register Worker", variant="primary")
-                            register_output = gr.Textbox(label="Registration Status", interactive=False)
-                        with gr.Column():
-                            registered_workers_info = gr.Markdown(value=attendance_system.get_registered_workers_info())
-                            refresh_workers_btn = gr.Button("🔄 Refresh List")
-
-                # Reports Tab
-                with gr.Tab("📈 Reports & Analytics"):
-                    gr.Markdown("### Attendance Reports")
-                    with gr.Row():
-                        start_date = gr.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="2024-01-01")
-                        end_date = gr.Textbox(label="End Date (YYYY-MM-DD)", placeholder="2024-12-31")
-                    
-                    with gr.Row():
-                        generate_report_btn = gr.Button("📊 Generate Report", variant="primary")
-                        export_csv_btn = gr.Button("💾 Export CSV")
+                gr.Markdown("### 2. Enhanced Features")
+                gr.Markdown("""
+                **🚀 New Improvements:**
+                - ✅ **Duplicate Prevention**: No duplicate attendance logs
+                - ✅ **Face Quality Control**: Only clear, high-quality faces are processed
+                - ✅ **Unique IDs**: Enhanced ID generation with timestamps
+                - ✅ **Speed Optimization**: Faster video processing with adaptive frame rates
+                - ✅ **Better Recognition**: Improved face matching to prevent false registrations
+                
+                **🎨 Color Coding:** 
+                - <span style='color: green'>**Green**</span> = Recognized Worker
+                - <span style='color: orange'>**Orange**</span> = New Registration  
+                - <span style='color: red'>**Red**</span> = Poor Quality/Unknown
+                """)
+            
+            with gr.Tab("📊 Output & Live Feed"):
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        video_output = gr.Image(label="🎥 Live Recognition Feed", interactive=False)
+                    with gr.Column(scale=1):
+                        session_log_display = gr.Markdown(label="📋 Live Session Log", value="System ready for processing...")
+
+            with gr.Tab("👤 Worker Management"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### Register New Worker")
+                        register_image = gr.Image(label="📸 Upload Clear Photo (Good Lighting Required)", type="pil")
+                        register_name = gr.Textbox(label="👤 Worker's Full Name", placeholder="Enter full name...")
+                        register_btn = gr.Button("✅ Register Worker", variant="primary", size="lg")
+                        register_output = gr.Textbox(label="Registration Status", interactive=False)
                     
-                    report_output = gr.Dataframe(label="Attendance Report")
-                    export_status = gr.Textbox(label="Export Status", interactive=False)
+                    with gr.Column():
+                        gr.Markdown("### Registered Workers")
+                        registered_workers_info = gr.Markdown(value=attendance_system.get_registered_workers_info())
+                        refresh_workers_btn = gr.Button("🔄 Refresh Workers List", variant="secondary")
+                        
+                        gr.Markdown("### Today's Statistics")
+                        attendance_stats = gr.Markdown(value=attendance_system.get_attendance_stats())
+                        refresh_stats_btn = gr.Button("📊 Refresh Statistics", variant="secondary")
 
-            # --- Event Handlers ---
-            def on_tab_select(evt: gr.SelectData): 
-                return evt.index
-            
-            video_tabs.select(fn=on_tab_select, inputs=None, outputs=[selected_tab_index])
-            
-            def start_wrapper(tab_index, cam_src, vid_path):
-                try:
-                    source = cam_src if tab_index == 0 else vid_path
-                    if source is None:
-                        return "❌ Please provide an input source."
-                    return attendance_system.start_processing(source)
-                except Exception as e:
-                    logger.error(f"Start processing error: {e}")
-                    return f"❌ Error starting processing: {str(e)}"
-            
-            def stop_wrapper():
-                try:
-                    return attendance_system.stop_processing()
-                except Exception as e:
-                    logger.error(f"Stop processing error: {e}")
-                    return f"❌ Error stopping processing: {str(e)}"
-            
-            def refresh_status():
-                try:
-                    return attendance_system.get_system_status(), attendance_system.get_processing_stats()
-                except Exception as e:
-                    logger.error(f"Refresh status error: {e}")
-                    return f"❌ Error: {str(e)}", f"❌ Error: {str(e)}"
-            
-            def generate_report(start_date_val, end_date_val):
-                try:
-                    df = attendance_system.generate_attendance_report(
-                        start_date_val if start_date_val else None,
-                        end_date_val if end_date_val else None
-                    )
-                    return df
-                except Exception as e:
-                    logger.error(f"Report generation error: {e}")
-                    return pd.DataFrame()
-            
-            def export_csv_wrapper(start_date_val, end_date_val):
+        # --- Event Handlers ---
+        def on_tab_select(evt: gr.SelectData): 
+            return evt.index
+        
+        video_tabs.select(fn=on_tab_select, inputs=None, outputs=[selected_tab_index])
+        
+        def start_wrapper(tab_index, cam_src, vid_path):
+            source = cam_src if tab_index == 0 else vid_path
+            if source is None:
+                return "❌ Please provide an input source."
+            return attendance_system.start_processing(source)
+        
+        start_btn.click(fn=start_wrapper, inputs=[selected_tab_index, camera_source, video_file], outputs=[status_box])
+        stop_btn.click(fn=attendance_system.stop_processing, inputs=None, outputs=[status_box])
+        
+        register_btn.click(
+            fn=attendance_system.register_worker_manual, 
+            inputs=[register_image, register_name], 
+            outputs=[register_output, registered_workers_info]
+        )
+        
+        refresh_workers_btn.click(
+            fn=attendance_system.get_registered_workers_info, 
+            outputs=[registered_workers_info]
+        )
+        
+        refresh_stats_btn.click(
+            fn=attendance_system.get_attendance_stats,
+            outputs=[attendance_stats]
+        )
+        
+        def update_ui_generator():
+            """Enhanced UI update generator with better error handling."""
+            while True:
                 try:
-                    return attendance_system.export_attendance_csv(
-                        start_date_val if start_date_val else None,
-                        end_date_val if end_date_val else None
-                    )
-                except Exception as e:
-                    logger.error(f"CSV export error: {e}")
-                    return f"❌ Export error: {str(e)}"
-            
-            # Connect event handlers
-            start_btn.click(
-                fn=start_wrapper, 
-                inputs=[selected_tab_index, camera_source, video_file], 
-                outputs=[status_box]
-            )
-            
-            stop_btn.click(fn=stop_wrapper, inputs=None, outputs=[status_box])
-            
-            register_btn.click(
-                fn=attendance_system.register_worker_manual, 
-                inputs=[register_image, register_name], 
-                outputs=[register_output, registered_workers_info]
-            )
-            
-            refresh_workers_btn.click(
-                fn=attendance_system.get_registered_workers_info, 
-                outputs=[registered_workers_info]
-            )
-            
-            refresh_status_btn.click(
-                fn=refresh_status,
-                outputs=[system_status, processing_stats]
-            )
-            
-            generate_report_btn.click(
-                fn=generate_report,
-                inputs=[start_date, end_date],
-                outputs=[report_output]
-            )
-            
-            export_csv_btn.click(
-                fn=export_csv_wrapper,
-                inputs=[start_date, end_date],
-                outputs=[export_status]
-            )
-            
-            # UI Update Generator
-            def update_ui_generator():
-                while True:
-                    try:
-                        if attendance_system.error_message:
-                            yield None, attendance_system.error_message
-                            time.sleep(2)
-                            attendance_system.error_message = None
-                            continue
+                    # Handle errors
+                    if attendance_system.error_message:
+                        yield None, f"❌ **Error**: {attendance_system.error_message}"
+                        time.sleep(3)
+                        attendance_system.error_message = None
+                        continue
+                    
+                    # Active processing
+                    if attendance_system.is_processing.is_set():
+                        frame = None
+                        log_content = "🔄 Processing..."
+                        
+                        # Get latest frame
+                        try:
+                            if not attendance_system.frame_queue.empty():
+                                frame = attendance_system.frame_queue.get_nowait()
+                                if frame is not None:
+                                    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                        except queue.Empty:
+                            pass
                         
-                        if attendance_system.is_processing.is_set():
-                            frame = None
-                            log_entries = attendance_system.session_log
-                            if log_entries:
-                                log_md = "\n".join(reversed(log_entries))
+                        # Format session log
+                        if attendance_system.session_log:
+                            recent_logs = attendance_system.session_log[-10:]  # Show last 10 entries
+                            log_content = "### 📋 Live Session Activity\n" + "\n".join(reversed(recent_logs))
+                        
+                        yield frame, log_content
+                    
+                    # Processing stopped - show final results
+                    else:
+                        if attendance_system.last_processed_frame is not None:
+                            final_frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
+                            final_log_content = "### 📋 Session Complete\n"
+                            
+                            if attendance_system.final_log:
+                                final_log_content += "\n".join(reversed(attendance_system.final_log))
                             else:
-                                log_md = "🔄 Processing started... Waiting for activity..."
+                                final_log_content += "No activities recorded in this session."
+                            
+                            # Add session summary
+                            if attendance_system.session_attendees:
+                                final_log_content += f"\n\n**📊 Session Summary:** {len(attendance_system.session_attendees)} unique attendees processed"
                             
-                            try:
-                                if not attendance_system.frame_queue.empty():
-                                    frame = attendance_system.frame_queue.get_nowait()
-                                    if frame is not None: 
-                                        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                            except queue.Empty: 
-                                pass
-                            yield frame, log_md
+                            yield final_frame, final_log_content
                         else:
-                            if attendance_system.last_processed_frame is not None:
-                                final_frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
-                                if attendance_system.final_log:
-                                    final_log_md = "\n".join(reversed(attendance_system.final_log))
-                                else:
-                                    final_log_md = "⏹️ Processing complete. Check system status for more information."
-                                yield final_frame, final_log_md
-                            else:
-                                yield None, "🔧 System ready. Go to 'Controls & Status' to start processing."
-                        
-                        time.sleep(0.1)
-                    except Exception as e:
-                        logger.error(f"UI update error: {e}")
-                        yield None, f"❌ UI Error: {str(e)}\n\nPlease refresh the page or restart the system."
-                        time.sleep(1)
+                            yield None, "### 🏠 System Ready\nGo to 'Controls & Status' tab to start processing."
+                    
+                    time.sleep(0.1)  # Reduced update frequency for better performance
+                    
+                except Exception as e:
+                    logger.error(f"UI update error: {e}")
+                    yield None, f"❌ UI Error: {str(e)}"
+                    time.sleep(1)
 
-            demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
-        
-        return demo
+        # Auto-refresh UI
+        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
     
-    except Exception as e:
-        logger.error(f"Interface creation error: {e}")
-        # Create a simple error interface
-        with gr.Blocks() as error_demo:
-            gr.Markdown(f"# ❌ System Error\n\nFailed to initialize the attendance system:\n\n`{str(e)}`\n\nPlease check the logs and ensure all dependencies are installed.")
-        return error_demo
+    return demo
 
 if __name__ == "__main__":
-    try:
-        app = create_interface()
-        app.queue()
-        app.launch(
-            server_name="0.0.0.0", 
-            server_port=7860, 
-            show_error=True, 
-            debug=True,
-            share=False  # Set to True if you want to create a public link
-        )
-    except Exception as e:
-        logger.error(f"Failed to launch application: {e}")
-        print(f"❌ Application failed to start: {e}")
-        print("Please check the requirements.txt file and install missing dependencies.")
+    print("🚀 Starting Advanced Face Recognition Attendance System v2.0...")
+    print("📊 Enhanced with: Quality Control, Duplicate Prevention, Speed Optimization")
+    
+    app = create_interface()
+    app.queue(max_size=20)  # Increased queue size for better performance
+    app.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        show_error=True, 
+        debug=False,  # Disabled debug for better performance
+        share=False
+    )