matrice 1.0.99139__py3-none-any.whl → 1.0.99141__py3-none-any.whl

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,9 +138,8 @@ 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
@@ -153,15 +147,29 @@ class ConcreteCrackUseCase(BaseProcessor):
 
             # Create tracker instance if it doesn't exist (preserves state across frames)
             if self.tracker is None:
-                tracker_config = TrackerConfig()
+                # 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
+                # the user passes a lower `confidence_threshold` in the post-processing config.
+                if config.confidence_threshold is not None:
+                    tracker_config = TrackerConfig(
+                        track_high_thresh=float(config.confidence_threshold),
+                        # Allow even lower detections to participate in secondary association
+                        track_low_thresh=max(0.05, float(config.confidence_threshold) / 2),
+                        new_track_thresh=float(config.confidence_threshold)
+                    )
+                else:
+                    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 with thresholds: "
+                    f"high={tracker_config.track_high_thresh}, "
+                    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_4-----------------------------------")
-            print(processed_data)
 
         except Exception as e:
             # If advanced tracker fails, fallback to unsmoothed detections
@@ -189,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
@@ -213,8 +219,8 @@ class ConcreteCrackUseCase(BaseProcessor):
                         "alerts": alerts,
                         "human_text": summary}
                     }
-    
-
+       
+       
         context.mark_completed()
 
         # Build result object following the new pattern
@@ -276,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]
@@ -289,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."""
         
@@ -355,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'],
@@ -373,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,
@@ -421,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():
@@ -431,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", []):
@@ -484,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": {
@@ -497,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 []
@@ -587,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)."""
@@ -595,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:
@@ -675,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.
@@ -686,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,

{matrice-1.0.99139.dist-info → matrice-1.0.99141.dist-info}/METADATA

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

{matrice-1.0.99139.dist-info → matrice-1.0.99141.dist-info}/RECORD

@@ -166,7 +166,7 @@ matrice/deploy/utils/post_processing/usecases/chicken_pose_detection.py,sha256=-
 matrice/deploy/utils/post_processing/usecases/child_monitoring.py,sha256=z3oymoqq4hDGwA8MkdEONZW_Vx5CAZmvzZaNLsqmCfw,39380
 matrice/deploy/utils/post_processing/usecases/color_detection.py,sha256=Z8-akjy8a7f8YyiOzXu_Zi1Km30v-TRrymDqQOPpJ_8,43277
 matrice/deploy/utils/post_processing/usecases/color_map_utils.py,sha256=SP-AEVcjLmL8rxblu-ixqUJC2fqlcr7ab4hWo4Fcr_k,2677
-matrice/deploy/utils/post_processing/usecases/concrete_crack_detection.py,sha256=9IVHC2z3FKu8Pg-UjQfNpIjx_4ssE520us3leeBe-dk,40624
+matrice/deploy/utils/post_processing/usecases/concrete_crack_detection.py,sha256=pxhOH_hG4hq9yytNepbGMdk2W_lTG8D1_2RAagaPBkg,40252
 matrice/deploy/utils/post_processing/usecases/crop_weed_detection.py,sha256=i7BWhC-D7liOg9fzFHFg_upd1fdvXlVHYzDRyHL-AdM,40322
 matrice/deploy/utils/post_processing/usecases/customer_service.py,sha256=UWS83qxguyAyhh8a0JF5QH9DtKxO8I-gI2BPOjLPxBw,44642
 matrice/deploy/utils/post_processing/usecases/defect_detection_products.py,sha256=flvTWv6vxa3q4zXD8_e8TW0pqNE5z3LIuvU9ceVKuXg,34481
@@ -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.99139.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99139.dist-info/METADATA,sha256=MvsxaJXsosePJ1fRCShaeA1k7WYQJRn5JIgT-0Okd2M,14624
-matrice-1.0.99139.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99139.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99139.dist-info/RECORD,,
+matrice-1.0.99141.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99141.dist-info/METADATA,sha256=7aK3PJ9ODjlD7ASl79Bf8RxjOtZd474MsY2WvUoBAlA,14624
+matrice-1.0.99141.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99141.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99141.dist-info/RECORD,,