matrice 1.0.99269__py3-none-any.whl → 1.0.99271__py3-none-any.whl

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)
         
 
         # --------------------------------------------------------------------- #
@@ -535,44 +536,44 @@ class ProximityUseCase(BaseProcessor):
                             }
             })
         if zone_analysis:
-            human_text_lines = []
-            current_timestamp = self._get_current_timestamp_str(stream_info, frame_id=frame_id)
-            start_timestamp = self._get_start_timestamp_str(stream_info)
-            human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
-
-            def robust_zone_total(zone_count):
-                if isinstance(zone_count, dict):
-                    total = 0
-                    for v in zone_count.values():
-                        if isinstance(v, int):
-                            total += v
-                        elif isinstance(v, list) and total == 0:
-                            total += len(v)
-                    return total
-                elif isinstance(zone_count, list):
-                    return len(zone_count)
-                elif isinstance(zone_count, int):
-                    return zone_count
-                else:
-                    return 0
-
-            human_text_lines.append(f"\t- People Detected: {total_people}")
-            human_text_lines.append("")
-            human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+                human_text_lines = []
+                current_timestamp = self._get_current_timestamp_str(stream_info, frame_id=frame_id)
+                start_timestamp = self._get_start_timestamp_str(stream_info)
+                human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
+
+                def robust_zone_total(zone_count):
+                    if isinstance(zone_count, dict):
+                        total = 0
+                        for v in zone_count.values():
+                            if isinstance(v, int):
+                                total += v
+                            elif isinstance(v, list) and total == 0:
+                                total += len(v)
+                        return total
+                    elif isinstance(zone_count, list):
+                        return len(zone_count)
+                    elif isinstance(zone_count, int):
+                        return zone_count
+                    else:
+                        return 0
 
-            for zone_name, zone_count in zone_analysis.items():
-                zone_total = robust_zone_total(zone_count)
-                human_text_lines.append(f"\t- Zone name: {zone_name}")
+                human_text_lines.append(f"\t- People Detected: {total_people}")
+                human_text_lines.append("")
+                human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+                
+                for zone_name, zone_count in zone_analysis.items():
+                        zone_total = robust_zone_total(zone_count)
+                        human_text_lines.append(f"\t- Zone name: {zone_name}")
                 human_text_lines.append(f"\t\t- Total count in zone: {zone_total}")
 
