matrice 1.0.99392__py3-none-any.whl → 1.0.99394__py3-none-any.whl

matrice/deploy/utils/post_processing/usecases/vehicle_monitoring.py

@@ -1,22 +1,24 @@
 from typing import Any, Dict, List, Optional, Tuple
+from dataclasses import asdict
 import time
 from datetime import datetime, timezone
 
-from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol
+from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
 from ..utils import (
     filter_by_confidence,
     filter_by_categories,
     apply_category_mapping,
     count_objects_by_category,
     count_objects_in_zones,
+    calculate_counting_summary,
     match_results_structure,
     bbox_smoothing,
     BBoxSmoothingConfig,
     BBoxSmoothingTracker
 )
-from ..utils.geometry_utils import point_in_polygon, get_bbox_bottom25_center
 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
 
 @dataclass
 class VehicleMonitoringConfig(BaseConfig):
@@ -30,24 +32,26 @@ class VehicleMonitoringConfig(BaseConfig):
     zone_config: Optional[ZoneConfig] = None
     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"
+            "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"
         ]
     )
     target_categories: List[str] = field(
-        default_factory=lambda: ['car', 'bicycle', 'bus', 'motorcycle']
+        default_factory=lambda: [
+            'car', 'bicycle', 'bus', 'truck', 'motorcycle']
     )
     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",
+        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",
@@ -62,7 +66,8 @@ class VehicleMonitoringConfig(BaseConfig):
                 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"}
+                77: "teddy bear", 78: "hair drier", 79: "toothbrush"
+            }
     )
 
 class VehicleMonitoringUseCase(BaseProcessor):
@@ -82,7 +87,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', 'motorbike']
+        self.target_categories = ['car', 'bicycle', 'bus', 'truck', 'motorcycle']
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -95,10 +100,22 @@ class VehicleMonitoringUseCase(BaseProcessor):
         self._ascending_alert_list: List[int] = []
         self.current_incident_end_timestamp: str = "N/A"
         self.start_timer = None
+        
+        # Track ID storage for total count calculation
+        self._total_track_ids = set()  # Store all unique track IDs seen across calls
+        self._current_frame_track_ids = set()  # Store track IDs from current frame
+        self._total_count = 0  # Cached total count
+        self._last_update_time = time.time()  # Track when last updated
+        
+        # Zone-based tracking storage
+        self._zone_current_track_ids = {}  # zone_name -> set of current track IDs in zone
+        self._zone_total_track_ids = {}  # zone_name -> set of all track IDs that have been in zone
+        self._zone_current_counts = {}  # zone_name -> current count in zone
+        self._zone_total_counts = {}  # zone_name -> total count that have been in zone
 
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
-        # Note: start_time not used; keeping processing focused on zone-based counts
+        start_time = time.time()
         if not isinstance(config, VehicleMonitoringConfig):
             return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
         if context is None:
@@ -150,36 +167,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
         except Exception as e:
             self.logger.warning(f"AdvancedTracker failed: {e}")
 
-        # If zones are configured, keep only detections that fall inside any zone
-        detections_for_counting = processed_data
-        if getattr(config, 'zone_config', None) and getattr(config.zone_config, 'zones', None):
-            zones = config.zone_config.zones
-            in_zone_detections = []
-            for det in processed_data:
-                matched_zones = []
-                for zone_name, zone_polygon in zones.items():
-                    if self._is_detection_in_zone(det, zone_polygon):
-                        matched_zones.append(zone_name)
-                if matched_zones:
-                    det_copy = dict(det)
-                    det_copy['zones'] = matched_zones
-                    in_zone_detections.append(det_copy)
-            detections_for_counting = in_zone_detections
-
-        self._update_tracking_state(detections_for_counting)
-        # Maintain cumulative per-zone unique track counts using canonicalized track_ids
-        if getattr(config, 'zone_config', None) and getattr(config.zone_config, 'zones', None):
-            if not hasattr(self, '_per_zone_total_track_ids'):
-                self._per_zone_total_track_ids = {}
-            for det in detections_for_counting:
-                track_id = det.get('track_id')
-                if track_id is None:
-                    continue
-                category = det.get('category', 'unknown')
-                for zone_name in det.get('zones', []):
-                    zone_map = self._per_zone_total_track_ids.setdefault(zone_name, {})
-                    cat_set = zone_map.setdefault(category, set())
-                    cat_set.add(track_id)
+        self._update_tracking_state(processed_data)
         self._total_frame_counter += 1
 
         frame_number = None
@@ -190,32 +178,41 @@ class VehicleMonitoringUseCase(BaseProcessor):
             if start_frame is not None and end_frame is not None and start_frame == end_frame:
                 frame_number = start_frame
 
-        # Compute zone-wise counts (and filter totals) if zones are provided
-        zone_counts = {}
-        if getattr(config, 'zone_config', None) and getattr(config.zone_config, 'zones', None):
-            try:
-                zone_counts = count_objects_in_zones(detections_for_counting, config.zone_config.zones)
-            except Exception as e:
-                self.logger.warning("Zone counting failed: %s", e)
-        counting_summary = self._count_categories(detections_for_counting, config)
+        general_counting_summary = calculate_counting_summary(data)
+        counting_summary = self._count_categories(processed_data, config)
         total_counts = self.get_total_counts()
         counting_summary['total_counts'] = total_counts
-        # Attach zone analysis to counting summary so it can be included in human text
-        counting_summary['zone_analysis'] = zone_counts
-        # Attach total zone analysis (unique canonical tracks per zone/category) if available
-        if hasattr(self, '_per_zone_total_track_ids'):
-            counting_summary['zone_analysis_total'] = {
-                zone_name: {cat: len(ids) for cat, ids in cat_map.items()}
-                for zone_name, cat_map in self._per_zone_total_track_ids.items()
-            }
-
-        alerts = self._check_alerts(counting_summary, frame_number, config)
-        # predictions are not required in the current agg_summary; skip computing to avoid unused variable
-
-        incidents_list = self._generate_incidents(counting_summary, alerts, config, frame_number, stream_info)
-        tracking_stats_list = self._generate_tracking_stats(counting_summary, alerts, config, frame_number, stream_info)
-        business_analytics_list = self._generate_business_analytics(counting_summary, alerts, config, stream_info, is_empty=True)
-        summary_list = self._generate_summary(counting_summary, incidents_list, tracking_stats_list, business_analytics_list, alerts)
+        for detection in processed_data:
+            category = detection.get("category", "unknown")
+            counting_summary["categories"][category] = counting_summary["categories"].get(category, 0) + 1
+        
+        zone_analysis = {}
+        if config.zone_config and config.zone_config.zones:
+            # Convert single frame to format expected by count_objects_in_zones
+            frame_data = processed_data #[frame_detections]
+            zone_analysis = count_objects_in_zones(frame_data, config.zone_config.zones)
+            
+            # Update zone tracking with current frame data
+            if zone_analysis and config.enable_tracking:
+                enhanced_zone_analysis = self._update_zone_tracking(zone_analysis, processed_data, config)
+                # Merge enhanced zone analysis with original zone analysis
+                for zone_name, enhanced_data in enhanced_zone_analysis.items():
+                    zone_analysis[zone_name] = enhanced_data
+                    
+        print("-----------------------------ZONEEEE-----------------------------------")
+        print(zone_analysis)
+        print("-----------------------------ZONEEEE-----------------------------------")
+
+        alerts = self._check_alerts(counting_summary,zone_analysis, frame_number, config)
+        predictions = self._extract_predictions(processed_data)
+
+        incidents_list = self._generate_incidents(counting_summary,zone_analysis, alerts, config, frame_number, stream_info)
+        tracking_stats_list = self._generate_tracking_stats(counting_summary,zone_analysis, alerts, config, frame_number, stream_info)
+        print("---------------------------TS--------------------------------------")
+        print(tracking_stats_list)
+        print("---------------------------TS--------------------------------------")
+        business_analytics_list = self._generate_business_analytics(counting_summary,zone_analysis, alerts, config, stream_info, is_empty=True)
+        summary_list = self._generate_summary(counting_summary,zone_analysis, incidents_list, tracking_stats_list, business_analytics_list, alerts)
 
         incidents = incidents_list[0] if incidents_list else {}
         tracking_stats = tracking_stats_list[0] if tracking_stats_list else {}
@@ -226,7 +223,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
             "tracking_stats": tracking_stats,
             "business_analytics": business_analytics,
             "alerts": alerts,
-            "zone_analysis": zone_counts,
+            "zone_analysis": zone_analysis,
             "human_text": summary}
         }
 
@@ -239,6 +236,84 @@ class VehicleMonitoringUseCase(BaseProcessor):
         )
         return result
 
