matrice 1.0.99268__py3-none-any.whl → 1.0.99270__py3-none-any.whl

matrice/deploy/utils/post_processing/core/config.py

@@ -391,6 +391,12 @@ class ProximityConfig(BaseConfig):
     enable_unique_counting: bool = True
     time_window_minutes: int = 60
     
+    proximity_threshold_meters: float = 1.0
+    proximity_threshold_pixels: float = 250.0
+    meters_per_pixel: float = 0.0028
+    scene_width_meters: float = 0.0
+    scene_height_meters: float = 0.0
+    
     # Category mapping
     person_categories: List[str] = field(default_factory=lambda: ["person"])
     index_to_category: Optional[Dict[int, str]] = None

matrice/deploy/utils/post_processing/usecases/proximity_detection.py

@@ -66,6 +66,7 @@ class ProximityUseCase(BaseProcessor):
         # Proximity counting
         self._total_proximity_count = 0  # Total proximity events across all calls
         self._observed_proximity_pairs: Set[frozenset] = set()  # Unique canonical ID pairs seen across frames
+        self._last_frame_proximity_pairs: Set[tuple] = set()  # Pairs detected in the most recent frame (track-id based)
         
 
         # --------------------------------------------------------------------- #
@@ -287,8 +288,8 @@ class ProximityUseCase(BaseProcessor):
         # Update tracking state BEFORE proximity calculation so we have canonical IDs
         self._update_tracking_state(counting_summary)
 
-        # Calculate unique proximity events for this frame
-        proximity_count = self._count_proximity_events(counting_summary["detections"])
+        # Calculate unique proximity events for this frame (meters-aware)
+        proximity_count = self._count_proximity_events(counting_summary["detections"], config, stream_info)
         counting_summary["proximity_events"] = proximity_count
         counting_summary["total_proximity_count"] = self._total_proximity_count
         
@@ -585,91 +586,166 @@ class ProximityUseCase(BaseProcessor):
         )
         return [tracking_stat]
     
-    def _count_proximity_events(self, detections: List[Dict[str, Any]]) -> int:
+    def _count_proximity_events(self, detections: List[Dict[str, Any]], config: ProximityConfig, stream_info: Optional[Dict[str, Any]] = None) -> int:
         """Count UNIQUE proximity events between detections in a frame.
 
         Rules:
-        - If canonical track IDs are present, deduplicate by track_id first.
-        - Otherwise, deduplicate overlapping boxes using IoU to avoid duplicate detections of the same person.
-        - Count each pair once (i < j) using Euclidean distance between bottom-center points.
+        - Use IoU-NMS to deduplicate overlapping boxes (highest confidence kept).
+        - Use track IDs when available to build stable (id1,id2) pairs.
+        - Count each pair once (i < j) using Euclidean distance between box centers.
+        - Distance is evaluated in meters when calibration is available; otherwise, fallback to pixel threshold.
         - Maintain a running set of unique canonical-ID pairs across frames to compute total unique proximity events.
         """
         if not detections:
             return 0
 
-        proximity_threshold = 400.0  # pixels, screen space
-        iou_duplicate_threshold = getattr(self, "_proximity_iou_duplicate_threshold", 0.5)
+        # Determine threshold strategy
+        meters_per_pixel = self._get_meters_per_pixel(config, stream_info)
+        threshold_meters = getattr(config, "proximity_threshold_meters", 1.0)
+        threshold_pixels_fallback = getattr(config, "proximity_threshold_pixels", 400.0)
 
-        # Step 1: Deduplicate detections
-        unique_detections: List[Dict[str, Any]] = []
-        seen_track_ids: Set[Any] = set()
+        overlap_iou_threshold = getattr(self, "_proximity_iou_duplicate_threshold", 0.5)
 
+        # Helper: convert bbox to xyxy list
+        def _to_xyxy(bbox: Any) -> List[float]:
+            if isinstance(bbox, list):
+                if len(bbox) >= 4:
+                    return [float(bbox[0]), float(bbox[1]), float(bbox[2]), float(bbox[3])]
+                return []
+            if isinstance(bbox, dict):
+                if all(k in bbox for k in ("xmin", "ymin", "xmax", "ymax")):
+                    return [float(bbox["xmin"]), float(bbox["ymin"]), float(bbox["xmax"]), float(bbox["ymax"])]
+                if all(k in bbox for k in ("x1", "y1", "x2", "y2")):
+                    return [float(bbox["x1"]), float(bbox["y1"]), float(bbox["x2"]), float(bbox["y2"])]
+                # Fallback: take first four values
+                vals = list(bbox.values())
+                if len(vals) >= 4:
+                    return [float(vals[0]), float(vals[1]), float(vals[2]), float(vals[3])]
+                return []
+            return []
+
+        # Prepare tracked detections (track_id, bbox_xyxy, conf)
+        tracked_detections: List[Dict[str, Any]] = []
         for det in detections:
-            track_id = det.get("track_id")
-            bbox = det.get("bounding_box", det.get("bbox", {}))
+            bbox = _to_xyxy(det.get("bounding_box", det.get("bbox", {})))
             if not bbox:
                 continue
+            tracked_detections.append({
+                "track_id": det.get("track_id"),
+                "bbox": bbox,
+                "confidence": float(det.get("confidence", 1.0))
+            })
 
-            # Prefer canonical track IDs if present (set earlier in _update_tracking_state)
-            if track_id is not None:
-                if track_id in seen_track_ids:
-                    continue
-                seen_track_ids.add(track_id)
-                unique_detections.append(det)
-                continue
+        # IoU-NMS to remove overlapping boxes, keep highest confidence
+        kept: List[Dict[str, Any]] = self._nms_by_iou(tracked_detections, overlap_iou_threshold)
+
+        # Compute centroids
+        centroids: Dict[Any, tuple] = {}
+        for td in kept:
+            x1, y1, x2, y2 = map(float, td["bbox"])
+            cx, cy = (x1 + x2) / 2.0, (y1 + y2) / 2.0
+            centroids[td.get("track_id")] = (cx, cy)
+
+        # Build current frame proximity pairs using track IDs only when both exist
+        current_pairs: Set[tuple] = set()
+        ids_list = [tid for tid in centroids.keys() if tid is not None]
+        for i in range(len(ids_list)):
+            for j in range(i + 1, len(ids_list)):
+                id1, id2 = ids_list[i], ids_list[j]
+                cx1, cy1 = centroids[id1]
+                cx2, cy2 = centroids[id2]
+                pixel_distance = math.hypot(cx1 - cx2, cy1 - cy2)
+
+                is_close = False
+                if meters_per_pixel:
+                    meters_distance = pixel_distance * float(meters_per_pixel)
+                    is_close = meters_distance < float(threshold_meters)
+                else:
+                    is_close = pixel_distance < float(threshold_pixels_fallback)
 
-            # Fallback: IoU-based dedup for pure detection outputs without track IDs
-            is_duplicate = False
-            for kept in unique_detections:
-                kept_bbox = kept.get("bounding_box", kept.get("bbox", {}))
-                if self._compute_iou(bbox, kept_bbox) >= iou_duplicate_threshold:
-                    is_duplicate = True
-                    break
-            if not is_duplicate:
-                unique_detections.append(det)
+                if is_close:
+                    pair = (id1, id2) if id1 <= id2 else (id2, id1)
+                    current_pairs.add(pair)
 
-        # Step 2: Compute proximity pairs uniquely (i < j)
-        frame_unique_count = 0
+        # Update global unique proximity pairs
+        new_unique_pairs = {frozenset(p) for p in current_pairs} - self._observed_proximity_pairs
+        if new_unique_pairs:
+            self._total_proximity_count += len(new_unique_pairs)
+            self._observed_proximity_pairs.update(new_unique_pairs)
 
-        for i in range(len(unique_detections)):
-            det_i = unique_detections[i]
-            bbox_i = det_i.get("bounding_box", det_i.get("bbox", {}))
-            p_i = get_bbox_bottom25_center(bbox_i) or get_bbox_center(bbox_i)
-            if not p_i:
-                continue
+        # Store last frame pairs
+        self._last_frame_proximity_pairs = current_pairs
+
+        # Return count of unique pairs in current frame
+        return len(current_pairs)
 
