Update app.py

app.py

@@ -84,12 +84,13 @@ class AttendanceSystem:
         
         # Session Tracking - Enhanced for better accuracy
         self.last_recognition_time = {}
-        self.recognition_cooldown = 10  # Increased cooldown to prevent duplicates
+        self.recognition_cooldown = 10  # Cooldown to prevent duplicates
         self.session_log: List[str] = []
         self.session_marked_present = set()  # Track who's already marked present in this session
         self.session_registered = set()  # Track who's already auto-registered in this session
         self.face_recognition_buffer = {}  # Buffer for multiple detections before confirming
-        self.buffer_threshold = 3  # Number of consistent detections needed
+        self.buffer_threshold = 2  # Reduced threshold for faster recognition
+        self.frame_skip_counter = 0  # Skip frames for better performance
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -177,8 +178,8 @@ class AttendanceSystem:
 
     def _register_worker_auto(self, face_image: np.ndarray, face_embedding: List[float]) -> Optional[Tuple[str, str]]:
         try:
-            # Enhanced duplicate check with multiple embeddings if possible
-            if self._is_duplicate_face(face_embedding, threshold=8.0):  # Stricter threshold
+            # Check for duplicates with more lenient threshold for auto-registration
+            if self._is_duplicate_face(face_embedding, threshold=12.0):
                 return None
                 
             worker_id = f"W{self.next_worker_id:04d}"
@@ -219,19 +220,19 @@ class AttendanceSystem:
             except Exception as e:
                 logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
 
-    def _is_duplicate_face(self, embedding: List[float], threshold: float = 8.0) -> bool:
-        """Enhanced duplicate detection with stricter threshold"""
+    def _is_duplicate_face(self, embedding: List[float], threshold: float = 10.0) -> bool:
+        """Enhanced duplicate detection"""
         if not self.known_face_embeddings: 
             return False
         
         embedding_array = np.array(embedding)
         for known_embedding in self.known_face_embeddings:
-            # Use cosine similarity as well as euclidean distance
-            cosine_sim = np.dot(embedding_array, known_embedding) / (np.linalg.norm(embedding_array) * np.linalg.norm(known_embedding))
+            # Use both euclidean distance and cosine similarity
             euclidean_dist = np.linalg.norm(embedding_array - known_embedding)
+            cosine_sim = np.dot(embedding_array, known_embedding) / (np.linalg.norm(embedding_array) * np.linalg.norm(known_embedding))
             
             # If either similarity is high or distance is low, consider it duplicate
-            if cosine_sim > 0.85 or euclidean_dist < threshold:
+            if cosine_sim > 0.80 or euclidean_dist < threshold:
                 return True
         
         return False
@@ -278,38 +279,6 @@ class AttendanceSystem:
                 pass
         return False
 
