matrice 1.0.99144__py3-none-any.whl → 1.0.99146__py3-none-any.whl

matrice/deploy/utils/post_processing/__init__.py

@@ -71,11 +71,13 @@ from .usecases.license_plate_detection import LicensePlateConfig
 from .usecases.pothole_segmentation import PotholeConfig
 from .usecases.wound_segmentation import WoundConfig, WoundSegmentationUseCase
 from .usecases.face_emotion import FaceEmotionConfig
+from .usecases.pipeline_detection import PipelineDetectionUseCase
 from .usecases.parking_space_detection import ParkingSpaceConfig
 from .usecases.underwater_pollution_detection import UnderwaterPlasticConfig
 from .usecases.pedestrian_detection import PedestrianDetectionConfig
 from .usecases.age_detection import AgeDetectionConfig
 from .usecases.mask_detection import MaskDetectionConfig
+from .usecases.pipeline_detection import PipelineDetectionConfig
 from .usecases.chicken_pose_detection import ChickenPoseDetectionConfig
 from .usecases.field_mapping import FieldMappingConfig, FieldMappingUseCase
 from .usecases.leaf_disease import LeafDiseaseDetectionConfig, LeafDiseaseDetectionUseCase
@@ -193,6 +195,7 @@ _underwater_pollution_detection = UnderwaterPlasticUseCase()
 _pedestrian_detection = PedestrianDetectionUseCase()
 _age_detection = AgeDetectionUseCase()
 _mask_detection = MaskDetectionUseCase()
+_pipeline_detection = PipelineDetectionUseCase()
 _banana_defect_detection = BananaMonitoringUseCase()
 _chicken_pose_detection = ChickenPoseDetectionUseCase()
 _theft_detection = TheftDetectionUseCase()