-            for j in range(i + 1, len(unique_detections)):
-                det_j = unique_detections[j]
-                bbox_j = det_j.get("bounding_box", det_j.get("bbox", {}))
-                p_j = get_bbox_bottom25_center(bbox_j) or get_bbox_center(bbox_j)
-                if not p_j:
-                    continue
-
-                dx = float(p_i[0]) - float(p_j[0])
-                dy = float(p_i[1]) - float(p_j[1])
-                distance = math.hypot(dx, dy)
-                if distance >= proximity_threshold:
-                    continue
-
-                frame_unique_count += 1
-
-                # Update global unique proximity pairs only when both have canonical IDs
-                id_i = det_i.get("track_id")
-                id_j = det_j.get("track_id")
-                if id_i is not None and id_j is not None:
-                    pair_key = frozenset({id_i, id_j})
-                    if pair_key not in self._observed_proximity_pairs:
-                        self._observed_proximity_pairs.add(pair_key)
-                        self._total_proximity_count += 1
-
-        return frame_unique_count
+    def _nms_by_iou(self, detections: List[Dict[str, Any]], iou_threshold: float) -> List[Dict[str, Any]]:
+        """Perform simple IoU-based NMS on a list of detections.
+
+        Each detection is a dict with keys: 'bbox' as [x1,y1,x2,y2], 'confidence' (float), and optional 'track_id'.
+        Keeps highest-confidence detections when overlap exceeds threshold.
+        """
+        if not detections:
+            return []
+        # Sort by confidence descending
+        dets = sorted(detections, key=lambda d: float(d.get("confidence", 1.0)), reverse=True)
+        kept: List[Dict[str, Any]] = []
+        for det in dets:
+            should_keep = True
+            for kept_det in kept:
+                if self._compute_iou(det["bbox"], kept_det["bbox"]) >= iou_threshold:
+                    should_keep = False
+                    break
+            if should_keep:
+                kept.append(det)
+        return kept
+
+    def _get_meters_per_pixel(self, config: ProximityConfig, stream_info: Optional[Dict[str, Any]] = None) -> Optional[float]:
+        """Compute meters-per-pixel scale using config and optional stream_info.
+
+        Priority:
+        1) config.meters_per_pixel (direct override)
+        2) config.scene_width_meters + frame width in pixels
+        3) config.scene_height_meters + frame height in pixels
+        Returns None if insufficient information.
+        """
+        # Direct override
+        if hasattr(config, "meters_per_pixel") and getattr(config, "meters_per_pixel"):
+            try:
+                return float(getattr(config, "meters_per_pixel"))
+            except Exception:  # noqa: BLE001
+                pass
+
+        width_px = None
+        height_px = None
+        if stream_info and isinstance(stream_info, dict):
+            input_settings = stream_info.get("input_settings", {}) or {}
+            resolution = input_settings.get("resolution", {}) or {}
+            width_px = resolution.get("width") or input_settings.get("frame_width")
+            height_px = resolution.get("height") or input_settings.get("frame_height")
+
+        # Derive from scene real-world width
+        if hasattr(config, "scene_width_meters") and getattr(config, "scene_width_meters") and width_px:
+            try:
+                return float(getattr(config, "scene_width_meters")) / float(width_px)
+            except Exception:  # noqa: BLE001
+                pass
+
+        # Derive from scene real-world height
+        if hasattr(config, "scene_height_meters") and getattr(config, "scene_height_meters") and height_px:
+            try:
+                return float(getattr(config, "scene_height_meters")) / float(height_px)
+            except Exception:  # noqa: BLE001
+                pass
+
+        return None
     
     def _generate_human_text_for_tracking(
         self,
-        _total_people: int,
+        total_people: int,
         detections,
-        _total_unique_count: int,
-        _config: ProximityConfig,
+        total_unique_count: int,
+        config: ProximityConfig,
         frame_id: str,
         alerts: Any = None,
         stream_info: Optional[Dict[str, Any]] = None) -> str:
@@ -681,8 +757,8 @@ class ProximityUseCase(BaseProcessor):
         
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
         
-        # Add proximity count to human text
-        proximity_count = self._count_proximity_events(detections)
+        # Add proximity count to human text (meters-aware)
+        proximity_count = self._count_proximity_events(detections, config, stream_info)
         if proximity_count > 0:
             human_text_lines.append(f"\t- Current Frame Proximity: {proximity_count}")
         else:
@@ -1592,6 +1668,33 @@ class ProximityUseCase(BaseProcessor):
                     "default": True,
                     "description": "Enable unique proximity detection using tracking"
                 },
