matrice 1.0.99178__py3-none-any.whl → 1.0.99180__py3-none-any.whl

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

@@ -10,7 +10,6 @@ from typing import Any, Dict, List, Optional
 from dataclasses import asdict
 import time
 from datetime import datetime, timezone
-import copy  # Added for deep copying detections to preserve original masks
 
 from ..core.base import BaseProcessor, ProcessingContext, ProcessingResult, ConfigProtocol, ResultFormat
 from ..utils import (
@@ -40,7 +39,7 @@ class PotholeConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
 
     #confidence thresholds
-    confidence_threshold: float = 0.6
+    confidence_threshold: float = 0.3
 
     usecase_categories: List[str] = field(
         default_factory=lambda: ['pothole']
@@ -54,28 +53,27 @@ class PotholeConfig(BaseConfig):
 
     index_to_category: Optional[Dict[int, str]] = field(
         default_factory=lambda: {
-           0:"pothole"
-
+            0: 'pothole'
         }
     )
 
 
 class PotholeSegmentationUseCase(BaseProcessor):
-
-    # Human-friendly display names for  categories
+    # Human-friendly display names for categories
     CATEGORY_DISPLAY = {
         "pothole": "pothole"
     }
+    
     def __init__(self):
         super().__init__("pothole_segmentation")
         self.category = "infrastructure"
 
+        self.CASE_TYPE: Optional[str] = 'pothole_segmentation'
+        self.CASE_VERSION: Optional[str] = '1.3'
+
         # List of  categories to track
         self.target_categories = ["pothole"]
 
-        self.CASE_TYPE: Optional[str] = 'Pothole_detection'
-        self.CASE_VERSION: Optional[str] = '1.3'
-
         # Initialize smoothing tracker
         self.smoothing_tracker = None
 
@@ -89,13 +87,6 @@ class PotholeSegmentationUseCase(BaseProcessor):
         # Track start time for "TOTAL SINCE" calculation
         self._tracking_start_time = None
 
-        # ------------------------------------------------------------------ #
-        # Canonical tracking aliasing to avoid duplicate counts              #
-        # ------------------------------------------------------------------ #
-        # Maps raw tracker-generated IDs to stable canonical IDs that persist
-        # even if the underlying tracker re-assigns a new ID after a short
-        # interruption. This mirrors the logic used in people_counting to
-        # provide accurate unique counting.
         self._track_aliases: Dict[Any, Any] = {}
         self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
         # Tunable parameters – adjust if necessary for specific scenarios
@@ -108,7 +99,7 @@ class PotholeSegmentationUseCase(BaseProcessor):
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         """
-        Main entry point for post-processing.
+        Main entry point for  post-processing.
         Applies category mapping, smoothing, counting, alerting, and summary generation.
         Returns a ProcessingResult with all relevant outputs.
         """
@@ -124,42 +115,39 @@ class PotholeSegmentationUseCase(BaseProcessor):
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
-        
-        # Step 1: Confidence filtering
+
         if config.confidence_threshold is not None:
             processed_data = filter_by_confidence(data, config.confidence_threshold)
+            self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
         else:
             processed_data = data
+            
             self.logger.debug(f"Did not apply confidence filtering with threshold since nothing was provided")
 
         # Step 2: Apply category mapping if provided
         if config.index_to_category:
             processed_data = apply_category_mapping(processed_data, config.index_to_category)
+            self.logger.debug("Applied category mapping")
 
-        # Step 3: Category filtering
         if config.target_categories:
             processed_data = [d for d in processed_data if d.get('category') in self.target_categories]
+            self.logger.debug(f"Applied  category filtering")
 
-        # Step 4: Apply bbox smoothing if enabled
-        # Deep-copy detections so that we preserve the original masks before any
-        # smoothing/tracking logic potentially removes them.
-        raw_processed_data = [copy.deepcopy(det) for det in processed_data]
+        # Apply bbox smoothing if enabled
         if config.enable_smoothing:
             if self.smoothing_tracker is None:
                 smoothing_config = BBoxSmoothingConfig(
                     smoothing_algorithm=config.smoothing_algorithm,
                     window_size=config.smoothing_window_size,
                     cooldown_frames=config.smoothing_cooldown_frames,
-                    confidence_threshold=config.confidence_threshold,
+                    confidence_threshold=config.confidence_threshold,  # Use mask threshold as default
                     confidence_range_factor=config.smoothing_confidence_range_factor,
                     enable_smoothing=True
                 )
                 self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
-           
             processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
-            # Restore masks after smoothing
 
-        # Step 5: Advanced tracking (BYTETracker-like)
+        # Advanced tracking (BYTETracker-like)
         try:
             from ..advanced_tracker import AdvancedTracker
             from ..advanced_tracker.config import TrackerConfig
@@ -168,24 +156,19 @@ class PotholeSegmentationUseCase(BaseProcessor):
             if self.tracker is None:
                 tracker_config = TrackerConfig()
                 self.tracker = AdvancedTracker(tracker_config)
-                self.logger.info("Initialized AdvancedTracker for Monitoring and tracking")
-           
+                self.logger.info("Initialized AdvancedTracker for  Monitoring and tracking")
+
+            # The tracker expects the data in the same format as input
+            # It will add track_id and frame_id to each detection
             processed_data = self.tracker.update(processed_data)
+
         except Exception as e:
             # If advanced tracker fails, fallback to unsmoothed detections
             self.logger.warning(f"AdvancedTracker failed: {e}")
 
-        # Update tracking state for total count per label
+        # Update  tracking state for total count per label
         self._update_tracking_state(processed_data)
 
-        # ------------------------------------------------------------------ #
-        # Re-attach segmentation masks that were present in the original input
-        # but may have been stripped during smoothing/tracking. We match each
-        # processed detection back to the raw detection with the highest IoU
-        # and copy over its "masks" field (if available).
-        # ------------------------------------------------------------------ #
-        processed_data = self._attach_masks_to_detections(processed_data, raw_processed_data)
-
         # Update frame counter
         self._total_frame_counter += 1
 
@@ -200,19 +183,19 @@ class PotholeSegmentationUseCase(BaseProcessor):
                 frame_number = start_frame
 
         # Compute summaries and alerts
-        general_counting_summary = calculate_counting_summary(data)
-        counting_summary = self._count_categories(processed_data, config)
-        # Add total unique counts after tracking using only local state
-        total_counts = self.get_total_counts()
-        counting_summary['total_counts'] = total_counts
-
+        general_counting_summary = calculate_counting_summary(data) 
+        counting_summary = self._count_categories(processed_data, config) 
+        # Add total unique  counts after tracking using only local state
+        total_counts = self.get_total_counts() 
+        counting_summary['total_counts'] = total_counts 
+        
         alerts = self._check_alerts(counting_summary, frame_number, config)
         predictions = self._extract_predictions(processed_data)
         
-        # Step: Generate structured events and tracking stats with frame-based keys
+        # Step: Generate structured incidents, tracking stats and business analytics with frame-based keys
         incidents_list = self._generate_incidents(counting_summary, alerts, config, frame_number, stream_info)
-        tracking_stats_list = self._generate_tracking_stats(counting_summary, alerts, config, frame_number,stream_info)
-        business_analytics_list = self._generate_business_analytics(counting_summary, alerts, config, frame_number, stream_info, is_empty=False)
+        tracking_stats_list = self._generate_tracking_stats(counting_summary, alerts, config, frame_number, stream_info)
+        business_analytics_list = self._generate_business_analytics(counting_summary, alerts, config, stream_info, is_empty=True)
         summary_list = self._generate_summary(counting_summary, incidents_list, tracking_stats_list, business_analytics_list, alerts)
 
         # Extract frame-based dictionaries from the lists
@@ -226,8 +209,9 @@ class PotholeSegmentationUseCase(BaseProcessor):
                         "business_analytics": business_analytics,
                         "alerts": alerts,
                         "human_text": summary}
-                      }
-       
+                    }
+
+
         context.mark_completed()
 
         # Build result object following the new pattern
@@ -289,8 +273,8 @@ class PotholeSegmentationUseCase(BaseProcessor):
                         "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'])
-                                    }                    
+                                    getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
+                                }                    
                     })
                 elif category in summary.get("per_category_count", {}):
                     count = summary.get("per_category_count", {})[category]
@@ -302,27 +286,25 @@ class PotholeSegmentationUseCase(BaseProcessor):
                             "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'])
-                                    }       
+                                        getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
+                                }       
                         })
         else:
             pass
         return alerts
 
     def _generate_incidents(self, counting_summary: Dict, alerts: List, config: PotholeConfig,
-                         frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[
+                        frame_number: Optional[int] = None, stream_info: Optional[Dict[str, Any]] = None) -> List[
         Dict]:
-        """Generate structured events for the output format with frame-based keys."""
-
-        # Use frame number as key, fallback to 'current_frame' if not available
-        frame_key = str(frame_number) if frame_number is not None else "current_frame"
-        incidents=[]
+        """Generate structured incidents for the output format with frame-based keys."""
+        
+        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:
             # Determine event level based on thresholds
             level = "low"
@@ -370,7 +352,7 @@ class PotholeSegmentationUseCase(BaseProcessor):
                     intensity = min(10.0, total_detections / 3.0)
                     self._ascending_alert_list.append(0)
 
-             # Generate human text in new format
+            # Generate human text in new format
             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)
@@ -388,9 +370,9 @@ class PotholeSegmentationUseCase(BaseProcessor):
                 })
         
             event= self.create_incident(incident_id=self.CASE_TYPE+'_'+str(frame_number), incident_type=self.CASE_TYPE,
-                       severity_level=level, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
-                       start_time=start_timestamp, end_time=self.current_incident_end_timestamp,
-                       level_settings= {"low": 1, "medium": 3, "significant":4, "critical": 7})
+                        severity_level=level, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
+                        start_time=start_timestamp, end_time=self.current_incident_end_timestamp,
+                        level_settings= {"low": 1, "medium": 3, "significant":4, "critical": 7})
             incidents.append(event)
 
         else:
@@ -402,22 +384,23 @@ class PotholeSegmentationUseCase(BaseProcessor):
     def _generate_tracking_stats(
             self,
             counting_summary: Dict,
-            alerts: Any,
+            alerts: List,
             config: PotholeConfig,
             frame_number: Optional[int] = None,
             stream_info: Optional[Dict[str, Any]] = None
     ) -> List[Dict]:
-        """Generate structured tracking stats for the output format with frame-based keys, including track_ids_info and detections with masks."""
-        #frame_key = str(frame_number) if frame_number is not None else "current_frame"
-        tracking_stats = [] #[{frame_key: []}]
-        #frame_tracking_stats = tracking_stats[0][frame_key]
-
-        total_detections = counting_summary.get("total_count", 0)
-        total_counts = counting_summary.get("total_counts", {})
-        cumulative_total = sum(total_counts.values()) if total_counts else 0
-        per_category_count = counting_summary.get("per_category_count", {})
-
-        track_ids_info = self._get_track_ids_info(counting_summary.get("detections", []))
+        """Generate structured tracking stats matching eg.json format."""
+        camera_info = self.get_camera_info_from_stream(stream_info)
+        
+        # frame_key = str(frame_number) if frame_number is not None else "current_frame"
+        # tracking_stats = [{frame_key: []}]
+        # frame_tracking_stats = tracking_stats[0][frame_key]
+        tracking_stats = []
+        
+        total_detections = counting_summary.get("total_count", 0) #CURRENT total count of all classes
+        total_counts_dict = counting_summary.get("total_counts", {}) #TOTAL cumulative counts per class
+        cumulative_total = sum(total_counts_dict.values()) if total_counts_dict else 0 #TOTAL combined cumulative count
+        per_category_count = counting_summary.get("per_category_count", {}) #CURRENT count per class
 
         current_timestamp = self._get_current_timestamp_str(stream_info, precision=False)
         start_timestamp = self._get_start_timestamp_str(stream_info, precision=False)
@@ -426,33 +409,16 @@ class PotholeSegmentationUseCase(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)
 
-        camera_info = self.get_camera_info_from_stream(stream_info)
-        human_text_lines = []
+    
+        # Build total_counts array in expected format
+        total_counts = []
+        for cat, count in total_counts_dict.items():
+            if count > 0:
+                total_counts.append({
+                    "category": cat,
+                    "count": count
+                })
 
-        # CURRENT FRAME section
-        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
-        if total_detections > 0:
-            category_counts = [f"{count} {cat}" for cat, count in per_category_count.items()]
-            if len(category_counts) == 1:
-                detection_text = category_counts[0] + " detected"
-            elif len(category_counts) == 2:
-                detection_text = f"{category_counts[0]} and {category_counts[1]} detected"
-            else:
-                detection_text = f"{', '.join(category_counts[:-1])}, and {category_counts[-1]} detected"
-            human_text_lines.append(f"\t- {detection_text}")
-        else:
-            human_text_lines.append(f"\t- No detections")
-
-        human_text_lines.append("")  # spacing
-
-        # TOTAL SINCE section
-        human_text_lines.append(f"TOTAL SINCE {start_timestamp}:")
-        human_text_lines.append(f"\t- Total Detected: {cumulative_total}")
-        # Add category-wise counts
-        if total_counts:
-            for cat, count in total_counts.items():
-                if count > 0:  # Only include categories with non-zero counts
-                    human_text_lines.append(f"\t- {cat}: {count}")
         # Build current_counts array in expected format  
         current_counts = []
         for cat, count in per_category_count.items():
@@ -462,9 +428,6 @@ class PotholeSegmentationUseCase(BaseProcessor):
                     "count": count
                 })
 
-        human_text = "\n".join(human_text_lines)
-
-        # Include detections with masks from counting_summary
         # Prepare detections without confidence scores (as per eg.json)
         detections = []
         for detection in counting_summary.get("detections", []):
@@ -493,10 +456,24 @@ class PotholeSegmentationUseCase(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']) 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'])
-                        }
+                                    getattr(config.alert_config, 'alert_value', ['JSON']) if hasattr(config.alert_config, 'alert_value') else ['JSON'])
+                            }
             })
 
+        # Generate human_text in expected format
+        human_text_lines = [f"Tracking Statistics:"]
+        human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
+        human_text_lines.append(f"Potholes Detected - ")
+        
+        for cat, count in per_category_count.items():
+            human_text_lines.append(f"\t{cat}: {count}")
+            
+        human_text_lines.append(f"TOTAL SINCE {start_timestamp}")
+        human_text_lines.append(f"Total Potholes Detected - ")
+        for cat, count in total_counts_dict.items():
+            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}")
@@ -504,7 +481,7 @@ class PotholeSegmentationUseCase(BaseProcessor):
             human_text_lines.append("Alerts: None")
 
         human_text = "\n".join(human_text_lines)
-        reset_settings = [
+        reset_settings=[
                 {
                     "interval_type": "daily",
                     "reset_time": {
@@ -515,14 +492,14 @@ class PotholeSegmentationUseCase(BaseProcessor):
             ]
 
         tracking_stat=self.create_tracking_stats(total_counts=total_counts, current_counts=current_counts,
-                             detections=detections, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
-                             reset_settings=reset_settings, start_time=high_precision_start_timestamp ,
-                             reset_time=high_precision_reset_timestamp)
+                            detections=detections, human_text=human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
+                            reset_settings=reset_settings, start_time=high_precision_start_timestamp ,
+                            reset_time=high_precision_reset_timestamp)
 
         tracking_stats.append(tracking_stat)
         return tracking_stats
 
-    def _generate_business_analytics(self, counting_summary: Dict, zone_analysis: Dict, config: PotholeConfig, stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
+    def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: PotholeConfig, stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
         """Generate standardized business analytics for the agg_summary structure."""
         if is_empty:
             return []
@@ -553,36 +530,6 @@ class PotholeSegmentationUseCase(BaseProcessor):
 
         return [lines]
 
-
-    def _count_categories(self, detections: list, config: PotholeConfig) -> dict:
-        """
-        Count the number of detections per category and return a summary dict.
-        The detections list is expected to have 'track_id' (from tracker), 'category', 'bounding_box', 'masks', etc.
-        Output structure will include 'track_id' and 'masks' for each detection as per AdvancedTracker output.
-        """
-        counts = {}
-        valid_detections = []
-        for det in detections:
-            cat = det.get('category', 'unknown')
-            if not all(k in det for k in ['category', 'confidence', 'bounding_box']):  # Validate required fields
-                self.logger.warning(f"Skipping invalid detection: {det}")
-                continue
-            counts[cat] = counts.get(cat, 0) + 1
-            valid_detections.append({
-                "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"),
-                "masks": det.get("masks", det.get("mask", []))  # Include masks, fallback to empty list
-            })
-        self.logger.debug(f"Valid detections after filtering: {len(valid_detections)}")
-        return {
-            "total_count": sum(counts.values()),
-            "per_category_count": counts,
-            "detections": valid_detections
-        }
-
     def _get_track_ids_info(self, detections: list) -> Dict[str, Any]:
         """
         Get detailed information about track IDs (per frame).
@@ -636,37 +583,45 @@ class PotholeSegmentationUseCase(BaseProcessor):
         """
         return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
 
-    def _format_timestamp_for_video(self, timestamp: float) -> str:
-        """Format timestamp for video chunks (HH:MM:SS.ms format)."""
-        hours = int(timestamp // 3600)
-        minutes = int((timestamp % 3600) // 60)
-        seconds = timestamp % 60
-        return f"{hours:02d}:{minutes:02d}:{seconds:06.2f}"
 
     def _format_timestamp_for_stream(self, timestamp: float) -> str:
         """Format timestamp for streams (YYYY:MM:DD HH:MM:SS format)."""
         dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
         return dt.strftime('%Y:%m:%d %H:%M:%S')
 
-    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
+    def _format_timestamp_for_video(self, timestamp: float) -> str:
+        """Format timestamp for video chunks (HH:MM:SS.ms format)."""
+        hours = int(timestamp // 3600)
+        minutes = int((timestamp % 3600) // 60)
+        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:
         """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("stream_type", "video_file") == "video_file":
-                stream_time_str = stream_info.get("video_timestamp", "")
-                return stream_time_str[:8]
+            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
             else:
                 return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
 
-        if stream_info.get("input_settings", {}).get("stream_type", "video_file") == "video_file":
-            # If video format, return video timestamp
-            stream_time_str = stream_info.get("video_timestamp", "")
-            return stream_time_str[:8]
+        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
         else:
             # For streams, use stream_time from stream_info
-            stream_time_str = stream_info.get("stream_time", "")
+            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:
@@ -685,23 +640,20 @@ class PotholeSegmentationUseCase(BaseProcessor):
         """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
         if not stream_info:
             return "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("stream_type", "video_file") == "video_file":
+            if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
                 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("stream_type", "video_file") == "video_file":
+        if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
             # If video format, start from 00:00:00
             return "00:00:00"
         else:
             # For streams, use tracking start time or current time with minutes/seconds reset
             if self._tracking_start_time is None:
                 # Try to extract timestamp from stream_time string
-                stream_time_str = stream_info.get("stream_time", "")
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
                 if stream_time_str:
                     try:
                         # Remove " UTC" suffix and parse
@@ -719,60 +671,31 @@ class PotholeSegmentationUseCase(BaseProcessor):
             dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
 
-    # ------------------------------------------------------------------ #
-    # Helper to merge masks back into detections                        #
-    # ------------------------------------------------------------------ #
-    def _attach_masks_to_detections(
-        self,
-        processed_detections: List[Dict[str, Any]],
-        raw_detections: List[Dict[str, Any]],
-        iou_threshold: float = 0.5,
-    ) -> List[Dict[str, Any]]:
+    def _count_categories(self, detections: list, config: PotholeConfig) -> dict:
         """
-        Attach segmentation masks from the original `raw_detections` list to the
-        `processed_detections` list returned after smoothing/tracking.
-
-        Matching between detections is performed using Intersection-over-Union
-        (IoU) of the bounding boxes. For each processed detection we select the
-        raw detection with the highest IoU above `iou_threshold` and copy its
-        `masks` (or `mask`) field. If no suitable match is found, the detection
-        keeps an empty list for `masks` to maintain a consistent schema.
+        Count the number of detections per category and return a summary dict.
+        The detections list is expected to have 'track_id' (from tracker), 'category', 'bounding_box', etc.
+        Output structure will include 'track_id' for each detection as per AdvancedTracker output.
         """
-
-        if not processed_detections or not raw_detections:
-            # Nothing to do – ensure masks key exists for downstream logic.
-            for det in processed_detections:
-                det.setdefault("masks", [])
-            return processed_detections
-
-        # Track which raw detections have already been matched to avoid
-        # assigning the same mask to multiple processed detections.
-        used_raw_indices = set()
-
-        for det in processed_detections:
-            best_iou = 0.0
-            best_idx = None
-
-            for idx, raw_det in enumerate(raw_detections):
-                if idx in used_raw_indices:
-                    continue
-
-                iou = self._compute_iou(det.get("bounding_box"), raw_det.get("bounding_box"))
-                if iou > best_iou:
-                    best_iou = iou
-                    best_idx = idx
-
-            if best_idx is not None and best_iou >= iou_threshold:
-                raw_det = raw_detections[best_idx]
-                masks = raw_det.get("masks", raw_det.get("mask"))
-                if masks is not None:
-                    det["masks"] = masks
-                used_raw_indices.add(best_idx)
-            else:
-                # No adequate match – default to empty list to keep schema consistent.
-                det.setdefault("masks", ["EMPTY"])
-
-        return processed_detections
+        counts = {}
+        for det in detections:
+            cat = det.get('category', 'unknown')
+            counts[cat] = counts.get(cat, 0) + 1
+        # Each detection dict will now include 'track_id' (and possibly 'frame_id')
+        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
+            ]
+        }
 
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:
         """
@@ -782,13 +705,11 @@ class PotholeSegmentationUseCase(BaseProcessor):
             {
                 "category": det.get("category", "unknown"),
                 "confidence": det.get("confidence", 0.0),
-                "bounding_box": det.get("bounding_box", {}),
-                "mask": det.get("mask", det.get("masks", None))  # Accept either key
+                "bounding_box": det.get("bounding_box", {})
             }
             for det in detections
         ]
 
-
     # ------------------------------------------------------------------ #
     # Canonical ID helpers                                               #
     # ------------------------------------------------------------------ #

{matrice-1.0.99178.dist-info → matrice-1.0.99180.dist-info}/METADATA

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

{matrice-1.0.99178.dist-info → matrice-1.0.99180.dist-info}/RECORD

@@ -189,7 +189,7 @@ matrice/deploy/utils/post_processing/usecases/pedestrian_detection.py,sha256=hPF
 matrice/deploy/utils/post_processing/usecases/people_counting.py,sha256=mDJOwcrs9OO4jIbJVr_ItWvjjGP2mgGFYlrP3R-mH2E,76528
 matrice/deploy/utils/post_processing/usecases/pipeline_detection.py,sha256=VsLTXMAqx0tRw7Olrxqx7SBLolZR7p2aFOrdSXLS-kE,30796
 matrice/deploy/utils/post_processing/usecases/plaque_segmentation_img.py,sha256=d__a0PkkObYVoC-Q5-2bFVfeyKnQHtB5xVAKVOCeFyk,41925
-matrice/deploy/utils/post_processing/usecases/pothole_segmentation.py,sha256=6Mv8SoEE5CGItY7S0g-SY5Lb3DV-WWVMlpEp04a86a8,43197
+matrice/deploy/utils/post_processing/usecases/pothole_segmentation.py,sha256=shxBDw9U59g2HPkNJTNPLBtXM10Zly_xC3QeB1oQrUE,39443
 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/road_lane_detection.py,sha256=V_KxwBtAHSNkyoH8sXw-U-P3J8ToXtX3ncc69gn6Tds,31591
@@ -227,8 +227,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.99178.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99178.dist-info/METADATA,sha256=eSLuCEZTq9CA6O6UdX5dYf6p-Tca5_aJrgFrOIZ1hGE,14624
-matrice-1.0.99178.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99178.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99178.dist-info/RECORD,,
+matrice-1.0.99180.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99180.dist-info/METADATA,sha256=h-xuX7F-7q5n5QY1M_WYSAJrUGwjS96CSGO2dK-3iUA,14624
+matrice-1.0.99180.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99180.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99180.dist-info/RECORD,,