Update app.py

app.py

@@ -25,7 +25,7 @@ import tenacity
 
 # ========================== # Configuration and Setup # ==========================
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-logger = logging.getLogger(__name__)
+logger = logging.getLogger(_name_)
 
 def check_ffmpeg():
     try:
@@ -38,9 +38,9 @@ def check_ffmpeg():
 
 FFMPEG_AVAILABLE = check_ffmpeg()
 
-# ========================== # Improved ByteTrack Implementation # ==========================
+# ========================== # ByteTrack Implementation # ==========================
 class BYTETracker:
-    def __init__(self, track_thresh=0.3, track_buffer=90, match_thresh=0.5, frame_rate=30):
+    def _init_(self, track_thresh=0.3, track_buffer=90, match_thresh=0.3, frame_rate=30, max_distance=100):
         self.track_thresh = track_thresh
         self.track_buffer = track_buffer
         self.match_thresh = match_thresh
@@ -49,68 +49,70 @@ class BYTETracker:
         self.tracks = {}
         self.worker_history = {}
         self.last_positions = {}
-        self.recently_removed = {}
-        self.worker_centroids = {}  # Store average positions for each worker
-        self.violation_types = {}   # Track violation types per worker
+        self.recently_removed = {}  # Store recently removed tracks for re-identification
+        self.track_attributes = {}  # Store additional attributes like appearance features
+        self.active_workers = set()  # Track currently active workers
+        self.worker_violation_history = {}  # Track violations per worker
+        self.max_worker_distance = max_distance
 
     def update(self, dets, scores, cls):
         tracks = []
         current_time = time.time()
-       
+        
         # Prune stale tracks
         stale_ids = []
         for track_id, track_info in self.tracks.items():
             if current_time - track_info['last_seen'] > self.track_buffer / self.frame_rate:
                 stale_ids.append(track_id)
-       
+        
         for track_id in stale_ids:
-            # Store recently removed tracks for re-identification (for 1 second)
+            # Store recently removed tracks for re-identification (for 2 seconds)
             self.recently_removed[track_id] = {
                 'bbox': self.tracks[track_id]['bbox'],
                 'last_seen': current_time,
                 'last_position': self.last_positions.get(track_id, [0, 0]),
-                'violation_types': self.violation_types.get(track_id, set())
+                'appearance': self.track_attributes.get(track_id, {}).get('appearance', None)
             }
             del self.tracks[track_id]
             if track_id in self.worker_history:
                 del self.worker_history[track_id]
             if track_id in self.last_positions:
                 del self.last_positions[track_id]
-            # Keep the centroid and violation types for re-identification
-            # Don't delete from self.worker_centroids or self.violation_types
+            if track_id in self.active_workers:
+                self.active_workers.remove(track_id)
 
-        # Clean up recently_removed tracks older than 1 second
+        # Clean up recently_removed tracks older than 2 seconds
         to_remove = []
         for track_id, info in self.recently_removed.items():
-            if current_time - info['last_seen'] > 1.0:
+            if current_time - info['last_seen'] > 2.0:
                 to_remove.append(track_id)
         for track_id in to_remove:
             del self.recently_removed[track_id]
 
+        # Process new detections
+        active_tracks = {}
+        
         for i, (det, score, cl) in enumerate(zip(dets, scores, cls)):
             if score < self.track_thresh:
                 continue
-               
+                
             x, y, w, h = det
             matched = False
             best_iou = 0
             best_track_id = None
             
-            # Get current violation type
-            violation_type = CONFIG["VIOLATION_LABELS"].get(int(cl), "unknown")
-           
             # Try to match with active tracks
             for track_id, track_info in self.tracks.items():
                 tx, ty, tw, th = track_info['bbox']
                 iou = self._calculate_iou([x, y, w, h], [tx, ty, tw, th])
                 
-                # Check if this is the same worker based on position and size
                 if iou > self.match_thresh and iou > best_iou:
                     best_iou = iou
                     best_track_id = track_id
                     matched = True
-           
+            
             if matched:
+                # Update existing track
                 self.tracks[best_track_id].update({
                     'bbox': [x, y, w, h],
                     'score': score,
@@ -118,114 +120,123 @@ class BYTETracker:
                     'last_seen': current_time
                 })
                 
-                # Update position history
+                if 'appearance' not in self.track_attributes.get(best_track_id, {}):
+                    self.track_attributes[best_track_id] = {'appearance': self._extract_appearance_features([x, y, w, h])}
+                
                 if best_track_id not in self.worker_history:
                     self.worker_history[best_track_id] = []
-                self.worker_history[best_track_id].append([x, y])
-                self.last_positions[best_track_id] = [x, y]
                 
-                # Update worker centroid with exponential moving average
-                if best_track_id not in self.worker_centroids:
-                    self.worker_centroids[best_track_id] = [x, y]
-                else:
-                    self.worker_centroids[best_track_id][0] = 0.7 * self.worker_centroids[best_track_id][0] + 0.3 * x
-                    self.worker_centroids[best_track_id][1] = 0.7 * self.worker_centroids[best_track_id][1] + 0.3 * y
+                self.worker_history[best_track_id].append({'pos': [x, y], 'time': current_time})
+                
+                if len(self.worker_history[best_track_id]) > 30:
+                    self.worker_history[best_track_id] = self.worker_history[best_track_id][-30:]
+                
+                self.last_positions[best_track_id] = [x, y]
+                self.active_workers.add(best_track_id)
                 
-                # Update violation types for this worker
-                if best_track_id not in self.violation_types:
-                    self.violation_types[best_track_id] = set()
-                self.violation_types[best_track_id].add(violation_type)
+                if cl is not None:
+                    if best_track_id not in self.worker_violation_history:
+                        self.worker_violation_history[best_track_id] = set()
+                    self.worker_violation_history[best_track_id].add(int(cl))
                 
-                tracks.append({
+                active_tracks[best_track_id] = {
                     'id': best_track_id,
                     'bbox': [x, y, w, h],
                     'score': score,
                     'cls': cl
-                })
+                }
             else:
-                # Try to match with any known worker based on position
-                matched_worker = False
-                best_distance = float('inf')
-                best_worker_id = None
-                
-                # First check active tracks
-                for worker_id, centroid in self.worker_centroids.items():
-                    if worker_id in self.tracks:  # Only consider active tracks
-                        distance = self._calculate_distance([x, y], centroid)
-                        if distance < CONFIG["MAX_WORKER_DISTANCE"] and distance < best_distance:
-                            best_distance = distance
-                            best_worker_id = worker_id
-                            matched_worker = True
-                
-                # If no match in active tracks, try recently removed tracks
-                if not matched_worker:
-                    for track_id, info in self.recently_removed.items():
-                        if track_id in self.worker_centroids:
-                            distance = self._calculate_distance([x, y], self.worker_centroids[track_id])
-                            if distance < CONFIG["MAX_WORKER_DISTANCE"] and distance < best_distance:
-                                best_distance = distance
-                                best_worker_id = track_id
-                                matched_worker = True
+                # Try to re-identify with recently removed tracks
+                reidentified = False
+                for track_id, info in self.recently_removed.items():
+                    if self._is_same_worker([x, y], info['last_position']):
+                        self.tracks[track_id] = {
+                            'bbox': [x, y, w, h],
+                            'score': score,
+                            'cls': cl,
+                            'last_seen': current_time
+                        }
+                        if track_id not in self.worker_history:
+                            self.worker_history[track_id] = []
+                        self.worker_history[track_id].append({'pos': [x, y], 'time': current_time})
+                        self.last_positions[track_id] = [x, y]
+                        self.active_workers.add(track_id)
+                        
+                        if cl is not None:
+                            if track_id not in self.worker_violation_history:
+                                self.worker_violation_history[track_id] = set()
+                            self.worker_violation_history[track_id].add(int(cl))
+                        
+                        active_tracks[track_id] = {
+                            'id': track_id,
+                            'bbox': [x, y, w, h],
+                            'score': score,
+                            'cls': cl
+                        }
+                        reidentified = True
+                        del self.recently_removed[track_id]
+                        break
                 
-                if matched_worker:
-                    # Reuse the existing worker ID
-                    self.tracks[best_worker_id] = {
-                        'bbox': [x, y, w, h],
-                        'score': score,
-                        'cls': cl,
-                        'last_seen': current_time
-                    }
-                    
-                    if best_worker_id not in self.worker_history:
-                        self.worker_history[best_worker_id] = []
-                    self.worker_history[best_worker_id].append([x, y])
-                    self.last_positions[best_worker_id] = [x, y]
-                    
-                    # Update centroid
-                    if best_worker_id not in self.worker_centroids:
-                        self.worker_centroids[best_worker_id] = [x, y]
-                    else:
-                        self.worker_centroids[best_worker_id][0] = 0.7 * self.worker_centroids[best_worker_id][0] + 0.3 * x
-                        self.worker_centroids[best_worker_id][1] = 0.7 * self.worker_centroids[best_worker_id][1] + 0.3 * y
-                    
-                    # Update violation types
-                    if best_worker_id not in self.violation_types:
-                        self.violation_types[best_worker_id] = set()
-                    self.violation_types[best_worker_id].add(violation_type)
-                    
-                    # If it was in recently_removed, remove it from there
-                    if best_worker_id in self.recently_removed:
-                        del self.recently_removed[best_worker_id]
-                    
-                    tracks.append({
-                        'id': best_worker_id,
-                        'bbox': [x, y, w, h],
-                        'score': score,
-                        'cls': cl
-                    })
-                else:
-                    # Create a new worker ID
-                    new_id = self.next_id
-                    self.tracks[new_id] = {
-                        'bbox': [x, y, w, h],
-                        'score': score,
-                        'cls': cl,
-                        'last_seen': current_time
-                    }
-                    self.worker_history[new_id] = [[x, y]]
-                    self.last_positions[new_id] = [x, y]
-                    self.worker_centroids[new_id] = [x, y]
-                    self.violation_types[new_id] = {violation_type}
+                if not reidentified:
+                    # Try to match with last positions of existing tracks via distance
+                    same_worker = False
+                    for worker_id, last_pos in self.last_positions.items():
+                        if self._is_same_worker([x, y], last_pos):
+                            self.tracks[worker_id] = {
+                                'bbox': [x, y, w, h],
+                                'score': score,
+                                'cls': cl,
+                                'last_seen': current_time
+                            }
+                            
+                            if worker_id not in self.worker_history:
+                                self.worker_history[worker_id] = []
+                            self.worker_history[worker_id].append({'pos': [x, y], 'time': current_time})
+                            self.last_positions[worker_id] = [x, y]
+                            self.active_workers.add(worker_id)
+                            
+                            if cl is not None:
+                                if worker_id not in self.worker_violation_history:
+                                    self.worker_violation_history[worker_id] = set()
+                                self.worker_violation_history[worker_id].add(int(cl))
+                            
+                            active_tracks[worker_id] = {
+                                'id': worker_id,
+                                'bbox': [x, y, w, h],
+                                'score': score,
+                                'cls': cl
+                            }
+                            same_worker = True
+                            break
                     
-                    tracks.append({
-                        'id': new_id,
-                        'bbox': [x, y, w, h],
-                        'score': score,
-                        'cls': cl
-                    })
-                    self.next_id += 1
-       
-        return tracks
+                    if not same_worker:
+                        # Register a new track
+                        new_id = self.next_id
+                        self.tracks[new_id] = {
+                            'bbox': [x, y, w, h],
+                            'score': score,
+                            'cls': cl,
+                            'last_seen': current_time
+                        }
+                        self.track_attributes[new_id] = {'appearance': self._extract_appearance_features([x, y, w, h])}
+                        self.worker_history[new_id] = [{'pos': [x, y], 'time': current_time}]
+                        self.last_positions[new_id] = [x, y]
+                        self.active_workers.add(new_id)
+                        
+                        if cl is not None:
+                            if new_id not in self.worker_violation_history:
+                                self.worker_violation_history[new_id] = set()
+                            self.worker_violation_history[new_id].add(int(cl))
+                        
+                        active_tracks[new_id] = {
+                            'id': new_id,
+                            'bbox': [x, y, w, h],
+                            'score': score,
+                            'cls': cl
+                        }
+                        self.next_id += 1
+        
+        return list(active_tracks.values())
 
     def _calculate_iou(self, box1, box2):
         x1, y1, w1, h1 = box1
