matrice 1.0.99269__tar.gz → 1.0.99270__tar.gz

{matrice-1.0.99269/src/matrice.egg-info → matrice-1.0.99270}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrice
-Version: 1.0.99269
+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.99269 → matrice-1.0.99270}/setup.py

@@ -14,7 +14,7 @@ long_description = (here / "README.md").read_text(encoding="utf-8")
 setup(
     name="matrice",
 
-    version = "1.0.99269",
+    version = "1.0.99270",
     
     description="SDK for connecting to matrice.ai services",
     long_description=long_description,

{matrice-1.0.99269 → matrice-1.0.99270}/src/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)
         
 
         # --------------------------------------------------------------------- #
@@ -589,10 +590,10 @@ class ProximityUseCase(BaseProcessor):
         """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.
-        - Distance is evaluated in meters when calibration is available. If unavailable, pixel threshold is used as a fallback.
+        - 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:
@@ -603,81 +604,101 @@ class ProximityUseCase(BaseProcessor):
         threshold_meters = getattr(config, "proximity_threshold_meters", 1.0)
         threshold_pixels_fallback = getattr(config, "proximity_threshold_pixels", 400.0)
 
-        iou_duplicate_threshold = getattr(self, "_proximity_iou_duplicate_threshold", 0.5)
+        overlap_iou_threshold = getattr(self, "_proximity_iou_duplicate_threshold", 0.5)
 
-        # Step 1: Deduplicate detections
-        unique_detections: List[Dict[str, Any]] = []
-        seen_track_ids: Set[Any] = set()
+        # 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
-
-            # 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)
-
-        # Step 2: Compute proximity pairs uniquely (i < j)
-        frame_unique_count = 0
-
-        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
-
-            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])
-                pixel_distance = math.hypot(dx, dy)
+        # 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)
-                    if meters_distance < float(threshold_meters):
-                        is_close = True
+                    is_close = meters_distance < float(threshold_meters)
                 else:
-                    if pixel_distance < float(threshold_pixels_fallback):
-                        is_close = True
+                    is_close = pixel_distance < float(threshold_pixels_fallback)
+
+                if is_close:
+                    pair = (id1, id2) if id1 <= id2 else (id2, id1)
+                    current_pairs.add(pair)
 
-                if not is_close:
-                    continue
+        # 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)
 
-                frame_unique_count += 1
+        # Store last frame pairs
+        self._last_frame_proximity_pairs = current_pairs
 
-                # 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 count of unique pairs in current frame
+        return len(current_pairs)
 
-        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.

{matrice-1.0.99269 → matrice-1.0.99270/src/matrice.egg-info}/PKG-INFO

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