Update app.py

app.py

@@ -87,9 +87,10 @@ class AttendanceSystem:
         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.auto_registration_candidates = {}  # Track faces for auto-registration
         self.face_recognition_buffer = {}  # Buffer for multiple detections before confirming
-        self.buffer_threshold = 2  # Reduced threshold for faster recognition
+        self.buffer_threshold = 3  # Increased threshold for more reliable recognition
+        self.auto_register_threshold = 5  # Detections needed before auto-registration
         self.frame_skip_counter = 0  # Skip frames for better performance
 
         # Initialize
@@ -176,31 +177,33 @@ class AttendanceSystem:
         except Exception as e:
             return f"❌ Registration error: {e}", self.get_registered_workers_info()
 
-    def _register_worker_auto(self, face_image: np.ndarray, face_embedding: List[float]) -> Optional[Tuple[str, str]]:
+    def _register_worker_auto(self, face_image: np.ndarray, face_embedding: List[float], embedding_key: str) -> Optional[Tuple[str, str]]:
+        """Enhanced auto-registration with better duplicate checking"""
         try:
-            # Check for duplicates with more lenient threshold for auto-registration
-            if self._is_duplicate_face(face_embedding, threshold=12.0):
+            # Enhanced duplicate check with more permissive threshold for auto-registration
+            if self._is_duplicate_face(face_embedding, threshold=15.0):
+                print("    -> Face too similar to existing worker, skipping auto-registration.")
                 return None
                 
             worker_id = f"W{self.next_worker_id:04d}"
-            
-            # Check if already auto-registered in this session
-            if worker_id in self.session_registered:
-                return None
-                
             worker_name = f"Unknown Worker {self.next_worker_id}"
+            
+            # Add to system
             self._add_worker_to_system(worker_id, worker_name, face_embedding, face_image)
             self.save_local_worker_data()
             
-            # Mark as registered in this session
-            self.session_registered.add(worker_id)
+            # Remove from candidates after successful registration
+            if embedding_key in self.auto_registration_candidates:
+                del self.auto_registration_candidates[embedding_key]
             
             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)
+            print(f"    ✅ AUTO-REGISTERED: {worker_name} ({worker_id})")
             return worker_id, worker_name
         except Exception as e:
             logger.error(f"❌ Auto-registration error: {e}")
+            print(f"    ❌ Auto-registration failed: {e}")
             return None
 
     def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
@@ -221,18 +224,22 @@ class AttendanceSystem:
                 logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
 
     def _is_duplicate_face(self, embedding: List[float], threshold: float = 10.0) -> bool:
-        """Enhanced duplicate detection"""
+        """Enhanced duplicate detection with configurable threshold"""
         if not self.known_face_embeddings: 
             return False
         
         embedding_array = np.array(embedding)
-        for known_embedding in self.known_face_embeddings:
+        for i, known_embedding in enumerate(self.known_face_embeddings):
             # 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))
             
+            # Debug output for duplicate checking
+            print(f"      Comparing with {self.known_face_names[i]}: Euclidean={euclidean_dist:.2f}, Cosine={cosine_sim:.3f}")
+            
             # If either similarity is high or distance is low, consider it duplicate
-            if cosine_sim > 0.80 or euclidean_dist < threshold:
+            if cosine_sim > 0.75 or euclidean_dist < threshold:
+                print(f"      -> DUPLICATE detected with {self.known_face_names[i]}")
                 return True
         
         return False
@@ -297,7 +304,7 @@ class AttendanceSystem:
             )
             
             # Combined score (lower is better)
-            combined_score = euclidean_dist * (1 - cosine_sim)
+            combined_score = euclidean_dist * (2 - cosine_sim)  # Adjusted weighting
             
             if combined_score < best_score:
                 best_score = combined_score
@@ -305,15 +312,19 @@ class AttendanceSystem:
                 
         return best_match_idx, best_score
 
+    def _create_embedding_key(self, embedding: np.ndarray) -> str:
+        """Create a unique key for an embedding for tracking purposes"""
+        return str(hash(tuple(embedding[:10])))  # Use first 10 values for key
+
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
         """
-        Enhanced frame processing with better accuracy and duplicate prevention
+        Enhanced frame processing with improved auto-registration
         """
         try:
             # Skip frames for better performance
             self.frame_skip_counter += 1
-            if self.frame_skip_counter % 3 != 0:  # Process every 3rd frame
+            if self.frame_skip_counter % 2 != 0:  # Process every 2nd frame
                 return frame
                 
             # Use multiple detection backends for better results
@@ -333,8 +344,8 @@ class AttendanceSystem:
                 confidence = face_obj.get('confidence', 0.0)
                 print(f"  Face #{i+1}: Confidence Score = {confidence:.2f}")
 
-                # More lenient confidence threshold
-                if confidence < 0.85:
+                # More lenient confidence threshold for auto-registration
+                if confidence < 0.80:
                     print("    -> Confidence too low, skipping.")
                     continue
 