+                "proximity_threshold_meters": {
+                    "type": "number",
+                    "minimum": 0.1,
+                    "default": 1.0,
+                    "description": "Distance threshold in meters to consider two people in proximity"
+                },
+                "meters_per_pixel": {
+                    "type": "number",
+                    "minimum": 0,
+                    "description": "Direct meters-per-pixel calibration override. If set, used for distance conversion."
+                },
+                "scene_width_meters": {
+                    "type": "number",
+                    "minimum": 0,
+                    "description": "Real-world width of the scene captured by the frame (meters). Used to derive meters-per-pixel with frame width."
+                },
+                "scene_height_meters": {
+                    "type": "number",
+                    "minimum": 0,
+                    "description": "Real-world height of the scene captured by the frame (meters). Used to derive meters-per-pixel with frame height."
+                },
+                "proximity_threshold_pixels": {
+                    "type": "number",
+                    "minimum": 1,
+                    "default": 400,
+                    "description": "Fallback pixel threshold if no calibration is available"
+                },
                 "time_window_minutes": {
                     "type": "integer",
                     "minimum": 1,

{matrice-1.0.99268.dist-info → matrice-1.0.99270.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice
-Version: 1.0.99268
+Version: 1.0.99270
 Summary: SDK for connecting to matrice.ai services
 Home-page: https://github.com/matrice-ai/python-sdk
 Author: Matrice.ai

{matrice-1.0.99268.dist-info → matrice-1.0.99270.dist-info}/RECORD

@@ -140,7 +140,7 @@ matrice/deploy/utils/post_processing/advanced_tracker/strack.py,sha256=rVH2xOysZ
 matrice/deploy/utils/post_processing/advanced_tracker/tracker.py,sha256=D-PKZ2Pxutmlu--icyxuxjvnWBrzrmZcEChYS0nx00M,14328
 matrice/deploy/utils/post_processing/core/__init__.py,sha256=MPMj_iRv--PfKBpYN12IjReAzSU7aRMVD6VW-LC95-M,1379
 matrice/deploy/utils/post_processing/core/base.py,sha256=V_DmaMLtrIunrN8Aq9iLeMIQPlkbCE-9d7n0Yz-nKQg,28228
-matrice/deploy/utils/post_processing/core/config.py,sha256=rU6EWou2HOA_4Ks0LUTSczQbT04jhN1FofuAQ7dtrZ4,102355
+matrice/deploy/utils/post_processing/core/config.py,sha256=ogmNUbfOoC4SE-SmUEkqIKBeR0p0j3M0hF2_KvzpNp0,102560
 matrice/deploy/utils/post_processing/core/config_utils.py,sha256=Y_Czm9RmtHuxzBZzGUBA57JRyx5r6tzrM5l89Dbdf_w,28871
 matrice/deploy/utils/post_processing/test_cases/__init__.py,sha256=zUU2kKrIcCl8WeyjjQViwp7PWTZlKPuF8M2pZkxoNNQ,42
 matrice/deploy/utils/post_processing/test_cases/run_tests.py,sha256=RBFGvxFR-gozxnQFzkWLrs90vLlp8Bsn-Z7MLQrNw4o,4731
@@ -204,7 +204,7 @@ matrice/deploy/utils/post_processing/usecases/plaque_segmentation_img.py,sha256=
 matrice/deploy/utils/post_processing/usecases/pothole_segmentation.py,sha256=jXTb8ZqInp5xJ-O3Zp3zQBiryFVD0-WBbhW6Kux_NDo,44905
 matrice/deploy/utils/post_processing/usecases/ppe_compliance.py,sha256=G9P9j9E9nfNJInHJxmK1Lb4daFBlG5hq0aqotTLvFFE,30146
 matrice/deploy/utils/post_processing/usecases/price_tag_detection.py,sha256=09Tp6MGAHh95s-NSAp-4WC9iCc20sajWApuUBAvgXiQ,39880
-matrice/deploy/utils/post_processing/usecases/proximity_detection.py,sha256=HjUZMKZHAgpD_YiyTXFAoaO4awF_QkY9oflCIVFlsiM,81157
+matrice/deploy/utils/post_processing/usecases/proximity_detection.py,sha256=EBpu9tR_OOPfES0lM-YzBJN4FMwxc31TRKMS4OSLg4k,86507
 matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=V_KxwBtAHSNkyoH8sXw-U-P3J8ToXtX3ncc69gn6Tds,31591
 matrice/deploy/utils/post_processing/usecases/road_traffic_density.py,sha256=YiHQ0kKhXglagHPvygywxMqZAw8s0WharrBQqLQj2q4,40311
 matrice/deploy/utils/post_processing/usecases/road_view_segmentation.py,sha256=BcBbOOg5622KuvzKrzs9cJW1wkRoIIcOab0N7BONQKQ,44986
@@ -243,8 +243,8 @@ matrice/deployment/camera_manager.py,sha256=e1Lc81RJP5wUWRdTgHO6tMWF9BkBdHOSVyx3
 matrice/deployment/deployment.py,sha256=HFt151eWq6iqIAMsQvurpV2WNxW6Cx_gIUVfnVy5SWE,48093
 matrice/deployment/inference_pipeline.py,sha256=6b4Mm3-qt-Zy0BeiJfFQdImOn3FzdNCY-7ET7Rp8PMk,37911
 matrice/deployment/streaming_gateway_manager.py,sha256=ifYGl3g25wyU39HwhPQyI2OgF3M6oIqKMWt8RXtMxY8,21401
-matrice-1.0.99268.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99268.dist-info/METADATA,sha256=aU45pkw_HtMNp9C-mI1pSRKXVAI9djwHr1UCaRvpbCA,14624
-matrice-1.0.99268.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99268.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99268.dist-info/RECORD,,
+matrice-1.0.99270.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99270.dist-info/METADATA,sha256=oBNUFZl4QKsG87Nbl2m9QwrbUSzHoKLMSEKZ3l9VMQI,14624
+matrice-1.0.99270.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99270.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99270.dist-info/RECORD,,