Update app.py

app.py

@@ -9,8 +9,6 @@ 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
@@ -63,49 +61,6 @@ def connect_to_salesforce() -> Optional[Salesforce]:
         logger.error(f"❌ Salesforce connection failed: {e}")
         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 60x60 pixels - reduced for better detection)
-    min_face_size = 50
-    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 = 30  # Further reduced threshold for better detection
-    blur_check = blur_score > blur_threshold
-    
-    # 3. Brightness check
-    brightness = np.mean(gray)
-    brightness_check = 20 < brightness < 230  # Even more lenient brightness range
-    
-    # 4. Face detection confidence (from facial_area if available)
-    confidence_check = facial_area.get('confidence', 0) > 0.80  # Further reduced threshold
-    
-    quality_metrics = {
-        'size_score': min(w, h),
-        'blur_score': blur_score,
-        'brightness_score': brightness,
-        'confidence_score': facial_area.get('confidence', 0),
-        'size_check': size_check,
-        'blur_check': blur_check,
-        'brightness_check': brightness_check,
-        'confidence_check': confidence_check
-    }
-    
-    # At least 2 out of 4 checks must pass for good quality (more lenient)
-    passed_checks = sum([size_check, blur_check, brightness_check, confidence_check])
-    is_good_quality = passed_checks >= 2
-    
-    return is_good_quality, quality_metrics
-
 # --- CORE LOGIC ---
 
 class AttendanceSystem:
@@ -118,63 +73,33 @@ class AttendanceSystem:
         self.is_processing = threading.Event()
         self.frame_queue = queue.Queue(maxsize=10)
         self.error_message = None 
-        self.last_processed_frame = None
-        self.final_log = None
+        self.last_processed_frame = None # Holds the final frame after processing
+        self.final_log = None # Holds the final log after processing
 
-        # Data Storage with improved structure
-        self.known_face_embeddings: List[List[np.ndarray]] = []  # Multiple embeddings per person
+        # Data Storage
+        self.known_face_embeddings: List[np.ndarray] = []
         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 with improvements
-        self.last_recognition_time = {}
-        self.recognition_cooldown = 3  # Reduced cooldown
+        # Session Tracking
+        self.last_recognition_time: Dict[str, float] = {}
+        self.recognition_cooldown = 5  # seconds
         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 = 1  # Process every frame initially
-        self.processing_resolution = (640, 480)
+        self.today_attendance: Dict[str, bool] = {}  # Track attendance for today
+        self.last_detected_faces: Dict[str, float] = {}  # Track last detection time per worker
+
+        # Performance optimization
+        self.frame_skip = 2  # Process every 3rd frame for faster processing
+        self.frame_counter = 0
 
         # Initialize
         self.sf = connect_to_salesforce()
         self._create_directories()
         self.load_worker_data()
-        self._load_daily_attendance()
 
     def _create_directories(self):
         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}"
-        
-        # 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_daily_attendance(self):
-        """Load today's attendance records to prevent duplicates."""
-        today_str = date.today().isoformat()
-        self.daily_attendance.clear()
-        
-        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...")
@@ -188,24 +113,14 @@ class AttendanceSystem:
                 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_embeddings.append(np.array(json.loads(worker['Face_Embedding__c'])))
                         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:])
+                            worker_num = int(worker['Worker_ID__c'][1:])
                             if worker_num > max_id:
                                 max_id = worker_num
-                        except (ValueError, TypeError, IndexError):
+                        except (ValueError, TypeError):
                             continue
                 
                 self.known_face_embeddings = temp_embeddings
@@ -224,28 +139,19 @@ class AttendanceSystem:
     def _load_local_worker_data(self):
         try:
             if os.path.exists("data/workers.pkl"):
