matrice 1.0.99142__py3-none-any.whl → 1.0.99144__py3-none-any.whl

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

@@ -1,10 +1,3 @@
-"""
-Road Lane Detection Use Case for Post-Processing
-
-This module provides road lane detection functionality with lane type classification,
-zone analysis, and alert generation.
-"""
-
 from typing import Any, Dict, List, Optional
 from dataclasses import asdict, dataclass, field
 import time
@@ -25,9 +18,10 @@ from ..utils import (
 )
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
+
 @dataclass
 class LaneDetectionConfig(BaseConfig):
-    """Configuration for road lane detection use case."""
+    """Configuration for lane detection use case in road monitoring."""
     enable_smoothing: bool = True
     smoothing_algorithm: str = "observability"
     smoothing_window_size: int = 20
@@ -52,6 +46,7 @@ class LaneDetectionConfig(BaseConfig):
         }
     )
 
+
 class LaneDetectionUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
         "Divider-Line": "Divider Line",
@@ -97,7 +92,7 @@ class LaneDetectionUseCase(BaseProcessor):
             self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
         else:
             processed_data = data
-            self.logger.debug("No confidence filtering applied")
+            self.logger.debug("Did not apply confidence filtering since no threshold provided")
 
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
@@ -256,7 +251,6 @@ class LaneDetectionUseCase(BaseProcessor):
                     level = "medium"
                     self._ascending_alert_list.append(1)
                 else:
-                    level = "low"
                     self._ascending_alert_list.append(0)
             else:
                 if total_detections > 30:
@@ -276,7 +270,7 @@ class LaneDetectionUseCase(BaseProcessor):
                     intensity = min(10.0, total_detections / 3.0)
                     self._ascending_alert_list.append(0)
 
-            human_text_lines = [f"LANE INCIDENTS DETECTED @ {current_timestamp}:"]
+            human_text_lines = [f"INCIDENTS DETECTED @ {current_timestamp}:"]
             human_text_lines.append(f"\tSeverity Level: {(self.CASE_TYPE, level)}")
             human_text = "\n".join(human_text_lines)
 
@@ -307,11 +301,11 @@ class LaneDetectionUseCase(BaseProcessor):
         else:
             self._ascending_alert_list.append(0)
             incidents.append({})
-
         return incidents
 
     def _generate_tracking_stats(self, counting_summary: Dict, alerts: List, config: LaneDetectionConfig,
                                 frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
+        """Generate structured tracking stats matching expected format."""
         camera_info = self.get_camera_info_from_stream(stream_info)
         tracking_stats = []
         total_detections = counting_summary.get("total_count", 0)
@@ -322,8 +316,13 @@ class LaneDetectionUseCase(BaseProcessor):
         high_precision_start_timestamp = self._get_current_timestamp_str(stream_info, precision=True)
         high_precision_reset_timestamp = self._get_start_timestamp_str(stream_info, precision=True)
 
-        total_counts = [{"category": cat, "count": count} for cat, count in total_counts_dict.items() if count > 0]
-        current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items() if count > 0 or total_detections > 0]
+        # Build total_counts and current_counts arrays
+        total_counts = [{"category": cat, "count": count} for cat, count in total_counts_dict.items()]
+        current_counts = [{"category": cat, "count": count} for cat, count in per_category_count.items()]
+
+        # Log counts for debugging
+        self.logger.debug(f"Total counts: {total_counts}")
+        self.logger.debug(f"Current counts: {current_counts}")
 
         detections = []
         for detection in counting_summary.get("detections", []):
@@ -350,7 +349,7 @@ class LaneDetectionUseCase(BaseProcessor):
                 "threshold_level": config.alert_config.count_thresholds if hasattr(config.alert_config, 'count_thresholds') else {},
                 "ascending": True,
                 "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
-                                                 getattr(config.alert_config, 'alert_value', ['JSON']))}
+                                                getattr(config.alert_config, 'alert_value', ['JSON']))}
             })
 
         human_text_lines = [f"Tracking Statistics:"]
@@ -359,9 +358,12 @@ class LaneDetectionUseCase(BaseProcessor):
             human_text_lines.append(f"\t{cat}: {count}")
         human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
         for cat, count in total_counts_dict.items():
-            if count > 0:
-                human_text_lines.append(f"\t{cat}: {count}")
-        human_text_lines.append(f"Alerts: {alerts[0].get('settings', {})} sent @ {current_timestamp}" if alerts else "Alerts: None")
+            human_text_lines.append(f"\t{cat}: {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)
 
         reset_settings = [{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]
@@ -389,18 +391,22 @@ class LaneDetectionUseCase(BaseProcessor):
         lines = {}
         lines["Application Name"] = self.CASE_TYPE
         lines["Application Version"] = self.CASE_VERSION
-        if incidents:
+        if len(incidents) > 0:
             lines["Incidents:"] = f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
-        if tracking_stats:
+        if len(tracking_stats) > 0:
             lines["Tracking Statistics:"] = f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
-        if business_analytics:
+        if len(business_analytics) > 0:
             lines["Business Analytics:"] = f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}\n"
-        if not incidents and not tracking_stats and not business_analytics:
+        if len(incidents) == 0 and len(tracking_stats) == 0 and len(business_analytics) == 0:
             lines["Summary"] = "No Summary Data"
         return [lines]
 
     def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
-        frame_track_ids = {det.get('track_id') for det in detections if det.get('track_id') is not None}
+        frame_track_ids = set()
+        for det in detections:
+            tid = det.get('track_id')
+            if tid is not None:
+                frame_track_ids.add(tid)
         total_track_ids = set()
         for s in getattr(self, '_per_category_total_track_ids', {}).values():
             total_track_ids.update(s)
@@ -444,68 +450,90 @@ class LaneDetectionUseCase(BaseProcessor):
 
     def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str] = None) -> str:
         if not stream_info:
-            return "00:00:00.00" if precision else "00:00:00"
+            return "00:00:00.00"
         if precision:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
-                start_time = (int(frame_id) if frame_id else stream_info.get("input_settings", {}).get("start_frame", 30)) / stream_info.get("input_settings", {}).get("original_fps", 30)
+                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)
                 return self._format_timestamp_for_video(start_time)
-            return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+            else:
+                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":
-            start_time = (int(frame_id) if frame_id else stream_info.get("input_settings", {}).get("start_frame", 30)) / stream_info.get("input_settings", {}).get("original_fps", 30)
+            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)
             return self._format_timestamp_for_video(start_time)
-        stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
-        if stream_time_str:
-            try:
-                timestamp_str = stream_time_str.replace(" UTC", "")
-                dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
-                timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
-                return self._format_timestamp_for_stream(timestamp)
-            except:
+        else:
+            stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+            if stream_time_str:
+                try:
+                    timestamp_str = stream_time_str.replace(" UTC", "")
+                    dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                    timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
+                    return self._format_timestamp_for_stream(timestamp)
+                except:
+                    return self._format_timestamp_for_stream(time.time())
+            else:
                 return self._format_timestamp_for_stream(time.time())
-        return self._format_timestamp_for_stream(time.time())
 
     def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
         if not stream_info:
-            return "00:00:00" if not precision else "00:00:00.00"
+            return "00:00:00"
         if precision:
             if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
-                return "00:00:00.00"
-            return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                return "00:00:00"
+            else:
+                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":
             return "00:00:00"
-        if self._tracking_start_time is None:
-            stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
-            if stream_time_str:
-                try:
-                    timestamp_str = stream_time_str.replace(" UTC", "")
-                    dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
-                    self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
-                except:
+        else:
+            if self._tracking_start_time is None:
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                if stream_time_str:
+                    try:
+                        timestamp_str = stream_time_str.replace(" UTC", "")
+                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                        self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
+                    except:
+                        self._tracking_start_time = time.time()
+                else:
                     self._tracking_start_time = time.time()
-            else:
-                self._tracking_start_time = time.time()
-        dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
-        dt = dt.replace(minute=0, second=0, microsecond=0)
-        return dt.strftime('%Y:%m:%d %H:%M:%S')
+            dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
+            dt = dt.replace(minute=0, second=0, microsecond=0)
+            return dt.strftime('%Y:%m:%d %H:%M:%S')
 
     def _count_categories(self, detections: list, config: LaneDetectionConfig) -> dict:
-        counts = {}
+        """
+        Count the number of detections per category and return a summary dict.
+        """
+        counts = {cat: 0 for cat in self.target_categories}  # Initialize with all target categories
+        valid_detections = []
+        
         for det in detections:
             cat = det.get('category', 'unknown')
-            counts[cat] = counts.get(cat, 0) + 1
+            # Normalize category to match target_categories
+            normalized_cat = cat.replace('-', ' ').title().replace(' ', '-')  # e.g., "solid-line" -> "Solid-Line"
+            if normalized_cat not in self.target_categories:
+                self.logger.debug(f"Skipping detection with category {normalized_cat}, not in target categories")
+                continue
+            counts[normalized_cat] += 1
+            det['category'] = normalized_cat  # Update detection with normalized category
+            valid_detections.append({
+                "bounding_box": det.get("bounding_box"),
+                "category": normalized_cat,
+                "confidence": det.get("confidence"),
+                "track_id": det.get("track_id"),
+                "frame_id": det.get("frame_id")
+            })
+            self.logger.debug(f"Counted detection for category {normalized_cat}, confidence {det.get('confidence')}")
+
         return {
             "total_count": sum(counts.values()),
             "per_category_count": counts,
-            "detections": [
-                {
-                    "bounding_box": det.get("bounding_box"),
-                    "category": det.get("category"),
-                    "confidence": det.get("confidence"),
-                    "track_id": det.get("track_id"),
-                    "frame_id": det.get("frame_id")
-                }
-                for det in detections
-            ]
+            "detections": valid_detections
         }
 
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:
@@ -582,7 +610,7 @@ class LaneDetectionUseCase(BaseProcessor):
         self._canonical_tracks[canonical_id] = {
             "last_bbox": bbox,
             "last_update": now,
-            "raw_ids": {raw_id}
+            "raw_ids": {raw_id},
         }
         return canonical_id
 

{matrice-1.0.99142.dist-info → matrice-1.0.99144.dist-info}/METADATA

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

{matrice-1.0.99142.dist-info → matrice-1.0.99144.dist-info}/RECORD

@@ -191,7 +191,7 @@ matrice/deploy/utils/post_processing/usecases/plaque_segmentation_img.py,sha256=
 matrice/deploy/utils/post_processing/usecases/pothole_segmentation.py,sha256=6Mv8SoEE5CGItY7S0g-SY5Lb3DV-WWVMlpEp04a86a8,43197
 matrice/deploy/utils/post_processing/usecases/ppe_compliance.py,sha256=G9P9j9E9nfNJInHJxmK1Lb4daFBlG5hq0aqotTLvFFE,30146
 matrice/deploy/utils/post_processing/usecases/price_tag_detection.py,sha256=Sn_Dvwf5f_dcfaiPIl-pqckgP8z96CeNIJ4hfeab3FM,39880
-matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=NILx7xkx8qARJt0L63ualPm7a95qSZWfQCfvEVaMkps,29778
+matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=ljWoDeFJb0IJJPClYaZrNnBZd87JqKI64jE_I79GAYo,31146
 matrice/deploy/utils/post_processing/usecases/shelf_inventory_detection.py,sha256=1juloltHnCj3U499Aps0ggE0nEI37x3iKe4DgfP4RCw,29140
 matrice/deploy/utils/post_processing/usecases/shoplifting_detection.py,sha256=zqeV_ARV5gJqMY2sJGBjlU6UOb0SthGGbC8UNj_mycs,34701
 matrice/deploy/utils/post_processing/usecases/shopping_cart_analysis.py,sha256=9Ej2xiZM7yq5sOBcSXIllou_z0rSZDJ_QHyYz6HxZSY,43957
@@ -225,8 +225,8 @@ matrice/deployment/camera_manager.py,sha256=ReBZqm1CNXRImKcbcZ4uWAT3TUWkof1D28oB
 matrice/deployment/deployment.py,sha256=PLIUD-PxTaC2Zxb3Y12wUddsryV-OJetjCjLoSUh7S4,48103
 matrice/deployment/inference_pipeline.py,sha256=bXLgd29ViA7o0c7YWLFJl1otBUQfTPb61jS6VawQB0Y,37918
 matrice/deployment/streaming_gateway_manager.py,sha256=w5swGsuFVfZIdOm2ZuBHRHlRdYYJMLopLsf2gb91lQ8,20946
-matrice-1.0.99142.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99142.dist-info/METADATA,sha256=mwmWB2ZlF49tBndisppxH6Kg4lTStAjy9Ie8CCXIk2Y,14624
-matrice-1.0.99142.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99142.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99142.dist-info/RECORD,,
+matrice-1.0.99144.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99144.dist-info/METADATA,sha256=xF8gj0tJeJ-JY50BNsnZfd9LLxRif6dtncWMdvo1pE4,14624
+matrice-1.0.99144.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99144.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99144.dist-info/RECORD,,