Update app.py

app.py

@@ -87,7 +87,7 @@ 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.session_auto_registered = set()  # Track embeddings that were auto-registered in this session
         self.face_recognition_buffer = {}  # Buffer for multiple detections before confirming
         self.buffer_threshold = 2  # Reduced threshold for faster recognition
         self.frame_skip_counter = 0  # Skip frames for better performance
@@ -160,40 +160,51 @@ class AttendanceSystem:
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
         try:
             image_array = np.array(image)
+            # Convert RGB to BGR for DeepFace
+            if len(image_array.shape) == 3 and image_array.shape[2] == 3:
+                image_array = cv2.cvtColor(image_array, cv2.COLOR_RGB2BGR)
+            
+            # Verify face detection first
             DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
-            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
-            if self._is_duplicate_face(embedding):
+            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet', enforce_detection=True)[0]['embedding']
+            
+            # Check for duplicates with reasonable threshold for manual registration
+            if self._is_duplicate_face(embedding, threshold=8.0):
                  return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
 
             worker_id = f"W{self.next_worker_id:04d}"
             name = name.strip().title()
             self._add_worker_to_system(worker_id, name, embedding, image_array)
             self.save_local_worker_data()
-            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 ValueError as e:
+            return f"❌ No face detected in the image! Error: {str(e)}", self.get_registered_workers_info()
         except Exception as e:
+            logger.error(f"Registration error: {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]]:
         try:
-            # Check for duplicates with more lenient threshold for auto-registration
-            if self._is_duplicate_face(face_embedding, threshold=12.0):
+            # Create a unique identifier for this embedding to track session registrations
+            embedding_hash = hash(tuple(np.round(face_embedding, 3)))
+            
+            # Check if this specific face was already auto-registered in this session
+            if embedding_hash in self.session_auto_registered:
                 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:
+            # Check for duplicates with more lenient threshold for auto-registration
+            if self._is_duplicate_face(face_embedding, threshold=10.0):
                 return None
                 
+            worker_id = f"W{self.next_worker_id:04d}"
             worker_name = f"Unknown Worker {self.next_worker_id}"
+            
             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)
+            # Mark this embedding as registered in this session
+            self.session_auto_registered.add(embedding_hash)
             
             log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
             self.session_log.append(log_msg)
@@ -208,8 +219,19 @@ class AttendanceSystem:
         self.known_face_names.append(name)
         self.known_face_ids.append(worker_id)
         self.next_worker_id += 1
-        face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
+        
+        # Ensure image is in RGB format for saving
+        if len(image_array.shape) == 3:
+            if image_array.shape[2] == 3:
+                # Check if BGR (OpenCV format) and convert to RGB
+                face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
+            else:
+                face_pil = Image.fromarray(image_array)
+        else:
+            face_pil = Image.fromarray(image_array)
+            
         face_pil.save(f"data/faces/{worker_id}.jpg")
+        
         caption = self._get_image_caption(face_pil)
         if self.sf:
             try:
@@ -227,12 +249,14 @@ class AttendanceSystem:
         
         embedding_array = np.array(embedding)
         for known_embedding in self.known_face_embeddings:
-            # Use both euclidean distance and cosine similarity
+            # Use euclidean distance as primary method
             euclidean_dist = np.linalg.norm(embedding_array - known_embedding)
+            
+            # Also check cosine similarity for additional validation
             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.80 or euclidean_dist < threshold:
+            # Consider it duplicate if distance is small OR similarity is very high
+            if euclidean_dist < threshold or cosine_sim > 0.85:
                 return True
         
         return False
@@ -285,25 +309,17 @@ class AttendanceSystem:
             return -1, float('inf')
             
         best_match_idx = -1
-        best_score = float('inf')
+        best_distance = float('inf')
         
         for i, known_embedding in enumerate(self.known_face_embeddings):
-            # Euclidean distance
+            # Primary: Euclidean distance
             euclidean_dist = np.linalg.norm(target_embedding - known_embedding)
             
-            # Cosine similarity
-            cosine_sim = np.dot(target_embedding, known_embedding) / (
-                np.linalg.norm(target_embedding) * np.linalg.norm(known_embedding)
-            )
-            
-            # Combined score (lower is better)
-            combined_score = euclidean_dist * (1 - cosine_sim)
-            
-            if combined_score < best_score:
-                best_score = combined_score
+            if euclidean_dist < best_distance:
+                best_distance = euclidean_dist
                 best_match_idx = i
                 
-        return best_match_idx, best_score
+        return best_match_idx, best_distance
 
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
@@ -334,7 +350,7 @@ class AttendanceSystem:
                 print(f"  Face #{i+1}: Confidence Score = {confidence:.2f}")
 
                 # More lenient confidence threshold
-                if confidence < 0.85:
+                if confidence < 0.80:
                     print("    -> Confidence too low, skipping.")
                     continue
 
@@ -348,7 +364,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
 
@@ -363,26 +379,15 @@ class AttendanceSystem:
                 color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
                 
                 if self.known_face_embeddings:
-                    # Enhanced matching
-                    match_index, match_score = self._find_best_match(embedding_array)
+                    # Find best match
+                    match_index, match_distance = self._find_best_match(embedding_array)
                     
-                    # 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]
+                    print(f"    -> Comparing to DB... Best Match Distance: {match_distance:.4f}")
+
+                    # Use reasonable threshold for recognition (12.0 works well with Facenet)
+                    if match_index != -1 and match_distance < 12.0:
+                        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}")
                         
@@ -402,26 +407,32 @@ 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
+                        # No match found - attempt auto-registration for new faces
+                        if match_distance > 12.0:  # Clearly different from existing faces
                             color = (0, 165, 255)  # Orange for potential new worker
-                            print(f"    ✗ NO MATCH. Attempting to register as new worker...")
+                            print(f"    ✗ NO MATCH (Distance: {match_distance:.4f}). Attempting auto-registration...")
                             new_worker = self._register_worker_auto(face_image, embedding)
                             if new_worker:
                                 worker_id, worker_name = new_worker[0], new_worker[1]
+                                color = (0, 255, 0)  # Change to green after successful registration
                                 if self.mark_attendance(worker_id, worker_name):
                                     self.last_recognition_time[worker_id] = time.time()
+                            else:
+                                print("    -> Auto-registration skipped (duplicate or session limit)")
                         else:
                             print("    ✗ Uncertain match, skipping registration.")
                 else:
-                    # No known faces, auto-register
+                    # No known faces, auto-register the first face
                     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]
+                        color = (0, 255, 0)  # Change to green after successful registration
                         if self.mark_attendance(worker_id, worker_name):
                             self.last_recognition_time[worker_id] = time.time()
+                    else:
+                        print("    -> Auto-registration failed")
                 
                 # Clean old buffer entries
                 current_time = time.time()
@@ -463,7 +474,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.session_auto_registered.clear()  # Reset session registration tracking
         self.face_recognition_buffer.clear()  # Reset recognition buffer
         self.error_message = None
         self.last_processed_frame = None