-                with open("data/workers.pkl", "rb") as f: 
-                    data = pickle.load(f)
+                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"❌ 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)
+            worker_data = {"embeddings": self.known_face_embeddings, "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)
         except Exception as e:
             logger.error(f"❌ Error saving local worker data: {e}")
     
@@ -253,433 +159,253 @@ class AttendanceSystem:
     def register_worker_manual(self, image: Image.Image, name: str) -> Tuple[str, str]:
         if image is None or not name.strip():
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
-        
         try:
             image_array = np.array(image)
+            # Analyze face quality before registration
+            analysis = DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
+            if analysis[0]['face_confidence'] < 0.95:
+                return "❌ Face not clear enough for registration!", self.get_registered_workers_info()
             
-            # 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()
-            
-            face_image, facial_area = best_face
-            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet')[0]['embedding']
-            
-            # 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()
+            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
+            if self._is_duplicate_face(embedding):
+                 return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
 
-            worker_id = self._generate_unique_worker_id()
+            worker_id = f"W{self.next_worker_id:04d}"
             name = name.strip().title()
-            self._add_worker_to_system(worker_id, name, [embedding], face_image, quality_metrics)
+            self._add_worker_to_system(worker_id, name, embedding, image_array)
             self.save_local_worker_data()
-            
-            return f"✅ {name} registered successfully with ID: {worker_id}!", self.get_registered_workers_info()
-            
-        except ValueError as e:
-            return f"❌ Face detection failed: {str(e)}", self.get_registered_workers_info()
+            self.load_worker_data()
+            return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
+        except ValueError:
+            return "❌ No face detected in the image!", self.get_registered_workers_info()
         except Exception as e:
             return f"❌ Registration error: {e}", self.get_registered_workers_info()
 
-    def _register_worker_auto(self, face_image: np.ndarray, facial_area: Dict) -> Optional[Tuple[str, str]]:
-        """Auto-register with enhanced quality and duplicate checking."""
+    def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
         try:
-            logger.info("Attempting auto-registration...")
-            
-            # Quality assessment for auto-registration
-            is_good_quality, quality_metrics = assess_face_quality(face_image, facial_area)
-            
-            logger.info(f"Quality check - Good: {is_good_quality}, Metrics: {quality_metrics}")
-            
-            # More lenient standards for auto-registration
-            if not is_good_quality:
-                logger.info(f"Face quality insufficient for auto-registration: {quality_metrics}")
+            # Check face quality before auto-registration
+            analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
+            if analysis[0]['face_confidence'] < 0.95:
                 return None
-            
-            logger.info("Generating embedding for auto-registration...")
+                
             embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            
-            # Check for duplicates with more lenient threshold for auto-registration
-            if self._is_duplicate_face_enhanced(embedding, threshold=15.0):
-                logger.info("Face matches existing worker - skipping auto-registration")
+            if self._is_duplicate_face(embedding): 
                 return None
-            
-            logger.info("Creating new worker record...")
-            worker_id = self._generate_unique_worker_id()
-            worker_name = f"Auto-Worker-{self.next_worker_id}"
-            
-            self._add_worker_to_system(worker_id, worker_name, [embedding], face_image, quality_metrics)
+                
+            worker_id = f"W{self.next_worker_id:04d}"
+            worker_name = f"Worker {self.next_worker_id}"
+            self._add_worker_to_system(worker_id, worker_name, embedding, face_image)
             self.save_local_worker_data()
-            
-            log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} (ID: {worker_id})"
+            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)
-            
             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, embeddings: List[np.ndarray], 
-                             image_array: np.ndarray, quality_metrics: Dict = None):
-        """Add worker with multiple embeddings support."""
-        self.known_face_embeddings.append(embeddings)
+    def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
+        self.known_face_embeddings.append(np.array(embedding))
         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
+        caption = self._get_image_caption(face_pil)
         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()
-                })
-                
+                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})
-                
+                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
-        
-        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 _is_duplicate_face(self, embedding: List[float], threshold: float = 10.0) -> bool:
+        if not self.known_face_embeddings: return False
+        distances = [np.linalg.norm(np.array(embedding) - known_embedding) for known_embedding in self.known_face_embeddings]
+        return min(distances) < threshold
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
-        """Mark attendance with duplicate prevention."""
+        today_str = date.today().isoformat()
+        
         # Check if already marked today
