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_auto_registered = set()  # Track embeddings that were auto-registered 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 = 2  # Reduced threshold for faster recognition
         self.frame_skip_counter = 0  # Skip frames for better performance
@@ -138,8 +138,7 @@ 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", [])
@@ -150,14 +149,8 @@ class AttendanceSystem:
 
     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
-            }
-            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}")
     
@@ -167,51 +160,40 @@ 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', enforce_detection=True)[0]['embedding']
-            
-            # Check for duplicates with reasonable threshold for manual registration
-            if self._is_duplicate_face(embedding, threshold=8.0):
+            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 = 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 as e:
-            return f"❌ No face detected in the image! Error: {str(e)}", self.get_registered_workers_info()
+        except ValueError:
+            return "❌ No face detected in the image!", 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:
-            # 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
-            
             # Check for duplicates with more lenient threshold for auto-registration
-            if self._is_duplicate_face(face_embedding, threshold=10.0):
+            if self._is_duplicate_face(face_embedding, threshold=12.0):
                 return None
                 
             worker_id = f"W{self.next_worker_id:04d}"
-            worker_name = f"Unknown Worker {self.next_worker_id}"
             
+            # 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}"
             self._add_worker_to_system(worker_id, worker_name, face_embedding, face_image)
             self.save_local_worker_data()
             
-            # Mark this embedding as registered in this session
-            self.session_auto_registered.add(embedding_hash)
+            # Mark as registered in this session
+            self.session_registered.add(worker_id)
             
             log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
             self.session_log.append(log_msg)
@@ -226,31 +208,14 @@ class AttendanceSystem:
         self.known_face_names.append(name)
         self.known_face_ids.append(worker_id)
         self.next_worker_id += 1
-        
-        # 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 = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
         face_pil.save(f"data/faces/{worker_id}.jpg")
-        
         caption = self._get_image_caption(face_pil)
         if self.sf:
             try:
-                worker_record = self.sf.Worker__c.create({
-                    'Name': name, 
-                    'Worker_ID__c': worker_id, 
-                    'Face_Embedding__c': json.dumps(embedding), 
-                    'Image_Caption__c': caption
-                })
+                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}")
@@ -262,17 +227,12 @@ class AttendanceSystem:
         
         embedding_array = np.array(embedding)
         for known_embedding in self.known_face_embeddings:
-            # Use euclidean distance as primary method
+            # 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))
             
-            # Calculate cosine similarity for additional validation
-            dot_product = np.dot(embedding_array, known_embedding)
-            norm_a = np.linalg.norm(embedding_array)
-            norm_b = np.linalg.norm(known_embedding)
-            cosine_sim = dot_product / (norm_a * norm_b) if (norm_a * norm_b) != 0 else 0
-            
-            # Consider it duplicate if distance is small OR similarity is very high
-            if euclidean_dist < threshold or cosine_sim > 0.85:
+            # If either similarity is high or distance is low, consider it duplicate
+            if cosine_sim > 0.80 or euclidean_dist < threshold:
                 return True
         
         return False
@@ -325,17 +285,25 @@ class AttendanceSystem:
             return -1, float('inf')
             
         best_match_idx = -1
-        best_distance = float('inf')
+        best_score = float('inf')
         
         for i, known_embedding in enumerate(self.known_face_embeddings):
-            # Primary: Euclidean distance
+            # Euclidean distance
             euclidean_dist = np.linalg.norm(target_embedding - known_embedding)
             
-            if euclidean_dist < best_distance:
-                best_distance = euclidean_dist
+            # 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
                 best_match_idx = i
                 
-        return best_match_idx, best_distance
+        return best_match_idx, best_score
 
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
@@ -366,7 +334,7 @@ class AttendanceSystem:
                 print(f"  Face #{i+1}: Confidence Score = {confidence:.2f}")
 
                 # More lenient confidence threshold
-                if confidence < 0.80:
+                if confidence < 0.85:
                     print("    -> Confidence too low, skipping.")
                     continue
 
@@ -380,7 +348,7 @@ class AttendanceSystem:
                     continue
 
                 # More lenient minimum face size check
-                if w < 40 or h < 40:
+                if w < 50 or h < 50:
                     print("    -> Face too small, skipping.")
                     continue
 
@@ -394,28 +362,37 @@ class AttendanceSystem:
                 
                 color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
                 
-                # Create a buffer key for this face location
-                buffer_key = f"{x}_{y}_{w}_{h}"
-                current_time = time.time()
-                
                 if self.known_face_embeddings:
-                    # Find best match using euclidean distance
-                    match_index, match_distance = self._find_best_match(embedding_array)
+                    # Enhanced matching
+                    match_index, match_score = self._find_best_match(embedding_array)
                     
-                    print(f"    -> Comparing to DB... Best Match Distance: {match_distance:.4f}")
-
-                    # Use consistent threshold for recognition (10.0 works well)
-                    if match_index != -1 and match_distance < 10.0:
-                        worker_id = self.known_face_ids[match_index]
-                        worker_name = self.known_face_names[match_index]
-                        color = (0, 255, 0)  # Green for recognized
+                    # 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}")
                         
