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

matrice_analytics/post_processing/__init__.py

@@ -86,6 +86,7 @@ from .usecases.parking import ParkingConfig
 from .usecases.abandoned_object_detection import AbandonedObjectConfig
 from .usecases.footfall import FootFallConfig
 from .usecases.vehicle_monitoring import VehicleMonitoringConfig
+from .usecases.crowdflow import CrowdflowConfig
 
 from .usecases.weld_defect_detection import WeldDefectConfig
 from .usecases.weapon_detection import WeaponDetectionConfig
@@ -132,6 +133,9 @@ from .usecases.natural_disaster import NaturalDisasterConfig, NaturalDisasterUse
 from .usecases.footfall import FootFallUseCase
 from .usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotUseCase, VehicleMonitoringParkingLotConfig
 from .usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewUseCase, VehicleMonitoringDroneViewConfig
+from .usecases.parking_lot_analytics import ParkingLotAnalyticsConfig, ParkingLotAnalyticsUseCase
+from .usecases.vehicle_monitoring_wrong_way import VehicleMonitoringWrongWayConfig, VehicleMonitoringWrongWayUseCase
+from .usecases.crowdflow import CrowdflowUseCase
 
 #Put all IMAGE based usecases here
 from .usecases.blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
@@ -212,6 +216,9 @@ from .usecases import (
     FootFallUseCase,
     VehicleMonitoringParkingLotUseCase,
     VehicleMonitoringDroneViewUseCase,
+    ParkingLotAnalyticsUseCase,
+    VehicleMonitoringWrongWayUseCase,
+    CrowdflowUseCase,
 
     #Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
@@ -296,6 +303,9 @@ _natural_disaster = NaturalDisasterUseCase()
 _footfall = FootFallUseCase()
 _vehicle_monitoring_parking_lot = VehicleMonitoringParkingLotUseCase()
 _vehicle_monitoring_drone_view = VehicleMonitoringDroneViewUseCase()
+_parking_lot_analytics = ParkingLotAnalyticsUseCase()
+_vehicle_monitoring_wrong_way = VehicleMonitoringWrongWayUseCase()
+_crowdflow= CrowdflowUseCase()
 
 # Face recognition with embeddings
 _face_recognition = FaceRecognitionEmbeddingUseCase()
@@ -383,6 +393,9 @@ registry.register_use_case(_natural_disaster.category, _natural_disaster.name, N
 registry.register_use_case(_footfall.category, _footfall.name, FaceEmotionUseCase)
 registry.register_use_case(_vehicle_monitoring_parking_lot.category, _vehicle_monitoring_parking_lot.name, VehicleMonitoringParkingLotUseCase)
 registry.register_use_case(_vehicle_monitoring_drone_view.category, _vehicle_monitoring_drone_view.name, VehicleMonitoringDroneViewUseCase)
+registry.register_use_case(_parking_lot_analytics.category, _parking_lot_analytics.name, ParkingLotAnalyticsUseCase)
+registry.register_use_case(_vehicle_monitoring_wrong_way.category, _vehicle_monitoring_wrong_way.name, VehicleMonitoringWrongWayUseCase)
+registry.register_use_case(_crowdflow.category, _crowdflow.name, CrowdflowUseCase )
 
 #Put all IMAGE based usecases here
 registry.register_use_case(_blood_cancer_detection.category, _blood_cancer_detection.name, BloodCancerDetectionUseCase)
@@ -591,6 +604,10 @@ __all__ = [
     'FootFallConfig',
     'VehicleMonitoringParkingLotConfig',
     'VehicleMonitoringDroneViewConfig',
+    'ParkingLotAnalyticsConfig',
+    'VehicleMonitoringWrongWayConfig',
+
+    'CrowdflowConfig'
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',
     'SkinCancerClassificationConfig',
@@ -667,6 +684,9 @@ __all__ = [
     'FootFallUseCase',
     'VehicleMonitoringParkingLotUseCase',
     'VehicleMonitoringDroneViewUseCase',
+    'ParkingLotAnalyticsUseCase',
+    'VehicleMonitoringWrongWayUseCase',
+    'CrowdflowUseCase'
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',
@@ -729,6 +749,8 @@ __all__ = [
     'detect_line_crossings',
     'analyze_track_movements',
     'filter_tracks_by_duration',
+    'ParkingAnalyticsTracker',
+    'WrongWayDetectionTracker',
     
     # New utilities
     'create_people_counting_config',

matrice_analytics/post_processing/advanced_tracker/config.py

@@ -1,6 +1,5 @@
 """
 Configuration classes for advanced tracker.
-
 This module provides configuration classes for the advanced tracker,
 including parameters for tracking algorithms and thresholds.
 """
@@ -8,7 +7,6 @@ including parameters for tracking algorithms and thresholds.
 from dataclasses import dataclass, field
 from typing import Optional
 
-
 @dataclass
 class TrackerConfig:
     """
@@ -46,6 +44,10 @@ class TrackerConfig:
     smoothing_window_size: int = 20
     smoothing_cooldown_frames: int = 5
     
+    # Class aggregation settings
+    enable_class_aggregation: bool = False
+    class_aggregation_window_size: int = 30
+    
     def __post_init__(self):
         """Validate configuration parameters."""
         if not 0.0 <= self.track_high_thresh <= 1.0:
@@ -72,6 +74,8 @@ class TrackerConfig:
         if self.output_format not in ["tracking", "detection"]:
             raise ValueError(f"Invalid output_format: {self.output_format}")
         
-        # Calculate max_time_lost if not explicitly set
         if self.max_time_lost == 30:  # Default value
-            self.max_time_lost = int(self.frame_rate / 30.0 * self.track_buffer) 
+            self.max_time_lost = int(self.frame_rate / 30.0 * self.track_buffer)
+        
+        if self.class_aggregation_window_size <= 0:
+            raise ValueError(f"class_aggregation_window_size must be positive, got {self.class_aggregation_window_size}")

matrice_analytics/post_processing/advanced_tracker/track_class_aggregator.py

@@ -0,0 +1,128 @@
+"""
+Track class aggregation for object tracking.
+
+This module provides a sliding-window-based mechanism to aggregate class labels
+across frames, reducing label flickering in tracking outputs through temporal voting.
+"""
+
+from typing import Any, Dict
+from collections import deque, Counter
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class TrackClassAggregator:
+    """
+    Maintains per-track sliding windows of class labels and returns the most frequent.
+    
+    This aggregator reduces class label flickering in tracking results by applying
+    temporal voting based on historical observations within a sliding window.
+    
+    Attributes:
+        window_size (int): Maximum number of frames to keep in the sliding window.
+        track_windows (Dict[int, deque]): Per-track sliding windows of class labels.
+    """
+    
+    def __init__(self, window_size: int = 30):
+        """
+        Initialize the TrackClassAggregator.
+        
+        Args:
+            window_size (int): Number of recent frames to consider for aggregation.
+                Must be positive. Larger windows provide more stability but slower
+                adaptation to genuine class changes.
+        """
+        if window_size <= 0:
+            raise ValueError(f"window_size must be positive, got {window_size}")
+        
+        self.window_size = window_size
+        self.track_windows: Dict[int, deque] = {}
+    
+    def update_and_aggregate(self, track_id: int, observed_class: Any) -> Any:
+        """
+        Update the sliding window for a track and return the aggregated class label.
+        
+        This method:
+        1. Adds the new observation to the track's window
+        2. Maintains window size by removing oldest entries if needed
+        3. Returns the most frequent class in the window
+        
+        Args:
+            track_id (int): Unique identifier for the track.
+            observed_class (Any): The class label observed in the current frame.
+        
+        Returns:
+            Any: The aggregated class label (most frequent in the window).
+                If there's a tie, returns the most recent among tied classes.
+        """
+        # Initialize window for new tracks
+        if track_id not in self.track_windows:
+            self.track_windows[track_id] = deque(maxlen=self.window_size)
+        
+        # Add current observation
+        window = self.track_windows[track_id]
+        window.append(observed_class)
+        
+        # Return most frequent class
+        if len(window) == 0:
+            return observed_class
+        
+        # Count frequencies and return most common
+        class_counts = Counter(window)
+        most_common = class_counts.most_common(1)[0][0]
+        
+        return most_common
+    
+    def get_aggregated_class(self, track_id: int, fallback_class: Any) -> Any:
+        """
+        Get the aggregated class for a track without updating the window.
+        
+        Args:
+            track_id (int): Unique identifier for the track.
+            fallback_class (Any): Class to return if track has no history.
+        
+        Returns:
+            Any: The aggregated class label, or fallback_class if no history exists.
+        """
+        if track_id not in self.track_windows:
+            return fallback_class
+        
+        window = self.track_windows[track_id]
+        if len(window) == 0:
+            return fallback_class
+        
+        class_counts = Counter(window)
+        return class_counts.most_common(1)[0][0]
+    
+    def remove_track(self, track_id: int) -> None:
+        """
+        Remove a track's window from memory.
+        
+        Args:
+            track_id (int): Unique identifier for the track to remove.
+        """
+        if track_id in self.track_windows:
+            del self.track_windows[track_id]
+    
+    def remove_tracks(self, track_ids: list) -> None:
+        """
+        Remove multiple tracks' windows from memory (batch operation).
+        
+        Args:
+            track_ids (list): List of track IDs to remove.
+        """
+        for track_id in track_ids:
+            self.remove_track(track_id)
+    
+    def reset(self) -> None:
+        """Clear all track windows."""
+        self.track_windows.clear()
+    
+    def get_active_track_count(self) -> int:
+        """Get the number of tracks currently being aggregated."""
+        return len(self.track_windows)
+    
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"TrackClassAggregator(window_size={self.window_size}, active_tracks={len(self.track_windows)})"

matrice_analytics/post_processing/advanced_tracker/tracker.py

@@ -34,6 +34,7 @@ class AdvancedTracker:
         config (TrackerConfig): Tracker configuration.
         max_time_lost (int): The maximum frames for a track to be considered as 'lost'.
         kalman_filter (KalmanFilterXYAH): Kalman Filter object.
+        class_smoother (Optional[ClassSmoother]): Optional class smoother for class label smoothing over flicker.
     """
 
     def __init__(self, config: TrackerConfig):
@@ -53,6 +54,11 @@ class AdvancedTracker:
         self.kalman_filter = self.get_kalmanfilter()
         self.reset_id()
 
+        self.class_aggregator = None
+        if config.enable_class_aggregation:
+            from .track_class_aggregator import TrackClassAggregator
+            self.class_aggregator = TrackClassAggregator(window_size=config.class_aggregation_window_size)
+
     def update(self, detections: Union[List[Dict], Dict[str, List[Dict]]], 
                img: Optional[np.ndarray] = None) -> Union[List[Dict], Dict[str, List[Dict]]]:
         """
@@ -186,7 +192,15 @@ class AdvancedTracker:
                     }
                 
                 detections.append(detection)
-        
+
+        if self.class_aggregator is not None:
+            for detection in detections:
+                aggregated_class = self.class_aggregator.update_and_aggregate(
+                    track_id=detection['track_id'],
+                    observed_class=detection['category']
+                )
+                detection['category'] = aggregated_class
+            
         return detections
 
     def _perform_tracking_update(self, detections: List[STrack], 
@@ -296,6 +310,10 @@ class AdvancedTracker:
         
         if len(self.removed_stracks) > 1000:
             self.removed_stracks = self.removed_stracks[-999:]
+        
+        # Clean up aggregator windows for removed tracks
+        if self.class_aggregator is not None and removed_stracks:
+            self.class_aggregator.remove_tracks([t.track_id for t in removed_stracks])
 
         return [x for x in self.tracked_stracks if x.is_activated]
 
@@ -327,6 +345,9 @@ class AdvancedTracker:
         self.frame_id = 0
         self.kalman_filter = self.get_kalmanfilter()
         self.reset_id()
+    
+        if self.class_aggregator is not None:
+            self.class_aggregator.reset()
 
     @staticmethod
     def joint_stracks(tlista: List[STrack], tlistb: List[STrack]) -> List[STrack]:

matrice_analytics/post_processing/config.py

@@ -7,6 +7,8 @@ APP_NAME_TO_USECASE = {
     "pipeline_detection": "pipeline_detection",
     "vehicle_monitoring": "vehicle_monitoring",
     "Vehicle Type Monitoring": "vehicle_monitoring",
+    "Vehicle Monitoring": "vehicle_monitoring",
+    "vehicle-monitoring": "vehicle_monitoring",
     "weapon_detection": "weapon_detection",
     "traffic_sign_monitoring": "traffic_sign_monitoring",
     "flare_analysis": "flare_analysis",
@@ -66,8 +68,14 @@ APP_NAME_TO_USECASE = {
     "suspicious_activity_detection": "suspicious_activity_detection",
     "natural_disaster_detection": "natural_disaster_detection",
     "Foot Fall": "footfall",
+    "Crowdflow": "crowdflow",
+    "Parking Lot Vehicle Monitoring": "vehicle_monitoring_parking_lot",
     "vehicle_monitoring_parking_lot": "vehicle_monitoring_parking_lot",
-    "vehicle_monitoring_drone_view": "vehicle_monitoring_drone_view",
+    "Vehicle Monitoring Parking Lot": "vehicle_monitoring_parking_lot",
+    "Drone view vehicle monitoring": "vehicle_monitoring_drone_view",
+    "Parking Lot Analytics": "parking_lot_analytics",
+    "Vehicle Monitoring Wrong Way": "vehicle_monitoring_wrong_way",
+    
 }
 
 APP_NAME_TO_CATEGORY = {
@@ -79,6 +87,8 @@ APP_NAME_TO_CATEGORY = {
     "pipeline_detection": "pipeline_detection",
     "vehicle_monitoring": "traffic",
     "Vehicle Type Monitoring": "traffic",
+    "Vehicle Monitoring": "traffic",
+    "vehicle-monitoring": "traffic",
     "weapon_detection": "security",
     "traffic_sign_monitoring": "traffic",
     "flare_analysis": "flare_detection",
@@ -139,8 +149,13 @@ APP_NAME_TO_CATEGORY = {
     "suspicious_activity_detection": "security",
     "natural_disaster_detection": "environmental",
     "Foot Fall": "retail",
+    "Crowdflow": "retail",
+    "Parking Lot Vehicle Monitoring": "traffic",
     "vehicle_monitoring_parking_lot": "traffic",
-    "vehicle_monitoring_drone_view": "traffic",
+    "Vehicle Monitoring Parking Lot": "traffic",
+    "Drone view vehicle monitoring": "traffic",
+    "Parking Lot Analytics": "traffic",
+    "Vehicle Monitoring Wrong Way": "traffic",
 }
 
 def get_usecase_from_app_name(app_name: str) -> str:

matrice_analytics/post_processing/core/config.py

@@ -909,6 +909,9 @@ class ConfigManager:
             'footfall': None,
             'vehicle_monitoring_parking_lot': None,
             'vehicle_monitoring_drone_view': None,
+            'parking_lot_analytics': None,
+            'vehicle_monitoring_wrong_way': None,
+            'crowdflow': None,
 
             #Put all image based usecases here::
             'blood_cancer_detection_img': None,
@@ -1438,6 +1441,31 @@ class ConfigManager:
         except ImportError:
             return None
         
+    def parking_lot_analytics_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.parking_lot_analytics import ParkingLotAnalyticsConfig
+            return ParkingLotAnalyticsConfig
+        except ImportError:
+            return None
+        
+    def crowdflow_detection_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.crowdflow import CrowdflowConfig
+            return CrowdflowConfig
+        except ImportError:
+            return None
+    
+        
+    def vehicle_monitoring_wrong_way_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.vehicle_monitoring_wrong_way import VehicleMonitoringWrongWayConfig
+            return VehicleMonitoringWrongWayConfig
+        except ImportError:
+            return None
+        
     #put all image based usecases here::
     def blood_cancer_detection_config_class(self):
         """Register a configuration class for a use case."""
@@ -2041,15 +2069,27 @@ class ConfigManager:
             from ..usecases.vehicle_monitoring import VehicleMonitoringConfig
 
             # Handle nested configurations
+            zone_config = kwargs.pop("zone_config", None)
+            # VehicleMonitoringConfig expects zone_config as Dict, not ZoneConfig object
+            # If it's a ZoneConfig object, convert it to dict
+            if zone_config and hasattr(zone_config, 'to_dict'):
+                zone_config = zone_config.to_dict()
+            elif zone_config and isinstance(zone_config, ZoneConfig):
+                zone_config = {"zones": zone_config.zones} if zone_config.zones else None
+
             alert_config = kwargs.pop("alert_config", None)
             if alert_config and isinstance(alert_config, dict):
                 alert_config = AlertConfig(**alert_config)
 
+            # Filter kwargs to only include valid parameters
+            filtered_kwargs = self._filter_kwargs_for_config(VehicleMonitoringConfig, kwargs)
+
             config = VehicleMonitoringConfig(
                 category=category or "traffic",
                 usecase=usecase,
+                zone_config=zone_config,
                 alert_config=alert_config,
-                **kwargs
+                **filtered_kwargs
             )
         
         elif usecase == "drone_traffic_monitoring":
@@ -2763,6 +2803,56 @@ class ConfigManager:
                 alert_config=alert_config,
                 **kwargs
             )
+
+        elif usecase == "parking_lot_analytics":
+            # Import here to avoid circular import
+            from ..usecases.parking_lot_analytics import ParkingLotAnalyticsConfig
+
+             # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = ParkingLotAnalyticsConfig(
+                category=category or "traffic",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+
+        elif usecase == "crowdflow":
+            # Import here to avoid circular import
+            from ..usecases.crowdflow import CrowdflowConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+            
+            config = CrowdflowConfig(
+                category=category or "retail",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+            
+
+        elif usecase == "vehicle_monitoring_wrong_way":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_wrong_way import VehicleMonitoringWrongWayConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = VehicleMonitoringWrongWayConfig(
+                category=category or "traffic",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+            
         
         #Add IMAGE based usecases here::
         elif usecase == "blood_cancer_detection_img":
@@ -3333,6 +3423,22 @@ class ConfigManager:
             default_config = VehicleMonitoringDroneViewConfig()
             return default_config.to_dict()
         
+        elif usecase == "parking_lot_analytics":
+            # Import here to avoid circular import
+            from ..usecases.parking_lot_analytics import ParkingLotAnalyticsConfig
+            default_config = ParkingLotAnalyticsConfig()
+            
+        elif usecase == "crowdflow":
+            # Import here to avoid circular import
+            from ..usecases.crowdflow import CrowdflowConfig
+            default_config = CrowdflowConfig()
+            return default_config.to_dict()
+        
+        elif usecase == "vehicle_monitoring_wrong_way":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_wrong_way import VehicleMonitoringWrongWayConfig
+            default_config = VehicleMonitoringWrongWayConfig()
+            return default_config.to_dict()
         
         elif usecase == "underground_pipeline_defect":
             # Import here to avoid circular import