-        if worker_id in self.daily_attendance:
-            logger.debug(f"Worker {worker_id} already marked present today")
+        if worker_id in self.today_attendance:
             return False
-        
-        # Check session cooldown
+            
+        # Check cooldown period
         current_time = time.time()
-        last_seen = self.last_recognition_time.get(worker_id, 0)
-        if current_time - last_seen < self.recognition_cooldown:
-            logger.debug(f"Worker {worker_id} in cooldown period")
-            return False
-        
-        # Check if already marked in this session
-        if worker_id in self.session_attendees:
-            logger.debug(f"Worker {worker_id} already marked in this session")
+        if worker_id in self.last_recognition_time and (current_time - self.last_recognition_time[worker_id] < self.recognition_cooldown):
             return False
-        
-        today_str = date.today().isoformat()
-        current_datetime = datetime.now()
-        
-        # Mark in Salesforce
+            
+        # Mark attendance
+        current_time_dt = datetime.now()
         if self.sf:
             try:
                 self.sf.Attendance__c.create({
                     'Worker_ID__c': worker_id, 
                     'Name__c': worker_name, 
                     'Date__c': today_str, 
-                    'Timestamp__c': current_datetime.isoformat(), 
+                    'Timestamp__c': current_time_dt.isoformat(), 
                     'Status__c': "Present"
                 })
             except Exception as e:
                 logger.error(f"❌ Error saving attendance to Salesforce: {e}")
         
-        # Update tracking sets
-        self.daily_attendance.add(worker_id)
-        self.session_attendees.add(worker_id)
+        self.today_attendance[worker_id] = True
         self.last_recognition_time[worker_id] = current_time
-        
-        log_msg = f"✅ [{current_datetime.strftime('%H:%M:%S')}] Marked Present: {worker_name} (ID: {worker_id})"
+        log_msg = f"✅ [{current_time_dt.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
         self.session_log.append(log_msg)
-        logger.info(log_msg)
-        
         return True
 
-    # --- Video Processing with Speed Optimizations ---
+    # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
         """
-        Optimized frame processing with better recognition and auto-registration.
+        Process a single video frame with optimizations for speed and accuracy.
         """
         try:
-            # Frame skipping for speed
-            self.frame_skip_count += 1
-            if self.frame_skip_count % self.frame_skip_rate != 0:
-                return frame
-            
-            # Resize frame for faster processing
-            original_height, original_width = frame.shape[:2]
-            target_width, target_height = self.processing_resolution
-            
-            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
-            try:
-                face_objs = DeepFace.extract_faces(img_path=resized_frame, detector_backend='opencv', enforce_detection=False)
-            except Exception as e:
-                logger.error(f"Face extraction failed: {e}")
+            # Skip frames for faster processing
+            self.frame_counter += 1
+            if self.frame_counter % (self.frame_skip + 1) != 0:
                 return frame
 
-            if face_objs and len(face_objs) > 0:
-                logger.info(f"Found {len(face_objs)} faces in frame")
-            else:
-                logger.debug("No faces detected in frame")
-                return frame
+            # Resize frame for faster processing (keeping aspect ratio)
+            height, width = frame.shape[:2]
+            new_width = 640
+            new_height = int((new_width / width) * height)
+            small_frame = cv2.resize(frame, (new_width, new_height))
 
-            for i, face_obj in enumerate(face_objs):
-                facial_area = face_obj['facial_area']
-                confidence = facial_area.get('confidence', 0)
-                
-                # Lower confidence threshold for better detection
-                if confidence < 0.85:
+            face_objs = DeepFace.extract_faces(
+                img_path=small_frame, 
+                detector_backend='opencv', 
+                enforce_detection=False,
+                align=True
+            )
+
+            for face_obj in face_objs:
+                confidence = face_obj['confidence']
+                if confidence < 0.95:  # Higher confidence threshold
                     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)
+                facial_area = face_obj['facial_area']
+                x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
                 
-                # Extract face from original frame
-                face_image = frame[y:y+h, x:x+w]
+                # Scale coordinates back to original frame size
+                x = int(x * width / new_width)
+                y = int(y * height / new_height)
+                w = int(w * width / new_width)
+                h = int(h * height / new_height)
                 
