matrice 1.0.99126__py3-none-any.whl → 1.0.99128__py3-none-any.whl

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

@@ -1,22 +1,28 @@
 from typing import Any, Dict, List, Optional
-from dataclasses import dataclass, field
+from dataclasses import asdict
 import time
 from datetime import datetime, timezone
 
 from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol
 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 ..core.config import BaseConfig, AlertConfig
+from dataclasses import dataclass, field
+from ..core.config import BaseConfig, AlertConfig, ZoneConfig
+
 
 @dataclass
 class WeldDefectConfig(BaseConfig):
-    """Configuration for Weld Defect detection use case."""
+    """Configuration for weld defect detection use case."""
     enable_smoothing: bool = True
     smoothing_algorithm: str = "observability"
     smoothing_window_size: int = 20
@@ -41,13 +47,23 @@ class WeldDefectConfig(BaseConfig):
         }
     )
 
+
 class WeldDefectUseCase(BaseProcessor):
-    """Weld Defect detection use case with smoothing and alerting."""
-    
+    CATEGORY_DISPLAY = {
+        "Bad Welding": "Bad Welding",
+        "Crack": "Crack",
+        "Porosity": "Porosity",
+        "Spatters": "Spatters",
+        "Good Welding": "Good Welding",
+        "Reinforcement": "Reinforcement"
+    }
+
     def __init__(self):
         super().__init__("weld_defect_detection")
         self.category = "weld"
-        self.defect_categories = ['Bad Welding', 'Crack', 'Porosity', 'Spatters', 'Good Welding', 'Reinforcement']
+        self.CASE_TYPE: Optional[str] = 'weld_defect_detection'
+        self.CASE_VERSION: Optional[str] = '1.0'
+        self.target_categories = ['Bad Welding', 'Crack', 'Porosity', 'Spatters']
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -57,142 +73,36 @@ class WeldDefectUseCase(BaseProcessor):
         self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
         self._track_merge_iou_threshold: float = 0.05
         self._track_merge_time_window: float = 7.0
+        self._ascending_alert_list: List[int] = []
+        self.current_incident_end_timestamp: str = "N/A"
 
