matrice-analytics 0.1.60__py3-none-any.whl → 0.1.89__py3-none-any.whl

matrice_analytics/post_processing/usecases/fire_detection.py

@@ -27,6 +27,8 @@ from ..utils import (
     BBoxSmoothingConfig,
     BBoxSmoothingTracker
 )
+# Import incident manager for publishing incidents on level change
+from ..utils.incident_manager_utils import INCIDENT_MANAGER, IncidentManagerFactory
 
 
 # ======================
@@ -75,6 +77,10 @@ class FireSmokeConfig(BaseConfig):
     smoothing_cooldown_frames: int = 10
     smoothing_confidence_range_factor: float = 0.2
     threshold_area: Optional[float] = 250200.0
+    
+    # Session and server configuration for incident manager
+    session: Optional[Any] = None  # Matrice session for Redis/Kafka initialization
+    server_id: Optional[str] = None  # Server ID for localhost/cloud detection
 
     def __post_init__(self):
         if not (0.0 <= self.confidence_threshold <= 1.0):
@@ -112,6 +118,114 @@ class FireSmokeUseCase(BaseProcessor):
         self.return_id_counter = 1
         self.start_timer = None
         self._tracking_start_time = None
+        
+        # Incident manager for publishing incidents on severity level change
+        self._incident_manager_factory: Optional[IncidentManagerFactory] = None
+        self._incident_manager: Optional[INCIDENT_MANAGER] = None
+        self._incident_manager_initialized: bool = False
+
+    def _initialize_incident_manager_once(self, config: FireSmokeConfig) -> None:
+        """
+        Initialize incident manager ONCE with Redis OR Kafka clients (Environment based).
+        Called from process() on first invocation.
+        Uses config.session (existing session from pipeline) or creates from environment.
+        """
+        if self._incident_manager_initialized:
+            return
+        
+        try:
+            self.logger.info("[INCIDENT_MANAGER] Starting incident manager initialization for fire detection...")
+            
+            # Create factory if not exists
+            if self._incident_manager_factory is None:
+                self._incident_manager_factory = IncidentManagerFactory(logger=self.logger)
+            
+            # Initialize using factory (handles session creation, Redis/Kafka setup)
+            self._incident_manager = self._incident_manager_factory.initialize(config)
+            
+            if self._incident_manager:
+                self.logger.info("[INCIDENT_MANAGER] ✓ Incident manager initialized successfully for fire detection")
+            else:
+                self.logger.warning("[INCIDENT_MANAGER] Incident manager not available, incidents won't be published")
+        
+        except Exception as e:
+            self.logger.error(f"[INCIDENT_MANAGER] Incident manager initialization failed: {e}", exc_info=True)
+        finally:
+            self._incident_manager_initialized = True  # Mark as initialized (don't retry every frame)
+
+    def _send_incident_to_manager(
+        self, 
+        incident: Dict, 
+        stream_info: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Send incident to incident manager for level tracking and publishing.
+        
+        The incident manager will:
+        1. Track the severity level
+        2. Wait for consecutive frames before publishing:
+           - 5 frames for medium/significant/critical
+           - 10 frames for low (stricter to avoid false positives)
+        3. Publish only when level changes
+        4. Send 'info' level after 101 consecutive empty frames (incident ended)
+        
+        Args:
+            incident: Incident dictionary from _generate_incidents
+            stream_info: Stream metadata containing camera info
+        """
+        if not self._incident_manager:
+            self.logger.debug("[INCIDENT_MANAGER] No incident manager available, skipping")
+            return
+        
+        # Extract camera_id from stream_info
+        # Priority: camera_info.camera_id > stream_info.camera_id > extract from topic
+        camera_id = ""
+        if stream_info:
+            camera_info = stream_info.get("camera_info", {}) or {}
+            camera_id = camera_info.get("camera_id", "") or camera_info.get("cameraId", "")
+            
+            if not camera_id:
+                camera_id = stream_info.get("camera_id", "") or stream_info.get("cameraId", "")
+            
+            # Extract camera_id from topic if not found elsewhere
+            # Topic format: {camera_id}_input_topic
+            if not camera_id:
+                topic = stream_info.get("topic", "")
+                if topic:
+                    if topic.endswith("_input_topic"):
+                        camera_id = topic[: -len("_input_topic")]
+                        self.logger.debug(f"[INCIDENT_MANAGER] Extracted camera_id from topic (underscore): {camera_id}")
+                    elif topic.endswith("_input-topic"):
+                        camera_id = topic[: -len("_input-topic")]
+                        self.logger.debug(f"[INCIDENT_MANAGER] Extracted camera_id from topic (hyphen): {camera_id}")
+                    else:
+                        # Fallback: split on known markers if not strictly at the end
+                        if "_input_topic" in topic:
+                            camera_id = topic.split("_input_topic")[0]
+                            self.logger.debug(f"[INCIDENT_MANAGER] Extracted camera_id from topic split (underscore): {camera_id}")
+                        elif "_input-topic" in topic:
+                            camera_id = topic.split("_input-topic")[0]
+                            self.logger.debug(f"[INCIDENT_MANAGER] Extracted camera_id from topic split (hyphen): {camera_id}")
+        
+        if not camera_id:
+            # Fallback to a default identifier
+            camera_id = "default_camera"
+            self.logger.debug(f"[INCIDENT_MANAGER] No camera_id found, using default: {camera_id}")
+        else:
+            self.logger.debug(f"[INCIDENT_MANAGER] Using camera_id: {camera_id}")
+        
+        try:
+            # Process the incident through the manager
+            published = self._incident_manager.process_incident(
+                camera_id=camera_id,
+                incident_data=incident,
+                stream_info=stream_info
+            )
+            
+            if published:
+                self.logger.info(f"[INCIDENT_MANAGER] Incident published for camera: {camera_id}")
+        except Exception as e:
+            self.logger.error(f"[INCIDENT_MANAGER] Error sending incident to manager: {e}", exc_info=True)
 
     def process(
             self,
@@ -135,6 +249,10 @@ class FireSmokeUseCase(BaseProcessor):
                     context=context,
                 )
 
+            # Step 0.5: Initialize incident manager once (for publishing incidents on level change)
+            if not self._incident_manager_initialized:
+                self._initialize_incident_manager_once(config)
+
             # Step 1: Init context
             if context is None:
                 context = ProcessingContext()
@@ -225,6 +343,18 @@ class FireSmokeUseCase(BaseProcessor):
                 stream_info=stream_info
             )
             business_analytics_list = self._generate_business_analytics(fire_smoke_summary, alerts, config, stream_info, is_empty=True)
+            
+            # Step 8.5: Send incident to incident manager for level tracking and publishing
+            # The incident manager handles:
+            # - 5-consecutive-frame validation
+            # - Publishing only on level change
+            # - Skipping "low" level incidents
+            incidents = incidents_list[0] if incidents_list else {}
+            self._send_incident_to_manager(incidents, stream_info)
+            # if incidents_list and len(incidents_list) > 0:
+            #     incident = incidents_list[0]
+            #     if incident and incident != {}:
+            #         self._send_incident_to_manager(incident, stream_info)
 
              # Step 9: Human-readable summary
             summary_list = self._generate_summary(fire_smoke_summary, general_summary, incidents_list, tracking_stats_list, business_analytics_list, alerts)
@@ -232,7 +362,7 @@ class FireSmokeUseCase(BaseProcessor):
             # Finalize context and return result
             context.processing_time = time.time() - start_time
 
-            incidents = incidents_list[0] if incidents_list else {}
+            
             tracking_stats = tracking_stats_list[0] if tracking_stats_list else {}
             #EVENT ENDED SIGNAL
 
@@ -245,8 +375,8 @@ class FireSmokeUseCase(BaseProcessor):
             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],
+                            "incidents": incidents,
+                            "tracking_stats": tracking_stats,
                             "business_analytics": business_analytics,
                             "alerts": alerts,
                             "human_text": summary}
@@ -363,6 +493,9 @@ class FireSmokeUseCase(BaseProcessor):
     ) -> Dict:
         """Generate structured events for fire and smoke detection output with frame-aware keys."""
 
+        level_params=[{"level":"low","percentage":0.0001},{"level":"medium","percentage":3},
+                      {"level":"significant","percentage":13},{"level":"critical","percentage":30}]
+
         def get_trend_incident(data, lookback=23, prior=14):
             '''
             Determine if the trend is ascending or descending based on actual value progression.
@@ -474,7 +607,11 @@ class FireSmokeUseCase(BaseProcessor):
 
                     # Generate human text in new format
                     human_text_lines = [f"INCIDENTS DETECTED @ {current_timestamp}:"]
-                    human_text_lines.append(f"\tSeverity Level: {(self.CASE_TYPE,level)}")
+                    if level=='significant':
+                        print_level = "high"
+                    else:
+                        print_level = level
+                    human_text_lines.append(f"\tSeverity Level: {(self.CASE_TYPE,print_level)}")
                     human_text = "\n".join(human_text_lines)
 
                     # Pass the last severity level **value** instead of a single-element list
@@ -504,6 +641,7 @@ class FireSmokeUseCase(BaseProcessor):
                             start_time=start_timestamp, end_time=self.current_incident_end_timestamp,
                             level_settings= {"low": 3, "medium": 5, "significant":15, "critical": 30})
                     event['duration'] = self.get_duration_seconds(start_timestamp, self.current_incident_end_timestamp)
+                    event['incident_quant'] = intensity_pct
                     incidents.append(event)
 
         else:
@@ -575,17 +713,17 @@ class FireSmokeUseCase(BaseProcessor):
             human_lines.append(f"\t- No fire or smoke detected")
 
         human_lines.append("")
-        human_lines.append(f"ALERTS SINCE @ {start_timestamp}:")
+        # human_lines.append(f"ALERTS SINCE @ {start_timestamp}:")
 
         recent_fire_detected = any(entry.get("fire", 0) > 0 for entry in self._fire_smoke_recent_history)
         recent_smoke_detected = any(entry.get("smoke", 0) > 0 for entry in self._fire_smoke_recent_history)
 
-        if recent_fire_detected:
-            human_lines.append(f"\t- Fire alert")
-        if recent_smoke_detected:
-            human_lines.append(f"\t- Smoke alert")
-        if not recent_fire_detected and not recent_smoke_detected:
-            human_lines.append(f"\t- No fire or smoke detected in recent frames")
+        # if recent_fire_detected:
+        #     human_lines.append(f"\t- Fire alert")
+        # if recent_smoke_detected:
+        #     human_lines.append(f"\t- Smoke alert")
+        # if not recent_fire_detected and not recent_smoke_detected:
+        #     human_lines.append(f"\t- No fire or smoke detected in recent frames")
 
         human_text = "\n".join(human_lines)