matrice-analytics 0.1.82__tar.gz → 0.1.115__tar.gz

{matrice_analytics-0.1.82 → matrice_analytics-0.1.115}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.82
+Version: 0.1.115
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_analytics-0.1.82 → matrice_analytics-0.1.115}/matrice_analytics.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice_analytics
-Version: 0.1.82
+Version: 0.1.115
 Summary: Common server utilities for Matrice.ai services
 Author-email: "Matrice.ai" <dipendra@matrice.ai>
 License-Expression: MIT

{matrice_analytics-0.1.82 → matrice_analytics-0.1.115}/matrice_analytics.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ src/matrice_analytics/post_processing/advanced_tracker/config.py
 src/matrice_analytics/post_processing/advanced_tracker/kalman_filter.py
 src/matrice_analytics/post_processing/advanced_tracker/matching.py
 src/matrice_analytics/post_processing/advanced_tracker/strack.py
+src/matrice_analytics/post_processing/advanced_tracker/track_class_aggregator.py
 src/matrice_analytics/post_processing/advanced_tracker/tracker.py
 src/matrice_analytics/post_processing/core/__init__.py
 src/matrice_analytics/post_processing/core/base.py
@@ -127,6 +128,7 @@ src/matrice_analytics/post_processing/usecases/field_mapping.py
 src/matrice_analytics/post_processing/usecases/fire_detection.py
 src/matrice_analytics/post_processing/usecases/flare_analysis.py
 src/matrice_analytics/post_processing/usecases/flower_segmentation.py
+src/matrice_analytics/post_processing/usecases/footfall.py
 src/matrice_analytics/post_processing/usecases/gas_leak_detection.py
 src/matrice_analytics/post_processing/usecases/gender_detection.py
 src/matrice_analytics/post_processing/usecases/human_activity_recognition.py
@@ -140,6 +142,7 @@ src/matrice_analytics/post_processing/usecases/litter_monitoring.py
 src/matrice_analytics/post_processing/usecases/mask_detection.py
 src/matrice_analytics/post_processing/usecases/natural_disaster.py
 src/matrice_analytics/post_processing/usecases/parking.py
+src/matrice_analytics/post_processing/usecases/parking_lot_analytics.py
 src/matrice_analytics/post_processing/usecases/parking_space_detection.py
 src/matrice_analytics/post_processing/usecases/pcb_defect_detection.py
 src/matrice_analytics/post_processing/usecases/pedestrian_detection.py
@@ -168,6 +171,8 @@ src/matrice_analytics/post_processing/usecases/traffic_sign_monitoring.py
 src/matrice_analytics/post_processing/usecases/underground_pipeline_defect_detection.py
 src/matrice_analytics/post_processing/usecases/underwater_pollution_detection.py
 src/matrice_analytics/post_processing/usecases/vehicle_monitoring.py
+src/matrice_analytics/post_processing/usecases/vehicle_monitoring_drone_view.py
+src/matrice_analytics/post_processing/usecases/vehicle_monitoring_parking_lot.py
 src/matrice_analytics/post_processing/usecases/warehouse_object_segmentation.py
 src/matrice_analytics/post_processing/usecases/waterbody_segmentation.py
 src/matrice_analytics/post_processing/usecases/weapon_detection.py
@@ -188,6 +193,7 @@ src/matrice_analytics/post_processing/utils/__init__.py
 src/matrice_analytics/post_processing/utils/advanced_counting_utils.py
 src/matrice_analytics/post_processing/utils/advanced_helper_utils.py
 src/matrice_analytics/post_processing/utils/advanced_tracking_utils.py
+src/matrice_analytics/post_processing/utils/agnostic_nms.py
 src/matrice_analytics/post_processing/utils/alert_instance_utils.py
 src/matrice_analytics/post_processing/utils/alerting_utils.py
 src/matrice_analytics/post_processing/utils/business_metrics_manager_utils.py
@@ -198,5 +204,6 @@ src/matrice_analytics/post_processing/utils/filter_utils.py
 src/matrice_analytics/post_processing/utils/format_utils.py
 src/matrice_analytics/post_processing/utils/geometry_utils.py
 src/matrice_analytics/post_processing/utils/incident_manager_utils.py
+src/matrice_analytics/post_processing/utils/parking_analytics_tracker.py
 src/matrice_analytics/post_processing/utils/smoothing_utils.py
 src/matrice_analytics/post_processing/utils/tracking_utils.py

{matrice_analytics-0.1.82 → matrice_analytics-0.1.115}/src/matrice_analytics/post_processing/__init__.py

@@ -84,7 +84,8 @@ from .usecases.field_mapping import FieldMappingConfig, FieldMappingUseCase
 from .usecases.leaf_disease import LeafDiseaseDetectionConfig, LeafDiseaseDetectionUseCase
 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.weld_defect_detection import WeldDefectConfig
 from .usecases.weapon_detection import WeaponDetectionConfig