-            if total_unique_count > 0:
-                human_text_lines.append(f"\t- Total unique people in the scene: {total_unique_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)
+                if total_unique_count > 0:
+                    human_text_lines.append(f"\t- Total unique people in the scene: {total_unique_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)  
         else:      
             human_text = self._generate_human_text_for_tracking(total_people, detections, total_unique_count, config, frame_id, alerts, stream_info)
         
@@ -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,113 @@ 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
-
-            # 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
+            tracked_detections.append({
+                "track_id": det.get("track_id"),
+                "bbox": bbox,
+                "confidence": float(det.get("confidence", 1.0))
+            })
 
-                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 and keep alignment arrays for IDs
+        centroids: List[tuple] = []
+        track_ids: List[Any] = []
+        for td in kept:
+            x1, y1, x2, y2 = map(float, td["bbox"])
+            # Use box center (matching your reference snippet); switch to bottom-center if needed
+            cx, cy = (x1 + x2) / 2.0, (y1 + y2) / 2.0
+            centroids.append((cx, cy))
+            track_ids.append(td.get("track_id"))
+
+        n = len(centroids)
+        current_pairs_by_ids: Set[tuple] = set()
+        current_pairs_all: Set[tuple] = set()
+
+        # Build current frame proximity pairs for all detections (even without IDs)
+        for i in range(n):
+            cx1, cy1 = centroids[i]
+            for j in range(i + 1, n):
+                cx2, cy2 = centroids[j]
+                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 not is_close:
                     continue
 
-                frame_unique_count += 1
+                # For per-frame count, include every close pair
+                current_pairs_all.add((i, j))
 
-                # 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")
+                # For global unique, require both IDs
+                id_i = track_ids[i]
+                id_j = track_ids[j]
                 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
+                    pair_ids = (id_i, id_j) if id_i <= id_j else (id_j, id_i)
+                    current_pairs_by_ids.add(pair_ids)
+
+        # Update global unique proximity pairs using ID pairs only
+        new_unique_pairs = {frozenset(p) for p in current_pairs_by_ids} - self._observed_proximity_pairs
+        if new_unique_pairs:
+            self._total_proximity_count += len(new_unique_pairs)
+            self._observed_proximity_pairs.update(new_unique_pairs)
+
+        # Store last frame pairs (ID pairs if available, else index pairs as fallback)
+        self._last_frame_proximity_pairs = current_pairs_by_ids if current_pairs_by_ids else current_pairs_all
 
-        return frame_unique_count
+        # Return count of pairs detected in the current frame
+        return len(current_pairs_by_ids) if current_pairs_by_ids else len(current_pairs_all)
+
+    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.
@@ -720,12 +753,12 @@ class ProximityUseCase(BaseProcessor):
         return None
     
     def _generate_human_text_for_tracking(
-        self,
-        total_people: int,
-        detections,
-        total_unique_count: int,
-        config: ProximityConfig,
-        frame_id: str,
+        self, 
+        total_people: int, 
+        detections, 
+        total_unique_count: int, 
+        config: ProximityConfig, 
+        frame_id: str, 
         alerts: Any = None,
         stream_info: Optional[Dict[str, Any]] = None) -> str:
         """Generate human-readable text for tracking stats in old format."""
@@ -744,12 +777,8 @@ class ProximityUseCase(BaseProcessor):
             human_text_lines.append("\t- No Proximity Events Detected")
 
         human_text_lines.append("")
-        if proximity_count > 0:
-            human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
-            # If tracking IDs are available, _total_proximity_count already includes this frame's new pairs
-            # Otherwise, fall back to showing the current frame's count
-            total_unique = self._total_proximity_count if self._total_proximity_count > 0 else proximity_count
-            human_text_lines.append(f"\t- Total Proximity Count: {total_unique}")
+        human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+        human_text_lines.append(f"\t- Total Proximity Count: {self._total_proximity_count}")
 
         if alerts:
             for alert in alerts:
@@ -1384,12 +1413,12 @@ class ProximityUseCase(BaseProcessor):
                 return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
 
         if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
-            if frame_id:
-                start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
-            else:
-                start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
-            stream_time_str = self._format_timestamp_for_video(start_time)
-            return stream_time_str
+                if frame_id:
+                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                else:
+                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                stream_time_str = self._format_timestamp_for_video(start_time)
+                return stream_time_str
         else:
             # For streams, use stream_time from stream_info
             stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")

{matrice-1.0.99269.dist-info → matrice-1.0.99271.dist-info}/METADATA

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

{matrice-1.0.99269.dist-info → matrice-1.0.99271.dist-info}/RECORD

@@ -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=QyknlaCyvzRg0j9Vndi1prYNW1elz0ARNBimHRyBak4,85207
+matrice/deploy/utils/post_processing/usecases/proximity_detection.py,sha256=tbERNzbuczj1GSLwApxt6_T3sYodFh8roThrPhj-OUI,87022
 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.99269.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99269.dist-info/METADATA,sha256=y9DrDgXE7DfQ8kc1rALCkIrPanFK1zTR3Eoc8DxVVyo,14624
-matrice-1.0.99269.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99269.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99269.dist-info/RECORD,,
+matrice-1.0.99271.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99271.dist-info/METADATA,sha256=KGoqAjTGhMEnZY1dF18S3l9f_ZK1Vn7EICyPlTbDkcg,14624
+matrice-1.0.99271.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99271.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99271.dist-info/RECORD,,