Update app.py

app.py

@@ -36,59 +36,96 @@ class BYTETracker:
         self.frame_rate = frame_rate
         self.next_id = 1
         self.tracks = {}  # Store active tracks
+        self.worker_history = {}  # Track worker positions over time
+        self.last_positions = {}  # Last known positions of workers
 
     def update(self, dets, scores, cls):
         tracks = []
+        current_time = time.time()
         
         # Update existing tracks with new detections
         for i, (det, score, cl) in enumerate(zip(dets, scores, cls)):
             if score < self.track_thresh:
-                logger.debug(f"Skipping detection with score {score} below threshold {self.track_thresh}")
                 continue
                 
             x, y, w, h = det
+            matched = False
+            best_iou = 0
+            best_track_id = None
             
             # Try to match with existing tracks
-            matched = False
             for track_id, track_info in self.tracks.items():
-                # Simple IOU-based matching
+                if current_time - track_info['last_seen'] > self.track_buffer / self.frame_rate:
+                    continue
+                    
                 tx, ty, tw, th = track_info['bbox']
                 iou = self._calculate_iou([x, y, w, h], [tx, ty, tw, th])
                 
-                if iou > self.match_thresh and track_info['cls'] == cl:
-                    # Update existing track
-                    self.tracks[track_id] = {
-                        'bbox': [x, y, w, h],
-                        'score': score,
-                        'cls': cl,
-                        'last_seen': time.time()
-                    }
-                    tracks.append({
-                        'id': track_id,
-                        'bbox': [x, y, w, h],
-                        'score': score,
-                        'cls': cl
-                    })
+                if iou > self.match_thresh and iou > best_iou:
+                    best_iou = iou
+                    best_track_id = track_id
                     matched = True
-                    break
             
-            if not matched:
-                # Create new track
-                self.tracks[self.next_id] = {
+            if matched:
+                # Update existing track
+                self.tracks[best_track_id].update({
                     'bbox': [x, y, w, h],
                     'score': score,
                     'cls': cl,
-                    'last_seen': time.time()
-                }
+                    'last_seen': current_time
+                })
+                
+                # 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]
+                
                 tracks.append({
-                    'id': self.next_id,
+                    'id': best_track_id,
                     'bbox': [x, y, w, h],
                     'score': score,
                     'cls': cl
                 })
-                self.next_id += 1
+            else:
+                # Create new track
+                # Check if this detection might be the same worker from a different angle
+                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
+                        }
+                        tracks.append({
+                            'id': worker_id,
+                            'bbox': [x, y, w, h],
+                            'score': score,
+                            'cls': cl
+                        })
+                        same_worker = True
+                        break
+                
+                if not same_worker:
+                    self.tracks[self.next_id] = {
+                        'bbox': [x, y, w, h],
+                        'score': score,
+                        'cls': cl,
+                        'last_seen': current_time
+                    }
+                    self.worker_history[self.next_id] = [[x, y]]
+                    self.last_positions[self.next_id] = [x, y]
+                    tracks.append({
+                        'id': self.next_id,
+                        'bbox': [x, y, w, h],
+                        'score': score,
+                        'cls': cl
+                    })
+                    self.next_id += 1
         
-        # Remove stale tracks
+        # Clean up old tracks
         current_time = time.time()
         stale_ids = []
         for track_id, track_info in self.tracks.items():
@@ -97,38 +134,41 @@ class BYTETracker:
         
         for track_id in stale_ids:
             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]
             
         return tracks
     
     def _calculate_iou(self, box1, box2):
-        """Calculate IOU between two boxes in format [x, y, w, h]"""
+        """Calculate IOU between two boxes"""
         x1, y1, w1, h1 = box1
         x2, y2, w2, h2 = box2
         
