matrice-analytics 0.1.97__py3-none-any.whl → 0.1.106__py3-none-any.whl

matrice_analytics/post_processing/face_reg/people_activity_logging.py

@@ -154,33 +154,40 @@ class PeopleActivityLogging:
         except Exception as e:
             self.logger.error(f"Error enqueueing detection: {e}", exc_info=True)
 
-    def _should_log_detection(self, employee_id: str) -> bool:
+    def _should_log_detection(self, employee_id: str, camera_id: str = "") -> bool:
         """
-        Check if detection should be logged based on employee ID and time threshold.
-        Only log if employee_id was not detected in the past 10 seconds.
+        Check if detection should be logged based on employee ID (+ camera ID) and time threshold.
+        Only log if the same (employee_id, camera_id) was not detected in the past N seconds.
+        If camera_id is empty, falls back to global employee_id de-duplication (backward compatible).
         
         TODO: Make this use track_id or similarity check instead of just employee_id in 10 secs window
         for better deduplication across different detection sessions.
         """
         current_time = time.time()
+        dedupe_key = f"{employee_id}::{camera_id}" if camera_id else employee_id
         
         # Clean up old entries (older than threshold)
         expired_keys = [
-            emp_id for emp_id, timestamp in self.recent_employee_detections.items()
+            key for key, timestamp in self.recent_employee_detections.items()
             if current_time - timestamp > self.employee_detection_threshold
         ]
-        for emp_id in expired_keys:
-            del self.recent_employee_detections[emp_id]
+        for key in expired_keys:
+            del self.recent_employee_detections[key]
         
-        # Check if employee was recently detected
-        if employee_id in self.recent_employee_detections:
-            last_detection = self.recent_employee_detections[employee_id]
+        # Check if employee was recently detected (per camera_id)
+        if dedupe_key in self.recent_employee_detections:
+            last_detection = self.recent_employee_detections[dedupe_key]
             if current_time - last_detection < self.employee_detection_threshold:
-                self.logger.debug(f"Skipping logging for employee {employee_id} - detected {current_time - last_detection:.1f}s ago")
+                self.logger.debug(
+                    "Skipping logging for employee %s (camera_id=%s) - detected %.1fs ago",
+                    employee_id,
+                    camera_id,
+                    current_time - last_detection,
+                )
                 return False
         
-        # Update detection time for this employee
-        self.recent_employee_detections[employee_id] = current_time
+        # Update detection time for this (employee, camera)
+        self.recent_employee_detections[dedupe_key] = current_time
         return True
 
     async def _process_activity(self, activity_data: Dict):
@@ -202,8 +209,12 @@ class PeopleActivityLogging:
                 return
 
             # Check if we should log this detection (avoid duplicates within time window)
-            if not self._should_log_detection(employee_id):
-                self.logger.debug(f"Skipping activity log for employee_id={employee_id} (within cooldown period)")
+            if not self._should_log_detection(employee_id, camera_id=camera_id):
+                self.logger.debug(
+                    "Skipping activity log for employee_id=%s (camera_id=%s) (within cooldown period)",
+                    employee_id,
+                    camera_id,
+                )
                 return None
 
             # Encode frame as base64 JPEG

matrice_analytics/post_processing/usecases/footfall.py

@@ -1,7 +1,10 @@
 from typing import Any, Dict, List, Optional
 from dataclasses import asdict
 import time
+import math
+import numpy as np
 from datetime import datetime, timezone
