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

matrice/deploy/utils/post_processing/config.py

@@ -26,6 +26,8 @@ APP_NAME_TO_USECASE = {
     "weld_defect_detection" : "weld_defect_detection",
     "fruit_monitoring" : "fruit_monitoring",
     "concrete_crack_detection": "concrete_crack_detection",
+    "lane_detection" : "lane_detection",
+    "shelf_inventory" :"shelf_inventory",
 }
 
 APP_NAME_TO_CATEGORY = {
@@ -56,6 +58,8 @@ APP_NAME_TO_CATEGORY = {
     "weld_defect_detection" : "weld",
     "fruit_monitoring" : "agriculture",
     "concrete_crack_detection": "general",
+    "lane_detection" : "traffic",
+    "shelf_inventory" : "retail",
 }
 
 def get_usecase_from_app_name(app_name: str) -> str:

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

@@ -22,7 +22,7 @@ from ..core.config import BaseConfig, AlertConfig, ZoneConfig
 
 @dataclass
 class ConcreteCrackConfig(BaseConfig):
-    """Configuration for concrete crack detection use case in concrete crack monitoring."""
+    """Configuration for Concrete Crack detection use case."""
     # Smoothing configuration
     enable_smoothing: bool = True
     smoothing_algorithm: str = "observability"  # "window" or "observability"
@@ -31,14 +31,14 @@ class ConcreteCrackConfig(BaseConfig):
     smoothing_confidence_range_factor: float = 0.5
 
     #confidence thresholds
-    confidence_threshold: float = 0.2
+    confidence_threshold: float = 0.6
 
     usecase_categories: List[str] = field(
-        default_factory=lambda: ['Cracks']
+        default_factory=lambda:  ["Cracks"]
     )
 
     target_categories: List[str] = field(
-        default_factory=lambda: ['Cracks']
+        default_factory=lambda: ["Cracks"]
     )
 
     alert_config: Optional[AlertConfig] = None
@@ -55,23 +55,23 @@ class ConcreteCrackUseCase(BaseProcessor):
     CATEGORY_DISPLAY = {
         "Cracks": "Cracks",
     }
-    
+
+
     def __init__(self):
         super().__init__("concrete_crack_detection")
         self.category = "general"
 
         self.CASE_TYPE: Optional[str] = 'concrete_crack_detection'
-        self.CASE_VERSION: Optional[str] = '1.3'
-
+        self.CASE_VERSION: Optional[str] = '1.2'
         # List of  categories to track
-        self.target_categories = ['Cracks']
+        self.target_categories =  ["Cracks"]
+
 
         # Initialize smoothing tracker
         self.smoothing_tracker = None
 
         # Initialize advanced tracker (will be created on first use)
         self.tracker = None
-
         # Initialize tracking state variables
         self._total_frame_counter = 0
         self._global_frame_offset = 0
@@ -88,6 +88,7 @@ class ConcreteCrackUseCase(BaseProcessor):
         self._ascending_alert_list: List[int] = []
         self.current_incident_end_timestamp: str = "N/A"
 
+
     def process(self, data: Any, config: ConfigProtocol, context: Optional[ProcessingContext] = None,
                 stream_info: Optional[Dict[str, Any]] = None) -> ProcessingResult:
         """
@@ -107,8 +108,6 @@ class ConcreteCrackUseCase(BaseProcessor):
         input_format = match_results_structure(data)
         context.input_format = input_format
         context.confidence_threshold = config.confidence_threshold
-        
-        
 
         if config.confidence_threshold is not None:
             processed_data = filter_by_confidence(data, config.confidence_threshold)
@@ -117,19 +116,15 @@ class ConcreteCrackUseCase(BaseProcessor):
             processed_data = data
             
             self.logger.debug(f"Did not apply confidence filtering with threshold since nothing was provided")
-        print("---------------------processed_1-----------------------------------")
-        print(processed_data)
+
         # 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")
-        print("---------------------processed_2-----------------------------------")
-        print(processed_data)
+
         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")
-        print("---------------------processed_3-----------------------------------")
-        print(processed_data)
 
         # Apply bbox smoothing if enabled
         if config.enable_smoothing:
@@ -143,11 +138,14 @@ class ConcreteCrackUseCase(BaseProcessor):
                     enable_smoothing=True
                 )
                 self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
-            print("---------------------processed_4-----------------------------------")
             processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
-            print(processed_data)
+
         # Advanced tracking (BYTETracker-like)
         try:
+            from ..advanced_tracker import AdvancedTracker
+            from ..advanced_tracker.config import TrackerConfig
+
+            # Create tracker instance if it doesn't exist (preserves state across frames)
             if self.tracker is None:
                 # Configure tracker thresholds based on the use-case confidence threshold so that
                 # low-confidence detections (e.g. < 0.7) can still be initialised as tracks when
@@ -168,9 +166,10 @@ class ConcreteCrackUseCase(BaseProcessor):
                     f"low={tracker_config.track_low_thresh}, "
                     f"new={tracker_config.new_track_thresh}"
                 )
+
+            # 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)
-            print("---------------------processed_5-----------------------------------")
-            print(processed_data)
 
         except Exception as e:
             # If advanced tracker fails, fallback to unsmoothed detections
@@ -198,16 +197,14 @@ class ConcreteCrackUseCase(BaseProcessor):
         # Add total unique  counts after tracking using only local state
         total_counts = self.get_total_counts() 
         counting_summary['total_counts'] = total_counts 
-        print("---------------------counting_summ-----------------------------------")
-        print(counting_summary)
+        
         alerts = self._check_alerts(counting_summary, frame_number, config)
         predictions = self._extract_predictions(processed_data)
         
         # 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=True)
-        business_analytics_list = []
+        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
@@ -222,8 +219,8 @@ class ConcreteCrackUseCase(BaseProcessor):
                         "alerts": alerts,
                         "human_text": summary}
                     }
-    
-
+       
+       
         context.mark_completed()
 
         # Build result object following the new pattern
@@ -285,8 +282,8 @@ class ConcreteCrackUseCase(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]
@@ -298,15 +295,15 @@ class ConcreteCrackUseCase(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: ConcreteCrackConfig,
-                        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 incidents for the output format with frame-based keys."""
         
@@ -364,12 +361,12 @@ class ConcreteCrackUseCase(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)
 
-            alert_settings = []
+            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']) if hasattr(config.alert_config, 'alert_type') else ['Default'],
@@ -382,17 +379,16 @@ class ConcreteCrackUseCase(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:
             self._ascending_alert_list.append(0)
             incidents.append({})
-        
+           
         return incidents
-
     def _generate_tracking_stats(
             self,
             counting_summary: Dict,
@@ -430,8 +426,7 @@ class ConcreteCrackUseCase(BaseProcessor):
                     "category": cat,
                     "count": count
                 })
-        print("-----------------------------total_counts---------------------------------------")
-        print(total_counts)
+
         # Build current_counts array in expected format  
         current_counts = []
         for cat, count in per_category_count.items():
@@ -440,8 +435,7 @@ class ConcreteCrackUseCase(BaseProcessor):
                     "category": cat,
                     "count": count
                 })
-        print("----------------------------------current_counts---------------------------------------")
-        print(current_counts)
+
         # Prepare detections without confidence scores (as per eg.json)
         detections = []
         for detection in counting_summary.get("detections", []):
@@ -493,9 +487,7 @@ class ConcreteCrackUseCase(BaseProcessor):
             human_text_lines.append("Alerts: None")
 
         human_text = "\n".join(human_text_lines)
-        print("-------------------------------human_text-----------------------------------------------------")
-        print(human_text)
-        reset_settings = [
+        reset_settings=[
                 {
                     "interval_type": "daily",
                     "reset_time": {
@@ -506,14 +498,14 @@ class ConcreteCrackUseCase(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: ConcreteCrackConfig, stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
+    def _generate_business_analytics(self, counting_summary: Dict, alerts:Any, config: ConcreteCrackConfig, 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 []
@@ -596,6 +588,12 @@ class ConcreteCrackUseCase(BaseProcessor):
         Return total unique track_id count for each category.
         """
         return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
+    
+
+    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 _format_timestamp_for_video(self, timestamp: float) -> str:
         """Format timestamp for video chunks (HH:MM:SS.ms format)."""
@@ -604,11 +602,6 @@ class ConcreteCrackUseCase(BaseProcessor):
         seconds = round(float(timestamp % 60),2)
         return f"{hours:02d}:{minutes:02d}:{seconds:.1f}"
 
-    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, frame_id: Optional[str]=None) -> str:
         """Get formatted current timestamp based on stream type."""
         if not stream_info:
@@ -684,6 +677,7 @@ class ConcreteCrackUseCase(BaseProcessor):
             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: ConcreteCrackConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.
@@ -695,10 +689,6 @@ class ConcreteCrackUseCase(BaseProcessor):
             cat = det.get('category', 'unknown')
             counts[cat] = counts.get(cat, 0) + 1
         # Each detection dict will now include 'track_id' (and possibly 'frame_id')
-        print("---------------------------------COUNTS-------------------------------------")
-        print(counts)
-        print("---------------------------------Detections-------------------------------------")
-        print(detections)
         return {
             "total_count": sum(counts.values()),
             "per_category_count": counts,