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

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

@@ -1,9 +1,9 @@
 from typing import Any, Dict, List, Optional
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict
 import time
 from datetime import datetime, timezone
 
-from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol
+from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
 from ..utils import (
     filter_by_confidence,
     filter_by_categories,
@@ -16,6 +16,7 @@ from ..utils import (
     BBoxSmoothingConfig,
     BBoxSmoothingTracker
 )
+from dataclasses import dataclass, field
 from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
 
@@ -29,40 +30,39 @@ class LaneDetectionConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
     confidence_threshold: float = 0.6
     usecase_categories: List[str] = field(
-        default_factory=lambda: ['Divider-Line', 'Dotted-Line', 'Double-Line', 'Random-Line', 'Road-Sign-Line', 'Solid-Line']
+        default_factory=lambda: ['divider-line', 'dotted-line', 'double-line', 'random-line', 'road-sign-line', 'solid-line']
     )
     target_categories: List[str] = field(
-        default_factory=lambda: ['Divider-Line', 'Dotted-Line', 'Double-Line', 'Random-Line', 'Road-Sign-Line', 'Solid-Line']
+        default_factory=lambda: ['divider-line', 'dotted-line', 'double-line', 'random-line', 'road-sign-line', 'solid-line']
     )
     alert_config: Optional[AlertConfig] = None
     index_to_category: Optional[Dict[int, str]] = field(
         default_factory=lambda: {
-            0: "Divider-Line",
-            1: "Dotted-Line",
-            2: "Double-Line",
-            3: "Random-Line",
-            4: "Road-Sign-Line",
-            5: "Solid-Line"
+            0: "divider-line",
+            1: "dotted-line",
+            2: "double-line",
+            3: "random-line",
+            4: "road-sign-line",
+            5: "solid-line"
         }
     )
 
 
 class LaneDetectionUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
-        "Divider-Line": "Divider Line",
-        "Dotted-Line": "Dotted Line",
-        "Double-Line": "Double Line",
-        "Random-Line": "Random Line",
-        "Road-Sign-Line": "Road Sign Line",
-        "Solid-Line": "Solid Line"
+        "divider-line": "Divider Line",
+        "dotted-line": "Dotted Line",
+        "double-line": "Double Line",
+        "random-line": "Random Line",
+        "road-sign-line": "Road Sign Line",
+        "solid-line": "Solid Line"
     }
-
     def __init__(self):
         super().__init__("lane_detection")
         self.category = "traffic"
         self.CASE_TYPE: Optional[str] = 'lane_detection'
         self.CASE_VERSION: Optional[str] = '1.0'
-        self.target_categories = ['Divider-Line', 'Dotted-Line', 'Double-Line', 'Random-Line', 'Road-Sign-Line', 'Solid-Line']
+        self.target_categories = ['divider-line', 'dotted-line', 'double-line', 'random-line', 'road-sign-line', 'solid-line']
         self.smoothing_tracker = None
         self.tracker = None
         self._total_frame_counter = 0
@@ -82,7 +82,6 @@ class LaneDetectionUseCase(BaseProcessor):
             return self.create_error_result("Invalid config type", usecase=self.name, category=self.category, context=context)
         if context is None:
             context = ProcessingContext()
-
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
@@ -92,7 +91,7 @@ class LaneDetectionUseCase(BaseProcessor):
             self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
         else:
             processed_data = data
-            self.logger.debug("Did not apply confidence filtering since no threshold provided")
+            self.logger.debug("Did not apply confidence filtering")
 
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
@@ -193,39 +192,42 @@ class LaneDetectionUseCase(BaseProcessor):
         if not config.alert_config:
             return alerts
 
+        total = summary.get("total_count", 0)
         if hasattr(config.alert_config, 'count_thresholds') and config.alert_config.count_thresholds:
             for category, threshold in config.alert_config.count_thresholds.items():
-                if category == "all" and total_detections > threshold:
-                    alerts.append({
-                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
-                        "alert_id": f"alert_{category}_{frame_key}",
-                        "incident_category": self.CASE_TYPE,
-                        "threshold_level": threshold,
-                        "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
-                        "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
-                                                         getattr(config.alert_config, 'alert_value', ['JSON']))}
-                    })
-                elif category in per_category_count and per_category_count[category] > threshold:
+                if category == "all" and total > threshold:
                     alerts.append({
-                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
-                        "alert_id": f"alert_{category}_{frame_key}",
+                        "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                        "alert_id": "alert_" + category + '_' + frame_key,
                         "incident_category": self.CASE_TYPE,
                         "threshold_level": threshold,
                         "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
-                        "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
-                                                         getattr(config.alert_config, 'alert_value', ['JSON']))}
+                        "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                     getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
                     })
+                elif category in per_category_count:
+                    count = per_category_count[category]
+                    if count > threshold:
+                        alerts.append({
+                            "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                            "alert_id": "alert_" + category + '_' + frame_key,
+                            "incident_category": self.CASE_TYPE,
+                            "threshold_level": threshold,
+                            "ascending": get_trend(self._ascending_alert_list, lookback=900, threshold=0.8),
+                            "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                         getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
+                        })
         return alerts
 
     def _generate_incidents(self, counting_summary: Dict, alerts: List, config: LaneDetectionConfig,
-                           frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
+                         frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
         incidents = []
         total_detections = counting_summary.get("total_count", 0)
         current_timestamp = self._get_current_timestamp_str(stream_info)
         camera_info = self.get_camera_info_from_stream(stream_info)
-
+        
         self._ascending_alert_list = self._ascending_alert_list[-900:] if len(self._ascending_alert_list) > 900 else self._ascending_alert_list
-
+        
         if total_detections > 0:
             level = "low"
             intensity = 5.0
@@ -251,6 +253,7 @@ 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:
@@ -258,7 +261,7 @@ class LaneDetectionUseCase(BaseProcessor):
                     intensity = 10.0
                     self._ascending_alert_list.append(3)
                 elif total_detections > 25:
-                    level = "significant"
+                    level = " significant"
                     intensity = 9.0
                     self._ascending_alert_list.append(2)
                 elif total_detections > 15:
@@ -277,16 +280,16 @@ class LaneDetectionUseCase(BaseProcessor):
             alert_settings = []
             if config.alert_config and hasattr(config.alert_config, 'alert_type'):
                 alert_settings.append({
-                    "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
+                    "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
                     "incident_category": self.CASE_TYPE,
                     "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']))}
+                    "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                        getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
                 })
 
             event = self.create_incident(
-                incident_id=f"{self.CASE_TYPE}_{frame_number}",
+                incident_id=self.CASE_TYPE + '_' + str(frame_number),
                 incident_type=self.CASE_TYPE,
                 severity_level=level,
                 human_text=human_text,
@@ -304,8 +307,7 @@ class LaneDetectionUseCase(BaseProcessor):
         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."""
+                              frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[Dict]:
         camera_info = self.get_camera_info_from_stream(stream_info)
         tracking_stats = []
         total_detections = counting_summary.get("total_count", 0)
@@ -316,13 +318,8 @@ 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)
 
-        # 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}")
+        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]
 
         detections = []
         for detection in counting_summary.get("detections", []):
@@ -344,12 +341,12 @@ class LaneDetectionUseCase(BaseProcessor):
         alert_settings = []
         if config.alert_config and hasattr(config.alert_config, 'alert_type'):
             alert_settings.append({
-                "alert_type": getattr(config.alert_config, 'alert_type', ['Default']),
+                "alert_type": getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
                 "incident_category": self.CASE_TYPE,
                 "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']))}
+                "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
+                                    getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])}
             })
 
         human_text_lines = [f"Tracking Statistics:"]
@@ -358,7 +355,8 @@ 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():
-            human_text_lines.append(f"\t{cat}: {count}")
+            if count > 0:
+                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}")
@@ -367,6 +365,7 @@ class LaneDetectionUseCase(BaseProcessor):
         human_text = "\n".join(human_text_lines)
 
         reset_settings = [{"interval_type": "daily", "reset_time": {"value": 9, "time_unit": "hour"}}]
+
         tracking_stat = self.create_tracking_stats(
             total_counts=total_counts,
             current_counts=current_counts,
@@ -383,7 +382,7 @@ class LaneDetectionUseCase(BaseProcessor):
         return tracking_stats
 
     def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: LaneDetectionConfig,
-                                    stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
+                                  stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
         if is_empty:
             return []
 
@@ -448,33 +447,42 @@ class LaneDetectionUseCase(BaseProcessor):
         seconds = round(float(timestamp % 60), 2)
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
-    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str] = None) -> str:
+    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
+        """Get formatted current timestamp based on stream type."""
         if not stream_info:
             return "00:00:00.00"
+        # is_video_chunk = stream_info.get("input_settings", {}).get("is_video_chunk", False)
         if precision:
             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)
+                    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)
+                    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:
                 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)
-            return self._format_timestamp_for_video(start_time)
+                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", "")
             if stream_time_str:
+                # Parse the high precision timestamp string to get timestamp
                 try:
+                    # Remove " UTC" suffix and parse
                     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:
+                    # Fallback to current time if parsing fails
                     return self._format_timestamp_for_stream(time.time())
             else:
                 return self._format_timestamp_for_stream(time.time())
@@ -506,34 +514,23 @@ class LaneDetectionUseCase(BaseProcessor):
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
     def _count_categories(self, detections: list, config: LaneDetectionConfig) -> dict:
-        """
-        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 = []
-        
+        counts = {}
         for det in detections:
             cat = det.get('category', 'unknown')
-            # 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')}")
-
+            counts[cat] = counts.get(cat, 0) + 1
         return {
             "total_count": sum(counts.values()),
             "per_category_count": counts,
-            "detections": valid_detections
+            "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
+            ]
         }
 
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:

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

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

{matrice-1.0.99144.dist-info → matrice-1.0.99145.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=ljWoDeFJb0IJJPClYaZrNnBZd87JqKI64jE_I79GAYo,31146
+matrice/deploy/utils/post_processing/usecases/road_lane_detection.py,sha256=V_KxwBtAHSNkyoH8sXw-U-P3J8ToXtX3ncc69gn6Tds,31591
 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.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,,
+matrice-1.0.99145.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99145.dist-info/METADATA,sha256=SZvAGseewa2r30bvP0UDZ6hMk3qOQVPIGonmT3kTSRc,14624
+matrice-1.0.99145.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99145.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99145.dist-info/RECORD,,