-        # Convert to xmin, ymin, xmax, ymax
-        xmin1, ymin1 = x1 - w1/2, y1 - h1/2
-        xmax1, ymax1 = x1 + w1/2, y1 + h1/2
-        xmin2, ymin2 = x2 - w2/2, y2 - h2/2
-        xmax2, ymax2 = x2 + w2/2, y2 + h2/2
-        
-        # Calculate area of intersection
-        x_left = max(xmin1, xmin2)
-        y_top = max(ymin1, ymin2)
-        x_right = min(xmax1, xmax2)
-        y_bottom = min(ymax1, ymax2)
+        # Calculate intersection coordinates
+        x_left = max(x1 - w1/2, x2 - w2/2)
+        y_top = max(y1 - h1/2, y2 - h2/2)
+        x_right = min(x1 + w1/2, x2 + w2/2)
+        y_bottom = min(y1 + h1/2, y2 + h2/2)
         
         if x_right < x_left or y_bottom < y_top:
             return 0.0
             
         intersection_area = (x_right - x_left) * (y_bottom - y_top)
         
-        # Calculate area of both boxes
         box1_area = w1 * h1
         box2_area = w2 * h2
         
-        # Calculate IOU
         iou = intersection_area / (box1_area + box2_area - intersection_area)
         return iou
+    
+    def _is_same_worker(self, pos1, pos2, threshold=100):
+        """Check if two positions likely belong to the same worker"""
+        x1, y1 = pos1
+        x2, y2 = pos2
+        distance = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
+        return distance < threshold
 
 # ========================== # Optimized Configuration # ==========================
 CONFIG = {
@@ -143,11 +183,11 @@ CONFIG = {
         4: "improper_tool_use"
     },
     "CLASS_COLORS": {
-        "no_helmet": (0, 0, 255),          # Red in BGR
-        "no_harness": (0, 165, 255),       # Orange in BGR
-        "unsafe_posture": (0, 255, 0),     # Green in BGR
-        "unsafe_zone": (255, 0, 0),        # Blue in BGR
-        "improper_tool_use": (255, 255, 0) # Cyan in BGR
+        "no_helmet": (0, 0, 255),          # Red
+        "no_harness": (0, 165, 255),       # Orange
+        "unsafe_posture": (0, 255, 0),     # Green
+        "unsafe_zone": (255, 0, 0),        # Blue
+        "improper_tool_use": (255, 255, 0) # Cyan
     },
     "DISPLAY_NAMES": {
         "no_helmet": "No Helmet Violation",
@@ -162,7 +202,7 @@ CONFIG = {
         "security_token": "AP4AQnPoidIKPvSvNEfAHyoK",
         "domain": "login"
     },
-    "PUBLIC_URL_BASE": "https://huggingface.co/spaces/PrashanthB461/AI_Sadio2/resolve/main/static/output/",
+    "PUBLIC_URL_BASE": "https://huggingface.co/spaces/PrashanthB461/AI_Safety_Demo2/resolve/main/static/output/",
     "CONFIDENCE_THRESHOLDS": {
         "no_helmet": 0.5,
         "no_harness": 0.3,
@@ -171,16 +211,17 @@ CONFIG = {
         "improper_tool_use": 0.3
     },
     "MIN_VIOLATION_FRAMES": 1,
-    "VIOLATION_COOLDOWN": 5.0,        # Time in seconds before same violation type can be detected again for the same worker
+    "VIOLATION_COOLDOWN": 30.0,  # Increased cooldown period
     "WORKER_TRACKING_DURATION": 5.0,
     "MAX_PROCESSING_TIME": 60,
-    "FRAME_SKIP": 1,
+    "FRAME_SKIP": 2,  # Skip more frames for faster processing
     "BATCH_SIZE": 16,
     "PARALLEL_WORKERS": max(1, cpu_count() - 1),
     "TRACK_BUFFER": 30,
     "TRACK_THRESH": 0.3,
     "MATCH_THRESH": 0.7,
-    "SNAPSHOT_QUALITY": 90           # JPEG quality for snapshots (0-100)
+    "SNAPSHOT_QUALITY": 95,  # Higher quality for better visibility
+    "MAX_WORKER_DISTANCE": 100  # Maximum pixel distance to consider same worker
 }
 
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
@@ -210,7 +251,7 @@ model = load_model()
 # ========================== # Helper Functions # ==========================
 def preprocess_frame(frame):
     """Apply basic preprocessing to enhance detection"""
-    frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=20)  # Increase contrast
+    frame = cv2.convertScaleAbs(frame, alpha=1.2, beta=20)
     return frame
 
 def draw_detections(frame, detections):
@@ -221,6 +262,7 @@ def draw_detections(frame, detections):
         label = det.get("violation", "Unknown")
         confidence = det.get("confidence", 0.0)
         x, y, w, h = det.get("bounding_box", [0, 0, 0, 0])
+        worker_id = det.get("worker_id", "Unknown")
 
         x1 = int(x - w/2)
         y1 = int(y - h/2)
@@ -229,20 +271,18 @@ def draw_detections(frame, detections):
         
         color = CONFIG["CLASS_COLORS"].get(label, (0, 0, 255))
         
-        # Draw thicker rectangle with border for better visibility
+        # Draw thicker rectangle with border
         cv2.rectangle(result_frame, (x1, y1), (x2, y2), color, 3)
         
-        # Add a black background behind text for better readability
-        display_text = f"{CONFIG['DISPLAY_NAMES'].get(label, label)}: {confidence:.2f}"
+        # Add black background behind text
+        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)
         
-        # Draw worker ID
-        worker_id = det.get("worker_id", "Unknown")
-        worker_text = f"Worker: {worker_id}"
-        cv2.putText(result_frame, worker_text, (x1+5, y2+20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
-        cv2.putText(result_frame, worker_text, (x1+5, y2+20), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+        # Add confidence score
+        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
 
@@ -256,15 +296,24 @@ def calculate_safety_score(violations):
         "improper_tool_use": 25
     }
     
-    # Count unique violation types
-    unique_violations = set()
+    # Count unique violation types per worker
+    worker_violations = {}
     for v in violations:
-        unique_violations.add(v.get("violation", "Unknown"))
+        worker_id = v.get("worker_id", "Unknown")
+        violation_type = v.get("violation", "Unknown")
+        
+        if worker_id not in worker_violations:
+            worker_violations[worker_id] = set()
+        worker_violations[worker_id].add(violation_type)
+    
+    # Calculate total penalty
+    total_penalty = 0
+    for worker_violations_set in worker_violations.values():
+        worker_penalty = sum(penalties.get(v, 0) for v in worker_violations_set)
+        total_penalty += worker_penalty
     
-    # Calculate penalty based on unique violation types
-    total_penalty = sum(penalties.get(v, 0) for v in unique_violations)
-    score = 100 - total_penalty
-    return max(score, 0)
+    score = max(0, 100 - total_penalty)
+    return score
 
 def generate_violation_pdf(violations, score):
     """Generate a PDF report for the detected violations"""
@@ -273,25 +322,38 @@ def generate_violation_pdf(violations, score):
         pdf_path = os.path.join(CONFIG["OUTPUT_DIR"], pdf_filename)
         pdf_file = BytesIO()
         c = canvas.Canvas(pdf_file, pagesize=letter)
+        
+        # Title
         c.setFont("Helvetica-Bold", 16)
         c.drawString(1 * inch, 10 * inch, "Worksite Safety Violation Report")
         
+        # Basic Information
         c.setFont("Helvetica", 12)
         c.drawString(1 * inch, 9.5 * inch, f"Date: {time.strftime('%Y-%m-%d')}")
         c.drawString(1 * inch, 9.2 * inch, f"Time: {time.strftime('%H:%M:%S')}")
         
+        # Safety Score
         c.setFont("Helvetica-Bold", 14)
         c.drawString(1 * inch, 8.7 * inch, f"Safety Compliance Score: {score}%")
 
+        # Violation Summary
         y_position = 8.2 * inch
         c.setFont("Helvetica-Bold", 12)
         c.drawString(1 * inch, y_position, "Summary:")
         y_position -= 0.3 * inch
         
+        # Group violations by worker
+        worker_violations = {}
+        for v in violations:
+            worker_id = v.get("worker_id", "Unknown")
+            if worker_id not in worker_violations:
+                worker_violations[worker_id] = []
+            worker_violations[worker_id].append(v)
+        
         c.setFont("Helvetica", 10)
         summary_data = {
+            "Total Workers with Violations": len(worker_violations),
             "Total Violations Found": len(violations),
-            "Unique Workers with Violations": len(set(v.get("worker_id", "Unknown") for v in violations)),
             "Analysis Timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
         }
         
@@ -299,45 +361,38 @@ def generate_violation_pdf(violations, score):
             c.drawString(1 * inch, y_position, f"{key}: {value}")
             y_position -= 0.25 * inch
 
-        if not violations:
-            y_position -= 0.3 * inch
-            c.drawString(1 * inch, y_position, "No violations detected.")
-        else:
-            y_position -= 0.5 * inch
-            c.setFont("Helvetica-Bold", 12)
-            c.drawString(1 * inch, y_position, "Violation Details:")
-            y_position -= 0.3 * inch
-            
-            c.setFont("Helvetica", 10)
-            # Sort violations by worker ID and type for better organization
-            sorted_violations = sorted(violations, key=lambda v: (v.get("worker_id", "Unknown"), v.get("violation", "Unknown")))
+        # Detailed Violations by Worker
+        y_position -= 0.5 * inch
+        c.setFont("Helvetica-Bold", 12)
+        c.drawString(1 * inch, y_position, "Violations by Worker:")
+        y_position -= 0.3 * inch
+        
+        c.setFont("Helvetica", 10)
+        for worker_id, worker_vios in worker_violations.items():
+            c.drawString(1 * inch, y_position, f"Worker {worker_id}:")
+            y_position -= 0.2 * inch
             
-            for v in sorted_violations:
-                worker_id = v.get("worker_id", "Unknown")
+            for v in worker_vios:
                 display_name = CONFIG["DISPLAY_NAMES"].get(v.get("violation", "Unknown"), "Unknown")
-                start_time = v.get('start_timestamp', 0.0)
-                end_time = v.get('end_timestamp', 0.0)
-                confidence = v.get('confidence', 0.0)
+                time_str = f"{v.get('timestamp', 0.0):.2f}s"
+                conf_str = f"{v.get('confidence', 0.0):.2f}"
                 
-                text = f"Worker ID: {worker_id} - {display_name}"
-                c.drawString(1 * inch, y_position, text)
+                violation_text = f"  - {display_name} at {time_str} (Confidence: {conf_str})"
+                c.drawString(1.2 * inch, y_position, violation_text)
                 y_position -= 0.2 * inch
                 
-                details = f"  Time: {start_time:.2f}s to {end_time:.2f}s (Confidence: {confidence:.2f})"
-                c.drawString(1.2 * inch, y_position, details)
-                y_position -= 0.3 * inch
-                
                 if y_position < 1 * inch:
                     c.showPage()
                     c.setFont("Helvetica", 10)
                     y_position = 10 * inch
 
-        c.showPage()
         c.save()
         pdf_file.seek(0)
 
+        # Save PDF file
         with open(pdf_path, "wb") as f:
             f.write(pdf_file.getvalue())
+            
         public_url = f"{CONFIG['PUBLIC_URL_BASE']}{pdf_filename}"
         logger.info(f"PDF generated: {public_url}")
         return pdf_path, public_url, pdf_file
@@ -394,12 +449,11 @@ def push_report_to_salesforce(violations, score, pdf_path, pdf_file):
         violations_text = ""
         for v in violations:
             display_name = CONFIG['DISPLAY_NAMES'].get(v.get('violation', 'Unknown'), 'Unknown')
-            worker_id = v.get('worker_id', 'N/A')
-            start_time = v.get('start_timestamp', 0.0)
-            end_time = v.get('end_timestamp', 0.0)
+            worker_id = v.get('worker_id', 'Unknown')
+            timestamp = v.get('timestamp', 0.0)
             confidence = v.get('confidence', 0.0)
             
-            violations_text += f"Worker {worker_id}: {display_name} ({start_time:.2f}s-{end_time:.2f}s, Conf: {confidence:.2f})\n"
+            violations_text += f"Worker {worker_id}: {display_name} at {timestamp:.2f}s (Conf: {confidence:.2f})\n"
         
         if not violations_text:
             violations_text = "No violations detected."
@@ -474,7 +528,7 @@ def process_video(video_data):
         )
 
         # Track unique violations by worker ID
-        unique_violations = {}  # {worker_id: {violation_type: {first_detection, last_detection, best_confidence, best_frame, cooldown}}}
+        unique_violations = {}  # {worker_id: {violation_type: first_detection_time}}
         snapshots = []
         start_time = time.time()
         frame_skip = CONFIG["FRAME_SKIP"]
@@ -502,6 +556,7 @@ def process_video(video_data):
                 
                 batch_frames.append(frame)
                 batch_indices.append(frame_idx)
+                processed_frames += 1
 
             if not batch_frames:
                 break
@@ -510,13 +565,12 @@ def process_video(video_data):
             results = model(batch_frames, device=device, conf=0.1, verbose=False)
             
             for i, (result, frame_idx) in enumerate(zip(results, batch_indices)):
-                processed_frames += 1
                 current_time = frame_idx / fps
                 
                 # Update progress every second
                 if time.time() - start_time > 1.0:
-                    progress = (frame_idx / total_frames) * 100
-                    yield f"Processing video... {progress:.1f}% complete (Frame {frame_idx}/{total_frames})", "", "", "", ""
+                    progress = (processed_frames / total_frames) * 100
+                    yield f"Processing video... {progress:.1f}% complete (Frame {processed_frames}/{total_frames})", "", "", "", ""
                     start_time = time.time()
 
                 boxes = result.boxes
@@ -528,11 +582,9 @@ def process_video(video_data):
                     label = CONFIG["VIOLATION_LABELS"].get(cls, None)
                     
                     if label is None:
-                        logger.debug(f"Unknown class ID {cls} detected, skipping")
                         continue
                         
                     if conf < CONFIG["CONFIDENCE_THRESHOLDS"].get(label, 0.25):
-                        logger.debug(f"Detection for {label} with confidence {conf} below threshold {CONFIG['CONFIDENCE_THRESHOLDS'].get(label, 0.25)}")
                         continue
 
                     bbox = box.xywh.cpu().numpy()[0]
@@ -542,7 +594,6 @@ def process_video(video_data):
                         "cls": cls
                     })
 
-                # Skip tracking if no detections
                 if not track_inputs:
                     continue
                     
@@ -551,8 +602,6 @@ def process_video(video_data):
                     np.array([t["conf"] for t in track_inputs]),
                     np.array([t["cls"] for t in track_inputs])
                 )
-                
-                logger.debug(f"Frame {frame_idx}: {len(tracked_objects)} objects tracked")
 
                 # Process tracked objects for violations
                 for obj in tracked_objects:
@@ -567,90 +616,55 @@ def process_video(video_data):
                     # Initialize worker if not seen before
                     if worker_id not in unique_violations:
                         unique_violations[worker_id] = {}
-                        
-                    # Check if this is a new violation type for this worker or if cooldown has passed
-                    is_new_violation = False
+                    
+                    # Check if this violation type has been recorded for this worker
                     if label not in unique_violations[worker_id]:
-                        # New violation type for this worker
-                        unique_violations[worker_id][label] = {
-                            'first_detection': current_time,
-                            'last_detection': current_time,
-                            'best_confidence': conf,
-                            'best_frame': frame_idx,
-                            'best_bbox': bbox,
-                            'cooldown': current_time + CONFIG["VIOLATION_COOLDOWN"]
-                        }
-                        is_new_violation = True
-                    elif current_time > unique_violations[worker_id][label]['cooldown']:
-                        # Cooldown period has passed, treat as a new violation
-                        unique_violations[worker_id][label] = {
-                            'first_detection': current_time,
-                            'last_detection': current_time,
-                            'best_confidence': conf,
-                            'best_frame': frame_idx,
-                            'best_bbox': bbox,
-                            'cooldown': current_time + CONFIG["VIOLATION_COOLDOWN"]
-                        }
-                        is_new_violation = True
-                    else:
-                        # Update existing violation
-                        violation_info = unique_violations[worker_id][label]
-                        violation_info['last_detection'] = current_time
+                        # This is a new violation type for this worker
+                        unique_violations[worker_id][label] = current_time
                         
-                        # Update if this is a better detection (higher confidence)
-                        if conf > violation_info['best_confidence']:
-                            violation_info['best_confidence'] = conf
-                            violation_info['best_frame'] = frame_idx
-                            violation_info['best_bbox'] = bbox
-                    
-                    # If this is a new violation, capture a snapshot
-                    if is_new_violation:
-                        # Create a detection object for the snapshot
+                        # Create detection object
                         detection = {
-                            "frame": frame_idx,
+                            "worker_id": worker_id,
                             "violation": label,
                             "confidence": round(conf, 2),
                             "bounding_box": bbox,
-                            "timestamp": current_time,
-                            "worker_id": worker_id
+                            "timestamp": current_time
                         }
                         
-                        # Take a snapshot for the new violation
+                        # Take snapshot for the new violation
                         snapshot_frame = batch_frames[i].copy()
                         snapshot_frame = draw_detections(snapshot_frame, [detection])
                         
-                        # Add timestamp to the image
+                        # Add timestamp to snapshot
                         cv2.putText(
-                            snapshot_frame, 
-                            f"Time: {current_time:.2f}s", 
-                            (10, 30), 
-                            cv2.FONT_HERSHEY_SIMPLEX, 
-                            0.7, 
-                            (255, 255, 255), 
+                            snapshot_frame,
+                            f"Time: {current_time:.2f}s",
+                            (10, 30),
+                            cv2.FONT_HERSHEY_SIMPLEX,
+                            0.7,
+                            (255, 255, 255),
                             2
                         )
                         
                         # Save snapshot with high quality
