matrice-analytics 0.1.2__py3-none-any.whl → 0.1.31__py3-none-any.whl

matrice_analytics/post_processing/usecases/drone_traffic_monitoring.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 from dataclasses import asdict
 import time
 from datetime import datetime, timezone
@@ -18,7 +18,6 @@ from ..utils import (
 )
 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 VehiclePeopleDroneMonitoringConfig(BaseConfig):
@@ -29,15 +28,6 @@ class VehiclePeopleDroneMonitoringConfig(BaseConfig):
     smoothing_cooldown_frames: int = 5
     smoothing_confidence_range_factor: float = 0.5
     confidence_threshold: float = 0.6
-
-    #JBK_720_GATE POLYGON = [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]]
-    zone_config: Optional[Dict[str, Dict[str, List[List[float]]]]] = None #field(
-#     default_factory=lambda: {
-#         "zones": {
-#             "Interest_Region": [[86, 328], [844, 317], [1277, 520], [1273, 707], [125, 713]],
-#         }
-#     }
-# )
     usecase_categories: List[str] = field(
         default_factory=lambda: [
             "pedestrian", "people", "bicycle", "car", "van", "truck", "tricycle", "awning-tricycle", "bus", "motor"
@@ -57,8 +47,7 @@ class VehiclePeopleDroneMonitoringConfig(BaseConfig):
 
 class DroneTrafficMonitoringUsecase(BaseProcessor):
     CATEGORY_DISPLAY = {
-        # Focus on vehicle-related COCO classes
-        "pedestrian": "Pesestrian",
+        "pedestrian": "Pedestrian",
         "people": "People",
         "bicycle": "Bicycle",
         "car": "Car",
@@ -87,54 +76,29 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
         self._track_merge_time_window: float = 7.0
         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
-        self._total_count_list = []
-        
-        # 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:
-        processing_start = time.time()
+        start_time = time.time()
         if not isinstance(config, VehiclePeopleDroneMonitoringConfig):
             return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
         if context is None:
             context = ProcessingContext()
-
-        # Normalize typical YOLO outputs (COCO pretrained) to internal schema
-        data = self._normalize_yolo_results(data, getattr(config, 'index_to_category', None))
-
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
-        config.confidence_threshold = 0.25
-
         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("Did not apply confidence filtering since no threshold provided")
-
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
             self.logger.debug("Applied category mapping")
-
-        processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
         if config.target_categories:
             processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
             self.logger.debug("Applied category filtering")
-        
-
         if config.enable_smoothing:
             if self.smoothing_tracker is None:
                 smoothing_config = BBoxSmoothingConfig(
@@ -147,7 +111,6 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                 )
                 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
@@ -158,10 +121,8 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
             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", {})
@@ -169,39 +130,16 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
             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
-        counting_summary['categories'] = {}
-        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'], stream_info)
-
-            if zone_analysis:
-                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
-                    
-
-        alerts = self._check_alerts(counting_summary,zone_analysis, frame_number, config)
+        alerts = self._check_alerts(counting_summary, frame_number, config)
         predictions = self._extract_predictions(processed_data)
-
-        incidents_list = self._generate_incidents(counting_summary,zone_analysis, alerts, config, frame_number, stream_info)
-        incidents_list = []
-        tracking_stats_list = self._generate_tracking_stats(counting_summary,zone_analysis, alerts, config, frame_number, stream_info)
-
-        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_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 {}
@@ -211,10 +149,8 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
             "tracking_stats": tracking_stats,
             "business_analytics": business_analytics,
             "alerts": alerts,
-            "zone_analysis": zone_analysis,
             "human_text": summary}
         }
-
         context.mark_completed()
         result = self.create_result(
             data={"agg_summary": agg_summary},
@@ -222,167 +158,9 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
             category=self.category,
             context=context
         )
-        proc_time = time.time() - processing_start
-        processing_latency_ms = proc_time * 1000.0
-        processing_fps = (1.0 / proc_time) if proc_time > 0 else None
-        # Log the performance metrics using the module-level logger
-        print("latency in ms:",processing_latency_ms,"| Throughput fps:",processing_fps,"| Frame_Number:",self._total_frame_counter)
         return result
 
-    def _update_zone_tracking(self, zone_analysis: Dict[str, Dict[str, int]], detections: List[Dict], config: VehiclePeopleDroneMonitoringConfig) -> 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)
-                    if track_id not in self._total_count_list:
-                        self._total_count_list.append(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:
-        - category/category_id: prefer string label using COCO mapping if available
-        - confidence: map from 'conf'/'score' to 'confidence'
-        - bounding_box: ensure dict with keys (x1,y1,x2,y2) or (xmin,ymin,xmax,ymax)
-        - supports list of detections and frame_id -> detections dict
-        """
-        def to_bbox_dict(d: Dict[str, Any]) -> Dict[str, Any]:
-            if "bounding_box" in d and isinstance(d["bounding_box"], dict):
-                return d["bounding_box"]
-            if "bbox" in d:
-                bbox = d["bbox"]
-                if isinstance(bbox, dict):
-                    return bbox
-                if isinstance(bbox, (list, tuple)) and len(bbox) >= 4:
-                    x1, y1, x2, y2 = bbox[0], bbox[1], bbox[2], bbox[3]
-                    return {"x1": x1, "y1": y1, "x2": x2, "y2": y2}
-            if "xyxy" in d and isinstance(d["xyxy"], (list, tuple)) and len(d["xyxy"]) >= 4:
-                x1, y1, x2, y2 = d["xyxy"][0], d["xyxy"][1], d["xyxy"][2], d["xyxy"][3]
-                return {"x1": x1, "y1": y1, "x2": x2, "y2": y2}
-            if "xywh" in d and isinstance(d["xywh"], (list, tuple)) and len(d["xywh"]) >= 4:
-                cx, cy, w, h = d["xywh"][0], d["xywh"][1], d["xywh"][2], d["xywh"][3]
-                x1, y1, x2, y2 = cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2
-                return {"x1": x1, "y1": y1, "x2": x2, "y2": y2}
-            return {}
-
-        def resolve_category(d: Dict[str, Any]) -> Tuple[str, Optional[int]]:
-            raw_cls = d.get("category", d.get("category_id", d.get("class", d.get("cls"))))
-            label_name = d.get("name")
-            if isinstance(raw_cls, int):
-                if index_to_category and raw_cls in index_to_category:
-                    return index_to_category[raw_cls], raw_cls
-                return str(raw_cls), raw_cls
-            if isinstance(raw_cls, str):
-                # Some YOLO exports provide string labels directly
-                return raw_cls, None
-            if label_name:
-                return str(label_name), None
-            return "unknown", None
-
-        def normalize_det(det: Dict[str, Any]) -> Dict[str, Any]:
-            category_name, category_id = resolve_category(det)
-            confidence = det.get("confidence", det.get("conf", det.get("score", 0.0)))
-            bbox = to_bbox_dict(det)
-            normalized = {
-                "category": category_name,
-                "confidence": confidence,
-                "bounding_box": bbox,
-            }
-            if category_id is not None:
-                normalized["category_id"] = category_id
-            # Preserve optional fields
-            for key in ("track_id", "frame_id", "masks", "segmentation"):
-                if key in det:
-                    normalized[key] = det[key]
-            return normalized
-
-        if isinstance(data, list):
-            return [normalize_det(d) if isinstance(d, dict) else d for d in data]
-        if isinstance(data, dict):
-            # Detect tracking style dict: frame_id -> list of detections
-            normalized_dict: Dict[str, Any] = {}
-            for k, v in data.items():
-                if isinstance(v, list):
-                    normalized_dict[k] = [normalize_det(d) if isinstance(d, dict) else d for d in v]
-                elif isinstance(v, dict):
-                    normalized_dict[k] = normalize_det(v)
-                else:
-                    normalized_dict[k] = v
-            return normalized_dict
-        return data
-
-    def _check_alerts(self, summary: dict, zone_analysis: Dict, frame_number: Any, config: VehiclePeopleDroneMonitoringConfig) -> List[Dict]:
+    def _check_alerts(self, summary: dict, frame_number: Any, config: VehiclePeopleDroneMonitoringConfig) -> List[Dict]:
         def get_trend(data, lookback=900, threshold=0.6):
             window = data[-lookback:] if len(data) >= lookback else data
             if len(window) < 2:
@@ -395,16 +173,13 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                 total += 1
             ratio = increasing / total
             return ratio >= threshold
-
         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", {})
         per_category_count = summary.get("per_category_count", {})
-
         if not config.alert_config:
             return alerts
-
         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:
@@ -415,7 +190,7 @@ class DroneTrafficMonitoringUsecase(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({
@@ -425,19 +200,17 @@ class DroneTrafficMonitoringUsecase(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, zone_analysis: Dict, alerts: List, config: VehiclePeopleDroneMonitoringConfig,
-                        frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
+    def _generate_incidents(self, counting_summary: Dict, alerts: List, config: VehiclePeopleDroneMonitoringConfig,
+                           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
@@ -449,8 +222,7 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                     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 hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
+            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:
@@ -482,11 +254,9 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                     level = "low"
                     intensity = min(10.0, total_detections / 3.0)
                     self._ascending_alert_list.append(0)
-
             human_text_lines = [f"VEHICLE 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({
@@ -497,7 +267,6 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                     "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
                                                      getattr(config.alert_config, 'alert_value', ['JSON']))}
                 })
-
             event = self.create_incident(
                 incident_id=f"{self.CASE_TYPE}_{frame_number}",
                 incident_type=self.CASE_TYPE,
@@ -516,7 +285,7 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
             incidents.append({})
         return incidents
 
-    def _generate_tracking_stats(self, counting_summary: Dict, zone_analysis: Dict, alerts: List, config: VehiclePeopleDroneMonitoringConfig,
+    def _generate_tracking_stats(self, counting_summary: Dict, alerts: List, config: VehiclePeopleDroneMonitoringConfig,
                                 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 = []
@@ -527,10 +296,8 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
         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 = [{"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", []):
             bbox = detection.get("bounding_box", {})
@@ -547,7 +314,6 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
             else:
                 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({
@@ -556,58 +322,22 @@ class DroneTrafficMonitoringUsecase(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}")
-        # Append zone-wise current counts if available
-        if zone_analysis:
-            human_text_lines.append("\tZones (current):")
-            for zone_name, zone_data in zone_analysis.items():
-                current_count = 0
-                if isinstance(zone_data, dict):
-                    if "current_count" in zone_data:
-                        current_count = zone_data.get("current_count", 0)
-                    else:
-                        counts_dict = zone_data.get("original_counts") if isinstance(zone_data.get("original_counts"), dict) else zone_data
-                        current_count = counts_dict.get(
-                            "total",
-                            sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
-                        )
-                human_text_lines.append(f"\t{zone_name}: {int(current_count)}")
-        else:
-            for cat, count in per_category_count.items():
-                human_text_lines.append(f"\t{cat}: {count}")
+        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}")
-        # Append zone-wise total counts if available
-        if zone_analysis:
-            human_text_lines.append("\tZones (total):")
-            for zone_name, zone_data in zone_analysis.items():
-                total_count = 0
-                if isinstance(zone_data, dict):
-                    # Prefer the numeric cumulative total if available
-                    if "total_count" in zone_data and isinstance(zone_data.get("total_count"), (int, float)):
-                        total_count = zone_data.get("total_count", 0)
-                    # Fallback: compute from list of total_track_ids if present
-                    elif "total_track_ids" in zone_data and isinstance(zone_data.get("total_track_ids"), list):
-                        total_count = len(zone_data.get("total_track_ids", []))
-                    else:
-                        # Last resort: try to sum numeric values present
-                        counts_dict = zone_data if isinstance(zone_data, dict) else {}
-                        total_count = sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
-                human_text_lines.append(f"\t{zone_name}: {int(total_count)}")
-        else:
-            for cat, count in total_counts_dict.items():
-                if count > 0:
-                    human_text_lines.append(f"\t{cat}: {count}")
+        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,
@@ -624,29 +354,24 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
         tracking_stats.append(tracking_stat)
         return tracking_stats
 
-    def _generate_business_analytics(self, counting_summary: Dict, zone_analysis: Dict, alerts: Any, config: VehiclePeopleDroneMonitoringConfig,
+    def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: VehiclePeopleDroneMonitoringConfig,
                                     stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
         if is_empty:
             return []
 
-    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.
-        """
-        lines = []
-        lines.append("Application Name: "+self.CASE_TYPE)
-        lines.append("Application Version: "+self.CASE_VERSION)
+    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.append("Incidents: "+f"\n\t{incidents[0].get('human_text', 'No incidents detected')}")
+            lines["Incidents:"] = f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
         if len(tracking_stats) > 0:
-            lines.append("Tracking Statistics: "+f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}")
+            lines["Tracking Statistics:"] = f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
         if len(business_analytics) > 0:
-            lines.append("Business Analytics: "+f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}")
-
+            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.append("Summary: "+"No Summary Data")
-
-        return ["\n".join(lines)]
+            lines["Summary"] = "No Summary Data"
+        return [lines]
 
     def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
         frame_track_ids = set()
@@ -670,7 +395,6 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
         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")
@@ -696,32 +420,23 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
         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:
-        """Get formatted current timestamp based on stream type."""
         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 self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
+                return self._format_timestamp_for_video(start_time)
             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 self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
+            return self._format_timestamp_for_video(start_time)
         else:
             stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
             if stream_time_str:
@@ -736,31 +451,16 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                 return self._format_timestamp_for_stream(time.time())
 
     def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
-        """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
         if not stream_info:
             return "00:00:00"
-        
         if precision:
-            if self.start_timer is None:
-                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
-                return self._format_timestamp(self.start_timer)
-            elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
-                self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
-                return self._format_timestamp(self.start_timer)
+            if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+                return "00:00:00"
             else:
-                return self._format_timestamp(self.start_timer)
-
-        if self.start_timer is None:
-            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
-            return self._format_timestamp(self.start_timer)
-        elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
-            self.start_timer = stream_info.get("input_settings", {}).get("stream_time", "NA")
-            return self._format_timestamp(self.start_timer)
-        
+                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.start_timer is not None:
-                return self._format_timestamp(self.start_timer)
-
             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:
@@ -772,57 +472,10 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                         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 _format_timestamp(self, timestamp: Any) -> str:
-        """Format a timestamp so that exactly two digits follow the decimal point (milliseconds).
-
-        The input can be either:
-        1. A numeric Unix timestamp (``float`` / ``int``) – it will first be converted to a
-           string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
-        2. A string already following the same layout.
-
-        The returned value preserves the overall format of the input but truncates or pads
-        the fractional seconds portion to **exactly two digits**.
-
-        Example
-        -------
-        >>> self._format_timestamp("2025-08-19-04:22:47.187574 UTC")
-        '2025-08-19-04:22:47.18 UTC'
-        """
-
-        # Convert numeric timestamps to the expected string representation first
-        if isinstance(timestamp, (int, float)):
-            timestamp = datetime.fromtimestamp(timestamp, timezone.utc).strftime(
-                '%Y-%m-%d-%H:%M:%S.%f UTC'
-            )
-
-        # Ensure we are working with a string from here on
-        if not isinstance(timestamp, str):
-            return str(timestamp)
-
-        # If there is no fractional component, simply return the original string
-        if '.' not in timestamp:
-            return timestamp
-
-        # Split out the main portion (up to the decimal point)
-        main_part, fractional_and_suffix = timestamp.split('.', 1)
-
-        # Separate fractional digits from the suffix (typically ' UTC')
-        if ' ' in fractional_and_suffix:
-            fractional_part, suffix = fractional_and_suffix.split(' ', 1)
-            suffix = ' ' + suffix  # Re-attach the space removed by split
-        else:
-            fractional_part, suffix = fractional_and_suffix, ''
-
-        # Guarantee exactly two digits for the fractional part
-        fractional_part = (fractional_part + '00')[:2]
-
-        return f"{main_part}.{fractional_part}{suffix}"
-
     def _count_categories(self, detections: list, config: VehiclePeopleDroneMonitoringConfig) -> dict:
         counts = {}
         for det in detections:
@@ -867,7 +520,6 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
                 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:
@@ -921,6 +573,9 @@ class DroneTrafficMonitoringUsecase(BaseProcessor):
         }
         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"