-    def _enhance_face_image(self, face_image: np.ndarray) -> np.ndarray:
-        """Enhance face image quality for better recognition"""
-        try:
-            # Convert to grayscale and back to improve contrast
-            gray = cv2.cvtColor(face_image, cv2.COLOR_BGR2GRAY)
-            # Apply histogram equalization
-            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
-            enhanced = clahe.apply(gray)
-            # Convert back to BGR
-            enhanced_bgr = cv2.cvtColor(enhanced, cv2.COLOR_GRAY2BGR)
-            return enhanced_bgr
-        except:
-            return face_image
-
-    def _get_multiple_embeddings(self, face_image: np.ndarray) -> List[np.ndarray]:
-        """Get multiple embeddings from slightly modified versions of the face"""
-        embeddings = []
-        try:
-            # Original embedding
-            original_embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            embeddings.append(np.array(original_embedding))
-            
-            # Enhanced version embedding
-            enhanced_face = self._enhance_face_image(face_image)
-            enhanced_embedding = DeepFace.represent(img_path=enhanced_face, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            embeddings.append(np.array(enhanced_embedding))
-            
-        except Exception as e:
-            logger.error(f"Error getting multiple embeddings: {e}")
-            
-        return embeddings
-
     def _find_best_match(self, target_embedding: np.ndarray) -> Tuple[int, float]:
         """Find best match using multiple comparison methods"""
         if not self.known_face_embeddings:
@@ -342,17 +311,30 @@ class AttendanceSystem:
         Enhanced frame processing with better accuracy and duplicate prevention
         """
         try:
-            face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
+            # Skip frames for better performance
+            self.frame_skip_counter += 1
+            if self.frame_skip_counter % 3 != 0:  # Process every 3rd frame
+                return frame
+                
+            # Use multiple detection backends for better results
+            face_objs = []
+            try:
+                face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
+            except:
+                try:
+                    face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='mtcnn', enforce_detection=False)
+                except:
+                    pass
 
             if face_objs:
                 print(f"\n--- Frame Processed: Found {len(face_objs)} faces. ---")
 
             for i, face_obj in enumerate(face_objs):
-                confidence = face_obj['confidence']
+                confidence = face_obj.get('confidence', 0.0)
                 print(f"  Face #{i+1}: Confidence Score = {confidence:.2f}")
 
-                # Stricter confidence threshold for better accuracy
-                if confidence < 0.98:
+                # More lenient confidence threshold
+                if confidence < 0.85:
                     print("    -> Confidence too low, skipping.")
                     continue
 
@@ -365,64 +347,81 @@ class AttendanceSystem:
                 if face_image.size == 0: 
                     continue
 
-                # Minimum face size check
-                if w < 80 or h < 80:
+                # More lenient minimum face size check
+                if w < 50 or h < 50:
                     print("    -> Face too small, skipping.")
                     continue
 
-                # Get enhanced embedding
+                # Get embedding
                 try:
                     embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
                     embedding_array = np.array(embedding)
-                except:
-                    print("    -> Could not generate embedding, skipping.")
+                except Exception as e:
+                    print(f"    -> Could not generate embedding: {e}, skipping.")
                     continue
                 
-                if not self.known_face_embeddings:
-                    print("    -> No known faces in database to compare against.")
-                    continue
-
-                # Enhanced matching
-                match_index, match_score = self._find_best_match(embedding_array)
-
-                print(f"    -> Comparing to DB... Best Match Score: {match_score:.4f}")
-
                 color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
                 
-                # Stricter threshold for matches
-                if match_index != -1 and match_score < 8.0:  # Adjusted threshold
-                    worker_id = self.known_face_ids[match_index]
-                    worker_name = self.known_face_names[match_index]
-                    color = (0, 255, 0)  # Green
-                    print(f"    ✓ MATCH! Recognized as {worker_name}")
+                if self.known_face_embeddings:
+                    # Enhanced matching
+                    match_index, match_score = self._find_best_match(embedding_array)
                     
-                    # Use buffering for consistent recognition
-                    buffer_key = f"{worker_id}_{x}_{y}"
-                    if buffer_key not in self.face_recognition_buffer:
-                        self.face_recognition_buffer[buffer_key] = {'count': 1, 'last_time': time.time()}
-                    else:
-                        self.face_recognition_buffer[buffer_key]['count'] += 1
-                        self.face_recognition_buffer[buffer_key]['last_time'] = time.time()
-                    
-                    # Only mark attendance after consistent detections
-                    if self.face_recognition_buffer[buffer_key]['count'] >= self.buffer_threshold:
-                        if self.mark_attendance(worker_id, worker_name):
-                            self.last_recognition_time[worker_id] = time.time()
-                        # Reset buffer after marking
-                        del self.face_recognition_buffer[buffer_key]
+                    # Also try simple euclidean distance for backup
+                    distances = [np.linalg.norm(embedding_array - known) for known in self.known_face_embeddings]
+                    min_dist = min(distances) if distances else float('inf')
+                    simple_match_index = distances.index(min_dist) if min_dist < 12.0 else -1
+
+                    print(f"    -> Comparing to DB... Combined Score: {match_score:.4f}, Simple Distance: {min_dist:.4f}")
+
+                    # Use more lenient thresholds for recognition
+                    if (match_index != -1 and match_score < 15.0) or (simple_match_index != -1 and min_dist < 12.0):
+                        # Use the better match
+                        if match_index != -1 and match_score < 15.0:
+                            final_match_index = match_index
+                        else:
+                            final_match_index = simple_match_index
+                            
+                        worker_id = self.known_face_ids[final_match_index]
+                        worker_name = self.known_face_names[final_match_index]
+                        color = (0, 255, 0)  # Green
+                        print(f"    ✓ MATCH! Recognized as {worker_name}")
                         
-                else:
-                    # More stringent check before auto-registration
-                    if match_score > 12.0:  # Only register if very different from existing faces
-                        color = (0, 165, 255)  # Orange for potential new worker
-                        print(f"    ✗ NO MATCH. Attempting to register as new worker...")
-                        new_worker = self._register_worker_auto(face_image, embedding)
-                        if new_worker:
-                            worker_id, worker_name = new_worker[0], new_worker[1]
+                        # Use buffering for consistent recognition
+                        buffer_key = f"{worker_id}"
+                        if buffer_key not in self.face_recognition_buffer:
+                            self.face_recognition_buffer[buffer_key] = {'count': 1, 'last_time': time.time()}
+                        else:
+                            self.face_recognition_buffer[buffer_key]['count'] += 1
+                            self.face_recognition_buffer[buffer_key]['last_time'] = time.time()
+                        
+                        # Mark attendance after consistent detections
+                        if self.face_recognition_buffer[buffer_key]['count'] >= self.buffer_threshold:
                             if self.mark_attendance(worker_id, worker_name):
                                 self.last_recognition_time[worker_id] = time.time()
+                            # Reset buffer after marking
+                            del self.face_recognition_buffer[buffer_key]
+                            
                     else:
-                        print("    ✗ Uncertain match, skipping registration.")
+                        # Check if this should be auto-registered
+                        if min_dist > 15.0:  # Only register if very different from existing faces
+                            color = (0, 165, 255)  # Orange for potential new worker
+                            print(f"    ✗ NO MATCH. Attempting to register as new worker...")
+                            new_worker = self._register_worker_auto(face_image, embedding)
+                            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()
+                        else:
+                            print("    ✗ Uncertain match, skipping registration.")
+                else:
+                    # No known faces, auto-register
+                    color = (0, 165, 255)  # Orange for new worker
+                    print("    -> No known faces in database. Auto-registering...")
+                    new_worker = self._register_worker_auto(face_image, embedding)
+                    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()
                 
                 # Clean old buffer entries
                 current_time = time.time()
@@ -469,6 +468,7 @@ class AttendanceSystem:
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
+        self.frame_skip_counter = 0
         self.is_processing.set()
         self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,))
         self.processing_thread.daemon = True