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

matrice_analytics/post_processing/usecases/license_plate_monitoring.py

@@ -610,6 +610,68 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             #self.logger.error(f"Error fetching external IP: {e}", exc_info=True)
             return "localhost"
 
+    def _fetch_location_name(self, location_id: str, session: Optional[Session] = None) -> str:
+        """
+        Fetch location name from API using location_id.
+        
+        Args:
+            location_id: The location ID to look up
+            session: Matrice session for API calls
+            
+        Returns:
+            Location name string, or 'Entry Reception' as default if API fails
+        """
+        default_location = "Entry Reception"
+        
+        if not location_id:
+            self.logger.debug(f"[LOCATION] No location_id provided, using default: '{default_location}'")
+            return default_location
+        
+        # Check cache first
+        if not hasattr(self, '_location_name_cache'):
+            self._location_name_cache: Dict[str, str] = {}
+        
+        if location_id in self._location_name_cache:
+            cached_name = self._location_name_cache[location_id]
+            self.logger.debug(f"[LOCATION] Using cached location name for '{location_id}': '{cached_name}'")
+            return cached_name
+        
+        if not session:
+            self.logger.warning(f"[LOCATION] No session provided, using default: '{default_location}'")
+            return default_location
+        
+        try:
+            endpoint = f"/v1/inference/get_location/{location_id}"
+            self.logger.info(f"[LOCATION] Fetching location name from API: {endpoint}")
+            
+            response = session.rpc.get(endpoint)
+            
+            if response and isinstance(response, dict):
+                success = response.get("success", False)
+                if success:
+                    data = response.get("data", {})
+                    location_name = data.get("locationName", default_location)
+                    self.logger.info(f"[LOCATION] ✓ Fetched location name: '{location_name}' for location_id: '{location_id}'")
+                    
+                    # Cache the result
+                    self._location_name_cache[location_id] = location_name
+                    return location_name
+                else:
+                    self.logger.warning(
+                        f"[LOCATION] API returned success=false for location_id '{location_id}': "
+                        f"{response.get('message', 'Unknown error')}"
+                    )
+            else:
+                self.logger.warning(f"[LOCATION] Invalid response format from API: {response}")
+                
+        except Exception as e:
+            self.logger.error(f"[LOCATION] Error fetching location name for '{location_id}': {e}", exc_info=True)
+        
+        # Use default on any failure
+        self.logger.info(f"[LOCATION] Using default location name: '{default_location}'")
+        self._location_name_cache[location_id] = default_location
+        return default_location
+
     def _initialize_alert_manager_once(self, config: LicensePlateMonitorConfig) -> None:
         """
         Initialize alert manager ONCE with Redis OR Kafka clients (Environment based).
@@ -839,13 +901,18 @@ class LicensePlateMonitorUseCase(BaseProcessor):
 
             # Create alert manager if client is available
             if redis_client or kafka_client:
+                # Get app_deployment_id from action_details for filtering alerts
+                app_deployment_id_for_alert = getattr(self, '_app_deployment_id', None)
+                self.logger.info(f"[ALERT] Using app_deployment_id for alert filtering: {app_deployment_id_for_alert}")
+                
                 self.alert_manager = ALERT_INSTANCE(
                     redis_client=redis_client,
                     kafka_client=kafka_client,
                     config_topic="alert_instant_config_request",
                     trigger_topic="alert_instant_triggered",
                     polling_interval=10,  # Poll every 10 seconds
-                    logger=self.logger
+                    logger=self.logger,
+                    app_deployment_id=app_deployment_id_for_alert
                 )
                 self.alert_manager.start()
                 transport = "Redis" if redis_client else "Kafka"
@@ -918,6 +985,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
         app_deployment_id = ""
         application_id = ""
         camera_name = ""
+        frame_id = ""
+        location_name = ""
 
         if stream_info:
             self.logger.debug(f"[ALERT_DEBUG] stream_info keys: {list(stream_info.keys())}")
@@ -933,13 +1002,31 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             app_deployment_id = stream_info.get("app_deployment_id", "")
             application_id = stream_info.get("application_id", stream_info.get("app_id", ""))
             
+            # Extract frame_id - it's at root level of stream_info
+            frame_id = stream_info.get("frame_id", "")
+            
+            # Extract location_id and fetch location_name from API
+            location_id = ""
+            if "camera_info" in stream_info:
+                location_id = stream_info.get("camera_info", {}).get("location", "")
+            
+            if location_id:
+                # Fetch location name from API
+                location_name = self._fetch_location_name(location_id, config.session)
+            else:
+                location_name = "Entry Reception"  # Default if no location_id
+            
             self.logger.debug(f"[ALERT_DEBUG] Extracted metadata from stream_info:")
             self.logger.debug(f"[ALERT_DEBUG]   - camera_id: '{camera_id}'")
             self.logger.debug(f"[ALERT_DEBUG]   - camera_name: '{camera_name}'")
             self.logger.debug(f"[ALERT_DEBUG]   - app_deployment_id: '{app_deployment_id}'")
             self.logger.debug(f"[ALERT_DEBUG]   - application_id: '{application_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - frame_id: '{frame_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - location_id: '{location_id}'")
+            self.logger.debug(f"[ALERT_DEBUG]   - location_name: '{location_name}'")
         else:
             self.logger.warning("[ALERT_DEBUG] stream_info is None")
+            location_name = "Entry Reception"  # Default
 
         # Process each detection with a valid plate_text
         sent_count = 0
@@ -1007,6 +1094,8 @@ class LicensePlateMonitorUseCase(BaseProcessor):
                 "frameUrl": "",  # Will be filled by analytics publisher if needed
                 "coordinates": coordinates,
                 "cameraName": camera_name,
+                "locationName": location_name,
+                "frame_id": frame_id,
                 "vehicleType": detection.get('vehicle_type', ''),
                 "vehicleColor": detection.get('vehicle_color', ''),
                 "timestamp": datetime.now(timezone.utc).isoformat()
@@ -1752,6 +1841,7 @@ class LicensePlateMonitorUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp
         )
+        tracking_stat['target_categories'] = self.target_categories
         tracking_stats.append(tracking_stat)
         return tracking_stats
 

matrice_analytics/post_processing/usecases/people_counting.py

@@ -36,7 +36,7 @@ class PeopleCountingUseCase(BaseProcessor):
         self.category = "general"
         self.CASE_TYPE: Optional[str] = 'people_counting'
         self.CASE_VERSION: Optional[str] = '1.4'
-        self.target_categories = ['person', 'people','human','man','woman','male','female']
+        self.target_categories = ['person'] #['person', 'people','human','man','woman','male','female']
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -50,6 +50,19 @@ class PeopleCountingUseCase(BaseProcessor):
         self.current_incident_end_timestamp: str = "N/A"
         self.start_timer = None
 
+    def _simple_tracker_update(self, detections: list) -> list:
+        """
+        ====== PERFORMANCE: Lightweight tracker alternative ======
+        Simple tracker using frame-local indexing.
+        Much faster than AdvancedTracker - O(n) complexity.
+        Does not persist track IDs across frames.
+        Enable via config.enable_simple_tracker = True
+        """
+        for i, det in enumerate(detections):
+            if det.get('track_id') is None:
+                det['track_id'] = f"simple_{self._total_frame_counter}_{i}"
+        return detections
+
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         processing_start = time.time()
@@ -90,20 +103,29 @@ class PeopleCountingUseCase(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
-            if self.tracker is None:
-                tracker_config = TrackerConfig(
-                    track_high_thresh=0.4,
-                    track_low_thresh=0.05,
-                    new_track_thresh=0.3,
-                    match_thresh=0.8)
-                self.tracker = AdvancedTracker(tracker_config)
-                self.logger.info("Initialized AdvancedTracker for People Counting")
-            processed_data = self.tracker.update(processed_data)
-        except Exception as e:
-            self.logger.warning(f"AdvancedTracker failed: {e}")
+        # ====== TRACKER SELECTION (both disabled by default for max performance) ======
+        # Set config.enable_advanced_tracker=True or config.enable_simple_tracker=True to enable
+        if getattr(config, 'enable_advanced_tracker', False):
+            # Heavy O(n³) tracker - use only when tracking quality is critical
+            try:
+                from ..advanced_tracker import AdvancedTracker
+                from ..advanced_tracker.config import TrackerConfig
+                if self.tracker is None:
+                    tracker_config = TrackerConfig(
+                        track_high_thresh=0.4,
+                        track_low_thresh=0.05,
+                        new_track_thresh=0.3,
+                        match_thresh=0.8)
+                    self.tracker = AdvancedTracker(tracker_config)
+                    self.logger.info("Initialized AdvancedTracker for People Counting")
+                processed_data = self.tracker.update(processed_data)
+            except Exception as e:
+                self.logger.warning(f"AdvancedTracker failed: {e}")
+        elif getattr(config, 'enable_simple_tracker', False):
+            # Lightweight O(n) tracker - fast but no cross-frame persistence
+            processed_data = self._simple_tracker_update(processed_data)
+        # else: No tracking - maximum performance, just use raw detections
+        # ====== END TRACKER SELECTION ======
 
         self._update_tracking_state(processed_data)
         self._total_frame_counter += 1
@@ -362,6 +384,7 @@ class PeopleCountingUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp
         )
+        tracking_stat['target_categories'] = self.target_categories
         tracking_stats.append(tracking_stat)
         return tracking_stats
 
@@ -414,14 +437,24 @@ class PeopleCountingUseCase(BaseProcessor):
 
         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:
+            track_id = det.get("track_id")
+            if cat not in self.target_categories:
                 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)
+
+            # ====== PERFORMANCE: Skip heavy track merging O(n*m) ======
+            # To enable track merging, uncomment below and comment the simple counting section
+            # bbox = det.get("bounding_box", det.get("bbox"))
+            # canonical_id = self._merge_or_register_track(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)
+            # ====== END HEAVY TRACK MERGING ======
+
+            # ====== SIMPLE COUNTING (default - no track merging overhead) ======
+            if track_id is not None:
+                self._per_category_total_track_ids.setdefault(cat, set()).add(track_id)
+                self._current_frame_track_ids[cat].add(track_id)
+            # ====== END SIMPLE COUNTING ======
 
     def get_total_counts(self):
         return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}

matrice_analytics/post_processing/usecases/vehicle_monitoring.py

@@ -683,6 +683,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp
         )
+        tracking_stat['target_categories'] = self.target_categories
         tracking_stats.append(tracking_stat)
         return tracking_stats
 

matrice_analytics/post_processing/usecases/weapon_detection.py

@@ -317,7 +317,7 @@ class WeaponDetectionUseCase(BaseProcessor):
         total_counts = [{"category": cat, "count": count} for cat, count in total_counts_dict.items() if count > 0]
 
         # Build current_counts
-        current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items() if count > 0]
+        current_counts = [{"category": 'Weapon', "count": count} for cat, count in per_category_count.items() if count > 0]
 
         # Prepare detections
         detections = []
@@ -377,6 +377,7 @@ class WeaponDetectionUseCase(BaseProcessor):
             start_time=high_precision_start_timestamp,
             reset_time=high_precision_reset_timestamp
         )
+        tracking_stat['target_categories'] = ['Weapon']
         tracking_stats.append(tracking_stat)
         return tracking_stats
 

matrice_analytics/post_processing/utils/alert_instance_utils.py

@@ -76,7 +76,8 @@ class ALERT_INSTANCE:
         config_topic: str = "alert_instant_config_request",
         trigger_topic: str = "alert_instant_triggered",
         polling_interval: int = 10,
-        logger: Optional[logging.Logger] = None
+        logger: Optional[logging.Logger] = None,
+        app_deployment_id: Optional[str] = None
     ):
         """
         Initialize ALERT_INSTANCE.
