matrice-analytics 0.1.89__py3-none-any.whl → 0.1.97__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

@@ -40,54 +40,35 @@ class VehicleMonitoringConfig(BaseConfig):
 # )
     usecase_categories: List[str] = field(
         default_factory=lambda: [
-            "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck", "boat",
-            "traffic light", "fire hydrant", "stop sign", "parking meter", "bench", "bird", "cat", "dog",
-            "horse", "sheep", "cow", "elephant", "bear", "zebra", "giraffe", "backpack", "umbrella",
-            "handbag", "tie", "suitcase", "frisbee", "skis", "snowboard", "sports ball", "kite",
-            "baseball bat", "baseball glove", "skateboard", "surfboard", "tennis racket", "bottle",
-            "wine glass", "cup", "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich",
-            "orange", "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
-            "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse", "remote",
-            "keyboard", "cell phone", "microwave", "oven", "toaster", "sink", "refrigerator", "book",
-            "clock", "vase", "scissors", "teddy bear", "hair drier", "toothbrush"
+            'bicycle', 'motorcycle', 'car', 'van', 'bus', 'truck' 
         ]
     )
     target_categories: List[str] = field(
         default_factory=lambda: [
-            'car', 'bicycle', 'bus','motorcycle']
+            'bicycle', 'motorcycle', 'car', 'van', 'bus', 'truck' 
+        ]
     )
     alert_config: Optional[AlertConfig] = None
     index_to_category: Optional[Dict[int, str]] = field(
         default_factory=lambda: {
-                0: "person", 1: "bicycle", 2: "car", 3: "motorcycle", 4: "airplane", 5: "bus",
-                6: "train", 7: "truck", 8: "boat", 9: "traffic light", 10: "fire hydrant",
-                11: "stop sign", 12: "parking meter", 13: "bench", 14: "bird", 15: "cat",
-                16: "dog", 17: "horse", 18: "sheep", 19: "cow", 20: "elephant", 21: "bear",
-                22: "zebra", 23: "giraffe", 24: "backpack", 25: "umbrella", 26: "handbag",
-                27: "tie", 28: "suitcase", 29: "frisbee", 30: "skis", 31: "snowboard",
-                32: "sports ball", 33: "kite", 34: "baseball bat", 35: "baseball glove",
-                36: "skateboard", 37: "surfboard", 38: "tennis racket", 39: "bottle",
-                40: "wine glass", 41: "cup", 42: "fork", 43: "knife", 44: "spoon", 45: "bowl",
-                46: "banana", 47: "apple", 48: "sandwich", 49: "orange", 50: "broccoli",
-                51: "carrot", 52: "hot dog", 53: "pizza", 54: "donut", 55: "cake", 56: "chair",
-                57: "couch", 58: "potted plant", 59: "bed", 60: "dining table", 61: "toilet",
-                62: "tv", 63: "laptop", 64: "mouse", 65: "remote", 66: "keyboard",
-                67: "cell phone", 68: "microwave", 69: "oven", 70: "toaster", 71: "sink",
-                72: "refrigerator", 73: "book", 74: "clock", 75: "vase", 76: "scissors",
-                77: "teddy bear", 78: "hair drier", 79: "toothbrush"
-            }
+            0: "bicycle",
+            1: "motorcycle", 
+            2: "car",
+            3: "van",
+            4: "bus",
+            5: "truck"
+        }
     )
 
 class VehicleMonitoringUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
         # Focus on vehicle-related COCO classes
         "bicycle": "Bicycle",
-        "car": "Car",
         "motorcycle": "Motorcycle",
+        "car": "Car",
+        "van": "Van",    
         "bus": "Bus",
         "truck": "Truck",
-        "train": "Train",
-        "boat": "Boat"
     }
 
     def __init__(self):
@@ -95,7 +76,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
         self.category = "traffic"
         self.CASE_TYPE: Optional[str] = 'vehicle_monitoring'
         self.CASE_VERSION: Optional[str] = '1.0'
-        self.target_categories = ['car', 'bicycle', 'bus', 'truck', 'motorcycle']
+        self.target_categories = ['bicycle', 'motorcycle', 'car', 'van', 'bus', 'truck' ]
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -141,6 +122,7 @@ class VehicleMonitoringUseCase(BaseProcessor):
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
         config.confidence_threshold = 0.25
+        # param to be updated 
 
         if config.confidence_threshold is not None:
             processed_data = filter_by_confidence(data, config.confidence_threshold)
@@ -683,6 +665,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