+                face_image = frame[y:y+h, x:x+w]
                 if face_image.size == 0: 
                     continue
 
-                # Quality assessment
-                is_good_quality, quality_metrics = assess_face_quality(face_image, facial_area)
+                # Only process faces that haven't been detected recently
+                current_time = time.time()
+                face_key = f"{x}_{y}_{w}_{h}"
+                if face_key in self.last_detected_faces and (current_time - self.last_detected_faces[face_key] < 2.0):
+                    continue
+                self.last_detected_faces[face_key] = current_time
+
+                embedding = DeepFace.represent(
+                    img_path=face_image, 
+                    model_name='Facenet', 
+                    enforce_detection=False,
+                    align=True
+                )[0]['embedding']
                 
-                # Show all faces but process only good quality ones
-                if not is_good_quality:
-                    # Draw yellow box for poor quality faces
-                    cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 255), 2)
-                    cv2.putText(frame, "Poor Quality - Skipped", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 255), 2)
-                    logger.debug(f"Skipping poor quality face: {quality_metrics}")
+                if not self.known_face_embeddings:
                     continue
 
-                try:
-                    # 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 - more lenient for existing workers
-                    recognition_threshold = 15.0
-                    
-                    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
-                        
-                        logger.info(f"Recognized {worker_name} with distance {min_distance:.4f}")
-                        
-                        # Try to mark attendance (will handle duplicates internally)
-                        attendance_marked = self.mark_attendance(worker_id, worker_name)
-                        if attendance_marked:
-                            label = f"{worker_name} - PRESENT"
-                        else:
-                            label = f"{worker_name} - Already Present"
-                    
-                    else:
-                        # Unknown face - attempt auto-registration
-                        color = (0, 165, 255)  # Orange
-                        label = "Unknown - Processing..."
-                        
-                        logger.debug(f"Unknown face with min distance {min_distance:.4f}")
-                        
-                        # Auto-register if quality is sufficient
-                        new_worker = self._register_worker_auto(face_image, facial_area)
+                distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
+                min_dist = min(distances) if distances else float('inf')
+                match_index = distances.index(min_dist) if min_dist < 10.0 else -1
+
+                color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
+                
+                if match_index != -1:
+                    worker_id = self.known_face_ids[match_index]
+                    worker_name = self.known_face_names[match_index]
+                    color = (0, 255, 0)  # Green for known workers
+                    self.mark_attendance(worker_id, worker_name)
+                else:
+                    # Only attempt auto-registration for high-quality faces
+                    analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
+                    if analysis[0]['face_confidence'] >= 0.95:
+                        color = (0, 165, 255)  # Orange for potential new worker
+                        new_worker = self._register_worker_auto(face_image)
                         if new_worker:
-                            worker_id, worker_name = new_worker
+                            worker_id, worker_name = new_worker[0], new_worker[1]
                             self.mark_attendance(worker_id, worker_name)
