matrice 1.0.99268__tar.gz → 1.0.99269__tar.gz

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

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

{matrice-1.0.99268 → matrice-1.0.99269}/setup.py

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

{matrice-1.0.99268 → matrice-1.0.99269}/src/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-1.0.99268 → matrice-1.0.99269}/src/matrice/deploy/utils/post_processing/usecases/proximity_detection.py

@@ -287,8 +287,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,19 +585,24 @@ 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.
+        - Distance is evaluated in meters when calibration is available. If unavailable, pixel threshold is used as a fallback.
         - 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
+        # 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)
+
         iou_duplicate_threshold = getattr(self, "_proximity_iou_duplicate_threshold", 0.5)
 
         # Step 1: Deduplicate detections
@@ -647,8 +652,18 @@ class ProximityUseCase(BaseProcessor):
 
                 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:
+                pixel_distance = math.hypot(dx, dy)
+
+                is_close = False
+                if meters_per_pixel:
+                    meters_distance = pixel_distance * float(meters_per_pixel)
+                    if meters_distance < float(threshold_meters):
+                        is_close = True
+                else:
+                    if pixel_distance < float(threshold_pixels_fallback):
+                        is_close = True
+
+                if not is_close:
                     continue
 
                 frame_unique_count += 1
@@ -663,13 +678,53 @@ class ProximityUseCase(BaseProcessor):
                         self._total_proximity_count += 1
 
         return frame_unique_count
+
+    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 +736,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 +1647,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 → matrice-1.0.99269/src/matrice.egg-info}/PKG-INFO

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