Update app.py

app.py

@@ -38,7 +38,7 @@ def check_ffmpeg():
 
 FFMPEG_AVAILABLE = check_ffmpeg()
 
-# ========================== # ByteTrack Implementation # ==========================
+# ========================== # Improved ByteTrack Implementation # ==========================
 class BYTETracker:
     def __init__(self, track_thresh=0.3, track_buffer=90, match_thresh=0.5, frame_rate=30):
         self.track_thresh = track_thresh
@@ -49,10 +49,9 @@ class BYTETracker:
         self.tracks = {}
         self.worker_history = {}
         self.last_positions = {}
-        self.recently_removed = {}  # Store recently removed tracks for re-identification
-        self.appearance_features = {}  # Store appearance features for better re-identification
-        self.track_continuity = {}  # Track temporal continuity
-        self.similarity_threshold = 0.75  # Higher threshold for appearance similarity
+        self.recently_removed = {}
+        self.worker_centroids = {}  # Store average positions for each worker
+        self.violation_types = {}   # Track violation types per worker
 
     def update(self, dets, scores, cls):
         tracks = []
@@ -65,69 +64,49 @@ class BYTETracker:
                 stale_ids.append(track_id)
        
         for track_id in stale_ids:
-            # Store recently removed tracks for re-identification (for 1.5 seconds)
+            # Store recently removed tracks for re-identification (for 1 second)
             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]),
-                'appearance': self.appearance_features.get(track_id, None),
-                'cls': self.tracks[track_id].get('cls', None)
+                'violation_types': self.violation_types.get(track_id, set())
             }
             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
 
-        # Clean up recently_removed tracks older than 1.5 seconds
+        # Clean up recently_removed tracks older than 1 second
         to_remove = []
         for track_id, info in self.recently_removed.items():
-            if current_time - info['last_seen'] > 1.5:
+            if current_time - info['last_seen'] > 1.0:
                 to_remove.append(track_id)
         for track_id in to_remove:
             del self.recently_removed[track_id]
-        
-        # Sort detections by score for high-confidence-first association
-        detection_indices = np.argsort(-np.array(scores))
-        
-        assigned_tracks = set()
-        matched_detections = set()
 
-        for i in detection_indices:
-            if i >= len(dets) or scores[i] < self.track_thresh:
+        for i, (det, score, cl) in enumerate(zip(dets, scores, cls)):
+            if score < self.track_thresh:
                 continue
-                
-            det, score, cl = dets[i], scores[i], cls[i]
+               
             x, y, w, h = det
-            
-            # Skip if this detection was already matched
-            if i in matched_detections:
-                continue
-                
             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():
-                # Skip if this track was already assigned in this frame
-                if track_id in assigned_tracks:
-                    continue
-                    
                 tx, ty, tw, th = track_info['bbox']
                 iou = self._calculate_iou([x, y, w, h], [tx, ty, tw, th])
                 
-                # If similar class and good IOU, consider a match
-                is_same_class = track_info.get('cls', None) == cl
-                position_match = self._is_same_worker([x, y], self.last_positions.get(track_id, [0, 0]), threshold=120)
-                
-                # Combined matching score with class consistency
-                match_score = iou
-                if is_same_class:
-                    match_score += 0.2  # Bonus for same class
-                
-                if position_match and match_score > self.match_thresh and match_score > best_iou:
-                    best_iou = match_score
+                # 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
            
@@ -139,33 +118,24 @@ class BYTETracker:
                     'last_seen': current_time
                 })
                 
-                # Update appearance feature with exponential moving average
-                if best_track_id not in self.appearance_features:
-                    self.appearance_features[best_track_id] = np.array([x, y, w, h, cl])
-                else:
-                    alpha = 0.7  # Weight for historical data
-                    current_feature = np.array([x, y, w, h, cl])
-                    self.appearance_features[best_track_id] = alpha * self.appearance_features[best_track_id] + (1-alpha) * current_feature
-                
+                # Update position history
                 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 position history with trajectory smoothing
-                if len(self.worker_history[best_track_id]) > 0:
-                    last_x, last_y = self.worker_history[best_track_id][-1]
-                    # Apply slight smoothing to reduce jitter
-                    smooth_x = 0.8 * x + 0.2 * last_x
-                    smooth_y = 0.8 * y + 0.2 * last_y
-                    self.worker_history[best_track_id].append([smooth_x, smooth_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_history[best_track_id].append([x, y])
+                    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.last_positions[best_track_id] = [x, y]
+                # 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)
                 
-                # Mark as assigned
-                assigned_tracks.add(best_track_id)
-                matched_detections.add(i)
-               
                 tracks.append({
                     'id': best_track_id,
                     'bbox': [x, y, w, h],
@@ -173,124 +143,87 @@ class BYTETracker:
                     'cls': cl
                 })
             else:
-                # Try to re-identify with recently removed tracks
-                reidentified = False
-                for track_id, info in self.recently_removed.items():
-                    appearance_match = False
-                    if info['appearance'] is not None:
-                        appearance_similarity = self._compute_appearance_similarity(
-                            np.array([x, y, w, h, cl]), 
-                            info['appearance']
-                        )
-                        appearance_match = appearance_similarity > self.similarity_threshold
+                # 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
+                
+                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
+                    }
                     
-                    position_match = self._is_same_worker([x, y], info['last_position'], threshold=120)
+                    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]
                     