-                            label = f"{worker_name} - NEWLY REGISTERED"
-                            color = (255, 0, 0)  # Blue for new registration
-                        else:
-                            label = "Unknown - Low Quality"
-                        
-                        # For debugging - show why auto-registration failed
-                        if not new_worker:
-                            logger.info(f"Auto-registration failed - Quality: {is_good_quality}, Distance: {min_distance:.2f}")
-                    
-                    # Draw bounding box and label
-                    cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
-                    
-                    # Add quality and distance info
-                    quality_text = f"Q:{quality_metrics.get('blur_score', 0):.0f} D:{min_distance:.1f}"
-                    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)
-
-                except Exception as embed_error:
-                    logger.error(f"Error generating embedding: {embed_error}")
-                    # Draw red box for embedding errors
-                    cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 2)
-                    cv2.putText(frame, "Processing Error", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+                
+                # Draw rectangle and label
+                label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
+                cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
+                cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
 
             return frame
-            
         except Exception as e:
             logger.error(f"ERROR in process_frame: {e}")
             return frame
 
     def _processing_loop(self, source):
-        """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."
+            err_msg = f"❌ **Error:** Could not open video source. The file may be corrupt or in an unsupported format. Please try converting it to a standard MP4."
             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)
+            
+        # Set higher FPS if possible (for live camera)
+        if isinstance(source, int):
             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
-            
-            frame_count += 1
-            
-            # Process frame
+                
             processed_frame = self.process_frame(frame)
             
-            # 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
-            
+            if not self.frame_queue.full(): 
+                self.frame_queue.put(processed_frame)
+                
             self.last_processed_frame = processed_frame
+            time.sleep(0.02)  # Reduced sleep for faster processing
             
-            # 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 session reset."""
         if self.is_processing.is_set(): 
             return "⚠️ Processing is already active."
-        
+            
         # Reset states for new session
         self.session_log.clear()
-        self.session_attendees.clear()
         self.last_recognition_time.clear()
+        self.today_attendance.clear()
+        self.last_detected_faces.clear()
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
-        self.frame_skip_count = 0
-        
-        # Reload daily attendance to get latest data
-        self._load_daily_attendance()
+        self.frame_counter = 0
         
         self.is_processing.set()
-        self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,))
-        self.processing_thread.daemon = True
+        self.processing_thread = threading.Thread(
+            target=self._processing_loop, 
+            args=(source,),
+            daemon=True
+        )
         self.processing_thread.start()
-        
-        return f"✅ Started processing with enhanced recognition..."
+        return f"✅ Started processing..."
 
     def stop_processing(self) -> str:
-        """Stop processing and clean up."""
         self.is_processing.clear()
         self.error_message = None
-        
-        # 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 "✅ Processing stopped. Session summary generated."
+        self.last_processed_frame = None
+        self.final_log = None
+        return "✅ Processing stopped by user."
 
     # --- Helper & Reporting ---
     def _get_image_caption(self, image: Image.Image) -> str:
@@ -690,7 +416,7 @@ class AttendanceSystem:
             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=10)
+            response = requests.post(HF_API_URL, headers=headers, data=img_data)
             response.raise_for_status()
             result = response.json()
             return result[0].get("generated_text", "No caption found.")
@@ -706,57 +432,35 @@ class AttendanceSystem:
             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, 
+                'Title': f'Image_{worker_id}',
+                'PathOnClient': f'{worker_id}.jpg',
+                'VersionData': encoded_image,
                 'FirstPublishLocationId': record_id
             })
-            return f"/{cv['id']}"
+            return f"/{cv['id']}"  # Relative URL
         except Exception as e:
             logger.error(f"Salesforce image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        """Get formatted info about registered workers."""
-        if not self.known_face_ids:
-            return "No workers registered yet."
-        
+        if not self.sf: 
+            return "❌ Salesforce not connected."
         try:
-            info_lines = [f"**👥 Registered Workers ({len(self.known_face_ids)})**\n"]
-            
-            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 "\n".join(info_lines)
-            
-        except Exception as e:
-            return f"Error loading worker info: {e}"
-
-    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
-        
-        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)}
-"""
+            records = self.sf.query_all("SELECT Name, Worker_ID__c FROM Worker__c ORDER BY Name")['records']
+            if not records: 
+                return "No workers registered."
+            return f"**👥 Registered Workers ({len(records)})**\n" + "\n".join(
+                [f"- **{w['Name']}** (ID: {w['Worker_ID__c']})" for w in records]
+            )
+        except Exception as e: 
+            return f"Error: {e}"
         
 # --- GRADIO UI ---
 attendance_system = AttendanceSystem()
 
 def create_interface():
-    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="Attendance System") as demo:
+        gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
         with gr.Tabs():
             with gr.Tab("⚙��� Controls & Status"):
                 gr.Markdown("### 1. Choose Input Source & Start Processing")
@@ -769,66 +473,51 @@ def create_interface():
                             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 Recognition & Auto-Registration")