+    def _update_zone_tracking(self, zone_analysis: Dict[str, Dict[str, int]], detections: List[Dict], config: VehicleMonitoringConfig) -> Dict[str, Dict[str, Any]]:
+        """
+        Update zone tracking with current frame data.
+        
+        Args:
+            zone_analysis: Current zone analysis results
+            detections: List of detections with track IDs
+            
+        Returns:
+            Enhanced zone analysis with tracking information
+        """
+        if not zone_analysis or not config.zone_config or not config.zone_config.zones:
+            return {}
+        
+        enhanced_zone_analysis = {}
+        zones = config.zone_config.zones
+        
+        # Get current frame track IDs in each zone
+        current_frame_zone_tracks = {}
+        
+        # Initialize zone tracking for all zones
+        for zone_name in zones.keys():
+            current_frame_zone_tracks[zone_name] = set()
+            if zone_name not in self._zone_current_track_ids:
+                self._zone_current_track_ids[zone_name] = set()
+            if zone_name not in self._zone_total_track_ids:
+                self._zone_total_track_ids[zone_name] = set()
+        
+        # Check each detection against each zone
+        for detection in detections:
+            track_id = detection.get("track_id")
+            if track_id is None:
+                continue
+            
+            # Get detection bbox
+            bbox = detection.get("bounding_box", detection.get("bbox"))
+            if not bbox:
+                continue
+            
+            # Get detection center point
+            center_point = get_bbox_bottom25_center(bbox) #get_bbox_center(bbox)
+            
+            # Check which zone this detection is in using actual zone polygons
+            for zone_name, zone_polygon in zones.items():
+                # Convert polygon points to tuples for point_in_polygon function
+                # zone_polygon format: [[x1, y1], [x2, y2], [x3, y3], ...]
+                polygon_points = [(point[0], point[1]) for point in zone_polygon]
+                
+                # Check if detection center is inside the zone polygon using ray casting algorithm
+                if point_in_polygon(center_point, polygon_points):
+                    current_frame_zone_tracks[zone_name].add(track_id)
+        
+        # Update zone tracking for each zone
+        for zone_name, zone_counts in zone_analysis.items():
+            # Get current frame tracks for this zone
+            current_tracks = current_frame_zone_tracks.get(zone_name, set())
+            
+            # Update current zone tracks
+            self._zone_current_track_ids[zone_name] = current_tracks
+            
+            # Update total zone tracks (accumulate all track IDs that have been in this zone)
+            self._zone_total_track_ids[zone_name].update(current_tracks)
+            
+            # Update counts
+            self._zone_current_counts[zone_name] = len(current_tracks)
+            self._zone_total_counts[zone_name] = len(self._zone_total_track_ids[zone_name])
+            
+            # Create enhanced zone analysis
+            enhanced_zone_analysis[zone_name] = {
+                "current_count": self._zone_current_counts[zone_name],
+                "total_count": self._zone_total_counts[zone_name],
+                "current_track_ids": list(current_tracks),
+                "total_track_ids": list(self._zone_total_track_ids[zone_name]),
+                "original_counts": zone_counts  # Preserve original zone counts
+            }
+        
+        return enhanced_zone_analysis
+
     def _normalize_yolo_results(self, data: Any, index_to_category: Optional[Dict[int, str]] = None) -> Any:
         """
         Normalize YOLO-style outputs to internal detection schema:
@@ -312,7 +387,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
             return normalized_dict
         return data
 
-    def _check_alerts(self, summary: dict, frame_number: Any, config: VehicleMonitoringConfig) -> List[Dict]:
+    def _check_alerts(self, summary: dict, zone_analysis: Dict, frame_number: Any, config: VehicleMonitoringConfig) -> List[Dict]:
         def get_trend(data, lookback=900, threshold=0.6):
             window = data[-lookback:] if len(data) >= lookback else data
             if len(window) < 2:
@@ -345,7 +420,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
                         "threshold_level": threshold,
                         "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
                         "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
-                                                         getattr(config.alert_config, 'alert_value', ['JSON']))}
+                                                        getattr(config.alert_config, 'alert_value', ['JSON']))}
                     })
                 elif category in per_category_count and per_category_count[category] > threshold:
                     alerts.append({
@@ -355,12 +430,12 @@ class VehicleMonitoringUseCase(BaseProcessor):
                         "threshold_level": threshold,
                         "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
                         "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
-                                                         getattr(config.alert_config, 'alert_value', ['JSON']))}
+                                                        getattr(config.alert_config, 'alert_value', ['JSON']))}
                     })
         return alerts
 
-    def _generate_incidents(self, counting_summary: Dict, alerts: List, config: VehicleMonitoringConfig,
-                           frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
+    def _generate_incidents(self, counting_summary: Dict, zone_analysis: Dict, alerts: List, config: VehicleMonitoringConfig,
+                        frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
         incidents = []
         total_detections = counting_summary.get("total_count", 0)
         current_timestamp = self._get_current_timestamp_str(stream_info)
@@ -446,7 +521,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
             incidents.append({})
         return incidents
 
-    def _generate_tracking_stats(self, counting_summary: Dict, alerts: List, config: VehicleMonitoringConfig,
+    def _generate_tracking_stats(self, counting_summary: Dict, zone_analysis: Dict, alerts: List, config: VehicleMonitoringConfig,
                                 frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
         camera_info = self.get_camera_info_from_stream(stream_info)
         tracking_stats = []
@@ -486,55 +561,17 @@ class VehicleMonitoringUseCase(BaseProcessor):
                 "threshold_level": config.alert_config.count_thresholds if hasattr(config.alert_config, 'count_thresholds') else {},
                 "ascending": True,
                 "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
-                                                 getattr(config.alert_config, 'alert_value', ['JSON']))}
+                                                getattr(config.alert_config, 'alert_value', ['JSON']))}
             })
 
         human_text_lines = [f"Tracking Statistics:"]
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
         for cat, count in per_category_count.items():
-            if cat in ['car', 'bicycle', 'bus', 'motorcycle']:
-                human_text_lines.append(f"\t{cat}: {count}")
-            else:
-                human_text_lines.append("No Detections in Frame")
-        # Append zone analysis for the current frame if available
-        zone_analysis = counting_summary.get("zone_analysis", {})
-        if zone_analysis:
-            human_text_lines.append("ZONE ANALYSIS (CURRENT FRAME):")
-            for zone_name, cat_counts in zone_analysis.items():
-                if isinstance(cat_counts, dict):
-                    total_in_zone = sum(cat_counts.values())
-                    car_count = (
-                        cat_counts.get('car', 0)
-                        + cat_counts.get('truck', 0)
-                    )
-                    if car_count > 0:
-                        human_text_lines.append(f"\t{zone_name}: total={total_in_zone} (car: {car_count})")
-                    else:
-                        human_text_lines.append(f"\t{zone_name}: total={total_in_zone}")
-                else:
-                    human_text_lines.append(f"\t{zone_name}: total=0")
+            human_text_lines.append(f"\t{cat}: {count}")
         human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
         for cat, count in total_counts_dict.items():
-            if cat in ['car', 'bicycle', 'bus', 'motorcycle']:
-                if count > 0:
-                    human_text_lines.append(f"\t{cat}: {count}")
-        # Append zone analysis totals across time if available
-        zone_analysis_total = counting_summary.get("zone_analysis_total", {})
-        if zone_analysis_total:
-            human_text_lines.append("ZONE ANALYSIS (TOTAL SINCE START):")
-            for zone_name, cat_counts in zone_analysis_total.items():
-                if isinstance(cat_counts, dict):
-                    total_in_zone = sum(cat_counts.values())
-                    car_count = (
-                        cat_counts.get('car', 0)
-                        + cat_counts.get('truck', 0)
-                    )
-                    if car_count > 0:
-                        human_text_lines.append(f"\t{zone_name}: total={total_in_zone} (car: {car_count})")
-                    else:
-                        human_text_lines.append(f"\t{zone_name}: total={total_in_zone}")
-                else:
-                    human_text_lines.append(f"\t{zone_name}: total=0")
+            if count > 0:
+                human_text_lines.append(f"\t{cat}: {count}")
         if alerts:
             for alert in alerts:
                 human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
@@ -558,12 +595,12 @@ class VehicleMonitoringUseCase(BaseProcessor):
         tracking_stats.append(tracking_stat)
         return tracking_stats
 
-    def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: VehicleMonitoringConfig,
+    def _generate_business_analytics(self, counting_summary: Dict, zone_analysis: Dict, alerts: Any, config: VehicleMonitoringConfig,
                                     stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
         if is_empty:
             return []
 
-    def _generate_summary(self, summary: dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[str]:
+    def _generate_summary(self, summary: dict, zone_analysis: Dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[str]:
         """
         Generate a human_text string for the tracking_stat, incident, business analytics and alerts.
         """
@@ -823,13 +860,6 @@ class VehicleMonitoringUseCase(BaseProcessor):
         union_area = area1 + area2 - inter_area
         return (inter_area / union_area) if union_area > 0 else 0.0
 
-    def _is_detection_in_zone(self, detection: Dict[str, Any], zone_polygon: List[List[float]]) -> bool:
-        bbox = detection.get("bounding_box", detection.get("bbox"))
-        if not bbox:
-            return False
-        bottom25_center = get_bbox_bottom25_center(bbox)
-        return point_in_polygon(bottom25_center, [(p[0], p[1]) for p in zone_polygon])
-
     def _merge_or_register_track(self, raw_id: Any, bbox: Any) -> Any:
         if raw_id is None or bbox is None:
             return raw_id

{matrice-1.0.99392.dist-info → matrice-1.0.99394.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice
-Version: 1.0.99392
+Version: 1.0.99394
 Summary: SDK for connecting to matrice.ai services
 Home-page: https://github.com/matrice-ai/python-sdk
 Author: Matrice.ai

{matrice-1.0.99392.dist-info → matrice-1.0.99394.dist-info}/RECORD

@@ -236,7 +236,7 @@ matrice/deploy/utils/post_processing/usecases/template_usecase.py,sha256=6NC-bTn
 matrice/deploy/utils/post_processing/usecases/theft_detection.py,sha256=Rs_zKn2z9YM10fGzTHR44Q3m8TIO1s5UMdiPWA03rbA,28671
 matrice/deploy/utils/post_processing/usecases/traffic_sign_monitoring.py,sha256=nDlEzHgMlUjy_VtJ7usnEzMcdSs-jouqaoJpJ8DYUMw,34351
 matrice/deploy/utils/post_processing/usecases/underwater_pollution_detection.py,sha256=jqP1ZKfDZe2-56Lyvgb2DxnbqRfvxm6pPL0Ck3esfBk,40356
-matrice/deploy/utils/post_processing/usecases/vehicle_monitoring.py,sha256=m8hGIw-86R9dbdUxznjV9eGzeKiyjWSy9EiujwqaTjc,44524
+matrice/deploy/utils/post_processing/usecases/vehicle_monitoring.py,sha256=-TtvPEHShXlslhxpjSEGFEdeeP0zY-OYu635969K51I,45525
 matrice/deploy/utils/post_processing/usecases/warehouse_object_segmentation.py,sha256=5uZXTJL_A3tUEN08T-_ZQpUoJ9gqbuuMc4z2mT4sMnQ,43753
 matrice/deploy/utils/post_processing/usecases/waterbody_segmentation.py,sha256=JsCxDEMB8s4WDcezfJDr2zrjM-TCjB9hxOztzSvWmpY,45268
 matrice/deploy/utils/post_processing/usecases/weapon_detection.py,sha256=gea-rjEHmP0hUjpcrcQIHOnhMMHQNqDI90cbpXHnlpI,31071
@@ -261,8 +261,8 @@ matrice/deployment/camera_manager.py,sha256=e1Lc81RJP5wUWRdTgHO6tMWF9BkBdHOSVyx3
 matrice/deployment/deployment.py,sha256=HFt151eWq6iqIAMsQvurpV2WNxW6Cx_gIUVfnVy5SWE,48093
 matrice/deployment/inference_pipeline.py,sha256=6b4Mm3-qt-Zy0BeiJfFQdImOn3FzdNCY-7ET7Rp8PMk,37911
 matrice/deployment/streaming_gateway_manager.py,sha256=ifYGl3g25wyU39HwhPQyI2OgF3M6oIqKMWt8RXtMxY8,21401
-matrice-1.0.99392.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99392.dist-info/METADATA,sha256=AF8yhoOaoOlO1d-jbJEqkzUkyJnFu-RGdOr4S9_vJQc,14624
-matrice-1.0.99392.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99392.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99392.dist-info/RECORD,,
+matrice-1.0.99394.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99394.dist-info/METADATA,sha256=3bISm-l43QIoOwL2kjo_BTbUsV2TC-dCMaMPPNgRvdQ,14624
+matrice-1.0.99394.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99394.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99394.dist-info/RECORD,,