-                    # Enhanced re-identification using both position and appearance
-                    if position_match or appearance_match:
-                        self.tracks[track_id] = {
-                            'bbox': [x, y, w, h],
-                            'score': score,
-                            'cls': cl,
-                            'last_seen': current_time
-                        }
-                        
-                        # Update appearance feature
-                        if track_id in self.appearance_features:
-                            alpha = 0.7  # Weight for historical data
-                            current_feature = np.array([x, y, w, h, cl])
-                            self.appearance_features[track_id] = alpha * self.appearance_features[track_id] + (1-alpha) * current_feature
-                        else:
-                            self.appearance_features[track_id] = np.array([x, y, w, h, cl])
-                        
-                        if track_id not in self.worker_history:
-                            self.worker_history[track_id] = []
-                        self.worker_history[track_id].append([x, y])
-                        self.last_positions[track_id] = [x, y]
-                        
-                        # Mark as assigned
-                        assigned_tracks.add(track_id)
-                        matched_detections.add(i)
-                        
-                        tracks.append({
-                            'id': track_id,
-                            'bbox': [x, y, w, h],
-                            'score': score,
-                            'cls': cl
-                        })
-                        reidentified = True
-                        del self.recently_removed[track_id]
-                        break
-               
-                if not reidentified:
-                    # Check if it matches an existing worker by position
-                    same_worker = False
-                    for worker_id, last_pos in self.last_positions.items():
-                        # Skip if this track was already assigned in this frame
-                        if worker_id in assigned_tracks:
-                            continue
-                            
-                        if self._is_same_worker([x, y], last_pos, threshold=120):
-                            self.tracks[worker_id] = {
-                                'bbox': [x, y, w, h],
-                                'score': score,
-                                'cls': cl,
-                                'last_seen': current_time
-                            }
-                            
-                            # Update appearance feature
-                            if worker_id in self.appearance_features:
-                                alpha = 0.7  # Weight for historical data
-                                current_feature = np.array([x, y, w, h, cl])
-                                self.appearance_features[worker_id] = alpha * self.appearance_features[worker_id] + (1-alpha) * current_feature
-                            else:
-                                self.appearance_features[worker_id] = np.array([x, y, w, h, cl])
-                            
-                            # Mark as assigned
-                            assigned_tracks.add(worker_id)
-                            matched_detections.add(i)
-                            
-                            tracks.append({
-                                'id': worker_id,
-                                'bbox': [x, y, w, h],
-                                'score': score,
-                                'cls': cl
-                            })
-                            same_worker = True
-                            break
-                   
-                    if not same_worker:
-                        # Create new track only if it doesn't overlap significantly with existing tracks
-                        should_create_new = True
-                        for track_id in self.tracks:
-                            tx, ty, tw, th = self.tracks[track_id]['bbox']
-                            overlap = self._calculate_iou([x, y, w, h], [tx, ty, tw, th])
-                            if overlap > 0.1:  # If significant overlap, don't create new track
-                                should_create_new = False
-                                break
-                                
-                        if should_create_new:
-                            self.tracks[self.next_id] = {
-                                'bbox': [x, y, w, h],
-                                'score': score,
-                                'cls': cl,
-                                'last_seen': current_time
-                            }
-                            self.appearance_features[self.next_id] = np.array([x, y, w, h, cl])
-                            self.worker_history[self.next_id] = [[x, y]]
-                            self.last_positions[self.next_id] = [x, y]
-                            
-                            # Mark as assigned
-                            assigned_tracks.add(self.next_id)
-                            matched_detections.add(i)
-                            
-                            tracks.append({
-                                'id': self.next_id,
-                                'bbox': [x, y, w, h],
-                                'score': score,
-                                'cls': cl
-                            })
-                            self.next_id += 1
+                    # 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}
+                    
+                    tracks.append({
+                        'id': new_id,
+                        'bbox': [x, y, w, h],
+                        'score': score,
+                        'cls': cl
+                    })
+                    self.next_id += 1
        
         return tracks
 