@@ -348,7 +359,7 @@ class AttendanceSystem:
                     continue
 
                 # More lenient minimum face size check
-                if w < 50 or h < 50:
+                if w < 40 or h < 40:
                     print("    -> Face too small, skipping.")
                     continue
 
@@ -361,6 +372,7 @@ class AttendanceSystem:
                     continue
                 
                 color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
+                embedding_key = self._create_embedding_key(embedding_array)
                 
                 if self.known_face_embeddings:
                     # Enhanced matching
@@ -402,34 +414,72 @@ class AttendanceSystem:
                             del self.face_recognition_buffer[buffer_key]
                             
                     else:
-                        # 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()
+                        # Unknown face - candidate for auto-registration
+                        print(f"    ✗ NO MATCH. Distance: {min_dist:.2f} - Candidate for auto-registration")
+                        color = (0, 165, 255)  # Orange for potential new worker
+                        
+                        # Track this face for auto-registration
+                        if embedding_key not in self.auto_registration_candidates:
+                            self.auto_registration_candidates[embedding_key] = {
+                                'count': 1,
+                                'embedding': embedding,
+                                'face_image': face_image.copy(),
+                                'last_time': time.time(),
+                                'quality_score': confidence
+                            }
+                            print(f"    -> Added to auto-registration candidates (1/{self.auto_register_threshold})")
                         else:
-                            print("    ✗ Uncertain match, skipping registration.")
+                            candidate = self.auto_registration_candidates[embedding_key]
+                            candidate['count'] += 1
+                            candidate['last_time'] = time.time()
+                            
+                            # Update with better quality image if available
+                            if confidence > candidate['quality_score']:
+                                candidate['face_image'] = face_image.copy()
+                                candidate['quality_score'] = confidence
+                            
+                            print(f"    -> Auto-registration candidate count: ({candidate['count']}/{self.auto_register_threshold})")
+                            
+                            # Auto-register if we've seen this face enough times
+                            if candidate['count'] >= self.auto_register_threshold:
+                                print(f"    -> Attempting auto-registration...")
+                                new_worker = self._register_worker_auto(candidate['face_image'], candidate['embedding'], embedding_key)
+                                if new_worker:
+                                    worker_id, worker_name = new_worker[0], new_worker[1]
+                                    color = (0, 255, 0)  # Change to green for registered
+                                    # Mark attendance for newly registered worker
+                                    if self.mark_attendance(worker_id, worker_name):
+                                        self.last_recognition_time[worker_id] = time.time()
+                        
+                        # Clean up if not auto-registered, use generic label
+                        if not worker_id:
+                            worker_name = "New Face"
                 else:
-                    # No known faces, auto-register
+                    # No known faces in database - immediate auto-registration attempt
+                    print("    -> No known faces in database. Attempting immediate auto-registration...")
                     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)
+                    new_worker = self._register_worker_auto(face_image, embedding, embedding_key)
                     if new_worker:
                         worker_id, worker_name = new_worker[0], new_worker[1]
+                        color = (0, 255, 0)  # Change to green for registered
                         if self.mark_attendance(worker_id, worker_name):
                             self.last_recognition_time[worker_id] = time.time()
+                    else:
+                        worker_name = "New Face"
                 
-                # Clean old buffer entries
+                # Clean old buffer entries and candidates
                 current_time = time.time()
                 keys_to_remove = [k for k, v in self.face_recognition_buffer.items() 
                                 if current_time - v['last_time'] > 5.0]
                 for key in keys_to_remove:
                     del self.face_recognition_buffer[key]
                 
+                # Clean old auto-registration candidates (older than 30 seconds)
+                candidates_to_remove = [k for k, v in self.auto_registration_candidates.items() 
+                                      if current_time - v['last_time'] > 30.0]
+                for key in candidates_to_remove:
+                    del self.auto_registration_candidates[key]
+                
                 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)
@@ -463,7 +513,7 @@ class AttendanceSystem:
         self.session_log.clear()
         self.last_recognition_time.clear()
         self.session_marked_present.clear()  # Reset session attendance tracking
-        self.session_registered.clear()  # Reset session registration tracking
+        self.auto_registration_candidates.clear()  # Reset auto-registration candidates
         self.face_recognition_buffer.clear()  # Reset recognition buffer
         self.error_message = None
         self.last_processed_frame = None
@@ -482,6 +532,7 @@ class AttendanceSystem:
         self.last_processed_frame = None
         self.final_log = None
         self.face_recognition_buffer.clear()
+        self.auto_registration_candidates.clear()
         return "✅ Processing stopped by user."
 
     # --- Helper & Reporting ---
@@ -541,7 +592,7 @@ def create_interface():
                         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")
+                gr.Markdown("**🎨 Color Coding:** <font color='green'>Green</font> = Known/Registered, <font color='orange'>Orange</font> = New Face, <font color='red'>Red</font> = Unknown")
             
             with gr.Tab("📊 Output & Log"):
                 with gr.Row():