-                        snapshot_filename = f"{label}_worker{worker_id}_{int(current_time)}_{frame_idx}.jpg"
+                        snapshot_filename = f"violation_{label}_worker{worker_id}_{int(current_time*100)}.jpg"
                         snapshot_path = os.path.join(CONFIG["OUTPUT_DIR"], snapshot_filename)
                         
-                        # Use higher quality for JPEG to ensure better visibility
                         cv2.imwrite(
-                            snapshot_path, 
-                            snapshot_frame, 
+                            snapshot_path,
+                            snapshot_frame,
                             [cv2.IMWRITE_JPEG_QUALITY, CONFIG["SNAPSHOT_QUALITY"]]
                         )
                         
                         snapshots.append({
                             "violation": label,
                             "worker_id": worker_id,
-                            "frame": frame_idx,
                             "timestamp": current_time,
                             "snapshot_path": snapshot_path,
                             "snapshot_url": f"{CONFIG['PUBLIC_URL_BASE']}{snapshot_filename}"
                         })
                         
-                        logger.info(f"Captured snapshot for {label} violation by worker {worker_id} at frame {frame_idx}")
+                        logger.info(f"Captured snapshot for {label} violation by worker {worker_id} at {current_time:.2f}s")
 
         cap.release()
         if os.path.exists(video_path):
@@ -662,15 +676,11 @@ def process_video(video_data):
         # Convert tracked violations to final violation list
         violations = []
         for worker_id, worker_violations in unique_violations.items():
-            for label, violation_info in worker_violations.items():
+            for label, detection_time in worker_violations.items():
                 violation = {
                     "worker_id": worker_id,
                     "violation": label,
-                    "confidence": violation_info['best_confidence'],
-                    "start_timestamp": violation_info['first_detection'],
-                    "end_timestamp": violation_info['last_detection'],
-                    "frame": violation_info['best_frame'],
-                    "bounding_box": violation_info['best_bbox']
+                    "timestamp": detection_time
                 }
                 violations.append(violation)
 
@@ -692,20 +702,18 @@ def process_video(video_data):
         violation_table = "| Violation | Worker ID | Time (s) | Confidence |\n"
         violation_table += "|-----------|-----------|----------|------------|\n"
         
-        for v in sorted(violations, key=lambda x: (x.get("worker_id", "Unknown"), x.get("start_timestamp", 0.0))):
+        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")
-            start_time = v.get('start_timestamp', 0.0)
-            end_time = v.get('end_timestamp', 0.0)
-            confidence = v.get('confidence', 0.0)
+            timestamp = v.get("timestamp", 0.0)
+            confidence = v.get("confidence", 0.0)
             
-            row = f"| {display_name} | {worker_id} | {start_time:.2f}-{end_time:.2f} | {confidence:.2f} |\n"
-            violation_table += row
+            violation_table += f"| {display_name} | {worker_id} | {timestamp:.2f} | {confidence:.2f} |\n"
 
         # Format snapshots for display
         snapshots_text = ""
-        for i, s in enumerate(snapshots):
-            display_name = CONFIG["DISPLAY_NAMES"].get(s['violation'], "Unknown")
+        for s in snapshots:
+            display_name = CONFIG["DISPLAY_NAMES"].get(s["violation"], "Unknown")
             worker_id = s.get("worker_id", "Unknown")
             timestamp = s.get("timestamp", 0.0)