@@ -309,32 +242,13 @@ class BYTETracker:
         iou = intersection_area / (box1_area + box2_area - intersection_area)
         return iou
    
-    def _is_same_worker(self, pos1, pos2, threshold=120):
+    def _calculate_distance(self, pos1, pos2):
         x1, y1 = pos1
         x2, y2 = pos2
-        distance = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
-        return distance < threshold
-    
-    def _compute_appearance_similarity(self, feature1, feature2):
-        # Compute normalized cosine similarity between appearance features
-        # We weight position/size and class differently
-        pos_size1 = feature1[:4]
-        pos_size2 = feature2[:4]
-        
-        # Normalize to unit vectors
-        pos_size1_norm = np.linalg.norm(pos_size1)
-        pos_size2_norm = np.linalg.norm(pos_size2)
-        
-        if pos_size1_norm == 0 or pos_size2_norm == 0:
-            pos_similarity = 0
-        else:
-            pos_similarity = np.dot(pos_size1, pos_size2) / (pos_size1_norm * pos_size2_norm)
-        
-        # Class similarity (1 if same, 0 if different)
-        class_similarity = 1.0 if feature1[4] == feature2[4] else 0.0
-        
-        # Combined similarity (weighted more toward position)
-        return 0.7 * pos_similarity + 0.3 * class_similarity
+        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
 
 # ========================== # Optimized Configuration # ==========================
 CONFIG = {
@@ -377,18 +291,17 @@ CONFIG = {
     },
     "MIN_VIOLATION_FRAMES": 1,
     "VIOLATION_COOLDOWN": 30.0,
-    "WORKER_TRACKING_DURATION": 5.0,
+    "WORKER_TRACKING_DURATION": 10.0,
     "MAX_PROCESSING_TIME": 60,
-    "FRAME_SKIP": 2,  # Skip more frames for faster processing
-    "BATCH_SIZE": 8,  # Increased batch size for better throughput
+    "FRAME_SKIP": 2,  # Increased to improve performance
+    "BATCH_SIZE": 8,  # Increased for better throughput
     "PARALLEL_WORKERS": max(1, cpu_count() - 1),
-    "TRACK_BUFFER": 90,  # 3.0 seconds at 30 fps
+    "TRACK_BUFFER": 150,
     "TRACK_THRESH": 0.3,
     "MATCH_THRESH": 0.5,
     "SNAPSHOT_QUALITY": 95,
-    "MAX_WORKER_DISTANCE": 120,
-    "TARGET_RESOLUTION": (384, 384),  # Smaller resolution for faster processing
-    "MAX_WORKERS": 5  # Maximum number of unique workers to track
+    "MAX_WORKER_DISTANCE": 150,
+    "TARGET_RESOLUTION": (384, 384)
 }
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
@@ -419,12 +332,9 @@ model = load_model()
 
 # ========================== # Helper Functions # ==========================
 def preprocess_frame(frame):
-    # Faster preprocessing with simpler operations
     target_res = CONFIG["TARGET_RESOLUTION"]
-    if frame.shape[0] != target_res[1] or frame.shape[1] != target_res[0]:
-        frame = cv2.resize(frame, target_res, interpolation=cv2.INTER_AREA)
-    # Simple contrast enhancement
-    frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=10)
+    frame = cv2.resize(frame, target_res, interpolation=cv2.INTER_LINEAR)
+    frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=20)
     return frame
 
 def draw_detections(frame, detections):
@@ -674,49 +584,6 @@ def verify_and_open_video(video_path):
    
     return cap
 
-def process_frames_batch(batch_data, model_path, device_type):
-    try:
-        batch_frames, batch_indices = batch_data
-        
-        # Load model in this process
-        local_model = YOLO(model_path)
-        if device_type == "cuda":
-            local_model = local_model.to("cuda")
-            local_model.model.half()
-        
-        # Process batch
-        batch_frames_np = np.array(batch_frames)
-        batch_frames_tensor = torch.from_numpy(batch_frames_np).permute(0, 3, 1, 2).float() / 255.0
-        
-        if device_type == "cuda":
-            batch_frames_tensor = batch_frames_tensor.to("cuda").half()
-        
-        results = local_model(batch_frames_tensor, conf=0.1, verbose=False)
-        
-        # Format results
-        processed_results = []
-        for i, (result, frame_idx) in enumerate(zip(results, batch_indices)):
-            boxes = result.boxes
-            detections = []
-            for box in boxes:
-                cls = int(box.cls)
-                conf = float(box.conf)
-                bbox = box.xywh.cpu().numpy()[0]
-                detections.append({
-                    "cls": cls,
-                    "conf": conf,
-                    "bbox": bbox
-                })
-            processed_results.append((frame_idx, detections))
-        
-        if device_type == "cuda":
-            torch.cuda.empty_cache()
-            
-        return processed_results
-    except Exception as e:
-        logger.error(f"Error in process_frames_batch: {e}")
-        return []
-
 def process_video(video_data, temp_dir):
     video_path = None
     output_dir = os.path.join(temp_dir, "output")
