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

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
@@ -333,20 +355,20 @@ class PeopleCountingUseCase(BaseProcessor):
             })
 
         human_text_lines = []
-        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
+        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
         for cat, count in per_category_count.items():
             human_text_lines.append(f"\t- People Detected: {count}")
         human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
-        for cat, count in total_counts_dict.items():
-            if count > 0:
-                human_text_lines.append("")
-                human_text_lines.append(f"\t- Total unique people count: {count}")
-        if alerts:
-            for alert in alerts:
-                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
-        else:
-            human_text_lines.append("Alerts: None")
+        # human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
+        # for cat, count in total_counts_dict.items():
+        #     if count > 0:
+        #         human_text_lines.append("")
+        #         human_text_lines.append(f"\t- Total unique people count: {count}")
+        # if alerts:
+        #     for alert in alerts:
+        #         human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+        # else:
+        #     human_text_lines.append("Alerts: None")
         human_text = "\n".join(human_text_lines)
 
         reset_settings = [{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]
@@ -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

@@ -633,40 +633,40 @@ class VehicleMonitoringUseCase(BaseProcessor):
                         human_text_lines.append(f"\t\t- {cat}: {count}")
 
         human_text_lines.append("")
-        human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
-
-        # Display total counts - zone-wise or category-wise
-        if zone_analysis:
-            human_text_lines.append("\t- Total Vehicles by Zone:")
-            for zone_name, zone_data in zone_analysis.items():
-                total_count = 0
-                if isinstance(zone_data, dict):
-                    # Prefer the numeric cumulative total if available
-                    if "total_count" in zone_data and isinstance(zone_data.get("total_count"), (int, float)):
-                        total_count = zone_data.get("total_count", 0)
-                    # Fallback: compute from list of total_track_ids if present
-                    elif "total_track_ids" in zone_data and isinstance(zone_data.get("total_track_ids"), list):
-                        total_count = len(zone_data.get("total_track_ids", []))
-                    else:
-                        # Last resort: try to sum numeric values present
-                        counts_dict = zone_data if isinstance(zone_data, dict) else {}
-                        total_count = sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
-                human_text_lines.append(f"\t\t- {zone_name}: {int(total_count)}")
-        else:
-            if total_counts_dict:
-                human_text_lines.append("\t- Total Unique Vehicles:")
-                for cat, count in total_counts_dict.items():
-                    if count > 0:
-                        human_text_lines.append(f"\t\t- {cat}: {count}")
-
-        # Display alerts
-        if alerts:
-            human_text_lines.append("")
-            for alert in alerts:
-                human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
-        else:
-            human_text_lines.append("")
-            human_text_lines.append("Alerts: None")
+        # human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+
+        # # Display total counts - zone-wise or category-wise
+        # if zone_analysis:
+        #     human_text_lines.append("\t- Total Vehicles by Zone:")
+        #     for zone_name, zone_data in zone_analysis.items():
+        #         total_count = 0
+        #         if isinstance(zone_data, dict):
+        #             # Prefer the numeric cumulative total if available
+        #             if "total_count" in zone_data and isinstance(zone_data.get("total_count"), (int, float)):
+        #                 total_count = zone_data.get("total_count", 0)
+        #             # Fallback: compute from list of total_track_ids if present
+        #             elif "total_track_ids" in zone_data and isinstance(zone_data.get("total_track_ids"), list):
+        #                 total_count = len(zone_data.get("total_track_ids", []))
+        #             else:
+        #                 # Last resort: try to sum numeric values present
+        #                 counts_dict = zone_data if isinstance(zone_data, dict) else {}
+        #                 total_count = sum(v for v in counts_dict.values() if isinstance(v, (int, float)))
+        #         human_text_lines.append(f"\t\t- {zone_name}: {int(total_count)}")
+        # else:
+        #     if total_counts_dict:
+        #         human_text_lines.append("\t- Total Unique Vehicles:")
+        #         for cat, count in total_counts_dict.items():
+        #             if count > 0:
+        #                 human_text_lines.append(f"\t\t- {cat}: {count}")
+
+        # # Display alerts
+        # if alerts:
+        #     human_text_lines.append("")
+        #     for alert in alerts:
+        #         human_text_lines.append(f"Alerts: {alert.get('settings', {})} sent @ {current_timestamp}")
+        # else:
+        #     human_text_lines.append("")
+        #     human_text_lines.append("Alerts: None")
 
         human_text = "\n".join(human_text_lines)
 
@@ -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