matrice-analytics 0.1.96__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/post_processor.py

@@ -100,6 +100,8 @@ from .usecases import (
     SusActivityUseCase,
     NaturalDisasterUseCase,
     FootFallUseCase,
+    VehicleMonitoringParkingLotUseCase,
+    VehicleMonitoringDroneViewUseCase,
     # Put all IMAGE based usecases here
     BloodCancerDetectionUseCase,
     SkinCancerClassificationUseCase,
@@ -573,6 +575,12 @@ class PostProcessor:
         registry.register_use_case(
             "retail", "footfall", FootFallUseCase
         )
+        registry.register_use_case(
+            "traffic", "vehicle_monitoring_parking_lot", VehicleMonitoringParkingLotUseCase
+        )
+        registry.register_use_case(
+            "traffic", "vehicle_monitoring_drone_view", VehicleMonitoringDroneViewUseCase
+        )
 
         # Put all IMAGE based usecases here
         registry.register_use_case(

matrice_analytics/post_processing/usecases/__init__.py

@@ -86,7 +86,8 @@ from .underground_pipeline_defect_detection import UndergroundPipelineDefectConf
 from .suspicious_activity_detection import SusActivityConfig, SusActivityUseCase
 from .natural_disaster import NaturalDisasterConfig, NaturalDisasterUseCase
 from .footfall import FootFallConfig, FootFallUseCase
-
+from .vehicle_monitoring_parking_lot import VehicleMonitoringParkingLotUseCase, VehicleMonitoringParkingLotConfig
+from .vehicle_monitoring_drone_view import VehicleMonitoringDroneViewUseCase, VehicleMonitoringDroneViewConfig
 
 #Put all IMAGE based usecases here
 from .blood_cancer_detection_img import BloodCancerDetectionConfig, BloodCancerDetectionUseCase
@@ -175,6 +176,8 @@ __all__ = [
     'SusActivityUseCase',
     'NaturalDisasterUseCase',
     'FootFallUseCase',
+    'VehicleMonitoringParkingLotUseCase',
+    'VehicleMonitoringDroneViewUseCase',
 
     #Put all IMAGE based usecases here
     'BloodCancerDetectionUseCase',
@@ -258,6 +261,9 @@ __all__ = [
     'SusActivityConfig',
     'NaturalDisasterConfig',
     'FootFallConfig',
+    'VehicleMonitoringParkingLotConfig',
+    'VehicleMonitoringDroneViewConfig',
+
     #Put all IMAGE based usecase CONFIGS here
     'BloodCancerDetectionConfig',
     'SkinCancerClassificationConfig',

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.py

@@ -40,54 +40,35 @@ class VehicleMonitoringConfig(BaseConfig):
 # )
     usecase_categories: List[str] = field(
         default_factory=lambda: [
-            "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat",
-            "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog",
-            "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella",
-            "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
-            "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
-            "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich",
-            "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
-            "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote",
-            "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book",
-            "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"
+            'bicycle', 'motorcycle', 'car', 'van', 'bus', 'truck' 
         ]
     )
     target_categories: List[str] = field(
         default_factory=lambda: [
-            'car', 'bicycle', 'bus','motorcycle']
+            'bicycle', 'motorcycle', 'car', 'van', 'bus', 'truck' 
+        ]
     )
     alert_config: Optional[AlertConfig] = None
     index_to_category: Optional[Dict[int, str]] = field(
         default_factory=lambda: {
-                0: "person", 1: "bicycle", 2: "car", 3: "motorcycle", 4: "airplane", 5: "bus",
-                6: "train", 7: "truck", 8: "boat", 9: "traffic light", 10: "fire hydrant",
-                11: "stop sign", 12: "parking meter", 13: "bench", 14: "bird", 15: "cat",
-                16: "dog", 17: "horse", 18: "sheep", 19: "cow", 20: "elephant", 21: "bear",
-                22: "zebra", 23: "giraffe", 24: "backpack", 25: "umbrella", 26: "handbag",
-                27: "tie", 28: "suitcase", 29: "frisbee", 30: "skis", 31: "snowboard",
-                32: "sports ball", 33: "kite", 34: "baseball bat", 35: "baseball glove",
-                36: "skateboard", 37: "surfboard", 38: "tennis racket", 39: "bottle",
-                40: "wine glass", 41: "cup", 42: "fork", 43: "knife", 44: "spoon", 45: "bowl",
-                46: "banana", 47: "apple", 48: "sandwich", 49: "orange", 50: "broccoli",
-                51: "carrot", 52: "hot dog", 53: "pizza", 54: "donut", 55: "cake", 56: "chair",
-                57: "couch", 58: "potted plant", 59: "bed", 60: "dining table", 61: "toilet",
-                62: "tv", 63: "laptop", 64: "mouse", 65: "remote", 66: "keyboard",
-                67: "cell phone", 68: "microwave", 69: "oven", 70: "toaster", 71: "sink",
-                72: "refrigerator", 73: "book", 74: "clock", 75: "vase", 76: "scissors",
-                77: "teddy bear", 78: "hair drier", 79: "toothbrush"
-            }
+            0: "bicycle",
+            1: "motorcycle", 
+            2: "car",
+            3: "van",
+            4: "bus",
+            5: "truck"
+        }
     )
 
 class VehicleMonitoringUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
         # Focus on vehicle-related COCO classes
         "bicycle": "Bicycle",
-        "car": "Car",
         "motorcycle": "Motorcycle",
+        "car": "Car",
+        "van": "Van",    
         "bus": "Bus",
         "truck": "Truck",
-        "train": "Train",
-        "boat": "Boat"
     }
 
     def __init__(self):
@@ -95,7 +76,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
         self.category = "traffic"
         self.CASE_TYPE: Optional[str] = 'vehicle_monitoring'
         self.CASE_VERSION: Optional[str] = '1.0'
-        self.target_categories = ['car', 'bicycle', 'bus', 'truck', 'motorcycle']
+        self.target_categories = ['bicycle', 'motorcycle', 'car', 'van', 'bus', 'truck' ]
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -141,6 +122,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
         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)