@@ -764,41 +631,44 @@ def process_video(video_data, temp_dir):
             frame_rate=fps
         )
 
-        # Force single worker for all violations (fixes the issue mentioned by the user)
-        worker_id_mapping = {}
-        next_worker_id = 1
-        
         unique_violations = {}
         violation_frames = {}
-        worker_violation_count = {}  # Track violation count per worker
+        worker_violation_count = {}
         start_time = time.time()
         frame_skip = CONFIG["FRAME_SKIP"]
         processed_frames = 0
         last_yield_time = start_time
-
-        # Process frames faster with optimized batching
+        
+        # Pre-allocate memory for batch processing
+        batch_size = CONFIG["BATCH_SIZE"]
+        batch_frames = []
+        batch_indices = []
+        
+        # Process frames in batches for better performance
         while processed_frames < total_frames:
+            # Clear previous batch
             batch_frames = []
             batch_indices = []
-           
-            # Create batch
-            for _ in range(CONFIG["BATCH_SIZE"]):
+            
+            # Fill the batch
+            for _ in range(batch_size):
                 frame_idx = int(cap.get(cv2.CAP_PROP_POS_FRAMES))
                 if frame_idx >= total_frames:
                     break
-               
+                
                 ret, frame = cap.read()
                 if not ret:
                     logger.warning(f"Failed to read frame {frame_idx}. Skipping.")
                     break
-               
+                
+                # Preprocess frame (resize and enhance)
                 frame = preprocess_frame(frame)
-               
-                # Skip frames to speed up processing
+                
+                # Skip frames for performance
                 for _ in range(frame_skip - 1):
                     if not cap.grab():
                         break
-               
+                
                 batch_frames.append(frame)
                 batch_indices.append(frame_idx)
                 processed_frames += 1
@@ -807,47 +677,50 @@ def process_video(video_data, temp_dir):
                 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:
-                # Fast batch processing using GPU
+                # 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()
 
-            # 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
-
-            # Process results and update tracker
+            # Process results for each frame in the batch
             for i, (result, frame_idx) in enumerate(zip(results, batch_indices)):
                 current_time = frame_idx / fps
-               
+                
                 boxes = result.boxes
                 track_inputs = []
-               
+                
+                # Prepare detection inputs for tracker
                 for box in boxes:
                     cls = int(box.cls)
                     conf = float(box.conf)
                     label = CONFIG["VIOLATION_LABELS"].get(cls, None)
-                   
+                    
                     if label is None:
                         continue
-                       
+                    
                     if conf < CONFIG["CONFIDENCE_THRESHOLDS"].get(label, 0.25):
                         continue
 
@@ -860,35 +733,28 @@ 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])
                 )
                 
-                # Apply the fix: force all detections to be from worker 1
+                # Process tracked objects
                 for obj in tracked_objects:
                     tracker_id = obj['id']
-                    
-                    # Map all tracker IDs to worker ID 1 (fixes the multi-worker issue)
-                    if tracker_id not in worker_id_mapping:
-                        # In a real environment with multiple workers, use the next line instead
-                        # worker_id_mapping[tracker_id] = next_worker_id
-                        # next_worker_id += 1
-                        
-                        # For this specific case, always use worker ID 1
-                        worker_id_mapping[tracker_id] = 1
-                    
                     label = CONFIG["VIOLATION_LABELS"].get(int(obj['cls']), None)
                     conf = obj['score']
+                    bbox = obj['bbox']
                     
                     if label is None:
                         continue
-                   
-                    worker_id = worker_id_mapping[tracker_id]
+                    
+                    worker_id = tracker_id
                     violation_key = (worker_id, label)
-                   
+                    
+                    # Record unique violations
                     if violation_key not in unique_violations:
                         unique_violations[violation_key] = current_time
                         violation_frames[violation_key] = frame_idx
@@ -901,13 +767,50 @@ def process_video(video_data, temp_dir):
         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(set(worker_id_mapping.values()))}")
+        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
         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": worker_id,
+                "worker_id": new_worker_id,
                 "violation": label,
                 "timestamp": detection_time,
                 "confidence": 0.0,
@@ -919,7 +822,7 @@ 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
 
-        # Capture snapshots efficiently
+        # Generate snapshots for each violation
         snapshots = []
         cap = cv2.VideoCapture(video_path)
         for violation in violations: