matrice-analytics 0.1.70__py3-none-any.whl → 0.1.96__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):
@@ -101,7 +107,7 @@ class FireSmokeUseCase(BaseProcessor):
 
         self.smoothing_tracker = None  # Required for bbox smoothing
         self._fire_smoke_recent_history = []
-        self.target_categories=['fire']
+        self.target_categories=['fire', 'smoke']  # Lowercase to match filtering logic at line 276
 
         self._ascending_alert_list: List[str] = []
         self.current_incident_end_timestamp: str = "N/A"
@@ -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
 
@@ -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.
@@ -405,9 +538,21 @@ class FireSmokeUseCase(BaseProcessor):
             count_thresholds = {}
             if config.alert_config and hasattr(config.alert_config, "count_thresholds"):
                 count_thresholds = config.alert_config.count_thresholds or {}
+            
+            # CRITICAL FIX: Ensure we have at least one category to process
+            # If count_thresholds is empty, use detected categories from per_category_count
+            # This ensures incidents are always generated when detections exist
+            per_category_count = summary.get("per_category_count", {})
+            if not count_thresholds and per_category_count:
+                # Create thresholds for all detected categories with threshold=0 (always trigger)
+                count_thresholds = {cat: 0 for cat in per_category_count.keys()}
+                self.logger.debug(f"[INCIDENT] count_thresholds was empty, using detected categories: {count_thresholds}")
+            
+            # Flag to track if we generated any incident
+            incident_generated = False
 
             for category, threshold in count_thresholds.items():
-                if category in summary.get("per_category_count", {}):
+                if category in per_category_count:
                     
                     #count = summary.get("per_category_count", {})[category]
                     start_timestamp = self._get_start_timestamp_str(stream_info)
@@ -474,7 +619,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,7 +653,57 @@ 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)
+                    incident_generated = True
+            
+            # CRITICAL FALLBACK: If no incident was generated despite having detections,
+            # generate a basic incident to ensure the incident manager receives data
+            if not incident_generated and total > 0:
+                self.logger.warning(f"[INCIDENT] No incident generated despite {total} detections. Generating fallback incident.")
+                # Calculate area and intensity for fallback
+                for det in detections:
+                    bbox = det.get("bounding_box") or det.get("bbox")
+                    if bbox:
+                        xmin, ymin = bbox.get("xmin"), bbox.get("ymin")
+                        xmax, ymax = bbox.get("xmax"), bbox.get("ymax")
+                        if None not in (xmin, ymin, xmax, ymax):
+                            width, height = xmax - xmin, ymax - ymin
+                            if width > 0 and height > 0:
+                                total_area += width * height
+                
+                threshold_area = config.threshold_area or 250200.0
+                intensity_pct = min(100.0, (total_area / threshold_area) * 100)
+                
+                # Determine severity level
+                if intensity_pct >= 30:
+                    level = "critical"
+                elif intensity_pct >= 13:
+                    level = "significant"
+                elif intensity_pct >= 3:
+                    level = "medium"
+                else:
+                    level = "low"
+                self._ascending_alert_list.append(level)
+                
+                start_timestamp = self._get_start_timestamp_str(stream_info)
+                human_text = f"INCIDENTS DETECTED @ {current_timestamp}:\n\tSeverity Level: {(self.CASE_TYPE, level)}"
+                
+                event = self.create_incident(
+                    incident_id='incident_' + self.CASE_TYPE + '_fallback',
+                    incident_type=self.CASE_TYPE,
+                    severity_level=level,
+                    human_text=human_text,
+                    camera_info=camera_info,
+                    alerts=alerts,
+                    alert_settings=[],
+                    start_time=start_timestamp,
+                    end_time='Incident still active',
+                    level_settings={"low": 3, "medium": 5, "significant": 15, "critical": 30}
+                )
+                event['incident_quant'] = intensity_pct
+                incidents.append(event)
+                self.logger.info(f"[INCIDENT] Generated fallback incident with level={level}, intensity={intensity_pct:.2f}%")
 
         else:
             #self._ascending_alert_list.append(level)
@@ -551,20 +750,39 @@ class FireSmokeUseCase(BaseProcessor):
 
     
         # Build total_counts array in expected format
+        # ALWAYS populate with all target categories to avoid empty arrays downstream
         total_counts = []
         if total > 0:
-                total_counts.append({
-                    "category": 'Fire/Smoke',  #TODO: Discuss and fix what to do with this
-                    "count": 1
-                })
+            total_counts.append({
+                "category": 'Fire/Smoke',
+                "count": 1
+            })
+        else:
+            # When no detections, send count=0 for each category to avoid empty array
+            total_counts.append({
+                "category": 'Fire',
+                "count": 0
+            })
+            total_counts.append({
+                "category": 'Smoke',
+                "count": 0
+            })
 
-        # Build current_counts array in expected format  
+        # Build current_counts array in expected format
+        # ALWAYS populate with all target categories to avoid empty arrays downstream
         current_counts = []
-        if total > 0:  # Include even if 0 when there are detections
-                current_counts.append({
-                    "category": 'Fire/Smoke',  #TODO: Discuss and fix what to do with this
-                    "count": 1
-                })
+        
+        # Add Fire entry (count=1 if detected, count=0 if not)
+        current_counts.append({
+            "category": 'Fire',
+            "count": 1 if total_fire > 0 else 0
+        })
+        
+        # Add Smoke entry (count=1 if detected, count=0 if not)
+        current_counts.append({
+            "category": 'Smoke',
+            "count": 1 if total_smoke > 0 else 0
+        })
 
         human_lines = [f"CURRENT FRAME @ {current_timestamp}:"]
         if total_fire > 0:
@@ -575,17 +793,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)
 
@@ -635,8 +853,8 @@ class FireSmokeUseCase(BaseProcessor):
                              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_stat['target_categories'] = self.target_categories
         tracking_stats.append(tracking_stat)
 
         if len(self.id_hit_list)==1: