Update app.py

app.py

@@ -47,15 +47,10 @@ SF_CREDENTIALS = {
     "domain": os.getenv("SF_DOMAIN", "login")
 }
 
-# --- MODIFICATION: Added configuration for performance and accuracy ---
-# Defines how many frames to skip between face analysis. Higher value = faster but less frequent detection.
+# Configuration for performance and accuracy
 FRAME_PROCESS_RATE = 3 
-# Stricter distance threshold for Facenet. Faces with distance > this are considered different people.
-# Default DeepFace threshold is ~10, which is too loose. A value between 0.4 and 0.7 is recommended for Facenet.
 FACE_MATCH_THRESHOLD = 0.6 
-# Minimum confidence score from the face detector to consider a face for auto-registration.
 AUTO_REGISTER_CONFIDENCE = 0.99 
-# --- END MODIFICATION ---
 
 # --- SALESFORCE CONNECTION ---
 
@@ -83,8 +78,8 @@ class AttendanceSystem:
         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.last_processed_frame = None
+        self.final_log = None
 
         # Data Storage
         self.known_face_embeddings: List[np.ndarray] = []
@@ -96,9 +91,7 @@ class AttendanceSystem:
         self.last_recognition_time = {}
         self.recognition_cooldown = 5
         self.session_log: List[str] = []
-        # --- MODIFICATION: Set to track workers already marked present in the current session for unique UI logs ---
         self.session_attended_ids = set()
-        # --- END MODIFICATION ---
 
         # Initialize
         self.sf = connect_to_salesforce()
@@ -124,7 +117,6 @@ class AttendanceSystem:
                         temp_names.append(worker['Name'])
                         temp_ids.append(worker['Worker_ID__c'])
                         try:
-                            # Robustly extract number from Worker ID like "W0042"
                             worker_num = int(''.join(filter(str.isdigit, worker['Worker_ID__c'])))
                             if worker_num > max_id:
                                 max_id = worker_num
@@ -169,20 +161,17 @@ class AttendanceSystem:
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
         try:
             image_array = np.array(image)
-            # Ensure a face exists before proceeding
             DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
             embedding = DeepFace.represent(img_path=image_array, model_name='Facenet', enforce_detection=False)[0]['embedding']
             
             if self._is_duplicate_face(embedding):
                  return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
 
-            # --- MODIFICATION: Ensure unique ID assignment is robust ---
             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() # Not strictly necessary, can rely on local update
             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()
@@ -213,7 +202,7 @@ class AttendanceSystem:
         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 ensures the next ID is always unique
+        self.next_worker_id += 1
 
         face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
         face_pil.save(f"data/faces/{worker_id}.jpg")
@@ -232,21 +221,17 @@ class AttendanceSystem:
         """Checks if a new face embedding is too close to any known embeddings."""
         if not self.known_face_embeddings: return False
         new_embedding = np.array(embedding)
-        # --- MODIFICATION: Using stricter threshold for duplicate check ---
         distances = [np.linalg.norm(new_embedding - known_embedding) for known_embedding in self.known_face_embeddings]
         return min(distances) < FACE_MATCH_THRESHOLD
-        # --- END MODIFICATION ---
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
         """Marks attendance if not already marked in this session. Returns True if newly marked."""
-        # --- MODIFICATION: Check session log first for immediate UI uniqueness ---
         if worker_id in self.session_attended_ids:
-            return False # Already logged in this session
-        # --- END MODIFICATION ---
+            return False 
 
         today_str = date.today().isoformat()
         if self._has_attended_today_in_sf(worker_id, today_str): 
-            self.session_attended_ids.add(worker_id) # Add to session log to prevent re-logging
+            self.session_attended_ids.add(worker_id)
             return False
 
         current_time = datetime.now()
@@ -258,7 +243,7 @@ class AttendanceSystem:
 
         log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
         self.session_log.append(log_msg)
-        self.session_attended_ids.add(worker_id) # Mark as attended for this session
+        self.session_attended_ids.add(worker_id)
         return True
 
     def _has_attended_today_in_sf(self, worker_id: str, today_str: str) -> bool:
@@ -277,14 +262,11 @@ class AttendanceSystem:
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
         """Main function to process a single video frame."""
         try:
-            # Using 'opencv' backend which is generally fastest
             face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
 
-            # Iterate through each face found in the frame
             for face_obj in face_objs:
                 confidence = face_obj['confidence']
                 
-                # Only process faces with a reasonable confidence score
                 if confidence < 0.95: 
                     continue
 
@@ -294,52 +276,41 @@ class AttendanceSystem:
                 
                 if face_image.size == 0: continue
 
-                # Get the embedding for the detected face
                 embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
                 
                 if not self.known_face_embeddings:
-                    # If no workers are registered yet, attempt to register this one
                     if confidence > AUTO_REGISTER_CONFIDENCE:
                         self._register_worker_auto(face_image)
                     continue
 
-                # Compare the face to all known faces
                 distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
                 min_dist = min(distances)
-                # --- MODIFICATION: Using the stricter threshold for matching ---
                 match_index = distances.index(min_dist) if min_dist < FACE_MATCH_THRESHOLD else -1
-                # --- END MODIFICATION ---
 
                 worker_id, worker_name = None, "Unknown"
                 color = (0, 0, 255) # Red for Unknown
 
                 if match_index != -1:
-                    # --- KNOWN FACE FOUND ---
                     worker_id = self.known_face_ids[match_index]
                     worker_name = self.known_face_names[match_index]
                     color = (0, 255, 0) # Green for Known/Present
                     if self.mark_attendance(worker_id, worker_name):
                         self.last_recognition_time[worker_id] = time.time()
                 else:
-                    # --- UNKNOWN FACE ---
                     color = (0, 165, 255) # Orange for newly registered
-                    # --- MODIFICATION: Only auto-register very clear faces ---
                     if confidence > AUTO_REGISTER_CONFIDENCE:
                         new_worker = self._register_worker_auto(face_image)
                         if new_worker:
                             worker_id, worker_name = new_worker
                             if self.mark_attendance(worker_id, worker_name):
                                 self.last_recognition_time[worker_id] = time.time()
-                    # --- END MODIFICATION ---
 
-                # Draw bounding box and label on the frame
                 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)
 
             return frame
         except Exception as e:
-            # Log error but don't crash the loop
             logger.error(f"ERROR in process_frame: {e}")
             return frame
 
@@ -351,32 +322,25 @@ class AttendanceSystem:
             self.is_processing.clear()
             return
         
-        # --- MODIFICATION: Frame skipping for performance ---
         frame_count = 0
         last_annotated_frame = None
-        # --- END MODIFICATION ---
 
         while self.is_processing.is_set():
             ret, frame = video_capture.read()
             if not ret: break
 
-            # --- MODIFICATION: Implement frame skipping ---
             frame_count += 1
             if frame_count % FRAME_PROCESS_RATE == 0:
-                # Process this frame fully
                 processed_frame = self.process_frame(frame)
-                last_annotated_frame = processed_frame.copy() # Save the annotated frame
+                last_annotated_frame = processed_frame.copy()
             else:
-                # For skipped frames, just use the last annotated frame to keep the UI responsive
                 processed_frame = last_annotated_frame if last_annotated_frame is not None else frame
-            # --- END MODIFICATION ---
 
             if not self.frame_queue.full(): 
                 self.frame_queue.put(processed_frame)
             
-            # Continuously update last frame to show at the end
             self.last_processed_frame = processed_frame 
-            time.sleep(0.01) # Small sleep to yield CPU
+            time.sleep(0.01)
 
         self.final_log = self.session_log.copy()
         video_capture.release()
@@ -384,15 +348,13 @@ class AttendanceSystem:
 
     def start_processing(self, source) -> str:
         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
-        # --- MODIFICATION: Clear the session attendance tracker ---
         self.session_attended_ids.clear()
-        # --- END MODIFICATION ---
 
         self.is_processing.set()
         self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,))
@@ -404,7 +366,6 @@ class AttendanceSystem:
         if not self.is_processing.is_set():
             return "⚠️ Processing is not currently active."
         self.is_processing.clear()
-        # Give the thread a moment to finish
         if self.processing_thread:
             self.processing_thread.join(timeout=2)
         return "✅ Processing stopped by user."
@@ -431,24 +392,20 @@ class AttendanceSystem:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
-            # Create a ContentVersion (File)
             cv = self.sf.ContentVersion.create({
                 'Title': f'Image_{worker_id}',
                 'PathOnClient': f'{worker_id}.jpg',
                 'VersionData': encoded_image,
-                'FirstPublishLocationId': record_id # Link to the Worker__c record
+                'FirstPublishLocationId': record_id
             })
-            # To get a usable URL, you query the ContentDocumentLink
             content_doc_link = self.sf.query(f"SELECT ContentDocumentId FROM ContentDocumentLink WHERE LinkedEntityId = '{record_id}'")['records'][0]
             content_doc_id = content_doc_link['ContentDocumentId']
-            # This relative URL can be used within Salesforce
             return f"/sfc/servlet.shepherd/document/download/{content_doc_id}"
         except Exception as e:
             logger.error(f"Salesforce image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        # Refresh local data from Salesforce before displaying
         self.load_worker_data() 
         if not self.known_face_ids: return "No workers registered."
         
@@ -522,10 +479,9 @@ def create_interface():
         
         def update_ui_generator():
             while True:
-                # Handle error messages first
                 if attendance_system.error_message:
                     error = attendance_system.error_message
-                    attendance_system.error_message = None # Clear after sending
+                    attendance_system.error_message = None 
                     yield None, error, f"Status: {error}"
                     time.sleep(2)
                     continue
@@ -535,21 +491,18 @@ def create_interface():
 
                 if attendance_system.is_processing.is_set():
                     try:
-                        # Non-blocking get from the queue
                         if not attendance_system.frame_queue.empty():
                             frame_bgr = attendance_system.frame_queue.get_nowait()
                             if frame_bgr is not None:
                                 frame = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
                     except queue.Empty:
-                        pass # No new frame, just update log
+                        pass
                     yield frame, log_md, "Status: Processing..."
                 else:
-                    # Processing has stopped
                     final_frame = None
                     if attendance_system.last_processed_frame is not None:
                         final_frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
                     
-                    final_log_md = "Processing complete. Here is the final log:"
                     if attendance_system.final_log:
                         final_log_md = "\n".join(reversed(attendance_system.final_log))
                     else:
@@ -557,22 +510,12 @@ def create_interface():
                     
                     yield final_frame, final_log_md, "Status: Stopped. Go to 'Controls & Status' to start."
                 
-                time.sleep(0.1) # UI update frequency
-
-        # Use a separate generator for status to avoid conflicts
-        def update_status_generator():
-             while True:
-                if attendance_system.is_processing.is_set():
-                    yield "Status: Processing..."
-                else:
-                    yield "Status: Stopped. Go to 'Controls & Status' to start."
-                time.sleep(1)
+                time.sleep(0.1)
 
         # Bind the generator to update the UI components
         demo.load(
             fn=update_ui_generator, 
-            outputs=[video_output, session_log_display, status_box],
-            every=0.1
+            outputs=[video_output, session_log_display, status_box]
         )
 
     return demo