+from collections import defaultdict, deque
 
 from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
 from ..utils import (
@@ -19,6 +22,76 @@ from ..utils import (
 from dataclasses import dataclass, field
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
+class TrajectoryCorrector:
+    """
+    Handles Velocity-Fusion logic to correct model orientation errors.
+    Stores history of track centers and applies EMA smoothing.
+    """
+    def __init__(self):
+        # track_id -> { "centers": deque, "smooth_angle": float }
+        self.history = defaultdict(lambda: {
+            "centers": deque(maxlen=10),  # Lookback for velocity
+            "smooth_angle": None          # For EMA smoothing
+        })
+
+    def update_and_correct(self, track_id, center, raw_angle_deg):
+        """
+        Returns the corrected angle based on velocity fusion.
+        """
+        state = self.history[track_id]
+        state["centers"].append(center)
+        
+        # 1. Calculate Velocity Angle
+        velocity_angle = self._compute_velocity_angle(state["centers"])
+        
+        # 2. Apply +90 Fix to Raw Model Angle (Matches your successful tests)
+        # Note: raw_angle_deg comes from predict.py
+        if raw_angle_deg is None: raw_angle_deg = 0.0
+        model_angle = (raw_angle_deg + 90) % 360
+        
+        # 3. Determine Target (Velocity vs Model)
+        # Hybrid Logic: If moving (velocity valid), use Physics. Else, use Visuals.
+        target_angle = velocity_angle if velocity_angle is not None else model_angle
+        
+        # 4. Apply EMA Smoothing (The Jitter Killer)
+        # alpha=0.2 means we trust new data 20%, old history 80%
+        state["smooth_angle"] = self._apply_ema(state["smooth_angle"], target_angle, alpha=0.2)
+        
+        return state["smooth_angle"]
+
+    def _compute_velocity_angle(self, centers):
+        if len(centers) < 2: 
+            return None
+            
+        # Look back 5 frames for stability
+        lookback = min(len(centers), 5)
+        (x_past, y_past) = centers[-lookback]
+        (x_now, y_now) = centers[-1]
+        
+        dx = x_now - x_past
+        dy = y_now - y_past
+        
+        # THRESHOLD: 2.5 pixels (Validated in your tests)
+        # If moving less than this, velocity is noise.
+        if math.hypot(dx, dy) < 2.5:
+            return None
+            
+        # Angle calculation (0-360)
+        return math.degrees(math.atan2(-dy, dx)) % 360
+
+    def _apply_ema(self, current_smooth, new_target, alpha=0.2):
+        if current_smooth is None:
+            return new_target
+            
+        # Vector smoothing to handle 0/360 wrap-around correctly
+        prev_rad = math.radians(current_smooth)
+        curr_rad = math.radians(new_target)
+        
+        new_sin = (1 - alpha) * math.sin(prev_rad) + alpha * math.sin(curr_rad)
+        new_cos = (1 - alpha) * math.cos(prev_rad) + alpha * math.cos(curr_rad)
+        
+        return math.degrees(math.atan2(new_sin, new_cos)) % 360
+
 @dataclass
 class FootFallConfig(BaseConfig):
     """Configuration for footfall use case."""
@@ -79,9 +152,12 @@ class FootFallUseCase(BaseProcessor):
         self.category = "retail"
         self.CASE_TYPE: Optional[str] = 'footfall'
         self.CASE_VERSION: Optional[str] = '1.1'
-        self.target_categories = ['person'] #['person', 'people','human','man','woman','male','female']
+        self.target_categories = ['person']
         self.smoothing_tracker = None
         self.tracker = None
+        
+        # Initialize the Velocity Logic 
+        self.trajectory_corrector = TrajectoryCorrector()
         self._total_frame_counter = 0
         self._global_frame_offset = 0
         self._tracking_start_time = None
@@ -144,9 +220,40 @@ class FootFallUseCase(BaseProcessor):
                     match_thresh=0.8)
                 self.tracker = AdvancedTracker(tracker_config)
                 self.logger.info("Initialized AdvancedTracker for People Counting")
+            
+            # 1. Run Standard Tracker (Assigns IDs)
             processed_data = self.tracker.update(processed_data)
+            
+            # =========================================================
+            # NEW: INJECT VELOCITY FUSION LOGIC
+            # =========================================================
+            for det in processed_data:
+                track_id = det.get("track_id")
+                bbox = det.get("bounding_box", det.get("bbox"))
+                
+                # Check for 'raw_angle' (from predict.py) or 'orientation'
+                raw_angle = det.get("raw_angle", det.get("orientation", 0.0))
+                
+                if track_id is not None and bbox:
+                    # Calculate Center (cx, cy)
+                    cx = int((bbox[0] + bbox[2]) / 2)
+                    cy = int((bbox[1] + bbox[3]) / 2)
+                    
+                    # Run Correction (Velocity + EMA + 90 Fix)
+                    final_angle = self.trajectory_corrector.update_and_correct(
+                        track_id, 
+                        (cx, cy), 
+                        raw_angle
+                    )
+                    
+                    # OVERWRITE the detection angle
+                    # This ensures _generate_tracking_stats uses YOUR logic
+                    det["orientation"] = final_angle  # For UI
+                    det["angle"] = final_angle        # For Analytics
+            # =========================================================
+
         except Exception as e:
-            self.logger.warning(f"AdvancedTracker failed: {e}")
+            self.logger.warning(f"AdvancedTracker/Velocity failed: {e}")
 
         self._update_tracking_state(processed_data)
         self._total_frame_counter += 1

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -535,6 +535,10 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self.plate_logger: Optional[LicensePlateMonitorLogger] = None
         self._logging_enabled = True # False  //ToDo: DISABLED FOR NOW, ENABLED FOR PRODUCTION. ##
         self._plate_logger_initialized = False  # Track if plate logger has been initialized
+        
+        # Track which track_ids have been logged to avoid duplicate logging
+        # Only log confirmed/consensus plates, not every OCR prediction
+        self._logged_track_ids: set = set()
 
         # Initialize instant alert manager (will be lazily initialized on first process() call)
         self.alert_manager: Optional[ALERT_INSTANCE] = None
@@ -942,6 +946,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         self._unique_plate_texts = {}
         self.helper = {}
         self.unique_plate_track = {}
+        # Reset logged track_ids to allow fresh logging
+        self._logged_track_ids = set()
         self.logger.info("Plate tracking state reset")
 
     def reset_all_tracking(self) -> None:
@@ -1147,13 +1153,19 @@ class LicensePlateMonitorUseCase(BaseProcessor):
     
     async def _log_detected_plates(self, detections: List[Dict[str, Any]], config: LicensePlateMonitorConfig, 
                             stream_info: Optional[Dict[str, Any]], image_bytes: Optional[bytes] = None) -> None:
-        """Log all detected plates to RPC server with cooldown."""
+        """
+        Log confirmed/consensus plates to RPC server.
+        
+        Only logs plates that have reached consensus (are in _tracked_plate_texts),
+        and only logs each track_id once to avoid duplicate logging of garbage OCR predictions.
+        Uses the confirmed consensus plate text, not the raw frame-by-frame OCR output.
+        """
         # Enhanced logging for diagnostics
         print(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
         self.logger.info(f"[LP_LOGGING] Starting plate logging check - detections count: {len(detections)}")
-        self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}, Stream info exists: {stream_info is not None}")
+        self.logger.info(f"[LP_LOGGING] Logging enabled: {self._logging_enabled}, Plate logger exists: {self.plate_logger is not None}")
+        self.logger.info(f"[LP_LOGGING] Confirmed plates (tracked): {len(self._tracked_plate_texts)}, Already logged tracks: {len(self._logged_track_ids)}")
         
-        #self._logging_enabled = False # ToDo: DISABLED FOR NOW, ENABLED FOR PRODUCTION
         if not self._logging_enabled:
             print("[LP_LOGGING] Plate logging is DISABLED")
             self.logger.warning("[LP_LOGGING] Plate logging is DISABLED - logging_enabled flag is False")
@@ -1164,11 +1176,6 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - plate_logger is not initialized (lpr_server_id may not be configured)")
             return
         
-        # if not stream_info:
-        #     print("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
-        #     self.logger.warning("[LP_LOGGING] Plate logging SKIPPED - stream_info is None")
-        #     return
-        
         print("[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
         self.logger.info(f"[LP_LOGGING] All pre-conditions met, proceeding with plate logging")
         
@@ -1195,35 +1202,45 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 else:
                     self.logger.warning(f"[LP_LOGGING] Failed to decode image bytes")
             except Exception as e:
-                #pass
                 self.logger.error(f"[LP_LOGGING] Exception while encoding frame image: {e}", exc_info=True)
         else:
             self.logger.info(f"[LP_LOGGING] No image_bytes provided, sending without image")
         
-        # Collect all unique plates from current detections
-        plates_to_log = set()
-        detections_without_text = 0
+        # Only log CONFIRMED/CONSENSUS plates from _tracked_plate_texts
+        # Avoid logging every raw OCR prediction - only log final confirmed plate per track_id
+        plates_to_log = {}  # track_id -> consensus_plate_text
+        
         for det in detections:
-            plate_text = det.get('plate_text')
-            if not plate_text:
-                detections_without_text += 1
+            track_id = det.get('track_id')
+            if track_id is None:
                 continue
-            plates_to_log.add(plate_text)
+            
+            # Skip if this track_id has already been logged
+            if track_id in self._logged_track_ids:
+                self.logger.debug(f"[LP_LOGGING] Skipping track_id={track_id} - already logged")
+                continue
+            
+            # Only log if this track_id has a confirmed/consensus plate
+            if track_id in self._tracked_plate_texts:
+                consensus_plate = self._tracked_plate_texts[track_id]
+                if consensus_plate:
+                    plates_to_log[track_id] = consensus_plate
+                    self.logger.debug(f"[LP_LOGGING] Found confirmed plate for track_id={track_id}: {consensus_plate}")
         
-        print(f"[LP_LOGGING] Collected {len(plates_to_log)} unique plates to log: {plates_to_log}")
-        self.logger.info(f"[LP_LOGGING] Collected {len(plates_to_log)} unique plates to log: {plates_to_log}")
-        if detections_without_text > 0:
-            self.logger.warning(f"[LP_LOGGING] {detections_without_text} detections have NO plate_text (OCR may have failed or not run yet)")
+        confirmed_count = len(plates_to_log)
+        raw_ocr_count = sum(1 for d in detections if d.get('plate_text'))
+        print(f"[LP_LOGGING] Confirmed plates to log: {confirmed_count} (from {raw_ocr_count} raw OCR detections)")
+        self.logger.info(f"[LP_LOGGING] Confirmed plates to log: {confirmed_count}, Raw OCR detections: {raw_ocr_count}")
+        self.logger.info(f"[LP_LOGGING] Plates: {list(plates_to_log.values())}")
         
-        # Log each unique plate directly with await (respecting cooldown)
+        # Log each confirmed plate (respecting cooldown)
         if plates_to_log:
-            print(f"[LP_LOGGING] Logging {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
-            self.logger.info(f"[LP_LOGGING] Logging {len(plates_to_log)} plates with cooldown={config.plate_log_cooldown}s")
+            print(f"[LP_LOGGING] Logging {len(plates_to_log)} confirmed plates with cooldown={config.plate_log_cooldown}s")
+            self.logger.info(f"[LP_LOGGING] Logging {len(plates_to_log)} confirmed plates with cooldown={config.plate_log_cooldown}s")
             try:
-                # Call log_plate directly with await for each plate
-                for plate_text in plates_to_log:
-                    print(f"[LP_LOGGING] Processing plate: {plate_text}")
-                    self.logger.info(f"[LP_LOGGING] Processing plate: {plate_text}")
+                for track_id, plate_text in plates_to_log.items():
+                    print(f"[LP_LOGGING] Processing confirmed plate: {plate_text} (track_id={track_id})")
+                    self.logger.info(f"[LP_LOGGING] Processing confirmed plate: {plate_text} (track_id={track_id})")
                     try:
                         result = await self.plate_logger.log_plate(
                             plate_text=plate_text,
@@ -1232,25 +1249,26 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                             image_data=image_data,
                             cooldown=config.plate_log_cooldown
                         )
-                        status = "SENT" if result else "SKIPPED (cooldown)"
-                        print(f"[LP_LOGGING] Plate {plate_text}: {status}")
-                        self.logger.info(f"[LP_LOGGING] Plate {plate_text}: {status}")
+                        if result:
+                            # Mark this track_id as logged to avoid duplicate logging
+                            self._logged_track_ids.add(track_id)
+                            print(f"[LP_LOGGING] Plate {plate_text}: SENT (track_id={track_id} marked as logged)")
+                            self.logger.info(f"[LP_LOGGING] Plate {plate_text}: SENT (track_id={track_id} marked as logged)")
+                        else:
+                            print(f"[LP_LOGGING] Plate {plate_text}: SKIPPED (cooldown)")
+                            self.logger.info(f"[LP_LOGGING] Plate {plate_text}: SKIPPED (cooldown)")
                     except Exception as e:
-                        #pass
                         print(f"[LP_LOGGING] ERROR - Plate {plate_text} failed: {e}")
                         self.logger.error(f"[LP_LOGGING] Plate {plate_text} raised exception: {e}", exc_info=True)
                 
                 print("[LP_LOGGING] Plate logging complete")
-                self.logger.info(f"[LP_LOGGING] Plate logging complete")
+                self.logger.info(f"[LP_LOGGING] Plate logging complete - {len(self._logged_track_ids)} total tracks logged so far")
             except Exception as e:
-                print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
-                
                 print(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}")
                 self.logger.error(f"[LP_LOGGING] CRITICAL ERROR during plate logging: {e}", exc_info=True)
-                pass
         else:
-            print("[LP_LOGGING] No plates to log")
-            self.logger.info(f"[LP_LOGGING] No plates to log (plates_to_log is empty)")
+            print("[LP_LOGGING] No confirmed plates to log (plates may still be reaching consensus)")
+            self.logger.info(f"[LP_LOGGING] No confirmed plates to log (waiting for consensus)")
 
     async def process(self, data: Any, config: ConfigProtocol, input_bytes: Optional[bytes] = None, 
                 context: Optional[ProcessingContext] = None, stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:

matrice_analytics/post_processing/usecases/vehicle_monitoring_drone_view.py

@@ -19,6 +19,7 @@ from ..utils import (
 from dataclasses import dataclass, field
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 from ..utils.geometry_utils import get_bbox_center, point_in_polygon, get_bbox_bottom25_center
+from ..utils.agnostic_nms import AgnosticNMS
 
 @dataclass
 class VehicleMonitoringDroneViewConfig(BaseConfig):
@@ -30,6 +31,17 @@ class VehicleMonitoringDroneViewConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
     confidence_threshold: float = 0.6
 
+    # Agnostic-NMS: Configuration parameters
+    enable_nms: bool = True
+    nms_iou_threshold: float = 0.45
+    nms_class_agnostic: bool = True
+    nms_min_box_size: float = 2.0
+    nms_use_vectorized: bool = True
+
+    # Class Aggregation: Configuration parameters
+    enable_class_aggregation: bool = True
+    class_aggregation_window_size: int = 30  # 30 frames ≈ 1 second at 30 FPS
+
     #JBK_720_GATE POLYGON = [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]]
     zone_config: Optional[Dict[str, List[List[float]]]] = None #field(
 #     default_factory=lambda: {
@@ -99,6 +111,9 @@ class VehicleMonitoringDroneViewUseCase(BaseProcessor):
         self._zone_current_counts = {}  # zone_name -> current count in zone
         self._zone_total_counts = {}  # zone_name -> total count that have been in zone
 
+        # Agnostic-NMS: Initialize reusable NMS module
+        self._nms_module = None
+
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         processing_start = time.time()
@@ -110,18 +125,28 @@ class VehicleMonitoringDroneViewUseCase(BaseProcessor):
         # Determine if zones are configured
         has_zones = bool(config.zone_config and config.zone_config.get('zones'))
 
+        # ===== DEBUG POINT 1: RAW INPUT =====
+        self._log_detection_stats(data, "01_RAW_INPUT", show_samples=True)  
+
         # Normalize typical YOLO outputs (COCO pretrained) to internal schema
         data = self._normalize_yolo_results(data, getattr(config, 'index_to_category', None))
 
+        # ===== DEBUG POINT 2: AFTER NORMALIZATION =====
+        self._log_detection_stats(data, "02_AFTER_NORMALIZATION", show_samples=True)
+
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
-        config.confidence_threshold = 0.25
+        # NOTE : Confidence Threshold overwrite disabled for now
+        # config.confidence_threshold = 0.25
+
         # param to be updated 
 
         if config.confidence_threshold is not None:
             processed_data = filter_by_confidence(data, config.confidence_threshold)
             self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
+            # ===== DEBUG POINT 3: AFTER CONFIDENCE FILTER =====
+            self._log_detection_stats(processed_data, "03_AFTER_CONFIDENCE_FILTER")
         else:
             processed_data = data
             self.logger.debug("Did not apply confidence filtering since no threshold provided")
@@ -129,11 +154,74 @@ class VehicleMonitoringDroneViewUseCase(BaseProcessor):
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
             self.logger.debug("Applied category mapping")
+            # ===== DEBUG POINT 4: AFTER CATEGORY MAPPING =====
+            self._log_detection_stats(processed_data, "04_AFTER_CATEGORY_MAPPING")
+
+        # Agnostic-NMS: Apply NMS using reusable module with safety
+        if getattr(config, 'enable_nms', False):
+            pre_nms_count = len(processed_data)
+
+            # ===== DEBUG POINT 5: BEFORE NMS =====
+            self._log_detection_stats(processed_data, "05_BEFORE_NMS", show_samples=True)
+        
+            
+            # Safety: Log pre-NMS state for debugging
+            if pre_nms_count > 0:
+                sample_det = processed_data[0]
+                self.logger.debug(
+                    f"Pre-NMS sample detection keys: {list(sample_det.keys())}, "
+                    f"category type: {type(sample_det.get('category')).__name__}, "
+                    f"confidence type: {type(sample_det.get('confidence')).__name__}"
+                )
+            
+            try:
+                # Initialize NMS module if needed
+                if self._nms_module is None:
+                    self._nms_module = AgnosticNMS(
+                        iou_threshold=getattr(config, 'nms_iou_threshold', 0.45),
+                        min_box_size=getattr(config, 'nms_min_box_size', 2.0),
+                        use_vectorized=getattr(config, 'nms_use_vectorized', True)
+                    )
+                    self.logger.info("AgnosticNMS module initialized")
+                
+                # Apply NMS
+                processed_data = self._nms_module.apply(
+                    processed_data,
+                    class_agnostic=getattr(config, 'nms_class_agnostic', True),
+                    target_categories=self.target_categories
+                )
+                
+                post_nms_count = len(processed_data)
+                suppressed_count = pre_nms_count - post_nms_count
+
+                # ===== DEBUG POINT 6: AFTER NMS =====
+                self._log_detection_stats(processed_data, "06_AFTER_NMS")
+                
+                self.logger.info(
+                    f"NMS applied successfully: {pre_nms_count} -> {post_nms_count} detections "
+                    f"({suppressed_count} suppressed, {100 * suppressed_count / max(pre_nms_count, 1):.1f}%)"
+                )
+                
+            except ValueError as ve:
+                # Schema validation error - log detailed diagnostics
+                self.logger.error(f"NMS schema validation failed: {ve}")
+                self.logger.error("Continuing without NMS. Check logs above for detailed diagnostics.")
+                
+            except Exception as e:
+                # Unexpected error - log full details
+                import traceback
+                self.logger.error(f"NMS failed with unexpected error: {e}")
+                self.logger.error(f"Traceback: {traceback.format_exc()}")
+                self.logger.error("Continuing without NMS.")
+
 
         processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
         if config.target_categories:
             processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
             self.logger.debug("Applied category filtering")
+
+            # ===== DEBUG POINT 7: AFTER TARGET CATEGORY FILTER =====
+            self._log_detection_stats(processed_data, "07_AFTER_TARGET_FILTER")
         
 
         if config.enable_smoothing:
@@ -149,14 +237,34 @@ class VehicleMonitoringDroneViewUseCase(BaseProcessor):
                 self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
             processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
 
+            # ===== DEBUG POINT 8: AFTER SMOOTHING =====
+            self._log_detection_stats(processed_data, "08_AFTER_SMOOTHING")
+
         try:
             from ..advanced_tracker import AdvancedTracker
             from ..advanced_tracker.config import TrackerConfig
             if self.tracker is None:
-                tracker_config = TrackerConfig()
+                tracker_config = TrackerConfig(
+                    # CLASS AGGREGATION: Map from use case config
+                    enable_class_aggregation=config.enable_class_aggregation,
+                    class_aggregation_window_size=config.class_aggregation_window_size
+                )
                 self.tracker = AdvancedTracker(tracker_config)
                 self.logger.info("Initialized AdvancedTracker for Vehicle Monitoring Drone View Use Case")
+    
+                if config.enable_class_aggregation:
+                    self.logger.info(
+                        f"AdvancedTracker initialized with class aggregation "
+                        f"(window_size={config.class_aggregation_window_size})"
+                    )
+                else:
+                    self.logger.info("AdvancedTracker initialized without class aggregation")
+            
             processed_data = self.tracker.update(processed_data)
+
+            # ===== DEBUG POINT 9: AFTER TRACKING =====
+            self._log_detection_stats(processed_data, "09_AFTER_TRACKING")
+    
         except Exception as e:
             self.logger.warning(f"AdvancedTracker failed: {e}")
 
@@ -1004,4 +1112,112 @@ class VehicleMonitoringDroneViewUseCase(BaseProcessor):
         return self._format_timestamp(self._tracking_start_time)
 
     def _set_tracking_start_time(self) -> None:
-        self._tracking_start_time = time.time()
+        self._tracking_start_time = time.time()
+
+
+    def _log_detection_stats(self, data: Any, stage_name: str, show_samples: bool = False) -> None:
+        """
+        Log detailed detection statistics at any pipeline stage.
+        
+        Args:
+            data: Detection data (list or dict format)
+            stage_name: Name of the pipeline stage for identification
+            show_samples: If True, show sample detection structure
+        """
+        separator = "=" * 80
+        print(f"\n{separator}")
+        print(f"[DETECTION_STATS] Stage: {stage_name}")
+        print(separator)
+        
+        # Handle different data formats
+        detections = []
+        if isinstance(data, list):
+            detections = data
+        elif isinstance(data, dict):
+            # Frame-based format
+            for frame_id, frame_dets in data.items():
+                if isinstance(frame_dets, list):
+                    detections.extend(frame_dets)
+        
+        if not detections:
+            print(f"  Total Detections: 0")
+            print(separator)
+            return
+        
+        # Calculate statistics
+        total_count = len(detections)
+        
+        # Count by category
+        category_counts = {}
+        confidence_sum = {}
+        confidence_min = {}
+        confidence_max = {}
+        bbox_format_count = {"x1/y1/x2/y2": 0, "xmin/ymin/xmax/ymax": 0, "other": 0}
+        
+        for det in detections:
+            if not isinstance(det, dict):
+                continue
+            
+            # Category counting
+            cat = det.get('category', 'UNKNOWN')
+            category_counts[cat] = category_counts.get(cat, 0) + 1
+            
+            # Confidence stats
+            conf = det.get('confidence', 0.0)
+            if cat not in confidence_sum:
+                confidence_sum[cat] = 0.0
+                confidence_min[cat] = conf
+                confidence_max[cat] = conf
+            confidence_sum[cat] += conf
+            confidence_min[cat] = min(confidence_min[cat], conf)
+            confidence_max[cat] = max(confidence_max[cat], conf)
+            
+            # BBox format detection
+            bbox = det.get('bounding_box', det.get('bbox', {}))
+            if isinstance(bbox, dict):
+                if 'x1' in bbox and 'y1' in bbox:
+                    bbox_format_count["x1/y1/x2/y2"] += 1
+                elif 'xmin' in bbox and 'ymin' in bbox:
+                    bbox_format_count["xmin/ymin/xmax/ymax"] += 1
+                else:
+                    bbox_format_count["other"] += 1
+        
+        # Print summary
+        print(f"  Total Detections: {total_count}")
+        print(f"\n  Category Distribution:")
+        
+        # Sort categories by count (descending)
+        sorted_cats = sorted(category_counts.items(), key=lambda x: x[1], reverse=True)
+        
+        for cat, count in sorted_cats:
+            percentage = (count / total_count) * 100
+            avg_conf = confidence_sum[cat] / count
+            min_conf = confidence_min[cat]
+            max_conf = confidence_max[cat]
+            
+            print(f"    [{cat:20s}] Count: {count:4d} ({percentage:5.1f}%) | "
+                f"Conf: avg={avg_conf:.3f}, min={min_conf:.3f}, max={max_conf:.3f}")
+        
+        # Print bbox format distribution
+        print(f"\n  BBox Format Distribution:")
+        for fmt, count in bbox_format_count.items():
+            if count > 0:
+                percentage = (count / total_count) * 100
+                print(f"    {fmt:25s}: {count:4d} ({percentage:5.1f}%)")
+        
+        # Show sample detection structure if requested
+        if show_samples and detections:
+            print(f"\n  Sample Detection Structure:")
+            sample = detections[0]
+            print(f"    Keys: {list(sample.keys())}")
+            print(f"    Category: {sample.get('category')} (type: {type(sample.get('category')).__name__})")
+            print(f"    Confidence: {sample.get('confidence')} (type: {type(sample.get('confidence')).__name__})")
+            
+            bbox = sample.get('bounding_box', sample.get('bbox', {}))
+            if isinstance(bbox, dict):
+                print(f"    BBox Keys: {list(bbox.keys())}")
+                if bbox:
+                    first_key = list(bbox.keys())[0]
+                    print(f"    BBox Coord Type: {type(bbox[first_key]).__name__}")
+        
+        print(separator)