matrice 1.0.99270__tar.gz → 1.0.99271__tar.gz

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

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

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

{matrice-1.0.99270 → matrice-1.0.99271}/src/matrice/deploy/utils/post_processing/usecases/proximity_detection.py

@@ -536,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)
         
@@ -629,7 +629,7 @@ class ProximityUseCase(BaseProcessor):
         for det in detections:
             bbox = _to_xyxy(det.get("bounding_box", det.get("bbox", {})))
             if not bbox:
-                continue
+                    continue
             tracked_detections.append({
                 "track_id": det.get("track_id"),
                 "bbox": bbox,
@@ -639,45 +639,57 @@ class ProximityUseCase(BaseProcessor):
         # 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] = {}
+        # 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[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]
+            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)
                     is_close = meters_distance < float(threshold_meters)
                 else:
                     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
+
+                # For per-frame count, include every close pair
+                current_pairs_all.add((i, j))
 
-        # Update global unique proximity pairs
-        new_unique_pairs = {frozenset(p) for p in current_pairs} - self._observed_proximity_pairs
+                # 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_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
-        self._last_frame_proximity_pairs = current_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 count of unique pairs in current frame
-        return len(current_pairs)
+        # 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.
@@ -741,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."""
@@ -765,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:
@@ -1405,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.99270 → matrice-1.0.99271/src/matrice.egg-info}/PKG-INFO

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