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

matrice_analytics/post_processing/usecases/vehicle_monitoring.py

@@ -30,6 +30,10 @@ class VehicleMonitoringConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
     confidence_threshold: float = 0.6
 
+    # 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: {
@@ -107,8 +111,24 @@ class VehicleMonitoringUseCase(BaseProcessor):
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         processing_start = time.time()
-        if not isinstance(config, VehicleMonitoringConfig):
-            return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
+        # Relaxed check: Accept VehicleMonitoringConfig OR any config with matching usecase/category
+        # This handles multiprocessing module path mismatches while maintaining type safety
+        is_valid_config = (
+            isinstance(config, VehicleMonitoringConfig) or
+            (hasattr(config, 'usecase') and config.usecase == 'vehicle_monitoring' and
+             hasattr(config, 'category') and config.category == 'traffic')
+        )
+        if not is_valid_config:
+            self.logger.error(
+                f"Config validation failed in vehicle_monitoring. "
+                f"Got type={type(config).__name__}, module={type(config).__module__}, "
+                f"usecase={getattr(config, 'usecase', 'N/A')}, category={getattr(config, 'category', 'N/A')}"
+            )
+            return self.create_error_result(
+                f"Invalid config type: expected VehicleMonitoringConfig or config with usecase='vehicle_monitoring', "
+                f"got {type(config).__name__} with usecase={getattr(config, 'usecase', 'N/A')}",
+                usecase=self.name, category=self.category, context=context
+            )
         if context is None:
             context = ProcessingContext()
 
@@ -158,9 +178,15 @@ class VehicleMonitoringUseCase(BaseProcessor):
             from ..advanced_tracker import AdvancedTracker
             from ..advanced_tracker.config import TrackerConfig
             if self.tracker is None:
-                tracker_config = TrackerConfig()
+                tracker_config = TrackerConfig(
+                    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")
+                self.logger.info(
+                    f"Initialized AdvancedTracker for Vehicle Monitoring "
+                    f"(class_aggregation={config.enable_class_aggregation})"
+                )
             processed_data = self.tracker.update(processed_data)
         except Exception as e:
             self.logger.warning(f"AdvancedTracker failed: {e}")

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,139 @@ 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 with frame identification.
+        
+        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
+        """
+        if not getattr(self, '_debug_detection_flow', True):
+            return
+        
+        # Use existing frame counter
+        frame_id = self._total_frame_counter
+        timestamp_str = datetime.now(timezone.utc).strftime('%H:%M:%S.%f')[:-3]
+        
+        # Create unique log identifier for grep
+        log_id = f"FRAME_{frame_id:06d}"
+        
+        separator = "=" * 80
+        print(f"\n{separator}")
+        print(f"[DETECTION_STATS] {log_id} | Time: {timestamp_str} | Stage: {stage_name}")
+        print(separator)
+        
+        # Handle different data formats
+        detections = []
+        if isinstance(data, list):
+            detections = data
+        elif isinstance(data, dict):
+            # Frame-based format
+            for fid, frame_dets in data.items():
+                if isinstance(frame_dets, list):
+                    detections.extend(frame_dets)
+        
+        if not detections:
+            print(f"  Frame: #{frame_id} | 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}
+        has_track_id = 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
+            
+            # Track ID presence
+            if det.get('track_id') is not None:
+                has_track_id += 1
+        
+        # Print summary
+        print(f"  Frame: #{frame_id} | Total Detections: {total_count}")
+        
+        if has_track_id > 0:
+            print(f"  Detections with Track ID: {has_track_id} ({100*has_track_id/total_count:.1f}%)")
+        
+        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__})")
+            
+            if sample.get('track_id') is not None:
+                print(f"    Track ID: {sample.get('track_id')} (type: {type(sample.get('track_id')).__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)

matrice_analytics/post_processing/usecases/vehicle_monitoring_parking_lot.py

@@ -30,6 +30,10 @@ class VehicleMonitoringParkingLotConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
     confidence_threshold: float = 0.6
 
+    # 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: {
@@ -106,8 +110,24 @@ class VehicleMonitoringParkingLotUseCase(BaseProcessor):
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         processing_start = time.time()
-        if not isinstance(config, VehicleMonitoringParkingLotConfig):
-            return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
+        # Relaxed check: Accept VehicleMonitoringParkingLotConfig OR any config with matching usecase/category
+        # This handles multiprocessing module path mismatches while maintaining type safety
+        is_valid_config = (
+            isinstance(config, VehicleMonitoringParkingLotConfig) or
+            (hasattr(config, 'usecase') and config.usecase == 'vehicle_monitoring_parking_lot' and
+             hasattr(config, 'category') and config.category == 'traffic')
+        )
+        if not is_valid_config:
+            self.logger.error(
+                f"Config validation failed in vehicle_monitoring_parking_lot. "
+                f"Got type={type(config).__name__}, module={type(config).__module__}, "
+                f"usecase={getattr(config, 'usecase', 'N/A')}, category={getattr(config, 'category', 'N/A')}"
+            )
+            return self.create_error_result(
+                f"Invalid config type: expected VehicleMonitoringParkingLotConfig or config with usecase='vehicle_monitoring_parking_lot', "
+                f"got {type(config).__name__} with usecase={getattr(config, 'usecase', 'N/A')}",
+                usecase=self.name, category=self.category, context=context
+            )
         if context is None:
             context = ProcessingContext()
 
@@ -157,9 +177,22 @@ class VehicleMonitoringParkingLotUseCase(BaseProcessor):
             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 Parking Lot 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)
         except Exception as e:
             self.logger.warning(f"AdvancedTracker failed: {e}")