@@ -256,6 +259,7 @@ registry.register_use_case(_age_detection.category, _age_detection.name, AgeDete
 registry.register_use_case(_pricetag_detection.category, _pricetag_detection.name, PriceTagUseCase)
 registry.register_use_case(_weld_defect_detection.category, _weld_defect_detection.name, WeldDefectUseCase  )
 registry.register_use_case(_mask_detection.category, _mask_detection.name, MaskDetectionUseCase)
+registry.register_use_case(_pipeline_detection.category, _pipeline_detection.name, PipelineDetectionUseCase)
 registry.register_use_case(_banana_defect_detection.category, _banana_defect_detection.name, BananaMonitoringUseCase)
 registry.register_use_case(_chicken_pose_detection.category, _chicken_pose_detection.name, ChickenPoseDetectionUseCase)
 registry.register_use_case(_theft_detection.category, _theft_detection.name, TheftDetectionUseCase)

matrice/deploy/utils/post_processing/config.py

@@ -1,6 +1,7 @@
 APP_NAME_TO_USECASE = {
     "people_counting": "people_counting",
     "mask_detection": "mask_detection",
+    "pipeline_detection": "pipeline_detection",
     "vehicle_monitoring": "vehicle_monitoring",
     "vehicle_type_monitoring": "vehicle_monitoring",
     "weapon_detection": "weapon_detection",
@@ -33,6 +34,7 @@ APP_NAME_TO_USECASE = {
 APP_NAME_TO_CATEGORY = {
     "people_counting": "general",
     "mask_detection": "mask_detection",
+    "pipeline_detection": "pipeline_detection",
     "vehicle_monitoring": "traffic",
     "vehicle_type_monitoring": "traffic",
     "weapon_detection": "security",

matrice/deploy/utils/post_processing/core/config.py

@@ -415,6 +415,7 @@ class ConfigManager:
             "fire_smoke_detection": None,
             "flare_analysis" : None,
             "mask_detection": None,
+            "pipeline_detection": None,
             "parking_space_detection": None,
             "car_damage_detection":None,
             "weld_defect_detection" : None,
@@ -592,6 +593,7 @@ class ConfigManager:
             return ParkingSpaceConfig
         except ImportError:
             return None
+
     def _get_mask_detection_config_class(self):
         """Register a configuration class for a use case."""
         try:
@@ -600,6 +602,14 @@ class ConfigManager:
         except ImportError:
             return None
 
+    def _get_pipeline_detection_config_class(self):
+        """Register a configuration class for a use case."""
+        try:
+            from ..usecases.pipeline_detection import PipelineDetectionConfig
+            return PipelineDetectionConfig
+        except ImportError:
+            return None
+
     def _get_pothole_segmentation_config_class(self):
         """Register a configuration class for a use case."""
         try:
@@ -972,6 +982,19 @@ class ConfigManager:
                 alert_config=alert_config,
                 **kwargs
             )
+        elif usecase == "pipeline_detection":
+            from ..usecases.pipeline_detection import PipelineDetectionConfig
+
+            alert_config = kwargs.pop("alert_config", None)
+            if alert_config and isinstance(alert_config, dict):
+                alert_config = AlertConfig(**alert_config)
+
+            config = PipelineDetectionConfig(
+                category=category or "pipeline_detection",
+                usecase=usecase,
+                alert_config=alert_config,
+                **kwargs
+            )
         elif usecase == "shoplifting_detection":
             # Import here to avoid circular import
             from ..usecases.shoplifting_detection import ShopliftingDetectionConfig
@@ -1759,6 +1782,11 @@ class ConfigManager:
             from ..usecases.mask_detection import MaskDetectionConfig
             default_config = MaskDetectionConfig()
             return default_config.to_dict()
+        
+        elif usecase == "pipeline_detection":
+            from ..usecases.pipeline_detection import PipelineDetectionConfig
+            default_config = PipelineDetectionConfig()
+            return default_config.to_dict()
 
         elif usecase == "fire_smoke_detection":
             # Import here to avoid circular import

matrice/deploy/utils/post_processing/processor.py

@@ -51,6 +51,7 @@ from .usecases import (
     ParkingUseCase,
     FaceEmotionUseCase,
     UnderwaterPlasticUseCase,
+    PipelineDetectionUseCase,
     PedestrianDetectionUseCase,
     ChickenPoseDetectionUseCase,
     TheftDetectionUseCase,
@@ -175,6 +176,7 @@ class PostProcessor:
         registry.register_use_case("weld", "weld_defect_detection", WeldDefectUseCase)
         registry.register_use_case("price_tag", "price_tag_detection", PriceTagUseCase)
         registry.register_use_case("mask_detection", "mask_detection", MaskDetectionUseCase)
+        registry.register_use_case("pipeline_detection", "pipeline_detection", PipelineDetectionUseCase)
         registry.register_use_case("automobile", "distracted_driver_detection", DistractedDriverUseCase)
         registry.register_use_case("traffic", "emergency_vehicle_detection", EmergencyVehicleUseCase)
         registry.register_use_case("energy", "solar_panel", SolarPanelUseCase)

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

@@ -28,6 +28,7 @@ from .banana_defect_detection import BananaMonitoringUseCase,BananaMonitoringCon
 from .car_damage_detection import CarDamageConfig, CarDamageDetectionUseCase
 from .price_tag_detection import PriceTagConfig, PriceTagUseCase
 from .mask_detection import MaskDetectionConfig, MaskDetectionUseCase
+from .pipeline_detection import PipelineDetectionConfig, PipelineDetectionUseCase
 from .distracted_driver_detection import DistractedDriverUseCase, DistractedDriverConfig
 from .emergency_vehicle_detection import EmergencyVehicleUseCase, EmergencyVehicleConfig
 from .solar_panel import SolarPanelUseCase, SolarPanelConfig

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

@@ -0,0 +1,605 @@
+"""
+Pipeline Monitoring Use Case for Post-Processing
+
+This module provides Pipeline monitoring functionality with congestion detection,
+zone analysis, and alert generation.
+
+"""
+
+from typing import Any, Dict, List, Optional
+from dataclasses import asdict
+import time
+from datetime import datetime, timezone
+
+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 dataclasses import dataclass, field
+from ..core.config import BaseConfig, AlertConfig, ZoneConfig
+
+
+@dataclass
+class PipelineDetectionConfig(BaseConfig):
+    """Configuration for pipeline detection use case in pipeline monitoring."""
+    # 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
+
+    # confidence thresholds
+    confidence_threshold: float = 0.4
+
+    usecase_categories: List[str] = field(
+        default_factory=lambda: ['pipe']
+    )
+
+    target_categories: List[str] = field(
+        default_factory=lambda: ['pipe']
+    )
+
+    alert_config: Optional[AlertConfig] = None
+
+    index_to_category: Optional[Dict[int, str]] = field(
+        default_factory=lambda: {
+           0: "pipe"
+        }
+    )
+
+
+class PipelineDetectionUseCase(BaseProcessor):
+    # Human-friendly display names for categories
+    CATEGORY_DISPLAY = {
+        "pipe": "pipe"
+    }
+    def __init__(self):
+        super().__init__("pipeline_detection")
+        self.category = "pipeline_detection"
+
+        self.CASE_TYPE: Optional[str] = 'pipeline_detection'
+        self.CASE_VERSION: Optional[str] = '1.0'
+
+        # List of categories to track
+        self.target_categories = ['pipe']
+
+        # Initialize smoothing tracker
+        self.smoothing_tracker = None
+
+        # Initialize advanced tracker (will be created on first use)
+        self.tracker = None
+
+        # Initialize tracking state variables
+        self._total_frame_counter = 0
+        self._global_frame_offset = 0
+
+        # Track start time for "TOTAL SINCE" calculation
+        self._tracking_start_time = None
+
+        self._track_aliases: Dict[Any, Any] = {}
+        self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
+        # Tunable parameters – adjust if necessary for specific scenarios
+        self._track_merge_iou_threshold: float = 0.05  # IoU ≥ 0.05 →
+        self._track_merge_time_window: float = 7.0  # seconds within which to merge
+
+        self._ascending_alert_list: List[int] = []
+        self.current_incident_end_timestamp: str = "N/A"
+
+
+    def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
+                stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
+        start_time = time.time()
+        if not isinstance(config, PipelineDetectionConfig):
+            return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
+        if context is None:
+            context = ProcessingContext()
+
+        input_format = match_results_structure(data)
+        context.input_format = input_format
+        context.confidence_threshold = config.confidence_threshold
+
+        if config.confidence_threshold is not None:
+            processed_data = filter_by_confidence(data, config.confidence_threshold)
+            self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
+        else:
+            processed_data = data
+            self.logger.debug(f"Did not apply confidence filtering with threshold since nothing was provided")
+
+        if config.index_to_category:
+            processed_data = apply_category_mapping(processed_data, config.index_to_category)
+            self.logger.debug("Applied category mapping")
+
+        if config.target_categories:
+            processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
+            self.logger.debug(f"Applied  category filtering")
+
+        if config.enable_smoothing:
+            if self.smoothing_tracker is None:
+                smoothing_config = BBoxSmoothingConfig(
+                    smoothing_algorithm=config.smoothing_algorithm,
+                    window_size=config.smoothing_window_size,
+                    cooldown_frames=config.smoothing_cooldown_frames,
+                    confidence_threshold=config.confidence_threshold,
+                    confidence_range_factor=config.smoothing_confidence_range_factor,
+                    enable_smoothing=True
+                )
+                self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
+            processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
+
+        try:
+            from ..advanced_tracker import AdvancedTracker
+            from ..advanced_tracker.config import TrackerConfig
+            if self.tracker is None:
+                tracker_config = TrackerConfig()
+                self.tracker = AdvancedTracker(tracker_config)
+                self.logger.info("Initialized AdvancedTracker for Pipeline Monitoring and tracking")
+            processed_data = self.tracker.update(processed_data)
+        except Exception as e:
+            self.logger.warning(f"AdvancedTracker failed: {e}")
+
+        self._update_tracking_state(processed_data)
+        self._total_frame_counter += 1
+
+        frame_number = None
+        if stream_info:
+            input_settings = stream_info.get("input_settings", {})
+            start_frame = input_settings.get("start_frame")
+            end_frame = input_settings.get("end_frame")
+            if start_frame is not None and end_frame is not None and start_frame == end_frame:
+                frame_number = start_frame
+
+        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
+
+        alerts = self._check_alerts(counting_summary, frame_number, config)
+        predictions = self._extract_predictions(processed_data)
+
+        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)
+
+        incidents = incidents_list[0] if incidents_list else {}
+        tracking_stats = tracking_stats_list[0] if tracking_stats_list else {}
+        business_analytics = business_analytics_list[0] if business_analytics_list else {}
+        summary = summary_list[0] if summary_list else {}
+        agg_summary = {str(frame_number): {
+                        "incidents": incidents,
+                        "tracking_stats": tracking_stats,
+                        "business_analytics": business_analytics,
+                        "alerts": alerts,
+                        "human_text": summary}
+                      }
+
+        context.mark_completed()
+
+        result = self.create_result(
+            data={"agg_summary": agg_summary},
+            usecase=self.name,
+            category=self.category,
+            context=context
+        )
+        return result
+
+
+    def _check_alerts(self, summary: dict, frame_number:Any, config: PipelineDetectionConfig) -> List[Dict]:
+        def get_trend(data, lookback=900, threshold=0.6):
+            window = data[-lookback:] if len(data) >= lookback else data
+            if len(window) < 2:
+                return True
+            increasing = 0
+            total = 0
+            for i in range(1, len(window)):
+                if window[i] >= window[i - 1]:
+                    increasing += 1
+                total += 1
+            ratio = increasing / total
+            if ratio >= threshold:
+                return True
+            elif ratio <= (1 - threshold):
+                return False
+
+        frame_key = str(frame_number) if frame_number is not None else "current_frame"
+        alerts = []
+        total_detections = summary.get("total_count", 0)
+        total_counts_dict = summary.get("total_counts", {})
+        cumulative_total = sum(total_counts_dict.values()) if total_counts_dict else 0
+        per_category_count = summary.get("per_category_count", {})
+
+        if not config.alert_config:
+            return alerts
+
+        total = summary.get("total_count", 0)
+        if hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
+            for category, threshold in config.alert_config.count_thresholds.items():
+                if category == "all" and total > threshold:
+                    alerts.append({
+                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                        "alert_id": "alert_"+category+'_'+frame_key,
+                        "incident_category": self.CASE_TYPE,
+                        "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']) if hasattr(config.alert_config, 'alert_type') else ['Default'], getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
+                    })
+                elif category in summary.get("per_category_count", {}):
+                    count = summary.get("per_category_count", {})[category]
+                    if count > threshold:
+                        alerts.append({
+                            "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                            "alert_id": "alert_"+category+'_'+frame_key,
+                            "incident_category": self.CASE_TYPE,
+                            "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']) if hasattr(config.alert_config, 'alert_type') else ['Default'], getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
+                        })
+        return alerts
+
+    def _generate_incidents(self, counting_summary: Dict, alerts: List, config: PipelineDetectionConfig, 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)
+        camera_info = self.get_camera_info_from_stream(stream_info)
+        self._ascending_alert_list = self._ascending_alert_list[-900:] if len(self._ascending_alert_list) > 900 else self._ascending_alert_list
+        if total_detections > 0:
+            level = "low"
+            intensity = 5.0
+            start_timestamp = self._get_start_timestamp_str(stream_info)
+            if start_timestamp and self.current_incident_end_timestamp=='N/A':
+                self.current_incident_end_timestamp = 'Incident still active'
+            elif start_timestamp and self.current_incident_end_timestamp=='Incident still active':
+                if len(self._ascending_alert_list) >= 15 and sum(self._ascending_alert_list[-15:]) / 15 < 1.5:
+                    self.current_incident_end_timestamp = current_timestamp
+            elif self.current_incident_end_timestamp!='Incident still active' and self.current_incident_end_timestamp!='N/A':
+                self.current_incident_end_timestamp = 'N/A'
+            if config.alert_config and config.alert_config.count_thresholds:
+                threshold = config.alert_config.count_thresholds.get("all", 15)
+                intensity = min(10.0, (total_detections / threshold) * 10)
+                if intensity >= 9:
+                    level = "critical"
+                    self._ascending_alert_list.append(3)
+                elif intensity >= 7:
+                    level = "significant"
+                    self._ascending_alert_list.append(2)
+                elif intensity >= 5:
+                    level = "medium"
+                    self._ascending_alert_list.append(1)
+                else:
+                    level = "low"
+                    self._ascending_alert_list.append(0)
+            else:
+                if total_detections > 30:
+                    level = "critical"
+                    intensity = 10.0
+                    self._ascending_alert_list.append(3)
+                elif total_detections > 25:
+                    level = "significant"
+                    intensity = 9.0
+                    self._ascending_alert_list.append(2)
+                elif total_detections > 15:
+                    level = "medium"
+                    intensity = 7.0
+                    self._ascending_alert_list.append(1)
+                else:
+                    level = "low"
+                    intensity = min(10.0, total_detections / 3.0)
+                    self._ascending_alert_list.append(0)
+            human_text_lines = [f"INCIDENTS DETECTED @ {current_timestamp}:"]
+            human_text_lines.append(f"\tSeverity Level: {(self.CASE_TYPE,level)}")
+            human_text = "\n".join(human_text_lines)
+            alert_settings=[]
+            if config.alert_config and hasattr(config.alert_config, 'alert_type'):
+                alert_settings.append({
+                    "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                    "incident_category": self.CASE_TYPE,
+                    "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']) if hasattr(config.alert_config, 'alert_type') else ['Default'], getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
+                })
+            event= self.create_incident(incident_id=self.CASE_TYPE+'_'+str(frame_number), incident_type=self.CASE_TYPE,
+                       severity_level=level, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
+                       start_time=start_timestamp, end_time=self.current_incident_end_timestamp,
+                       level_settings= {"low": 1, "medium": 3, "significant":4, "critical": 7})
+            incidents.append(event)
+        else:
+            self._ascending_alert_list.append(0)
+            incidents.append({})
+        return incidents
+
+    def _generate_tracking_stats(self, counting_summary: Dict, alerts: List, config: PipelineDetectionConfig, 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 = []
+        total_detections = counting_summary.get("total_count", 0)
+        total_counts_dict = counting_summary.get("total_counts", {})
+        cumulative_total = sum(total_counts_dict.values()) if total_counts_dict else 0
+        per_category_count = counting_summary.get("per_category_count", {})
+        current_timestamp = self._get_current_timestamp_str(stream_info, precision=False)
+        start_timestamp = self._get_start_timestamp_str(stream_info, precision=False)
+        high_precision_start_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
+        high_precision_reset_timestamp = self._get_start_timestamp_str(stream_info, precision=True)
+        total_counts = []
+        for cat, count in total_counts_dict.items():
+            if count > 0:
+                total_counts.append({"category": cat, "count": count})
+        current_counts = []
+        for cat, count in per_category_count.items():
+            if count > 0 or total_detections > 0:
+                current_counts.append({"category": cat, "count": count})
+        detections = []
+        for detection in counting_summary.get("detections", []):
+            bbox = detection.get("bounding_box", {})
+            category = detection.get("category", "pipe")
+            detection_obj = self.create_detection_object(category, bbox)
+            detections.append(detection_obj)
+        alert_settings = []
+        if config.alert_config and hasattr(config.alert_config, 'alert_type'):
+            alert_settings.append({
+                "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                "incident_category": self.CASE_TYPE,
+                "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']) if hasattr(config.alert_config, 'alert_type') else ['Default'], getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
+            })
+        human_text_lines = [f"Tracking Statistics:"]
+        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
+        for cat, count in per_category_count.items():
+            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 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}")
+        else:
+            human_text_lines.append("Alerts: None")
+        human_text = "\n".join(human_text_lines)
+        reset_settings=[{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]
+        tracking_stat=self.create_tracking_stats(total_counts=total_counts, current_counts=current_counts,
+                             detections=detections, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
+                             reset_settings=reset_settings, start_time=high_precision_start_timestamp ,
+                             reset_time=high_precision_reset_timestamp)
+        tracking_stats.append(tracking_stat)
+        return tracking_stats
+
+    def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: PipelineDetectionConfig, 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]:
+        lines = {}
+        lines["Application Name"] = self.CASE_TYPE
+        lines["Application Version"] = self.CASE_VERSION
+        if len(incidents) > 0:
+            lines["Incidents:"]=f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
+        if len(tracking_stats) > 0:
+            lines["Tracking Statistics:"]=f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
+        if len(business_analytics) > 0:
+            lines["Business Analytics:"]=f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}\n"
+        if len(incidents) == 0 and len(tracking_stats) == 0 and len(business_analytics) == 0:
+            lines["Summary"] = "No Summary Data"
+        return [lines]
+
+    def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
+        frame_track_ids = set()
+        for det in detections:
+            tid = det.get('track_id')
+            if tid is not None:
+                frame_track_ids.add(tid)
+        total_track_ids = set()
+        for s in getattr(self, '_per_category_total_track_ids', {}).values():
+            total_track_ids.update(s)
+        return {
+            "total_count": len(total_track_ids),
+            "current_frame_count": len(frame_track_ids),
+            "total_unique_track_ids": len(total_track_ids),
+            "current_frame_track_ids": list(frame_track_ids),
+            "last_update_time": time.time(),
+            "total_frames_processed": getattr(self, '_total_frame_counter', 0)
+        }
+
+    def _update_tracking_state(self, detections: list):
+        if not hasattr(self, "_per_category_total_track_ids"):
+            self._per_category_total_track_ids = {cat: set() for cat in self.target_categories}
+        self._current_frame_track_ids = {cat: set() for cat in self.target_categories}
+        for det in detections:
+            cat = det.get("category")
+            raw_track_id = det.get("track_id")
+            if cat not in self.target_categories or raw_track_id is None:
+                continue
+            bbox = det.get("bounding_box", det.get("bbox"))
+            canonical_id = self._merge_or_register_track(raw_track_id, bbox)
+            det["track_id"] = canonical_id
+            self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
+            self._current_frame_track_ids[cat].add(canonical_id)
+
+    def get_total_counts(self):
+        return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
+
+    def _format_timestamp_for_stream(self, timestamp: float) -> str:
+        dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
+        return dt.strftime('%Y:%m:%d %H:%M:%S')
+
+    def _format_timestamp_for_video(self, timestamp: float) -> str:
+        hours = int(timestamp // 3600)
+        minutes = int((timestamp % 3600) // 60)
+        seconds = round(float(timestamp % 60),2)
+        return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
+
+    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
+        if not stream_info:
+            return "00:00:00.00"
+        if precision:
+            if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+                if frame_id:
+                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                else:
+                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                stream_time_str = self._format_timestamp_for_video(start_time)
+                return stream_time_str
+            else:
+                return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+        if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+                if frame_id:
+                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                else:
+                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                stream_time_str = self._format_timestamp_for_video(start_time)
+                return stream_time_str
+        else:
+            stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+            if stream_time_str:
+                try:
+                    timestamp_str = stream_time_str.replace(" UTC", "")
+                    dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                    timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
+                    return self._format_timestamp_for_stream(timestamp)
+                except:
+                    return self._format_timestamp_for_stream(time.time())
+            else:
+                return self._format_timestamp_for_stream(time.time())
+
+    def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
+        if not stream_info:
+            return "00:00:00"
+        if precision:
+            if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+                return "00:00:00"
+            else:
+                return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+        if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+            return "00:00:00"
+        else:
+            if self._tracking_start_time is None:
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                if stream_time_str:
+                    try:
+                        timestamp_str = stream_time_str.replace(" UTC", "")
+                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                        self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
+                    except:
+                        self._tracking_start_time = time.time()
+                else:
+                    self._tracking_start_time = time.time()
+            dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
+            dt = dt.replace(minute=0, second=0, microsecond=0)
+            return dt.strftime('%Y:%m:%d %H:%M:%S')
+
+    def _count_categories(self, detections: list, config: PipelineDetectionConfig) -> dict:
+        counts = {}
+        for det in detections:
+            cat = det.get('category', 'unknown')
+            counts[cat] = counts.get(cat, 0) + 1
+        return {
+            "total_count": sum(counts.values()),
+            "per_category_count": counts,
+            "detections": [
+                {
+                    "bounding_box": det.get("bounding_box"),
+                    "category": det.get("category"),
+                    "confidence": det.get("confidence"),
+                    "track_id": det.get("track_id"),
+                    "frame_id": det.get("frame_id")
+                }
+                for det in detections
+            ]
+        }
+
+    def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:
+        return [
+            {
+                "category": det.get("category", "unknown"),
+                "confidence": det.get("confidence", 0.0),
+                "bounding_box": det.get("bounding_box", {})
+            }
+            for det in detections
+        ]
+
+    def _compute_iou(self, box1: Any, box2: Any) -> float:
+        def _bbox_to_list(bbox):
+            if bbox is None:
+                return []
+            if isinstance(bbox, list):
+                return bbox[:4] if len(bbox) >= 4 else []
+            if isinstance(bbox, dict):
+                if "xmin" in bbox:
+                    return [bbox["xmin"], bbox["ymin"], bbox["xmax"], bbox["ymax"]]
+                if "x1" in bbox:
+                    return [bbox["x1"], bbox["y1"], bbox["x2"], bbox["y2"]]
+                values = [v for v in bbox.values() if isinstance(v, (int, float))]
+                return values[:4] if len(values) >= 4 else []
+            return []
+        l1 = _bbox_to_list(box1)
+        l2 = _bbox_to_list(box2)
+        if len(l1) < 4 or len(l2) < 4:
+            return 0.0
+        x1_min, y1_min, x1_max, y1_max = l1
+        x2_min, y2_min, x2_max, y2_max = l2
+        x1_min, x1_max = min(x1_min, x1_max), max(x1_min, x1_max)
+        y1_min, y1_max = min(y1_min, y1_max), max(y1_min, y1_max)
+        x2_min, x2_max = min(x2_min, x2_max), max(x2_min, x2_max)
+        y2_min, y2_max = min(y2_min, y2_max), max(y2_min, y2_max)
+        inter_x_min = max(x1_min, x2_min)
+        inter_y_min = max(y1_min, y2_min)
+        inter_x_max = min(x1_max, x2_max)
+        inter_y_max = min(y1_max, y2_max)
+        inter_w = max(0.0, inter_x_max - inter_x_min)
+        inter_h = max(0.0, inter_y_max - inter_y_min)
+        inter_area = inter_w * inter_h
+        area1 = (x1_max - x1_min) * (y1_max - y1_min)
+        area2 = (x2_max - x2_min) * (y2_max - y2_min)
+        union_area = area1 + area2 - inter_area
+        return (inter_area / union_area) if union_area > 0 else 0.0
+
+    def _merge_or_register_track(self, raw_id: Any, bbox: Any) -> Any:
+        if raw_id is None or bbox is None:
+            return raw_id
+        now = time.time()
+        if raw_id in self._track_aliases:
+            canonical_id = self._track_aliases[raw_id]
+            track_info = self._canonical_tracks.get(canonical_id)
+            if track_info is not None:
+                track_info["last_bbox"] = bbox
+                track_info["last_update"] = now
+                track_info["raw_ids"].add(raw_id)
+            return canonical_id
+        for canonical_id, info in self._canonical_tracks.items():
+            if now - info["last_update"] > self._track_merge_time_window:
+                continue
+            iou = self._compute_iou(bbox, info["last_bbox"])
+            if iou >= self._track_merge_iou_threshold:
+                self._track_aliases[raw_id] = canonical_id
+                info["last_bbox"] = bbox
+                info["last_update"] = now
+                info["raw_ids"].add(raw_id)
+                return canonical_id
+        canonical_id = raw_id
+        self._track_aliases[raw_id] = canonical_id
+        self._canonical_tracks[canonical_id] = {
+            "last_bbox": bbox,
+            "last_update": now,
+            "raw_ids": {raw_id},
+        }
+        return canonical_id
+
+    def _format_timestamp(self, timestamp: float) -> str:
+        return datetime.fromtimestamp(timestamp, timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
+
+    def _get_tracking_start_time(self) -> str:
+        if self._tracking_start_time is None:
+            return "N/A"
+        return self._format_timestamp(self._tracking_start_time)
+
+    def _set_tracking_start_time(self) -> None:
+        self._tracking_start_time = time.time()

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

@@ -1,9 +1,9 @@
 from typing import Any, Dict, List, Optional
-from dataclasses import asdict, dataclass, field
+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,
@@ -16,6 +16,7 @@ from ..utils import (
     BBoxSmoothingConfig,
     BBoxSmoothingTracker
 )
+from dataclasses import dataclass, field
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
 
@@ -29,40 +30,39 @@ class LaneDetectionConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
     confidence_threshold: float = 0.6
     usecase_categories: List[str] = field(
-        default_factory=lambda: ['Divider-Line', 'Dotted-Line', 'Double-Line', 'Random-Line', 'Road-Sign-Line', 'Solid-Line']
+        default_factory=lambda: ['divider-line', 'dotted-line', 'double-line', 'random-line', 'road-sign-line', 'solid-line']
     )
     target_categories: List[str] = field(
-        default_factory=lambda: ['Divider-Line', 'Dotted-Line', 'Double-Line', 'Random-Line', 'Road-Sign-Line', 'Solid-Line']
+        default_factory=lambda: ['divider-line', 'dotted-line', 'double-line', 'random-line', 'road-sign-line', 'solid-line']
     )
     alert_config: Optional[AlertConfig] = None
     index_to_category: Optional[Dict[int, str]] = field(
         default_factory=lambda: {
-            0: "Divider-Line",
-            1: "Dotted-Line",
-            2: "Double-Line",
-            3: "Random-Line",
-            4: "Road-Sign-Line",
-            5: "Solid-Line"
+            0: "divider-line",
+            1: "dotted-line",
+            2: "double-line",
+            3: "random-line",
+            4: "road-sign-line",
+            5: "solid-line"
         }
     )
 
 
 class LaneDetectionUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
-        "Divider-Line": "Divider Line",
-        "Dotted-Line": "Dotted Line",
-        "Double-Line": "Double Line",
-        "Random-Line": "Random Line",
-        "Road-Sign-Line": "Road Sign Line",
-        "Solid-Line": "Solid Line"
+        "divider-line": "Divider Line",
+        "dotted-line": "Dotted Line",
+        "double-line": "Double Line",
+        "random-line": "Random Line",
+        "road-sign-line": "Road Sign Line",
+        "solid-line": "Solid Line"
     }
-
     def __init__(self):
         super().__init__("lane_detection")
         self.category = "traffic"
         self.CASE_TYPE: Optional[str] = 'lane_detection'
         self.CASE_VERSION: Optional[str] = '1.0'
-        self.target_categories = ['Divider-Line', 'Dotted-Line', 'Double-Line', 'Random-Line', 'Road-Sign-Line', 'Solid-Line']
+        self.target_categories = ['divider-line', 'dotted-line', 'double-line', 'random-line', 'road-sign-line', 'solid-line']
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -82,7 +82,6 @@ class LaneDetectionUseCase(BaseProcessor):
             return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
         if context is None:
             context = ProcessingContext()
-
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
@@ -92,7 +91,7 @@ class LaneDetectionUseCase(BaseProcessor):
             self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
         else:
             processed_data = data
-            self.logger.debug("Did not apply confidence filtering since no threshold provided")
+            self.logger.debug("Did not apply confidence filtering")
 
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
@@ -193,39 +192,42 @@ class LaneDetectionUseCase(BaseProcessor):
         if not config.alert_config:
             return alerts
 
+        total = summary.get("total_count", 0)
         if hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
             for category, threshold in config.alert_config.count_thresholds.items():
-                if category == "all" and total_detections > threshold:
-                    alerts.append({
-                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
-                        "alert_id": f"alert_{category}_{frame_key}",
-                        "incident_category": self.CASE_TYPE,
-                        "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']))}
-                    })
-                elif category in per_category_count and per_category_count[category] > threshold:
+                if category == "all" and total > threshold:
                     alerts.append({
-                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
-                        "alert_id": f"alert_{category}_{frame_key}",
+                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                        "alert_id": "alert_" + category + '_' + frame_key,
                         "incident_category": self.CASE_TYPE,
                         "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']))}
+                        "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                     getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
                     })
+                elif category in per_category_count:
+                    count = per_category_count[category]
+                    if count > threshold:
+                        alerts.append({
+                            "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                            "alert_id": "alert_" + category + '_' + frame_key,
+                            "incident_category": self.CASE_TYPE,
+                            "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']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                         getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
+                        })
         return alerts
 
     def _generate_incidents(self, counting_summary: Dict, alerts: List, config: LaneDetectionConfig,
-                           frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
+                         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)
         camera_info = self.get_camera_info_from_stream(stream_info)
-
+        
         self._ascending_alert_list = self._ascending_alert_list[-900:] if len(self._ascending_alert_list) > 900 else self._ascending_alert_list
-
+        
         if total_detections > 0:
             level = "low"
             intensity = 5.0
@@ -251,6 +253,7 @@ class LaneDetectionUseCase(BaseProcessor):
                     level = "medium"
                     self._ascending_alert_list.append(1)
                 else:
+                    level = "low"
                     self._ascending_alert_list.append(0)
             else:
                 if total_detections > 30:
@@ -258,7 +261,7 @@ class LaneDetectionUseCase(BaseProcessor):
                     intensity = 10.0
                     self._ascending_alert_list.append(3)
                 elif total_detections > 25:
-                    level = "significant"
+                    level = " significant"
                     intensity = 9.0
                     self._ascending_alert_list.append(2)
                 elif total_detections > 15:
@@ -277,16 +280,16 @@ class LaneDetectionUseCase(BaseProcessor):
             alert_settings = []
             if config.alert_config and hasattr(config.alert_config, 'alert_type'):
                 alert_settings.append({
-                    "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
+                    "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
                     "incident_category": self.CASE_TYPE,
                     "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']))}
+                    "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                        getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
                 })
 
             event = self.create_incident(
-                incident_id=f"{self.CASE_TYPE}_{frame_number}",
+                incident_id=self.CASE_TYPE + '_' + str(frame_number),
                 incident_type=self.CASE_TYPE,
                 severity_level=level,
                 human_text=human_text,
@@ -304,8 +307,7 @@ class LaneDetectionUseCase(BaseProcessor):
         return incidents
 
     def _generate_tracking_stats(self, counting_summary: Dict, alerts: List, config: LaneDetectionConfig,
-                                frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
-        """Generate structured tracking stats matching expected format."""
+                              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 = []
         total_detections = counting_summary.get("total_count", 0)
@@ -316,13 +318,8 @@ class LaneDetectionUseCase(BaseProcessor):
         high_precision_start_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
         high_precision_reset_timestamp = self._get_start_timestamp_str(stream_info, precision=True)
 
-        # Build total_counts and current_counts arrays
-        total_counts = [{"category": cat, "count": count} for cat, count in total_counts_dict.items()]
-        current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items()]
-
-        # Log counts for debugging
-        self.logger.debug(f"Total counts: {total_counts}")
-        self.logger.debug(f"Current counts: {current_counts}")
+        total_counts = [{"category": cat, "count": count} for cat, count in total_counts_dict.items() if count > 0]
+        current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items() if count > 0 or total_detections > 0]
 
         detections = []
         for detection in counting_summary.get("detections", []):
@@ -344,12 +341,12 @@ class LaneDetectionUseCase(BaseProcessor):
         alert_settings = []
         if config.alert_config and hasattr(config.alert_config, 'alert_type'):
             alert_settings.append({
-                "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
+                "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
                 "incident_category": self.CASE_TYPE,
                 "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']))}
+                "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                    getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
             })
 
         human_text_lines = [f"Tracking Statistics:"]
@@ -358,7 +355,8 @@ class LaneDetectionUseCase(BaseProcessor):
             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():
-            human_text_lines.append(f"\t{cat}: {count}")
+            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}")
@@ -367,6 +365,7 @@ class LaneDetectionUseCase(BaseProcessor):
         human_text = "\n".join(human_text_lines)
 
         reset_settings = [{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]
+
         tracking_stat = self.create_tracking_stats(
             total_counts=total_counts,
             current_counts=current_counts,
@@ -383,7 +382,7 @@ class LaneDetectionUseCase(BaseProcessor):
         return tracking_stats
 
     def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: LaneDetectionConfig,
-                                    stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
+                                  stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
         if is_empty:
             return []
 
@@ -448,33 +447,42 @@ class LaneDetectionUseCase(BaseProcessor):
         seconds = round(float(timestamp % 60), 2)
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
-    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str] = None) -> str:
+    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
+        """Get formatted current timestamp based on stream type."""
         if not stream_info:
             return "00:00:00.00"
+        # is_video_chunk = stream_info.get("input_settings", {}).get("is_video_chunk", False)
         if precision:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
                 if frame_id:
-                    start_time = int(frame_id) / stream_info.get("input_settings", {}).get("original_fps", 30)
+                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
                 else:
-                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30) / stream_info.get("input_settings", {}).get("original_fps", 30)
-                return self._format_timestamp_for_video(start_time)
+                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                stream_time_str = self._format_timestamp_for_video(start_time)
+                return stream_time_str
             else:
                 return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+
         if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
-            if frame_id:
-                start_time = int(frame_id) / stream_info.get("input_settings", {}).get("original_fps", 30)
-            else:
-                start_time = stream_info.get("input_settings", {}).get("start_frame", 30) / stream_info.get("input_settings", {}).get("original_fps", 30)
-            return self._format_timestamp_for_video(start_time)
+                if frame_id:
+                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                else:
+                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                stream_time_str = self._format_timestamp_for_video(start_time)
+                return stream_time_str
         else:
+            # For streams, use stream_time from stream_info
             stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
             if stream_time_str:
+                # Parse the high precision timestamp string to get timestamp
                 try:
+                    # Remove " UTC" suffix and parse
                     timestamp_str = stream_time_str.replace(" UTC", "")
                     dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
                     timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
                     return self._format_timestamp_for_stream(timestamp)
                 except:
+                    # Fallback to current time if parsing fails
                     return self._format_timestamp_for_stream(time.time())
             else:
                 return self._format_timestamp_for_stream(time.time())
@@ -506,34 +514,23 @@ class LaneDetectionUseCase(BaseProcessor):
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
     def _count_categories(self, detections: list, config: LaneDetectionConfig) -> dict:
-        """
-        Count the number of detections per category and return a summary dict.
-        """
-        counts = {cat: 0 for cat in self.target_categories}  # Initialize with all target categories
-        valid_detections = []
-        
+        counts = {}
         for det in detections:
             cat = det.get('category', 'unknown')
-            # Normalize category to match target_categories
-            normalized_cat = cat.replace('-', ' ').title().replace(' ', '-')  # e.g., "solid-line" -> "Solid-Line"
-            if normalized_cat not in self.target_categories:
-                self.logger.debug(f"Skipping detection with category {normalized_cat}, not in target categories")
-                continue
-            counts[normalized_cat] += 1
-            det['category'] = normalized_cat  # Update detection with normalized category
-            valid_detections.append({
-                "bounding_box": det.get("bounding_box"),
-                "category": normalized_cat,
-                "confidence": det.get("confidence"),
-                "track_id": det.get("track_id"),
-                "frame_id": det.get("frame_id")
-            })
-            self.logger.debug(f"Counted detection for category {normalized_cat}, confidence {det.get('confidence')}")
-
+            counts[cat] = counts.get(cat, 0) + 1
         return {
             "total_count": sum(counts.values()),
             "per_category_count": counts,
-            "detections": valid_detections
+            "detections": [
+                {
+                    "bounding_box": det.get("bounding_box"),
+                    "category": det.get("category"),
+                    "confidence": det.get("confidence"),
+                    "track_id": det.get("track_id"),
+                    "frame_id": det.get("frame_id")
+                }
+                for det in detections
+            ]
         }
 
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:

{matrice-1.0.99144.dist-info → matrice-1.0.99146.dist-info}/METADATA

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

{matrice-1.0.99144.dist-info → matrice-1.0.99146.dist-info}/RECORD

@@ -126,9 +126,9 @@ matrice/deploy/utils/boundary_drawing_internal/__init__.py,sha256=4mUOm5_T-vf-XA
 matrice/deploy/utils/boundary_drawing_internal/boundary_drawing_internal.py,sha256=5SPGXS9EIhJJtvC5qTBBmOTQqSKU2byxHIFgo6Bmt-U,43944
 matrice/deploy/utils/boundary_drawing_internal/boundary_drawing_tool.py,sha256=eY0VQGZ8BfTmR4_ThIAXaumBjh8_c7w69w-d3kta8p0,15421
 matrice/deploy/utils/boundary_drawing_internal/example_usage.py,sha256=cUBhxxsVdTQWIPvIOjCUGrhqon7ZBr5N6qNewjrTIuk,6434
-matrice/deploy/utils/post_processing/__init__.py,sha256=QaVlnp8KYxWlFabtX4dcZzGHcNL_Wf1E1usnd67sCKY,22862
-matrice/deploy/utils/post_processing/config.py,sha256=AaWAGXW2NNbRa_8kyXfHSyT8Vuyx-MblWuXJ915iGq0,3128
-matrice/deploy/utils/post_processing/processor.py,sha256=_tRjlZH-HEAwT0bHDCcXkbP6Hmx0m8DD1NMmYh4xMs0,30414
+matrice/deploy/utils/post_processing/__init__.py,sha256=4ncfhhVFoKIGzCXPcnOnzmAyouNplqvdnFcyCPXk3wY,23151
+matrice/deploy/utils/post_processing/config.py,sha256=KjEPeKUGjq6QFPYJc8WWyHDR11gogHbhC4bya4TP-ns,3224
+matrice/deploy/utils/post_processing/processor.py,sha256=x6XdUva0tOr0eUfO_YFpxaUhcSK96cppGBeaeobfXAo,30549
 matrice/deploy/utils/post_processing/advanced_tracker/__init__.py,sha256=tAPFzI_Yep5TLX60FDwKqBqppc-EbxSr0wNsQ9DGI1o,423
 matrice/deploy/utils/post_processing/advanced_tracker/base.py,sha256=VqWy4dd5th5LK-JfueTt2_GSEoOi5QQfQxjTNhmQoLc,3580
 matrice/deploy/utils/post_processing/advanced_tracker/config.py,sha256=hEVJVbh4uUrbIynmoq4OhuxF2IZA5AMCBLpixScp5FI,2865
@@ -138,7 +138,7 @@ matrice/deploy/utils/post_processing/advanced_tracker/strack.py,sha256=rVH2xOysZ
 matrice/deploy/utils/post_processing/advanced_tracker/tracker.py,sha256=D-PKZ2Pxutmlu--icyxuxjvnWBrzrmZcEChYS0nx00M,14328
 matrice/deploy/utils/post_processing/core/__init__.py,sha256=sCdnjfgypTh3TsnyAYJtN0Z8EQne96Nk4j7ICQVXjWE,1312
 matrice/deploy/utils/post_processing/core/base.py,sha256=V_DmaMLtrIunrN8Aq9iLeMIQPlkbCE-9d7n0Yz-nKQg,28228
-matrice/deploy/utils/post_processing/core/config.py,sha256=n-nPjVnfgErVJ_DJABEcwIxUPQppeLSFhLowM0COCYU,80621
+matrice/deploy/utils/post_processing/core/config.py,sha256=4y4Z3lFAw2N4mNM22tz4TRdOZUeBJKZNBDmtf9zKcdI,81723
 matrice/deploy/utils/post_processing/core/config_utils.py,sha256=fVZbYRWJr7dq7mz3FMYBVbYUwWDB-5t7oBuhJix9ghE,23102
 matrice/deploy/utils/post_processing/test_cases/__init__.py,sha256=zUU2kKrIcCl8WeyjjQViwp7PWTZlKPuF8M2pZkxoNNQ,42
 matrice/deploy/utils/post_processing/test_cases/run_tests.py,sha256=RBFGvxFR-gozxnQFzkWLrs90vLlp8Bsn-Z7MLQrNw4o,4731
@@ -152,7 +152,7 @@ matrice/deploy/utils/post_processing/test_cases/test_people_counting.py,sha256=j
 matrice/deploy/utils/post_processing/test_cases/test_processor.py,sha256=nwF2EIAnQAuLAFpMH4sJjHHN-t6UN3DAydBPV6L4wAk,19802
 matrice/deploy/utils/post_processing/test_cases/test_utilities.py,sha256=lmT5bp5_T5yYy1HQ4X01myfScAqnMgf4pd7hHBCjr6A,13414
 matrice/deploy/utils/post_processing/test_cases/test_utils.py,sha256=bfmOT1rr9asv3jpr-p_UrjnnSZ1qEWM2LEqNKkyvJZ8,29370
-matrice/deploy/utils/post_processing/usecases/__init__.py,sha256=Nb13P5IZSs7tl9j-RZWE0ryuVqu6fvGTAfJhWe3644k,7323
+matrice/deploy/utils/post_processing/usecases/__init__.py,sha256=kyFqU_7j42042wmnYRLWiCM9wqv5BI2CD3AVMQuWe3c,7405
 matrice/deploy/utils/post_processing/usecases/advanced_customer_service.py,sha256=ELt5euxr6P4X2s8-YGngmj27QscOHefjOsx3774sNFk,75914
 matrice/deploy/utils/post_processing/usecases/age_detection.py,sha256=cgOIx2zqPd_OWQMfTDV_4HSlvXlI8eKcZSEZ85SnZWA,35263
 matrice/deploy/utils/post_processing/usecases/anti_spoofing_detection.py,sha256=XdtDdXGzZMLQdWcoOoiE5t4LPYHhgOtJ7tZCNlq1A2E,31329
@@ -187,11 +187,12 @@ matrice/deploy/utils/post_processing/usecases/parking.py,sha256=lqTGqcjUZZPFw3tu
 matrice/deploy/utils/post_processing/usecases/parking_space_detection.py,sha256=1bZaspmzvJAggyr4Lk_hPX79xm6NFpGakAxbuqDnHb8,34524
 matrice/deploy/utils/post_processing/usecases/pedestrian_detection.py,sha256=hPFtvpWXXEsbDavmuiXIhrosMNlOhGya--jukT-ZOHA,39288
 matrice/deploy/utils/post_processing/usecases/people_counting.py,sha256=mDJOwcrs9OO4jIbJVr_ItWvjjGP2mgGFYlrP3R-mH2E,76528
+matrice/deploy/utils/post_processing/usecases/pipeline_detection.py,sha256=VsLTXMAqx0tRw7Olrxqx7SBLolZR7p2aFOrdSXLS-kE,30796
 matrice/deploy/utils/post_processing/usecases/plaque_segmentation_img.py,sha256=d__a0PkkObYVoC-Q5-2bFVfeyKnQHtB5xVAKVOCeFyk,41925
 matrice/deploy/utils/post_processing/usecases/pothole_segmentation.py,sha256=6Mv8SoEE5CGItY7S0g-SY5Lb3DV-WWVMlpEp04a86a8,43197
 matrice/deploy/utils/post_processing/usecases/ppe_compliance.py,sha256=G9P9j9E9nfNJInHJxmK1Lb4daFBlG5hq0aqotTLvFFE,30146
 matrice/deploy/utils/post_processing/usecases/price_tag_detection.py,sha256=Sn_Dvwf5f_dcfaiPIl-pqckgP8z96CeNIJ4hfeab3FM,39880
-matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=ljWoDeFJb0IJJPClYaZrNnBZd87JqKI64jE_I79GAYo,31146
+matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=V_KxwBtAHSNkyoH8sXw-U-P3J8ToXtX3ncc69gn6Tds,31591
 matrice/deploy/utils/post_processing/usecases/shelf_inventory_detection.py,sha256=1juloltHnCj3U499Aps0ggE0nEI37x3iKe4DgfP4RCw,29140
 matrice/deploy/utils/post_processing/usecases/shoplifting_detection.py,sha256=zqeV_ARV5gJqMY2sJGBjlU6UOb0SthGGbC8UNj_mycs,34701
 matrice/deploy/utils/post_processing/usecases/shopping_cart_analysis.py,sha256=9Ej2xiZM7yq5sOBcSXIllou_z0rSZDJ_QHyYz6HxZSY,43957
@@ -225,8 +226,8 @@ matrice/deployment/camera_manager.py,sha256=ReBZqm1CNXRImKcbcZ4uWAT3TUWkof1D28oB
 matrice/deployment/deployment.py,sha256=PLIUD-PxTaC2Zxb3Y12wUddsryV-OJetjCjLoSUh7S4,48103
 matrice/deployment/inference_pipeline.py,sha256=bXLgd29ViA7o0c7YWLFJl1otBUQfTPb61jS6VawQB0Y,37918
 matrice/deployment/streaming_gateway_manager.py,sha256=w5swGsuFVfZIdOm2ZuBHRHlRdYYJMLopLsf2gb91lQ8,20946
-matrice-1.0.99144.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99144.dist-info/METADATA,sha256=xF8gj0tJeJ-JY50BNsnZfd9LLxRif6dtncWMdvo1pE4,14624
-matrice-1.0.99144.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99144.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99144.dist-info/RECORD,,
+matrice-1.0.99146.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99146.dist-info/METADATA,sha256=8hOZtHnM6nfjXFFoPu7nYRM3eTJ_4kui-4SPqwcDsh8,14624
+matrice-1.0.99146.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99146.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99146.dist-info/RECORD,,