@@ -241,14 +252,26 @@ class BYTETracker:
         box2_area = w2 * h2
         iou = intersection_area / (box1_area + box2_area - intersection_area)
         return iou
-   
-    def _calculate_distance(self, pos1, pos2):
+    
+    def _is_same_worker(self, pos1, pos2):
         x1, y1 = pos1
         x2, y2 = pos2
-        return np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
-   
-    def _is_same_worker(self, pos1, pos2, threshold=150):
-        return self._calculate_distance(pos1, pos2) < threshold
+        distance = np.sqrt((x1 - x2)*2 + (y1 - y2)*2)
+        return distance < self.max_worker_distance
+    
+    def _extract_appearance_features(self, bbox):
+        """Simple appearance feature extraction (placeholder)"""
+        _, _, w, h = bbox
+        return [w, h, w/h]
+    
+    def get_active_worker_count(self):
+        return len(self.active_workers)
+    
+    def get_worker_violation_types(self, worker_id):
+        return self.worker_violation_history.get(worker_id, set())
+    
+    def get_all_workers(self):
+        return set(list(self.tracks.keys()) + list(self.recently_removed.keys()))
 
 # ========================== # Optimized Configuration # ==========================
 CONFIG = {
@@ -293,14 +316,14 @@ CONFIG = {
     "VIOLATION_COOLDOWN": 30.0,
     "WORKER_TRACKING_DURATION": 10.0,
     "MAX_PROCESSING_TIME": 60,
-    "FRAME_SKIP": 2,  # Increased to improve performance
-    "BATCH_SIZE": 20,  # Increased for better throughput
+    "FRAME_SKIP": 1,
+    "BATCH_SIZE": 15,
     "PARALLEL_WORKERS": max(1, cpu_count() - 1),
-    "TRACK_BUFFER": 150,
+    "TRACK_BUFFER": 150,  # 5.0 seconds at 30 fps
     "TRACK_THRESH": 0.3,
-    "MATCH_THRESH": 0.5,
+    "MATCH_THRESH": 0.3,
     "SNAPSHOT_QUALITY": 95,
-    "MAX_WORKER_DISTANCE": 150,
+    "MAX_WORKER_DISTANCE": 100,
     "TARGET_RESOLUTION": (384, 384)
 }
 
@@ -318,7 +341,7 @@ def load_model():
             if not os.path.isfile(model_path):
                 logger.info(f"Downloading fallback model: {model_path}")
                 torch.hub.download_url_to_file('https://github.com/ultralytics/assets/releases/download/v8.3.0/yolov8n.pt', model_path)
-               
+                
         model = YOLO(model_path).to(device)
         if device.type == "cuda":
             model.model.half()
@@ -339,7 +362,7 @@ def preprocess_frame(frame):
 
 def draw_detections(frame, detections):
     result_frame = frame.copy()
-   
+    
     for det in detections:
         label = det.get("violation", "Unknown")
         confidence = det.get("confidence", 0.0)
@@ -350,19 +373,19 @@ def draw_detections(frame, detections):
         y1 = int(y - h/2)
         x2 = int(x + w/2)
         y2 = int(y + h/2)
-       
+        
         color = CONFIG["CLASS_COLORS"].get(label, (0, 0, 255))
-       
+        
         cv2.rectangle(result_frame, (x1, y1), (x2, y2), color, 3)
-       
+        
         display_text = f"{CONFIG['DISPLAY_NAMES'].get(label, label)} (Worker {worker_id})"
         text_size = cv2.getTextSize(display_text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
         cv2.rectangle(result_frame, (x1, y1-text_size[1]-10), (x1+text_size[0]+10, y1), (0, 0, 0), -1)
         cv2.putText(result_frame, display_text, (x1+5, y1-5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-       
+        
         conf_text = f"Conf: {confidence:.2f}"
         cv2.putText(result_frame, conf_text, (x1+5, y2+20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
-       
+        
     return result_frame
 
 def calculate_safety_score(violations):
@@ -548,7 +571,7 @@ def push_report_to_salesforce(violations, score, pdf_path, pdf_file):
             uploaded_url = upload_pdf_to_salesforce(sf, pdf_file, record_id)
             if uploaded_url:
                 try:
-                    sf.Safety_Video_Report__c.update(record_id, {"PDF_Report_URL__c": uploaded_url})
+                    sf.Safety_Video_Report_c.update(record_id, {"PDF_Report_URL_c": uploaded_url})
                     logger.info(f"Updated record {record_id} with PDF URL: {uploaded_url}")
                 except Exception as e:
                     logger.error(f"Failed to update Safety_Video_Report__c: {e}")
@@ -589,11 +612,11 @@ def process_video(video_data, temp_dir):
     output_dir = os.path.join(temp_dir, "output")
     os.makedirs(output_dir, exist_ok=True)
     os.environ['YOLO_CONFIG_DIR'] = temp_dir
-   
+    
     try:
         if not video_data:
             raise ValueError("Empty video data provided.")
-       
+        
         logger.info(f"Received video data size: {len(video_data)} bytes")
         if len(video_data) == 0:
             raise ValueError("Video data is empty.")
@@ -628,30 +651,34 @@ def process_video(video_data, temp_dir):
             track_thresh=CONFIG["TRACK_THRESH"],
             track_buffer=CONFIG["TRACK_BUFFER"],
             match_thresh=CONFIG["MATCH_THRESH"],
-            frame_rate=fps
+            frame_rate=fps,
+            max_distance=CONFIG["MAX_WORKER_DISTANCE"]
         )
 
         unique_violations = {}
         violation_frames = {}
-        worker_violation_count = {}
+        violation_confidences = {}
         start_time = time.time()
         frame_skip = CONFIG["FRAME_SKIP"]
         processed_frames = 0
         last_yield_time = start_time
         
-        # Pre-allocate memory for batch processing
-        batch_size = CONFIG["BATCH_SIZE"]
-        batch_frames = []
-        batch_indices = []
+        logger.info("First pass: Worker detection and tracking")
+        all_workers = set()
+        worker_first_seen = {}
+        worker_last_seen = {}
         
-        # Process frames in batches for better performance
         while processed_frames < total_frames:
-            # Clear previous batch
             batch_frames = []
             batch_indices = []
+            batch_timestamps = []
             
-            # Fill the batch
-            for _ in range(batch_size):
+            for _ in range(CONFIG["BATCH_SIZE"]):
+                # Skip frames BEFORE reading to speed up
+                for _ in range(frame_skip - 1):
+                    if not cap.grab():
+                        break
+                
                 frame_idx = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
                 if frame_idx >= total_frames:
                     break
@@ -661,58 +688,45 @@ def process_video(video_data, temp_dir):
                     logger.warning(f"Failed to read frame {frame_idx}. Skipping.")
                     break
                 
-                # Preprocess frame (resize and enhance)
                 frame = preprocess_frame(frame)
-                
-                # Skip frames for performance
-                for _ in range(frame_skip - 1):
-                    if not cap.grab():
-                        break
+                timestamp = frame_idx / fps
                 
                 batch_frames.append(frame)
                 batch_indices.append(frame_idx)
+                batch_timestamps.append(timestamp)
                 processed_frames += 1
 
             if not batch_frames:
                 logger.info("No more frames to process.")
                 break
 
-            # Update progress
-            current_time = time.time()
-            if current_time - last_yield_time > 0.1:
-                progress = (processed_frames / total_frames) * 100
-                elapsed_time = current_time - start_time
-                fps_processed = processed_frames / elapsed_time if elapsed_time > 0 else 0
-                yield f"Processing video... {progress:.1f}% complete (Frame {processed_frames}/{total_frames}, {fps_processed:.1f} FPS)", "", "", "", ""
-                last_yield_time = current_time
-
             try:
-                # Convert batch to tensor for efficient processing
                 batch_frames_np = np.array(batch_frames)
                 batch_frames_tensor = torch.from_numpy(batch_frames_np).permute(0, 3, 1, 2).float() / 255.0
                 batch_frames_tensor = batch_frames_tensor.to(device)
                 if device.type == "cuda":
                     batch_frames_tensor = batch_frames_tensor.half()
 
-                # Run inference on batch
                 results = model(batch_frames_tensor, device=device, conf=0.1, verbose=False)
             except Exception as e:
                 logger.error(f"Model inference failed: {e}")
                 raise ValueError(f"Failed to process video frames with YOLO model: {str(e)}")
             finally:
-                # Clear memory
-                batch_frames = []
                 if device.type == "cuda":
                     torch.cuda.empty_cache()
 
-            # Process results for each frame in the batch
-            for i, (result, frame_idx) in enumerate(zip(results, batch_indices)):
-                current_time = frame_idx / fps
-                
+            current_time = time.time()
+            if current_time - last_yield_time > 0.1:
+                progress = (processed_frames / total_frames) * 100
+                elapsed_time = current_time - start_time
+                fps_processed = processed_frames / elapsed_time if elapsed_time > 0 else 0
+                yield f"Processing video... {progress:.1f}% complete (Frame {processed_frames}/{total_frames}, {fps_processed:.1f} FPS)", "", "", "", ""
+                last_yield_time = current_time
+
+            for i, (result, frame_idx, timestamp) in enumerate(zip(results, batch_indices, batch_timestamps)):
                 boxes = result.boxes
                 track_inputs = []
                 
-                # Prepare detection inputs for tracker
                 for box in boxes:
                     cls = int(box.cls)
                     conf = float(box.conf)
@@ -733,87 +747,48 @@ def process_video(video_data, temp_dir):
 
                 if not track_inputs:
                     continue
-                
-                # Update tracker with new detections
+                    
                 tracked_objects = tracker.update(
                     np.array([t["bbox"] for t in track_inputs]),
                     np.array([t["conf"] for t in track_inputs]),
                     np.array([t["cls"] for t in track_inputs])
                 )
                 
-                # Process tracked objects
                 for obj in tracked_objects:
                     tracker_id = obj['id']
+                    all_workers.add(tracker_id)
+                    
+                    if tracker_id not in worker_first_seen:
+                        worker_first_seen[tracker_id] = timestamp
+                    worker_last_seen[tracker_id] = timestamp
+                    
                     label = CONFIG["VIOLATION_LABELS"].get(int(obj['cls']), None)
                     conf = obj['score']
-                    bbox = obj['bbox']
                     
                     if label is None:
                         continue
                     
-                    worker_id = tracker_id
-                    violation_key = (worker_id, label)
+                    violation_key = (tracker_id, label)
                     
-                    # Record unique violations
-                    if violation_key not in unique_violations:
-                        unique_violations[violation_key] = current_time
+                    if violation_key not in unique_violations or conf > violation_confidences.get(violation_key, 0.0):
+                        unique_violations[violation_key] = timestamp
                         violation_frames[violation_key] = frame_idx
-                        
-                        # Update violation count for this worker
-                        if worker_id not in worker_violation_count:
-                            worker_violation_count[worker_id] = 0
-                        worker_violation_count[worker_id] += 1
+                        violation_confidences[violation_key] = conf
 
         cap.release()
         processing_time = time.time() - start_time
         logger.info(f"Processing complete in {processing_time:.2f}s")
-        logger.info(f"Total unique workers detected: {len(tracker.worker_centroids)}")
-        logger.info(f"Violations per worker: {worker_violation_count}")
-
-        # Consolidate workers based on spatial proximity
-        consolidated_workers = {}
-        processed_workers = set()
         
-        # Sort worker IDs to ensure deterministic consolidation
-        worker_ids = sorted(tracker.worker_centroids.keys())
-        
-        for i, worker_id in enumerate(worker_ids):
-            if worker_id in processed_workers:
-                continue
-                
-            processed_workers.add(worker_id)
-            consolidated_workers[worker_id] = [worker_id]
-            
-            for j, other_id in enumerate(worker_ids):
-                if i == j or other_id in processed_workers:
-                    continue
-                    
-                # Check if workers are close enough to be considered the same person
-                if worker_id in tracker.worker_centroids and other_id in tracker.worker_centroids:
-                    distance = tracker._calculate_distance(
-                        tracker.worker_centroids[worker_id],
-                        tracker.worker_centroids[other_id]
-                    )
-                    
-                    if distance < CONFIG["MAX_WORKER_DISTANCE"] * 0.8:  # More strict for consolidation
-                        consolidated_workers[worker_id].append(other_id)
-                        processed_workers.add(other_id)
-        
-        # Create a mapping from old worker IDs to new consolidated IDs
-        worker_id_mapping = {}
-        for new_id, old_ids in enumerate(consolidated_workers.values(), 1):
-            for old_id in old_ids:
-                worker_id_mapping[old_id] = new_id
-        
-        # Update violations with consolidated worker IDs
+        total_workers = len(all_workers)
+        logger.info(f"Total unique workers detected: {total_workers}")
+
         violations = []
         for (worker_id, label), detection_time in unique_violations.items():
-            new_worker_id = worker_id_mapping.get(worker_id, worker_id)
             violations.append({
-                "worker_id": new_worker_id,
+                "worker_id": worker_id,
                 "violation": label,
                 "timestamp": detection_time,
-                "confidence": 0.0,
+                "confidence": violation_confidences.get((worker_id, label), 0.0),
                 "frame_idx": violation_frames[(worker_id, label)]
             })
 
@@ -822,7 +797,6 @@ def process_video(video_data, temp_dir):
             yield "No violations detected in the video.", "Safety Score: 100%", "No snapshots captured.", "N/A", "N/A"
             return
 
-        # Generate snapshots for each violation
         snapshots = []
         cap = cv2.VideoCapture(video_path)
         for violation in violations:
@@ -867,7 +841,7 @@ def process_video(video_data, temp_dir):
                         (255, 255, 255),
                         2
                     )
-                    snapshot_filename = f"violation_{label}_worker{violation['worker_id']}_{int(violation['timestamp']*100)}.jpg"
+                    snapshot_filename = f"violation_{label}worker{violation['worker_id']}{int(violation['timestamp']*100)}.jpg"
                     snapshot_path = os.path.join(output_dir, snapshot_filename)
                     cv2.imwrite(
                         snapshot_path,
@@ -889,40 +863,28 @@ def process_video(video_data, temp_dir):
 
         score = calculate_safety_score(violations)
         pdf_path, pdf_url, pdf_file = generate_violation_pdf(violations, score, output_dir)
-       
+        
         record_id, final_pdf_url = push_report_to_salesforce(violations, score, pdf_path, pdf_file)
 
-        # Generate summary of workers and their violations
-        worker_summary = {}
+        worker_violations = {}
         for v in violations:
-            worker_id = v["worker_id"]
-            if worker_id not in worker_summary:
-                worker_summary[worker_id] = {
-                    "count": 0,
-                    "violations": set()
-                }
-            worker_summary[worker_id]["count"] += 1
-            worker_summary[worker_id]["violations"].add(v["violation"])
-
-        # Create violation table with worker summary
-        violation_table = "## Worker Safety Violation Summary\n\n"
-        violation_table += "| Worker ID | Total Violations | Violation Types |\n"
-        violation_table += "|-----------|------------------|-----------------|\n"
-        
-        for worker_id, info in worker_summary.items():
-            violation_types = ", ".join([CONFIG["DISPLAY_NAMES"].get(v, v) for v in info["violations"]])
-            violation_table += f"| {worker_id} | {info['count']} | {violation_types} |\n"
+            worker_id = v.get("worker_id", "Unknown")
+            if worker_id not in worker_violations:
+                worker_violations[worker_id] = []
+            worker_violations[worker_id].append(v)
         
-        violation_table += "\n## Detailed Violation Log\n\n"
-        violation_table += "| Violation | Worker ID | Time (s) | Confidence |\n"
+        violation_table = f"## Total Workers Detected: {total_workers}\n\n"
+        violation_table += "| Worker ID | Violation | Time (s) | Confidence |\n"
         violation_table += "|-----------|-----------|----------|------------|\n"
-       
-        for v in sorted(violations, key=lambda x: (x.get("worker_id", "Unknown"), x.get("timestamp", 0.0))):
-            display_name = CONFIG["DISPLAY_NAMES"].get(v.get("violation", "Unknown"), "Unknown")
-            worker_id = v.get("worker_id", "Unknown")
-            timestamp = v.get("timestamp", 0.0)
-            confidence = v.get("confidence", 0.0)
-            violation_table += f"| {display_name} | {worker_id} | {timestamp:.2f} | {confidence:.2f} |\n"
+        
+        for worker_id, vios in sorted(worker_violations.items()):
+            vios.sort(key=lambda x: x.get("violation", ""))
+            
+            for v in vios:
+                display_name = CONFIG["DISPLAY_NAMES"].get(v.get("violation", "Unknown"), "Unknown")
+                timestamp = v.get("timestamp", 0.0)
+                confidence = v.get("confidence", 0.0)
+                violation_table += f"| {worker_id} | {display_name} | {timestamp:.2f} | {confidence:.2f} |\n"
 
         snapshots_text = ""
         for s in snapshots:
@@ -937,7 +899,7 @@ def process_video(video_data, temp_dir):
 
         yield (
             violation_table,
-            f"Safety Score: {score}%",
+            f"Safety Score: {score}% (Based on {total_workers} workers)",
             snapshots_text,
             f"Salesforce Record ID: {record_id}",
             final_pdf_url
@@ -962,14 +924,14 @@ def gradio_interface(video_file):
     try:
         if not video_file:
             return "No file uploaded.", "", "No file uploaded.", "", ""
-       
+        
         temp_dir = tempfile.mkdtemp(prefix="Ultralytics_")
         logger.info(f"Created temporary directory for video processing: {temp_dir}")
 
         with open(video_file, "rb") as f:
             video_data = f.read()
         logger.info(f"Read Gradio video file: {video_file}, size: {len(video_data)} bytes")
-       
+        
         if len(video_data) == 0:
             return "Uploaded video file is empty.", "", "", "", ""
 
@@ -984,7 +946,7 @@ def gradio_interface(video_file):
 
         for status, score, snapshots_text, record_id, details_url in process_video(video_data, temp_dir):
             yield status, score, snapshots_text, record_id, details_url
-           
+            
     except Exception as e:
         logger.error(f"Error in Gradio interface: {e}", exc_info=True)
         yield f"Error: {str(e)}", "", "Error in processing.", "", ""
@@ -995,7 +957,7 @@ def gradio_interface(video_file):
                 logger.info(f"Cleaned up local temporary video file: {local_video_path}")
             except Exception as e:
                 logger.error(f"Failed to clean up local temporary video file {local_video_path}: {e}")
-       
+        
         if temp_dir and os.path.exists(temp_dir):
             shutil.rmtree(temp_dir, ignore_errors=True)
             logger.info(f"Cleaned up temporary directory: {temp_dir}")
@@ -1014,10 +976,10 @@ interface = gr.Interface(
         gr.Textbox(label="Violation Details URL")
     ],
     title="Worksite Safety Violation Analyzer",
-    description="Upload site videos to detect safety violations (No Helmet, No Harness, Unsafe Posture, Unsafe Zone, Improper Tool Use). Each unique violation is detected only once per worker.",
+    description="Upload site videos to detect safety violations (No Helmet, No Harness, Unsafe Posture, Unsafe Zone, Improper Tool Use). The system tracks individual workers and their specific violations.",
     allow_flagging="never"
 )
 
-if __name__ == "__main__":
+if _name_ == "_main_":
     logger.info("Launching Enhanced Safety Analyzer App...")
     interface.launch()