-                        # Use buffer for consistent detections
+                        # 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': current_time, 'worker_id': worker_id}
+                            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'] = current_time
+                            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:
@@ -425,30 +402,24 @@ class AttendanceSystem:
                             del self.face_recognition_buffer[buffer_key]
                             
                     else:
-                        # No match found - check if this should be auto-registered
-                        print(f"    ✗ NO MATCH (Distance: {match_distance:.4f})")
-                        
-                        # Only auto-register if distance is significantly different (> 15.0)
-                        # and not a duplicate according to our duplicate detection
-                        if match_distance > 15.0 and not self._is_duplicate_face(embedding, threshold=12.0):
+                        # 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"    -> Attempting auto-registration...")
+                            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]
-                                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("    -> Distance too close to existing faces, skipping auto-registration.")
+                            print("    ✗ Uncertain match, skipping registration.")
                 else:
-                    # No known faces in database, auto-register the first face
+                    # 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]
-                        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()
                 
@@ -477,11 +448,9 @@ class AttendanceSystem:
             return
         while self.is_processing.is_set():
             ret, frame = video_capture.read()
-            if not ret: 
-                break
+            if not ret: break
             processed_frame = self.process_frame(frame)
-            if not self.frame_queue.full(): 
-                self.frame_queue.put(processed_frame)
+            if not self.frame_queue.full(): self.frame_queue.put(processed_frame)
             self.last_processed_frame = processed_frame # Continuously update last frame
             time.sleep(0.05)
         self.final_log = self.session_log.copy() # Save the final log
@@ -489,13 +458,12 @@ class AttendanceSystem:
         self.is_processing.clear()
 
     def start_processing(self, source) -> str:
-        if self.is_processing.is_set(): 
-            return "⚠️ Processing is already active."
+        if self.is_processing.is_set(): return "⚠️ Processing is already active."
         # Reset states for the new session
         self.session_log.clear()
         self.last_recognition_time.clear()
         self.session_marked_present.clear()  # Reset session attendance tracking
-        self.session_auto_registered.clear()  # Reset session registration tracking
+        self.session_registered.clear()  # Reset session registration tracking
         self.face_recognition_buffer.clear()  # Reset recognition buffer
         self.error_message = None
         self.last_processed_frame = None
@@ -518,8 +486,7 @@ class AttendanceSystem:
 
     # --- Helper & Reporting ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        if not HF_API_TOKEN: 
-            return "Hugging Face API token not configured."
+        if not HF_API_TOKEN: return "Hugging Face API token not configured."
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
@@ -534,37 +501,27 @@ class AttendanceSystem:
             return "Caption generation failed."
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        if not self.sf: 
-            return None
+        if not self.sf: return None
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
-            cv = self.sf.ContentVersion.create({
-                'Title': f'Image_{worker_id}', 
-                'PathOnClient': f'{worker_id}.jpg', 
-                'VersionData': encoded_image, 
-                'FirstPublishLocationId': record_id
-            })
+            cv = self.sf.ContentVersion.create({'Title': f'Image_{worker_id}', 'PathOnClient': f'{worker_id}.jpg', 'VersionData': encoded_image, 'FirstPublishLocationId': record_id})
             return f"/{cv['id']}" # Relative URL
         except Exception as e:
             logger.error(f"Salesforce image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        if not self.sf: 
-            return "❌ Salesforce not connected."
+        if not self.sf: return "❌ Salesforce not connected."
         try:
             records = self.sf.query_all("SELECT Name, Worker_ID__c FROM Worker__c ORDER BY Name")['records']
-            if not records: 
-                return "No workers registered."
+            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}"
+        except Exception as e: return f"Error: {e}"
         
 # --- GRADIO UI ---
 attendance_system = AttendanceSystem()
-
 def create_interface():
     with gr.Blocks(theme=gr.themes.Soft(), title="Attendance System") as demo:
         gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
@@ -605,15 +562,11 @@ def create_interface():
                         refresh_workers_btn = gr.Button("🔄 Refresh List")
 
         # --- Event Handlers ---
-        def on_tab_select(evt: gr.SelectData): 
-            return evt.index
-        
+        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
             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])
         stop_btn.click(fn=attendance_system.stop_processing, inputs=None, outputs=[status_box])
         register_btn.click(fn=attendance_system.register_worker_manual, inputs=[register_image, register_name], outputs=[register_output, registered_workers_info])
@@ -623,18 +576,15 @@ def create_interface():
             while True:
                 if attendance_system.error_message:
                     yield None, attendance_system.error_message
-                    time.sleep(2)
-                    attendance_system.error_message = None
+                    time.sleep(2); attendance_system.error_message = None
                     continue
                 if attendance_system.is_processing.is_set():
                     frame, log_md = None, "\n".join(reversed(attendance_system.session_log)) 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
+                            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: