Update app.py

app.py

@@ -73,9 +73,8 @@ class AttendanceSystem:
         self.is_processing = threading.Event()
         self.frame_queue = queue.Queue(maxsize=10)
         self.error_message = None 
-        self.last_processed_frame = None
-        self.final_log = None
-        self.processed_workers = set()  # Track workers processed in this session
+        self.last_processed_frame = None # Holds the final frame after processing
+        self.final_log = None # Holds the final log after processing
 
         # Data Storage
         self.known_face_embeddings: List[np.ndarray] = []
@@ -87,11 +86,11 @@ class AttendanceSystem:
         self.last_recognition_time: Dict[str, float] = {}
         self.recognition_cooldown = 5  # seconds
         self.session_log: List[str] = []
-        self.today_attendance: Dict[str, bool] = {}
-        self.last_detected_faces: Dict[str, float] = {}
+        self.today_attendance: Dict[str, bool] = {}  # Track attendance for today
+        self.last_detected_faces: Dict[str, float] = {}  # Track last detection time per worker
 
         # Performance optimization
-        self.frame_skip = 1  # Process every 2nd frame
+        self.frame_skip = 2  # Process every 3rd frame for faster processing
         self.frame_counter = 0
 
         # Initialize
@@ -121,7 +120,7 @@ class AttendanceSystem:
                             worker_num = int(worker['Worker_ID__c'][1:])
                             if worker_num > max_id:
                                 max_id = worker_num
-                        except (ValueError, TypeError):
+                        except (ValueError, TypeTypeError):
                             continue
                 
                 self.known_face_embeddings = temp_embeddings
@@ -162,6 +161,7 @@ class AttendanceSystem:
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
         try:
             image_array = np.array(image)
+            # Analyze face quality before registration
             analysis = DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
             if analysis[0]['face_confidence'] < 0.95:
                 return "❌ Face not clear enough for registration!", self.get_registered_workers_info()
@@ -183,6 +183,7 @@ class AttendanceSystem:
 
     def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
         try:
+            # Check face quality before auto-registration
             analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
             if analysis[0]['face_confidence'] < 0.95:
                 return None
@@ -226,24 +227,26 @@ class AttendanceSystem:
         return min(distances) < threshold
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
-        if worker_id in self.processed_workers:
-            return False
-            
         today_str = date.today().isoformat()
+        
+        # Check if already marked today
         if worker_id in self.today_attendance:
             return False
             
+        # Check cooldown period
         current_time = time.time()
         if worker_id in self.last_recognition_time and (current_time - self.last_recognition_time[worker_id] < self.recognition_cooldown):
             return False
             
+        # Mark attendance
+        current_time_dt = 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': datetime.now().isoformat(), 
+                    'Timestamp__c': current_time_dt.isoformat(), 
                     'Status__c': "Present"
                 })
             except Exception as e:
@@ -251,10 +254,8 @@ class AttendanceSystem:
         
         self.today_attendance[worker_id] = True
         self.last_recognition_time[worker_id] = current_time
-        self.processed_workers.add(worker_id)
-        log_msg = f"✅ [{datetime.now().strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
+        log_msg = f"✅ [{current_time_dt.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
         self.session_log.append(log_msg)
-        logger.info(log_msg)
         return True
 
     # --- Video Processing ---
@@ -263,46 +264,43 @@ class AttendanceSystem:
         Process a single video frame with optimizations for speed and accuracy.
         """
         try:
+            # Skip frames for faster processing
             self.frame_counter += 1
             if self.frame_counter % (self.frame_skip + 1) != 0:
                 return frame
 
-            # Resize frame to a smaller size for faster processing
+            # Resize frame for faster processing (keeping aspect ratio)
             height, width = frame.shape[:2]
-            new_width = 480
+            new_width = 360  # Reduced from 640 for speed
             new_height = int((new_width / width) * height)
             small_frame = cv2.resize(frame, (new_width, new_height))
 
-            # Use OpenCV detector for better reliability
             face_objs = DeepFace.extract_faces(
-                img_path=small_frame,
-                detector_backend='opencv',
+                img_path=small_frame, 
+                detector_backend='opencv',  # More reliable detector
                 enforce_detection=False,
                 align=True
             )
 
-            if not face_objs:
-                logger.warning("No faces detected in this frame.")
-                return frame
-
             for face_obj in face_objs:
-                confidence = face_obj.get('confidence', 0.0)
+                confidence = face_obj['confidence']
                 if confidence < 0.90:  # Lowered threshold for detection
                     continue
 
                 facial_area = face_obj['facial_area']
                 x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
                 
+                # Scale coordinates back to original frame size
                 x = int(x * width / new_width)
                 y = int(y * height / new_height)
                 w = int(w * width / new_width)
                 h = int(h * height / new_height)
                 
                 face_image = frame[y:y+h, x:x+w]
-                if face_image.size == 0:
+                if face_image.size == 0: 
                     continue
 
-                # Skip recently detected faces
+                # Only process faces that haven't been detected recently
                 current_time = time.time()
                 face_key = f"{x}_{y}_{w}_{h}"
                 if face_key in self.last_detected_faces and (current_time - self.last_detected_faces[face_key] < 2.0):
@@ -310,39 +308,36 @@ class AttendanceSystem:
                 self.last_detected_faces[face_key] = current_time
 
                 embedding = DeepFace.represent(
-                    img_path=face_image,
-                    model_name='Facenet512',
+                    img_path=face_image, 
+                    model_name='Facenet', 
                     enforce_detection=False,
                     align=True
                 )[0]['embedding']
                 
                 if not self.known_face_embeddings:
-                    logger.info("No known face embeddings loaded.")
                     continue
 
                 distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
                 min_dist = min(distances) if distances else float('inf')
-                match_index = distances.index(min_dist) if min_dist < 8.0 else -1
+                match_index = distances.index(min_dist) if min_dist < 10.0 else -1
 
                 color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
                 
                 if match_index != -1:
                     worker_id = self.known_face_ids[match_index]
                     worker_name = self.known_face_names[match_index]
-                    if worker_id not in self.processed_workers:
-                        color = (0, 255, 0)
-                        if self.mark_attendance(worker_id, worker_name):
-                            pass  # Log already handled in mark_attendance
+                    color = (0, 255, 0)  # Green for known workers
+                    self.mark_attendance(worker_id, worker_name)
                 else:
+                    # Only attempt auto-registration for high-quality faces
                     analysis = DeepFace.analyze(img_path=face_image, actions=['emotion'], enforce_detection=False)
-                    if analysis[0].get('face_confidence', 0.0) >= 0.90:
-                        color = (0, 165, 255)
+                    if analysis[0]['face_confidence'] >= 0.90:  # Lowered threshold
+                        color = (0, 165, 255)  # Orange for potential new worker
                         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):
-                                pass  # Log already handled in _register_worker_auto
-
+                            self.mark_attendance(worker_id, worker_name)
+                
                 # Draw rectangle and label
                 label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
                 cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
@@ -356,31 +351,34 @@ class AttendanceSystem:
     def _processing_loop(self, source):
         video_capture = cv2.VideoCapture(source)
         if not video_capture.isOpened():
-            err_msg = f"❌ **Error:** Could not open video source."
+            err_msg = f"❌ **Error:** Could not open video source. The file may be corrupt or in an unsupported format. Please try converting it to a standard MP4."
             self.error_message = err_msg
             self.is_processing.clear()
             return
             
+        # Set higher FPS if possible (for live camera)
         if isinstance(source, int):
             video_capture.set(cv2.CAP_PROP_FPS, 30)
             
         while self.is_processing.is_set():
             ret, frame = video_capture.read()
-            if not ret:
+            if not ret: 
                 break
                 
             processed_frame = self.process_frame(frame)
-            if processed_frame is not None and not self.frame_queue.full():
+            
+            if not self.frame_queue.full(): 
                 self.frame_queue.put(processed_frame)
                 
             self.last_processed_frame = processed_frame
+            time.sleep(0.01)  # Reduced sleep for faster processing
             
         self.final_log = self.session_log.copy()
         video_capture.release()
         self.is_processing.clear()
 
     def start_processing(self, source) -> str:
-        if self.is_processing.is_set():
+        if self.is_processing.is_set(): 
             return "⚠️ Processing is already active."
             
         # Reset states for new session
@@ -388,7 +386,6 @@ class AttendanceSystem:
         self.last_recognition_time.clear()
         self.today_attendance.clear()
         self.last_detected_faces.clear()
-        self.processed_workers.clear()
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
@@ -408,12 +405,11 @@ class AttendanceSystem:
         self.error_message = None
         self.last_processed_frame = None
         self.final_log = None
-        self.processed_workers.clear()
         return "✅ Processing stopped by user."
 
     # --- Helper & Reporting ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        if not HF_API_TOKEN:
+        if not HF_API_TOKEN: 
             return "Hugging Face API token not configured."
         try:
             buffered = BytesIO()
@@ -429,7 +425,7 @@ 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:
+        if not self.sf: 
             return None
         try:
             buffered = BytesIO()
@@ -441,22 +437,22 @@ class AttendanceSystem:
                 'VersionData': encoded_image,
                 'FirstPublishLocationId': record_id
             })
-            return f"/{cv['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:
+        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:
+            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:
+        except Exception as e: 
             return f"Error: {e}"
         
 # --- GRADIO UI ---
@@ -489,7 +485,6 @@ def create_interface():
                         video_output = gr.Image(label="Recognition Output", interactive=False)
                     with gr.Column(scale=1):
                         session_log_display = gr.Markdown(label="📋 Session Log", value="System is ready.")
-                        workers_summary = gr.Markdown(label="📋 Workers Processed", value="No workers processed yet.")
 
             with gr.Tab("👤 Worker Management"):
                 with gr.Row():
@@ -538,38 +533,31 @@ def create_interface():
         def update_ui_generator():
             while True:
                 if attendance_system.error_message:
-                    yield None, attendance_system.error_message, "No workers processed yet."
+                    yield None, attendance_system.error_message
                     time.sleep(2)
                     attendance_system.error_message = None
                     continue
                     
                 if attendance_system.is_processing.is_set():
-                    frame = None
+                    frame, log_md = None, "\n".join(reversed(attendance_system.session_log[-20:])) or "Processing..."
                     try:
                         if not attendance_system.frame_queue.empty():
                             frame = attendance_system.frame_queue.get_nowait()
-                            if frame is not None:
+                            if frame is not None: 
                                 frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    except queue.Empty:
+                    except queue.Empty: 
                         pass
-                    log_md = "\n".join(reversed(attendance_system.session_log[-20:])) or "Processing..."
-                    workers_md = f"**Workers Processed ({len(attendance_system.processed_workers)})**\n" + "\n".join(
-                        [f"- {log.split('] ')[1]}" for log in reversed(attendance_system.session_log[-20:]) if 'Marked Present' in log or 'Auto-registered' in log]
-                    ) if attendance_system.session_log else "No workers processed yet."
-                    yield frame, log_md, workers_md
+                    yield frame, log_md
                 else:
                     if attendance_system.last_processed_frame is not None:
                         final_frame = cv2.cvtColor(attendance_system.last_processed_frame, cv2.COLOR_BGR2RGB)
-                        final_log_md = "\n".join(reversed(attendance_system.final_log[-20:])) or "Processing complete."
-                        workers_md = f"**Workers Processed ({len(attendance_system.processed_workers)})**\n" + "\n".join(
-                            [f"- {log.split('] ')[1]}" for log in reversed(attendance_system.final_log[-20:]) if 'Marked Present' in log or 'Auto-registered' in log]
-                        ) if attendance_system.final_log else "No workers processed."
-                        yield final_frame, final_log_md, workers_md
+                        final_log_md = "\n".join(reversed(attendance_system.final_log[-20:])) or "Processing complete. No log entries."
+                        yield final_frame, final_log_md
                     else:
-                        yield None, "System stopped. Go to 'Controls & Status' to start.", "No workers processed yet."
-                time.sleep(0.03)
+                        yield None, "System stopped. Go to 'Controls & Status' to start."
+                time.sleep(0.05)  # Faster UI updates
 
-        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display, workers_summary])
+        demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
     return demo
 
 if __name__ == "__main__":