-                
-                gr.Markdown("### 2. Enhanced Features")
-                gr.Markdown("""
-                **🚀 Key Features:**
-                - ✅ **Smart Recognition**: Recognizes existing workers from different angles
-                - ✅ **Auto-Registration**: Automatically registers unknown faces with good quality
-                - ✅ **Duplicate Prevention**: No duplicate attendance logs per day/session
-                - ✅ **Unique IDs**: Enhanced ID generation with timestamps and UUIDs
-                - ✅ **Quality Control**: Only processes clear, high-quality faces
-                - ✅ **Speed Optimization**: Fast video processing for live feeds
-                
-                **🎨 Color Coding:** 
-                - <span style='color: green'>**Green**</span> = Recognized Worker (Present)
-                - <span style='color: blue'>**Blue**</span> = New Auto-Registration  
-                - <span style='color: orange'>**Orange**</span> = Unknown Face
-                - <span style='color: yellow'>**Yellow**</span> = Poor Quality Face
-                """)
+                        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. 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.Tab("📊 Output & Live Feed"):
+            with gr.Tab("📊 Output & Log"):
                 with gr.Row():
                     with gr.Column(scale=2):
-                        video_output = gr.Image(label="🎥 Live Recognition Feed", interactive=False)
+                        video_output = gr.Image(label="Recognition Output", interactive=False)
                     with gr.Column(scale=1):
-                        session_log_display = gr.Markdown(label="📋 Live Session Log", value="System ready for processing...")
+                        session_log_display = gr.Markdown(label="📋 Session Log", value="System is ready.")
 
             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_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():
-                        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")
+                        refresh_workers_btn = gr.Button("🔄 Refresh List")
 
         # --- 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)
+            return "Please provide an input source." if source is None else attendance_system.start_processing(source)
+            
+        start_btn.click(
+            fn=start_wrapper, 
+            inputs=[selected_tab_index, camera_source, video_file], 
+            outputs=[status_box]
+        )
         
-        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])
+        stop_btn.click(
+            fn=attendance_system.stop_processing, 
+            inputs=None, 
+            outputs=[status_box]
+        )
         
         register_btn.click(
             fn=attendance_system.register_worker_manual, 
@@ -841,84 +530,37 @@ def create_interface():
             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:
-                    # 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
-                        
-                        # 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
+                if attendance_system.error_message:
+                    yield None, attendance_system.error_message
+                    time.sleep(2)
+                    attendance_system.error_message = None
+                    continue
                     
-                    # Processing stopped - show final results
+                if attendance_system.is_processing.is_set():
+                    frame, log_md = None, "\n".join(reversed(attendance_system.session_log[-20:])) or "Processing..."
+                    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
+                else:
+                    if attendance_system.last_processed_frame is not None:
+                        final_frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
+                        final_log_md = "\n".join(reversed(attendance_system.final_log[-20:])) or "Processing complete. No log entries."
+                        yield final_frame, final_log_md
                     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:
-                                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"
-                            
-                            yield final_frame, final_log_content
-                        else:
-                            yield None, "### 🏠 System Ready\nGo to 'Controls & Status' tab to start processing."
-                    
-                    time.sleep(0.1)  # Update frequency
-                    
-                except Exception as e:
-                    logger.error(f"UI update error: {e}")
-                    yield None, f"❌ UI Error: {str(e)}"
-                    time.sleep(1)
+                        yield None, "System stopped. Go to 'Controls & Status' to start."
+                time.sleep(0.05)  # Faster UI updates
 
-        # Auto-refresh UI
         demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
-    
     return demo
 
 if __name__ == "__main__":
-    print("🚀 Starting Advanced Face Recognition Attendance System v2.0...")
-    print("📊 Enhanced with: Smart Recognition, Auto-Registration, Quality Control")
-    
     app = create_interface()
-    app.queue(max_size=20)
-    app.launch(
-        server_name="0.0.0.0", 
-        server_port=7860, 
-        show_error=True, 
-        debug=False,
-        share=False
-    )
+    app.queue()
+    app.launch(server_name="0.0.0.0", server_port=7860, show_error=True, debug=True)