@@ -88,6 +89,7 @@ class ALERT_INSTANCE:
             trigger_topic: Topic/stream name for publishing triggers
             polling_interval: Seconds between config polling
             logger: Python logger instance
+            app_deployment_id: App deployment ID to filter incoming alerts (only process alerts matching this ID)
         """
         self.redis_client = redis_client
         self.kafka_client = kafka_client
@@ -95,6 +97,7 @@ class ALERT_INSTANCE:
         self.trigger_topic = trigger_topic
         self.polling_interval = polling_interval
         self.logger = logger or logging.getLogger(__name__)
+        self.app_deployment_id = app_deployment_id
 
         # In-memory alert storage: {instant_alert_id: AlertConfig}
         self._alerts: Dict[str, AlertConfig] = {}
@@ -114,7 +117,7 @@ class ALERT_INSTANCE:
         self.logger.info(
             f"Initialized ALERT_INSTANCE with config_topic={config_topic}, "
             f"trigger_topic={trigger_topic}, polling_interval={polling_interval}s, "
-            f"cooldown={self._cooldown_seconds}s"
+            f"cooldown={self._cooldown_seconds}s, app_deployment_id={app_deployment_id}"
         )
 
     def start(self):
@@ -394,6 +397,29 @@ class ALERT_INSTANCE:
                 self.logger.warning("[ALERT_DEBUG] Skipping malformed config with 'raw' key only")
                 return
             
+            # Log detection_service field (informational only, no filtering)
+            detection_service = config_data.get('detection_service', '')
+            self.logger.info(f"[ALERT_DEBUG] detection_service: '{detection_service}'")
+            
+            # Filter by app_deployment_id - only process alerts that match our app_deployment_id
+            incoming_app_deployment_id = config_data.get('app_deployment_id', '')
+            if self.app_deployment_id:
+                if incoming_app_deployment_id != self.app_deployment_id:
+                    self.logger.info(
+                        f"[ALERT_DEBUG] Skipping alert - app_deployment_id mismatch: "
+                        f"incoming='{incoming_app_deployment_id}', ours='{self.app_deployment_id}'"
+                    )
+                    return
+                else:
+                    self.logger.info(
+                        f"[ALERT_DEBUG] ✓ app_deployment_id match: '{incoming_app_deployment_id}'"
+                    )
+            else:
+                self.logger.warning(
+                    f"[ALERT_DEBUG] No app_deployment_id filter set, processing all alerts. "
+                    f"Incoming app_deployment_id: '{incoming_app_deployment_id}'"
+                )
+            
             # Log individual fields before creating AlertConfig
             self.logger.debug(f"[ALERT_DEBUG] Extracted fields from config_data:")
             self.logger.debug(f"[ALERT_DEBUG]   - instant_alert_id: '{config_data.get('instant_alert_id', 'MISSING')}'")
@@ -706,7 +732,13 @@ class ALERT_INSTANCE:
         detection: Dict[str, Any],
         config: Dict[str, Any]
     ) -> bool:
-        """Evaluate license plate detection against alert criteria."""
+        """
+        Evaluate license plate detection against alert criteria.
+        
+        Supports two alert conditions:
+        - "in_list" (BLACKLIST): Alert ONLY when detected plate IS in targetPlates list
+        - "not_in_list" (WHITELIST): Alert when detected plate is NOT in targetPlates list
+        """
         self.logger.debug(f"[ALERT_DEBUG] ========== EVALUATING LPR ALERT ==========")
         self.logger.debug(f"[ALERT_DEBUG] Alert ID: {alert.instant_alert_id}")
         self.logger.debug(f"[ALERT_DEBUG] Alert Name: {alert.alert_name}")
@@ -715,9 +747,12 @@ class ALERT_INSTANCE:
         
         target_plates = config.get("targetPlates", [])
         min_confidence = config.get("minConfidence", 0.0)
+        # Get alertCondition: "in_list" (blacklist) or "not_in_list" (whitelist)
+        alert_condition = config.get("alertCondition", "in_list")
         
         self.logger.debug(f"[ALERT_DEBUG] Target plates: {target_plates}")
         self.logger.debug(f"[ALERT_DEBUG] Min confidence: {min_confidence}")
+        self.logger.info(f"[ALERT_DEBUG] Alert condition: '{alert_condition}' (in_list=blacklist, not_in_list=whitelist)")
 
         plate_number = detection.get("plateNumber", "").upper().strip()
         confidence = detection.get("confidence", 0.0)
@@ -725,37 +760,68 @@ class ALERT_INSTANCE:
         self.logger.debug(f"[ALERT_DEBUG] Detected plate (normalized): '{plate_number}'")
         self.logger.debug(f"[ALERT_DEBUG] Detection confidence: {confidence}")
 
+        # Skip empty plate numbers
+        if not plate_number:
+            self.logger.debug(f"[ALERT_DEBUG] ✗ Empty plate number, skipping")
+            return False
+
         # Check if plate matches target list (case-insensitive)
-        plate_match = any(
-            plate_number == str(target).upper().strip()
-            for target in target_plates
-        )
+        normalized_targets = [str(t).upper().strip() for t in target_plates]
+        plate_in_list = plate_number in normalized_targets
         
-        self.logger.debug(f"[ALERT_DEBUG] Plate match result: {plate_match}")
-        if not plate_match and target_plates:
-            normalized_targets = [str(t).upper().strip() for t in target_plates]
-            self.logger.debug(f"[ALERT_DEBUG] Normalized target plates: {normalized_targets}")
-            self.logger.debug(f"[ALERT_DEBUG] Plate '{plate_number}' not in {normalized_targets}")
+        self.logger.debug(f"[ALERT_DEBUG] Normalized target plates: {normalized_targets}")
+        self.logger.debug(f"[ALERT_DEBUG] Plate '{plate_number}' in list: {plate_in_list}")
 
-        # Check confidence threshold
-        min_confidence=0.05
+        # Check confidence threshold (minimum 0.05)
+        min_confidence = max(0.05, min_confidence)
         confidence_match = confidence >= min_confidence
         
         self.logger.debug(f"[ALERT_DEBUG] Confidence match result: {confidence_match} ({confidence} >= {min_confidence})")
 
-        if plate_match:
-            self.logger.info(
-                f"[ALERT_DEBUG] ✓ LPR ALERT TRIGGERED: {alert.alert_name} - "
-                f"Plate: {plate_number}, Confidence: {confidence:.2f}"
-            )
-            return True
+        # Determine if alert should trigger based on alertCondition
+        should_trigger = False
+        
+        if alert_condition == "in_list":
+            # BLACKLIST: Alert only when plate IS in the target list
+            if plate_in_list and confidence_match:
+                should_trigger = True
+                self.logger.info(
+                    f"[ALERT_DEBUG] ✓ LPR BLACKLIST ALERT TRIGGERED: {alert.alert_name} - "
+                    f"Plate: {plate_number} IS in blacklist, Confidence: {confidence:.2f}"
+                )
+            else:
+                self.logger.debug(
+                    f"[ALERT_DEBUG] ✗ LPR blacklist alert NOT triggered: {alert.alert_name} - "
+                    f"Plate '{plate_number}' in_list={plate_in_list}, confidence_match={confidence_match}"
+                )
+        
+        elif alert_condition == "not_in_list":
+            # WHITELIST: Alert when plate is NOT in the target list
+            if not plate_in_list and confidence_match:
+                should_trigger = True
+                self.logger.info(
+                    f"[ALERT_DEBUG] ✓ LPR WHITELIST ALERT TRIGGERED: {alert.alert_name} - "
+                    f"Plate: {plate_number} is NOT in whitelist, Confidence: {confidence:.2f}"
+                )
+            else:
+                self.logger.debug(
+                    f"[ALERT_DEBUG] ✗ LPR whitelist alert NOT triggered: {alert.alert_name} - "
+                    f"Plate '{plate_number}' in_list={plate_in_list} (whitelisted), confidence_match={confidence_match}"
+                )
+        
         else:
-            self.logger.debug(
-                f"[ALERT_DEBUG] ✗ LPR alert NOT triggered: {alert.alert_name} - "
-                f"Plate match: {plate_match}"
+            # Unknown condition, default to blacklist behavior for backward compatibility
+            self.logger.warning(
+                f"[ALERT_DEBUG] Unknown alertCondition '{alert_condition}', defaulting to 'in_list' (blacklist) behavior"
             )
+            if plate_in_list and confidence_match:
+                should_trigger = True
+                self.logger.info(
+                    f"[ALERT_DEBUG] ✓ LPR ALERT TRIGGERED (default): {alert.alert_name} - "
+                    f"Plate: {plate_number}, Confidence: {confidence:.2f}"
+                )
 
-        return False
+        return should_trigger
 
     def _evaluate_count_alert(
         self,
@@ -868,10 +934,11 @@ class ALERT_INSTANCE:
             "detectionType": detection_type_raw,
             "confidence": detection.get("confidence", 0.0),
             "coordinates": detection.get("coordinates", {}),
-            "cameraName": detection.get("cameraName", "")
+            "cameraName": detection.get("cameraName", ""),
+            "locationName": detection.get("locationName", "")
         }
 
-        # Add type-specific fieldss
+        # Add type-specific fields
         if detection_type_raw == "license_plate":
             context_data.update({
                 "plateNumber": detection.get("plateNumber", ""),
@@ -900,6 +967,7 @@ class ALERT_INSTANCE:
         trigger_message = {
             "instant_alert_id": alert.instant_alert_id,
             "camera_id": alert.camera_id,
+            "frame_id": detection.get("frame_id", ""),
             "triggered_at": datetime.now(timezone.utc).isoformat(),
             "context_data": context_data
         }