-    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, '_defect_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)
-        }
-
-    @staticmethod
-    def _iou(bbox1, bbox2):
-        x1 = max(bbox1["xmin"], bbox2["xmin"])
-        y1 = max(bbox1["ymin"], bbox2["ymin"])
-        x2 = min(bbox1["xmax"], bbox2["xmax"])
-        y2 = min(bbox1["ymax"], bbox2["ymax"])
-        inter_w = max(0, x2 - x1)
-        inter_h = max(0, y2 - y1)
-        inter_area = inter_w * inter_h
-        area1 = (bbox1["xmax"] - bbox1["xmin"]) * (bbox1["ymax"] - bbox1["ymin"])
-        area2 = (bbox2["xmax"] - bbox2["xmin"]) * (bbox2["ymax"] - bbox2["ymin"])
-        union = area1 + area2 - inter_area
-        return 0.0 if union == 0 else inter_area / union
-
-    @staticmethod
-    def _deduplicate_defects(detections, iou_thresh=0.7):
-        filtered = []
-        used = [False] * len(detections)
-        for i, det in enumerate(detections):
-            if used[i]:
-                continue
-            group = [i]
-            for j in range(i+1, len(detections)):
-                if used[j]:
-                    continue
-                if det.get("category") == detections[j].get("category"):
-                    bbox1 = det.get("bounding_box")
-                    bbox2 = detections[j].get("bounding_box")
-                    if bbox1 and bbox2:
-                        iou = WeldDefectUseCase._iou(bbox1, bbox2)
-                        if iou > iou_thresh:
-                            used[j] = True
-                            group.append(j)
-            best_idx = max(group, key=lambda idx: detections[idx].get("confidence", 0))
-            filtered.append(detections[best_idx])
-            used[best_idx] = True
-        return filtered
-
-    def _update_defect_tracking_state(self, detections: list):
-        if not hasattr(self, "_defect_total_track_ids"):
-            self._defect_total_track_ids = {cat: set() for cat in self.defect_categories}
-        self._defect_current_frame_track_ids = {cat: set() for cat in self.defect_categories}
-
-        for det in detections:
-            cat = det.get("category")
-            raw_track_id = det.get("track_id")
-            if cat not in self.defect_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._defect_total_track_ids.setdefault(cat, set()).add(canonical_id)
-            self._defect_current_frame_track_ids[cat].add(canonical_id)
-
-    def get_total_defect_counts(self):
-        return {cat: len(ids) for cat, ids in getattr(self, '_defect_total_track_ids', {}).items()}
-
-    def _format_timestamp_for_video(self, timestamp: float) -> str:
-        hours = int(timestamp // 3600)
-        minutes = int((timestamp % 3600) // 60)
-        seconds = timestamp % 60
-        return f"{hours:02d}:{minutes:02d}:{seconds:06.2f}"
-
-    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 _get_current_timestamp_str(self, stream: Optional[Dict[str, Any]]) -> str:
-        if not stream:
-            return "00:00:00.00"
-        if stream.get("input_settings", {}).get("stream_type", "video_file") == "video_file":
-            stream_time_str = stream.get("video_timestamp", "")
-            return stream_time_str[:8]
-        else:
-            stream_time_str = stream.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())
-            return self._format_timestamp_for_stream(time.time())
-
-    def _get_start_timestamp_str(self, stream: Optional[Dict[str, Any]]) -> str:
-        if not stream:
-            return "00:00:00"
-        if stream.get("input_settings", {}).get("is_video_chunk", False) or stream.get("input_settings", {}).get("stream_type", "video_file") == "video_file":
-            return "00:00:00"
-        else:
-            if self._tracking_start_time is None:
-                stream_time_str = stream.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 process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None, stream: Optional[Dict[str, Any]] = None) -> ProcessingResult:
+    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, WeldDefectConfig):
-            return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
+            return self.create_error_result("Invalid config type", usecase=self.name, category=self.category,
+                                            context=context)
         if context is None:
             context = ProcessingContext()
 
-        processed_data = filter_by_confidence(data, config.confidence_threshold) if config.confidence_threshold else data
+        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("No confidence filtering applied")
+
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
-        processed_data = [d for d in processed_data if d.get('category') in self.defect_categories]
+            self.logger.debug("Applied category mapping")
+
+        if config.target_defect_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:
@@ -213,185 +123,387 @@ class WeldDefectUseCase(BaseProcessor):
             if self.tracker is None:
                 tracker_config = TrackerConfig()
                 self.tracker = AdvancedTracker(tracker_config)
+                self.logger.info("Initialized AdvancedTracker for Weld Defect Detection")
             processed_data = self.tracker.update(processed_data)
         except Exception as e:
             self.logger.warning(f"AdvancedTracker failed: {e}")
 
-        processed_data = self._deduplicate_defects(processed_data, iou_thresh=0.95)
-        self._update_defect_tracking_state(processed_data)
+        self._update_tracking_state(processed_data)
         self._total_frame_counter += 1
 
         frame_number = None
-        if stream:
-            input_settings = stream.get("input_settings", {})
+        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_defect_counts = self.get_total_defect_counts()
-        counting_summary['total_defect_counts'] = total_defect_counts
-        insights = self._generate_insights(counting_summary, config)
-        alerts = self._check_alerts(counting_summary, 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)
-        summary = self._generate_summary(counting_summary, alerts)
 
-        events_list = self._generate_events(counting_summary, alerts, config, frame_number, stream)
-        tracking_stats_list = self._generate_tracking_stats(counting_summary, insights, summary, config, frame_number, stream)
+        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)
 
-        events = events_list[0] if events_list else {}
+        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={
-                "counting_summary": counting_summary,
-                "alerts": alerts,
-                "total_defects": counting_summary.get("total_count", 0),
-                "events": events,
-                "tracking_stats": tracking_stats,
-            },
+            data={"agg_summary": agg_summary},
             usecase=self.name,
             category=self.category,
             context=context
         )
-        result.summary = summary
-        result.insights = insights
-        result.predictions = predictions
         return result
 
-    def reset_tracker(self) -> None:
-        if self.tracker is not None:
-            self.tracker.reset()
-            self.logger.info("AdvancedTracker reset")
+    def _check_alerts(self, summary: dict, frame_number: Any, config: WeldDefectConfig) -> 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
+            return ratio >= threshold
 
-    def reset_defect_tracking(self) -> None:
-        self._defect_total_track_ids = {cat: set() for cat in self.defect_categories}
-        self._total_frame_counter = 0
-        self._global_frame_offset = 0
-        self._tracking_start_time = None
-        self._track_aliases.clear()
-        self._canonical_tracks.clear()
-        self.logger.info("Weld Defect tracking state reset")
+        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", {})
 
-    def reset_all_tracking(self) -> None:
-        self.reset_tracker()
-        self.reset_defect_tracking()
-        self.logger.info("All Weld Defect tracking state reset")
+        if not config.alert_config:
+            return alerts
 
-    def _generate_events(self, counting_summary: Dict, alerts: List, config: WeldDefectConfig, frame_number: Optional[int] = None, stream: Optional[Dict[str, Any]] = None) -> List[Dict]:
-        frame_key = str(frame_number) if frame_number is not None else "current_frame"
-        events = [{frame_key: []}]
-        frame_events = events[0][frame_key]
-        total_defects = counting_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:
+                    count = per_category_count[category]
+                    if count > 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']))}
+                        })
+        return alerts
 
-        if total_defects > 0:
-            level = "info"
+    def _generate_incidents(self, counting_summary: Dict, alerts: List, config: WeldDefectConfig,
+                           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", 5)
-                intensity = min(10.0, (total_defects / threshold) * 10)
-                level = "critical" if intensity >= 7 else "warning" if intensity >= 5 else "info"
+                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:
-                level = "critical" if total_defects > 10 else "warning" if total_defects > 5 else "info"
-                intensity = min(10.0, total_defects / 2.0)
+                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 = ["EVENTS DETECTED:"]
-            human_text_lines.append(f"    - {total_defects} Weld Defect(s) detected [INFO]")
+            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)
 
-            event = {
-                "type": "weld_defect_detection",
-                "stream_time": datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S UTC"),
-                "level": level,
-                "intensity": round(intensity, 1),
-                "config": {"min_value": 0, "max_value": 10, "level_settings": {"info": 2, "warning": 5, "critical": 7}},
-                "application_name": "Weld Defect Detection System",
-                "application_version": "1.0",
-                "location_info": None,
-                "human_text": human_text
-            }
-            frame_events.append(event)
-
-        for alert in alerts:
-            total_defects = counting_summary.get("total_count", 0)
-            intensity_message = "ALERT: Low defect density"
-            if config.alert_config and config.alert_config.count_thresholds:
-                threshold = config.alert_config.count_thresholds.get("all", 5)
-                percentage = (total_defects / threshold) * 100 if threshold > 0 else 0
-                intensity_message = f"ALERT: {'Severe' if percentage > 70 else 'Heavy' if percentage > 50 else 'Moderate' if percentage > 20 else 'Low'} defect density"
-            else:
-                intensity_message = f"ALERT: {'Heavy' if total_defects > 5 else 'Low'} defect density"
-
-            alert_event = {
-                "type": alert.get("type", "defect_alert"),
-                "stream_time": datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S UTC"),
-                "level": alert.get("severity", "warning"),
-                "intensity": 8.0,
-                "config": {"min_value": 0, "max_value": 10, "level_settings": {"info": 2, "warning": 5, "critical": 7}},
-                "application_name": "Defect Alert System",
-                "application_version": "1.0",
-                "location_info": alert.get("zone"),
-                "human_text": f"{datetime.now(timezone.utc).strftime('%Y-%m-%d-%H:%M:%S UTC')} : {intensity_message}"
-            }
-            frame_events.append(alert_event)
+            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']),
+                    "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']))}
+                })
+
+            event = self.create_incident(
+                incident_id=f"{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 events
+        return incidents
 
-    def _generate_tracking_stats(self, counting_summary: Dict, insights: List[str], summary: str, config: WeldDefectConfig, frame_number: Optional[int] = None, stream: Optional[Dict[str, Any]] = None) -> List[Dict]:
-        frame_key = str(frame_number) if frame_number is not None else "current_frame"
-        tracking_stats = [{frame_key: []}]
-        frame_tracking_stats = tracking_stats[0][frame_key]
-
-        total_defects = counting_summary.get("total_count", 0)
-        total_defect_counts = counting_summary.get("total_defect_counts", {})
-        cumulative_total = sum(total_defect_counts.values()) if total_defect_counts else 0
+    def _generate_tracking_stats(self, counting_summary: Dict, alerts: List, config: WeldDefectConfig,
+                                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", {})
         per_category_count = counting_summary.get("per_category_count", {})
-
-        track_ids_info = self._get_track_ids_info(counting_summary.get("detections", []))
-        current_timestamp = self._get_current_timestamp_str(stream)
-        start_timestamp = self._get_start_timestamp_str(stream)
-
-        human_text_lines = []
-        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
-        if total_defects > 0:
-            category_counts = [f"{count} {cat}" for cat, count in per_category_count.items()]
-            if len(category_counts) == 1:
-                defects_text = category_counts[0] + " detected"
-            elif len(category_counts) == 2:
-                defects_text = f"{category_counts[0]} and {category_counts[1]} detected"
+        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 = [{"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", {})
+            category = detection.get("category", "defect")
+            if detection.get("masks"):
+                segmentation = detection.get("masks", [])
+                detection_obj = self.create_detection_object(category, bbox, segmentation=segmentation)
+            elif detection.get("segmentation"):
+                segmentation = detection.get("segmentation")
+                detection_obj = self.create_detection_object(category, bbox, segmentation=segmentation)
+            elif detection.get("mask"):
+                segmentation = detection.get("mask")
+                detection_obj = self.create_detection_object(category, bbox, segmentation=segmentation)
             else:
-                defects_text = f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
-            human_text_lines.append(f"\t- {defects_text}")
+                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']),
+                "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']))}
+            })
+
+        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(f"\t- No defects detected")
+            human_text_lines.append("Alerts: None")
+        human_text = "\n".join(human_text_lines)
 
-        human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
-        human_text_lines.append(f"\t- Total Defects Detected: {cumulative_total}")
-        for cat, count in total_defect_counts.items():
-            if count > 0:
-                human_text_lines.append(f"\t- {cat}: {count}")
+        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
 
-        human_text = "\n".join(human_text_lines)
+    def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: WeldDefectConfig,
+                                    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[dict]:
+        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]
 
-        tracking_stat = {
-            "type": "weld_defect_tracking",
-            "category": "weld",
-            "count": total_defects,
-            "insights": insights,
-            "summary": summary,
-            "timestamp": datetime.now(timezone.utc).strftime('%Y-%m-%d-%H:%M:%S UTC'),
-            "human_text": human_text,
-            "track_ids_info": track_ids_info,
-            "global_frame_offset": getattr(self, '_global_frame_offset', 0),
-            "local_frame_id": frame_key,
-            "detections": counting_summary.get("detections", [])
+    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)
         }
 
-        frame_tracking_stats.append(tracking_stat)
-        return tracking_stats
+    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)
+                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)
+            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:
+                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: WeldDefectConfig) -> dict:
         counts = {}
@@ -413,61 +525,6 @@ class WeldDefectUseCase(BaseProcessor):
             ]
         }
 
-    CATEGORY_DISPLAY = {
-        "Bad Welding": "Bad Welding",
-        "Crack": "Crack",
-        "Porosity": "Porosity",
-        "Spatters": "Spatters",
-        "Good Welding": "Good Welding",
-        "Reinforcement": "Reinforcement"
-    }
-
-    def _generate_insights(self, summary: dict, config: WeldDefectConfig) -> List[str]:
-        insights = []
-        per_cat = summary.get("per_category_count", {})
-        total_defects = summary.get("total_count", 0)
-
-        if total_defects == 0:
-            insights.append("No weld defects detected in the scene")
-            return insights
-        insights.append(f"EVENT: Detected {total_defects} weld defect(s) in the scene")
-        intensity_threshold = config.alert_config.count_thresholds.get("all", 5) if config.alert_config and config.alert_config.count_thresholds else 5
-        percentage = (total_defects / intensity_threshold) * 100
-        insights.append(f"INTENSITY: {'Severe' if percentage > 70 else 'Heavy' if percentage > 50 else 'Moderate' if percentage > 20 else 'Low'} defect density ({percentage:.1f}% of capacity)")
-        for cat, count in per_cat.items():
-            display = self.CATEGORY_DISPLAY.get(cat, cat)
-            insights.append(f"{display}: {count}")
-        return insights
-
-    def _check_alerts(self, summary: dict, config: WeldDefectConfig) -> List[Dict]:
-        alerts = []
-        if not config.alert_config:
-            return alerts
-        total = summary.get("total_count", 0)
-        if config.alert_config.count_thresholds:
-            for category, threshold in config.alert_config.count_thresholds.items():
-                if category == "all" and total >= threshold:
-                    alerts.append({
-                        "type": "count_threshold",
-                        "severity": "warning",
-                        "message": f"Total defect count ({total}) exceeds threshold ({threshold})",
-                        "category": category,
-                        "current_count": total,
-                        "threshold": threshold
-                    })
-                elif category in summary.get("per_category_count", {}):
-                    count = summary.get("per_category_count", {})[category]
-                    if count >= threshold:
-                        alerts.append({
-                            "type": "count_threshold",
-                            "severity": "warning",
-                            "message": f"{category} count ({count}) exceeds threshold ({threshold})",
-                            "category": category,
-                            "current_count": count,
-                            "threshold": threshold
-                        })
-        return alerts
-
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:
         return [
             {
@@ -478,25 +535,6 @@ class WeldDefectUseCase(BaseProcessor):
             for det in detections
         ]
 
-    def _generate_summary(self, summary: dict, alerts: List) -> str:
-        total = summary.get("total_count", 0)
-        per_cat = summary.get("per_category_count", {})
-        cumulative = summary.get("total_defect_counts", {})
-        cumulative_total = sum(cumulative.values()) if cumulative else 0
-        lines = []
-        if total > 0:
-            lines.append(f"{total} Weld Defect(s) detected")
-            if per_cat:
-                lines.append("Defects:")
-                for cat, count in per_cat.items():
-                    lines.append(f"\t{cat}: {count}")
-        else:
-            lines.append("No weld defect detected")
-        lines.append(f"Total defects detected: {cumulative_total}")
-        if alerts:
-            lines.append(f"{len(alerts)} alert(s)")
-        return "\n".join(lines)
-
     def _compute_iou(self, box1: Any, box2: Any) -> float:
         def _bbox_to_list(bbox):
             if bbox is None:
@@ -518,31 +556,25 @@ class WeldDefectUseCase(BaseProcessor):
             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]
@@ -552,7 +584,6 @@ class WeldDefectUseCase(BaseProcessor):
                 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
@@ -563,7 +594,6 @@ class WeldDefectUseCase(BaseProcessor):
                 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] = {
@@ -577,7 +607,9 @@ class WeldDefectUseCase(BaseProcessor):
         return datetime.fromtimestamp(timestamp, timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')
 
     def _get_tracking_start_time(self) -> str:
-        return self._format_timestamp(self._tracking_start_time) if self._tracking_start_time else "N/A"
+        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()