@@ -128,7 +129,10 @@ from .usecases.pcb_defect_detection import PCBDefectConfig, PCBDefectUseCase
 from .usecases.underground_pipeline_defect_detection import UndergroundPipelineDefectConfig,UndergroundPipelineDefectUseCase
 from .usecases.suspicious_activity_detection import SusActivityConfig, SusActivityUseCase
 from .usecases.natural_disaster import NaturalDisasterConfig, NaturalDisasterUseCase
-
+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
 #Put all IMAGE based usecases here
 from .usecases.blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
 from .usecases.skin_cancer_classification_img import SkinCancerClassificationConfig, SkinCancerClassificationUseCase
@@ -205,6 +209,10 @@ from .usecases import (
 
     SusActivityUseCase,
     NaturalDisasterUseCase,
+    FootFallUseCase,
+    VehicleMonitoringParkingLotUseCase,
+    VehicleMonitoringDroneViewUseCase,
+    ParkingLotAnalyticsUseCase,
 
     #Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
@@ -286,6 +294,10 @@ _pcb_defect_detection = PCBDefectUseCase()
 _underground_pipeline_defect = UndergroundPipelineDefectUseCase()
 _suspicious_activity_detection = SusActivityUseCase()
 _natural_disaster = NaturalDisasterUseCase()
+_footfall = FootFallUseCase()
+_vehicle_monitoring_parking_lot = VehicleMonitoringParkingLotUseCase()
+_vehicle_monitoring_drone_view = VehicleMonitoringDroneViewUseCase()
+_parking_lot_analytics = ParkingLotAnalyticsUseCase()
 
 # Face recognition with embeddings
 _face_recognition = FaceRecognitionEmbeddingUseCase()
@@ -370,6 +382,10 @@ registry.register_use_case(_pcb_defect_detection.category, _pcb_defect_detection
 registry.register_use_case(_underground_pipeline_defect.category, _underground_pipeline_defect.name, UndergroundPipelineDefectUseCase)
 registry.register_use_case(_suspicious_activity_detection.category, _suspicious_activity_detection.name, SusActivityUseCase)
 registry.register_use_case(_natural_disaster.category, _natural_disaster.name, NaturalDisasterUseCase)
+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)
 
 #Put all IMAGE based usecases here
 registry.register_use_case(_blood_cancer_detection.category, _blood_cancer_detection.name, BloodCancerDetectionUseCase)
@@ -574,7 +590,11 @@ __all__ = [
     'UndergroundPipelineDefectConfig',
     'SusActivityConfig',
     'NaturalDisasterConfig',
-    'VehiclePeopleDroneMonitoringConfig'
+    'VehiclePeopleDroneMonitoringConfig',
+    'FootFallConfig',
+    'VehicleMonitoringParkingLotConfig',
+    'VehicleMonitoringDroneViewConfig',
+    'ParkingLotAnalyticsConfig',
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',
     'SkinCancerClassificationConfig',
@@ -648,6 +668,10 @@ __all__ = [
     'UndergroundPipelineDefectUseCase',
     'SusActivityUseCase',
     'NaturalDisasterUseCase',
+    'FootFallUseCase',
+    'VehicleMonitoringParkingLotUseCase',
+    'VehicleMonitoringDroneViewUseCase',
+    'ParkingLotAnalyticsUseCase',
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',
@@ -710,6 +734,7 @@ __all__ = [
     'detect_line_crossings',
     'analyze_track_movements',
     'filter_tracks_by_duration',
+    'ParkingAnalyticsTracker',
     
     # New utilities
     'create_people_counting_config',

{matrice_analytics-0.1.82 → matrice_analytics-0.1.115}/src/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-0.1.115/src/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-0.1.82 → matrice_analytics-0.1.115}/src/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-0.1.82 → matrice_analytics-0.1.115}/src/matrice_analytics/post_processing/config.py

@@ -7,11 +7,13 @@ 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",
     "ppe_compliance": "ppe_compliance",
-    "advanced_customer_service": "advanced_customer_service",
+    "Customer Activity Analysis": "advanced_customer_service",
     "assembly_line_detection": "assembly_line_detection",
     "crop_weed_detection"  : "crop_weed_detection",
     "emergency_vehicle_detection": "emergency_vehicle_detection",
@@ -65,6 +67,12 @@ APP_NAME_TO_USECASE = {
     "underground_pipeline_defect" : "underground_pipeline_defect",
     "suspicious_activity_detection": "suspicious_activity_detection",
     "natural_disaster_detection": "natural_disaster_detection",
+    "Foot Fall": "footfall",
+    "Parking Lot Vehicle Monitoring": "vehicle_monitoring_parking_lot",
+    "vehicle_monitoring_parking_lot": "vehicle_monitoring_parking_lot",
+    "Vehicle Monitoring Parking Lot": "vehicle_monitoring_parking_lot",
+    "Drone view vehicle monitoring": "vehicle_monitoring_drone_view",
+    "Parking Lot Analytics": "parking_lot_analytics",
 }
 
 APP_NAME_TO_CATEGORY = {
@@ -76,11 +84,13 @@ 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",
     "ppe_compliance": "security",
-    "advanced_customer_service": "sales",
+    "Customer Activity Analysis": "sales",
     "assembly_line_detection": "manufacturing",
     "crop_weed_detection": "agriculture",
     "emergency_vehicle_detection": "traffic",
@@ -135,6 +145,12 @@ APP_NAME_TO_CATEGORY = {
     "underground_pipeline_defect" : "general",
     "suspicious_activity_detection": "security",
     "natural_disaster_detection": "environmental",
+    "Foot Fall": "retail",
+    "Parking Lot Vehicle Monitoring": "traffic",
+    "vehicle_monitoring_parking_lot": "traffic",
+    "Vehicle Monitoring Parking Lot": "traffic",
+    "Drone view vehicle monitoring": "traffic",
+    "Parking Lot Analytics": "traffic",
 }
 
 def get_usecase_from_app_name(app_name: str) -> str:

{matrice_analytics-0.1.82 → matrice_analytics-0.1.115}/src/matrice_analytics/post_processing/core/config.py

@@ -352,14 +352,19 @@ class AlertConfig:
 @dataclass
 class PeopleCountingConfig(BaseConfig):
     """Configuration for people counting use case."""
-    
+
     # Smoothing configuration
     enable_smoothing: bool = True
     smoothing_algorithm: str = "observability"  # "window" or "observability"
     smoothing_window_size: int = 20
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
-    
+
+    # ====== PERFORMANCE: Tracker selection (both disabled by default for max throughput) ======
+    enable_advanced_tracker: bool = False  # Heavy O(n³) tracker - enable only when tracking quality is critical
+    enable_simple_tracker: bool = False    # Lightweight O(n) tracker - fast but no cross-frame persistence
+    # ====== END PERFORMANCE CONFIG ======
+
     # Zone configuration
     zone_config: Optional[ZoneConfig] = None
     
@@ -901,6 +906,10 @@ class ConfigManager:
             'underground_pipeline_defect' : None,
             'suspicious_activity_detection': None,
             'natural_disaster_detection': None,
+            'footfall': None,
+            'vehicle_monitoring_parking_lot': None,
+            'vehicle_monitoring_drone_view': None,
+            'parking_lot_analytics': None,
 
             #Put all image based usecases here::
             'blood_cancer_detection_img': None,
@@ -1405,7 +1414,39 @@ class ConfigManager:
             return NaturalDisasterConfig
         except ImportError:
             return None
-    
+        
+    def footfall_detection_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.footfall import FootFallConfig
+            return FootFallConfig
+        except ImportError:
+            return None
+        
+    def vehicle_monitoring_parking_lot_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotConfig
+            return VehicleMonitoringParkingLotConfig
+        except ImportError:
+            return None
+        
+    def vehicle_monitoring_drone_view_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewConfig
+            return VehicleMonitoringDroneViewConfig
+        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
+        
     #put all image based usecases here::
     def blood_cancer_detection_config_class(self):
         """Register a configuration class for a use case."""
@@ -2009,15 +2050,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":
@@ -2684,6 +2737,70 @@ class ConfigManager:
                 **kwargs
             )
         
+        elif usecase == "footfall":
+            # Import here to avoid circular import
+            from ..usecases.footfall import FootFallConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = FootFallConfig(
+                category=category or "retail",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+
+        elif usecase == "vehicle_monitoring_parking_lot":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = VehicleMonitoringParkingLotConfig(
+                category=category or "traffic",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
+
+        elif usecase == "vehicle_monitoring_drone_view":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewConfig
+
+            # Handle nested configurations
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = VehicleMonitoringDroneViewConfig(
+                category=category or "traffic",
+                usecase=usecase,
+                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
+            )
+        
         #Add IMAGE based usecases here::
         elif usecase == "blood_cancer_detection_img":
             # Import here to avoid circular import
@@ -3234,6 +3351,31 @@ class ConfigManager:
             from ..usecases.natural_disaster import NaturalDisasterConfig
             default_config = NaturalDisasterConfig()
             return default_config.to_dict()
+
+        elif usecase == "footfall":
+            # Import here to avoid circular import
+            from ..usecases.footfall import FootFallConfig
+            default_config = FootFallConfig()
+            return default_config.to_dict()
+        
+        elif usecase == "vehicle_monitoring_parking_lot":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotConfig
+            default_config = VehicleMonitoringParkingLotConfig()
+            return default_config.to_dict()
+        
+        elif usecase == "vehicle_monitoring_drone_view":
+            # Import here to avoid circular import
+            from ..usecases.vehicle_monitoring_drone_view import VehicleMonitoringDroneViewConfig
+            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()
+            return default_config.to_dict()
+        
         
         elif usecase == "underground_pipeline_defect":
             # Import here to avoid circular import