Update app.py

app.py

@@ -72,9 +72,17 @@ class AttendanceSystem:
         self.processing_thread = None
         self.is_processing = threading.Event()
         self.frame_queue = queue.Queue(maxsize=10)
-        self.error_message = None 
-        self.last_processed_frame = None # Holds the final frame after processing
-        self.final_log = None # Holds the final log after processing
+        self.error_message = None
+        self.last_processed_frame = None
+        self.final_log = None
+
+        # Recognition Parameters (KEY IMPROVEMENT)
+        # Using two thresholds for better accuracy.
+        # RECOGNITION_THRESHOLD: A strict value for a confident match.
+        # DUPLICATE_THRESHOLD: A looser value to catch variations (e.g., different angles)
+        # and prevent re-registering a known person.
+        self.RECOGNITION_THRESHOLD = 1.1 # For Facenet L2 distance, a value around 1.1 is a confident match.
+        self.DUPLICATE_THRESHOLD = 1.3   # Anything below this is likely the same person at a different angle.
 
         # Data Storage
         self.known_face_embeddings: List[np.ndarray] = []
@@ -83,10 +91,10 @@ class AttendanceSystem:
         self.next_worker_id: int = 1
         
         # Session Tracking
-        self.last_recognition_time = {}
-        self.recognition_cooldown = 5
         self.session_log: List[str] = []
-        self.today_attendance = set()  # Track attendance for current session
+        # NEW: Set to track worker IDs that have been logged in the current session
+        # to prevent duplicate "Marked Present" messages in the UI.
+        self.session_logged_ids = set()
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -158,13 +166,15 @@ class AttendanceSystem:
             image_array = np.array(image)
             DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
             embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
+            
+            # Use the duplicate check to see if face already exists
             if self._is_duplicate_face(embedding):
-                 return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
+                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.save_local_worker_data() # Save and then reload to ensure consistency
             self.load_worker_data()
             return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
         except ValueError:
@@ -175,24 +185,25 @@ class AttendanceSystem:
     def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
         try:
             embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            if self._is_duplicate_face(embedding): return None
+            
+            # An unknown face should not match anyone, even with the looser threshold.
+            if self._is_duplicate_face(embedding):
+                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, embedding, face_image)
             self.save_local_worker_data()
-            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)
+            self.load_worker_data() # Reload data to include the new worker immediately
+            
             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, 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.next_worker_id += 1
+        # This function now just adds the data. In-memory lists will be updated by load_worker_data().
         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)
@@ -205,138 +216,107 @@ 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 = 10.0) -> bool:
+    def _is_duplicate_face(self, embedding: List[float]) -> bool:
+        """Checks if a face is too similar to an already registered one."""
         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
+        # Use the looser threshold to avoid re-registering known faces at different angles
+        return min(distances) < self.DUPLICATE_THRESHOLD
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
+        """Marks attendance in Salesforce if not already done today. Returns True if newly marked."""
         today_str = date.today().isoformat()
-        
-        # Check if already marked today in this session
-        if worker_id in self.today_attendance:
-            return False
-            
-        # Check if already marked in Salesforce
         if self._has_attended_today(worker_id, today_str):
-            self.today_attendance.add(worker_id)  # Add to session tracking
-            return False
-            
+            return False # Already attended, no new action needed
+
         current_time = 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_time.isoformat(), 
-                    'Status__c': "Present"
-                })
+                self.sf.Attendance__c.create({'Worker_ID__c': worker_id, 'Name__c': worker_name, 'Date__c': today_str, 'Timestamp__c': current_time.isoformat(), 'Status__c': "Present"})
+                logger.info(f"Salesforce attendance marked for {worker_id}")
+                return True
             except Exception as e:
                 logger.error(f"❌ Error saving attendance to Salesforce: {e}")
                 return False
-                
-        log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
-        self.session_log.append(log_msg)
-        self.today_attendance.add(worker_id)
-        return True
+        return True # Assume success if not connected to Salesforce
 
     def _has_attended_today(self, worker_id: str, today_str: str) -> bool:
+        """Checks Salesforce to see if an attendance record exists for the worker today."""
         if self.sf:
             try:
-                query = f"SELECT Id FROM Attendance__c WHERE Worker_ID__c = '{worker_id}' AND Date__c = '{today_str}'"
-                return self.sf.query(query)['totalSize'] > 0
-            except Exception as e:
-                logger.error(f"❌ Error checking attendance in Salesforce: {e}")
+                if self.sf.query(f"SELECT Id FROM Attendance__c WHERE Worker_ID__c = '{worker_id}' AND Date__c = {today_str}")['totalSize'] > 0:
+                    return True
+            except Exception: pass # If query fails, assume not attended
         return False
 
     # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
-        """
-        Process a single video frame with improved accuracy and duplicate handling.
-        """
+        """Main function to process a single video frame with improved accuracy logic."""
         try:
-            # Convert to RGB for better face detection
-            rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            
-            # Extract faces with higher confidence threshold
-            face_objs = DeepFace.extract_faces(
-                img_path=rgb_frame, 
-                detector_backend='opencv', 
-                enforce_detection=False,
-                align=True
-            )
+            face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
 
             for face_obj in face_objs:
-                confidence = face_obj['confidence']
-                
-                # Skip low confidence detections
-                if confidence < 0.97:  # Higher threshold for better accuracy
-                    continue
+                if face_obj['confidence'] < 0.95: continue
 
                 facial_area = face_obj['facial_area']
                 x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
-                face_image = rgb_frame[y:y+h, x:x+w]
+                face_image = frame[y:y+h, x:x+w]
                 
-                if face_image.size == 0: 
-                    continue
+                if face_image.size == 0: continue
 
-                # Get face embedding with normalization
-                embedding = np.array(DeepFace.represent(
-                    img_path=face_image, 
-                    model_name='Facenet', 
-                    enforce_detection=False,
-                    normalization='base'
-                )[0]['embedding'])
-
-                # Skip if no known faces
-                if not self.known_face_embeddings:
-                    cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 2)
-                    cv2.putText(frame, "Unknown", (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
-                    continue
-
-                # Calculate distances with all known faces
-                distances = [np.linalg.norm(embedding - known) for known in self.known_face_embeddings]
-                min_dist = min(distances)
-                match_index = np.argmin(distances)
+                # Default to Unknown (Red)
+                color, label_text = (0, 0, 255), "Unknown"
                 
-                # Determine recognition result
-                recognized = min_dist < 8.0  # Lower threshold for stricter matching
-                worker_id = self.known_face_ids[match_index] if recognized else None
-                worker_name = self.known_face_names[match_index] if recognized else "Unknown"
-
-                # Set display properties based on recognition status
-                if recognized:
-                    color = (0, 255, 0)  # Green for known workers
-                    label = f"{worker_name} ({worker_id})"
+                try:
+                    embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
                     
-                    # Mark attendance if not already done today
-                    if worker_id not in self.today_attendance:
-                        self.mark_attendance(worker_id, worker_name)
-                else:
-                    # Attempt auto-registration only if face is clear enough
-                    if w > 100 and h > 100:  # Minimum face size threshold
-                        new_worker = self._register_worker_auto(face_image)
-                        if new_worker:
-                            worker_id, worker_name = new_worker
-                            color = (0, 165, 255)  # Orange for new workers
-                            label = f"{worker_name} ({worker_id})"
-                            self.mark_attendance(worker_id, worker_name)
-                        else:
-                            color = (0, 0, 255)  # Red for unknown
-                            label = "Unknown"
-                    else:
-                        color = (0, 0, 255)  # Red for unknown
-                        label = "Unknown (Too small)"
-
-                # Draw rectangle and label
+                    if self.known_face_embeddings:
+                        distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
+                        min_dist = min(distances)
+                        match_index = distances.index(min_dist)
+
+                        # CASE 1: CONFIDENT MATCH (Recognized Worker)
+                        if min_dist < self.RECOGNITION_THRESHOLD:
+                            worker_id = self.known_face_ids[match_index]
+                            worker_name = self.known_face_names[match_index]
+                            color = (0, 255, 0) # Green
+                            label_text = f"{worker_name} ({worker_id})"
+                            
+                            # Log attendance only ONCE per session for a clean UI
+                            if worker_id not in self.session_logged_ids:
+                                if self.mark_attendance(worker_id, worker_name):
+                                    log_msg = f"✅ [{datetime.now().strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
+                                    self.session_log.append(log_msg)
+                                    self.session_logged_ids.add(worker_id)
+
+                        # CASE 2: UNKNOWN FACE (Not a confident match)
+                        # We also check if it's a potential duplicate before trying to register
+                        elif not self._is_duplicate_face(embedding):
+                            # Attempt to auto-register this new face
+                            new_worker = self._register_worker_auto(face_image)
+                            if new_worker:
+                                worker_id, worker_name = new_worker
+                                color = (0, 165, 255) # Orange for new worker
+                                label_text = f"{worker_name} ({worker_id})"
+
+                                if worker_id not in self.session_logged_ids:
+                                    log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
+                                    self.session_log.append(log_msg)
+                                    self.mark_attendance(worker_id, worker_name)
+                                    self.session_logged_ids.add(worker_id)
+                        # else: Face is in the "gray area" (between 1.1 and 1.3). Treat as "Unknown" but don't register.
+
+                except Exception as e:
+                    logger.debug(f"Could not process a face, likely too small or blurry. Error: {e}")
+
+                # Draw bounding box and label
                 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)
-
+                cv2.putText(frame, label_text, (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
+            logger.error(f"CRITICAL ERROR in process_frame: {e}")
+            return frame # Return original frame on error
 
     def _processing_loop(self, source):
         video_capture = cv2.VideoCapture(source)
@@ -346,58 +326,40 @@ class AttendanceSystem:
             self.is_processing.clear()
             return
             
-        # Reset attendance tracking for new session
-        self.today_attendance.clear()
-        self.session_log.clear()
-        
         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
+            self.last_processed_frame = processed_frame # Continuously update last frame
             time.sleep(0.05)
             
-        self.final_log = self.session_log.copy()
+        self.final_log = self.session_log.copy() # Save the final log
         video_capture.release()
         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.error_message = None
-        self.last_processed_frame = None
-        self.final_log = None
-        
+        self.session_logged_ids.clear() # IMPORTANT: Clear the session log tracker
+        self.error_message = None; self.last_processed_frame = None; self.final_log = None
         self.is_processing.set()
-        self.processing_thread = threading.Thread(
-            target=self._processing_loop, 
-            args=(source,),
-            daemon=True
-        )
+        self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,)); self.processing_thread.daemon = True
         self.processing_thread.start()
         return f"✅ Started processing..."
 
     def stop_processing(self) -> str:
-        self.is_processing.clear()
-        self.error_message = None
-        self.last_processed_frame = None
-        self.final_log = None
+        # Reset states when stopping manually
+        self.is_processing.clear(); self.error_message = None
+        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:
-        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")
@@ -412,39 +374,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."
-            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}"
+            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="Attendance System") as demo:
         gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
@@ -485,55 +435,32 @@ 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]
-        )
-        
-        refresh_workers_btn.click(
-            fn=attendance_system.get_registered_workers_info, 
-            outputs=[registered_workers_info]
-        )
+        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])
+        refresh_workers_btn.click(fn=attendance_system.get_registered_workers_info, outputs=[registered_workers_info])
         
         def update_ui_generator():
             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:
@@ -544,10 +471,7 @@ def create_interface():
                         yield None, "System stopped. Go to 'Controls & Status' to start."
                 time.sleep(0.1)
 
-        demo.load(
-            fn=update_ui_generator, 
-            outputs=[video_output, session_log_display]
-        )
+        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
     return demo
 
 if __name__ == "__main__":