matrice 1.0.99286__py3-none-any.whl → 1.0.99287__py3-none-any.whl

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

@@ -1,9 +1,3 @@
-"""
-Crop weed detection usecase
-This module provides functionality for detecting crops in images or video streams.
-
-"""
-
 from typing import Any, Dict, List, Optional
 from dataclasses import asdict
 import time
@@ -67,44 +61,63 @@ class CropWeedDetectionUseCase(BaseProcessor):
         "Maize": "Maize",
         "NarWeed": "Nar Weed"
     }
+
     def __init__(self):
         super().__init__("crop_weed_detection")
         self.category = "agriculture"
-
         self.CASE_TYPE: Optional[str] = 'crop_weed_detection'
         self.CASE_VERSION: Optional[str] = '1.2'
-
-        # List of  categories to track
         self.target_categories = ['plants', 'BroWeed', 'Maize', 'NarWeed']
-
-
-        # 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
-
-        # Track start time for "TOTAL SINCE" calculation
         self._tracking_start_time = None
-
         self._track_aliases: Dict[Any, Any] = {}
         self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
-        # Tunable parameters – adjust if necessary for specific scenarios
-        self._track_merge_iou_threshold: float = 0.05  # IoU ≥ 0.05 →
-        self._track_merge_time_window: float = 7.0  # seconds within which to merge
-
+        self._track_merge_iou_threshold: float = 0.05
+        self._track_merge_time_window: float = 7.0
         self._ascending_alert_list: List[int] = []
         self.current_incident_end_timestamp: str = "N/A"
 
+    def _normalize_category(self, category: str) -> str:
+        """
+        Dynamically normalize category names by stripping quotes and correcting known misspellings.
+        Returns the normalized category or the original if no match is found.
+        """
+        if not isinstance(category, str):
+            self.logger.warning(f"Invalid category type: {type(category)}, returning as-is")
+            return category
+
+        # Strip quotes and whitespace
+        cleaned_category = category.strip("'").strip('"').strip()
+
+        # Define known misspellings or variations
+        category_corrections = {
+            "plantss": "plants",
+            "Plants": "plants",
+            "broweed": "BroWeed",
+            "maize": "Maize",
+            "narweed": "NarWeed"
+        }
+
+        # Check if the cleaned category is in target_categories
+        if cleaned_category in self.target_categories:
+            return cleaned_category
+
+        # Check for known misspellings
+        normalized_category = category_corrections.get(cleaned_category.lower(), cleaned_category)
+
+        # Log if the category is unrecognized
+        if normalized_category not in self.target_categories:
+            self.logger.warning(f"Unrecognized category '{category}' normalized to '{normalized_category}'")
+        
+        return normalized_category
 
     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.
         """
@@ -112,41 +125,45 @@ class CropWeedDetectionUseCase(BaseProcessor):
         # Ensure config is correct type
         if not isinstance(config, CropWeedDetectionConfig):
             return self.create_error_result("Invalid config type", usecase=self.name, category=self.category,
-                                            context=context)
+                                           context=context)
         if context is None:
             context = ProcessingContext()
-        
 
         # Detect input format and store in context
         input_format = match_results_structure(data)
         
-        # DEBUG
+        # DEBUG: Log raw input data
         print(f"Detected data: {data}")
-        
-
-        context.input_format = input_format
-        context.confidence_threshold = config.confidence_threshold
 
+        # Normalize category names dynamically
         processed_data = [
             {**d, 'category': self._normalize_category(d.get('category'))}
             for d in data
         ]
+        print(f"Data after category normalization: {processed_data}")
+
+        context.input_format = input_format
+        context.confidence_threshold = config.confidence_threshold
 
+        # Apply confidence filtering
         if config.confidence_threshold is not None:
-            processed_data = filter_by_confidence(data, config.confidence_threshold)
+            processed_data = filter_by_confidence(processed_data, config.confidence_threshold)
             self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
+            print(f"Detections after confidence filtering: {processed_data}")
         else:
-            processed_data = data
-            self.logger.debug(f"Did not apply confidence filtering with threshold since nothing was provided")
+            self.logger.debug("Did not apply confidence filtering since no threshold provided")
 
-        # Step 2: Apply category mapping if provided
+        # 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(f"Detections after category mapping: {processed_data}")
 
+        # Apply 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")
+            self.logger.debug(f"Applied category filtering")
+            print(f"Detections after category filtering: {processed_data}")
 
         # Apply bbox smoothing if enabled
         if config.enable_smoothing:
@@ -155,28 +172,23 @@ class CropWeedDetectionUseCase(BaseProcessor):
                     smoothing_algorithm=config.smoothing_algorithm,
                     window_size=config.smoothing_window_size,
                     cooldown_frames=config.smoothing_cooldown_frames,
-                    confidence_threshold=config.confidence_threshold,  # Use mask threshold as default
+                    confidence_threshold=config.confidence_threshold,
                     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)
-
-        # DEBUG:
-        print(f"Processed data after filtering and smoothing: {processed_data}")
+            print(f"Processed data after smoothing: {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:
                 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)
                     )
@@ -184,20 +196,16 @@ class CropWeedDetectionUseCase(BaseProcessor):
                     tracker_config = TrackerConfig()
                 self.tracker = AdvancedTracker(tracker_config)
                 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}"
+                    f"Initialized AdvancedTracker with thresholds: high={tracker_config.track_high_thresh}, "
+                    f"low={tracker_config.track_low_thresh}, 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(f"Data after tracking: {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
         self._update_tracking_state(processed_data)
 
         # Update frame counter
@@ -209,45 +217,40 @@ class CropWeedDetectionUseCase(BaseProcessor):
             input_settings = stream_info.get("input_settings", {})
             start_frame = input_settings.get("start_frame")
             end_frame = input_settings.get("end_frame")
-            # If start and end frame are the same, it's a single frame
             if start_frame is not None and end_frame is not None and start_frame == end_frame:
                 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)
+        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 incidents, tracking stats and business analytics with frame-based keys
+        # Generate structured outputs
         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, 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
+        # Extract frame-based dictionaries
         incidents = incidents_list[0] if incidents_list else {}
         tracking_stats = tracking_stats_list[0] if tracking_stats_list else {}
         business_analytics = business_analytics_list[0] if business_analytics_list else {}
         summary = summary_list[0] if summary_list else {}
         agg_summary = {str(frame_number): {
-                        "incidents": incidents,
-                        "tracking_stats": tracking_stats,
-                        "business_analytics": business_analytics,
-                        "alerts": alerts,
-                        "human_text": summary}
-                      }
-       
-       
+            "incidents": incidents,
+            "tracking_stats": tracking_stats,
+            "business_analytics": business_analytics,
+            "alerts": alerts,
+            "human_text": summary}
+        }
+        
         context.mark_completed()
 
-        # Build result object following the new pattern
-
-        # DEBUG:
+        # DEBUG: Log final summary
         print(f"Final aggregated summary: {agg_summary}")
 
         result = self.create_result(
@@ -259,18 +262,14 @@ class CropWeedDetectionUseCase(BaseProcessor):
         
         return result
 
-    def _check_alerts(self, summary: dict, frame_number:Any, config: CropWeedDetectionConfig) -> List[Dict]:
+    def _check_alerts(self, summary: dict, frame_number: Any, config: CropWeedDetectionConfig) -> List[Dict]:
         """
         Check if any alert thresholds are exceeded and return alert dicts.
         """
         def get_trend(data, lookback=900, threshold=0.6):
-            '''
-            Determine if the trend is ascending or descending based on actual value progression.
-            Now works with values 0,1,2,3 (not just binary).
-            '''
             window = data[-lookback:] if len(data) >= lookback else data
             if len(window) < 2:
-                return True  # not enough data to determine trend
+                return True
             increasing = 0
             total = 0
             for i in range(1, len(window)):
@@ -285,53 +284,44 @@ class CropWeedDetectionUseCase(BaseProcessor):
 
         frame_key = str(frame_number) if frame_number is not None else "current_frame"
         alerts = []
-        total_detections = summary.get("total_count", 0) #CURRENT combined total count of all classes
-        total_counts_dict = 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 = summary.get("per_category_count", {}) #CURRENT count per class
+        total_detections = summary.get("total_count", 0)
+        total_counts_dict = summary.get("total_counts", {})
+        cumulative_total = sum(total_counts_dict.values()) if total_counts_dict else 0
+        per_category_count = summary.get("per_category_count", {})
 
         if not config.alert_config:
             return alerts
 
         total = summary.get("total_count", 0)
-        #self._ascending_alert_list
         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 > threshold:  
-
+                if category == "all" and total > 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,
+                        "alert_type": getattr(config.alert_config, 'alert_type', ['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'])
-                                    }                    
+                        "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 summary.get("per_category_count", {}):
                     count = summary.get("per_category_count", {})[category]
-                    if count > threshold:  # Fixed logic: alert when EXCEEDING threshold
+                    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,
+                            "alert_type": getattr(config.alert_config, 'alert_type', ['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'])
-                                    }       
+                            "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
+                                                             getattr(config.alert_config, 'alert_value', ['JSON']))}
                         })
-        else:
-            pass
         return alerts
 
     def _generate_incidents(self, counting_summary: Dict, alerts: List, config: CropWeedDetectionConfig,
-                         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]:
         """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)
@@ -340,22 +330,20 @@ class CropWeedDetectionUseCase(BaseProcessor):
         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"
             intensity = 5.0
             start_timestamp = self._get_start_timestamp_str(stream_info)
-            if start_timestamp and self.current_incident_end_timestamp=='N/A':
+            if start_timestamp and self.current_incident_end_timestamp == 'N/A':
                 self.current_incident_end_timestamp = 'Incident still active'
-            elif start_timestamp and self.current_incident_end_timestamp=='Incident still active':
-                if len(self._ascending_alert_list) >= 15 and sum(self._ascending_alert_list[-15:]) / 15 < 1.5: 
+            elif start_timestamp and self.current_incident_end_timestamp == 'Incident still active':
+                if len(self._ascending_alert_list) >= 15 and sum(self._ascending_alert_list[-15:]) / 15 < 1.5:
                     self.current_incident_end_timestamp = current_timestamp
-            elif self.current_incident_end_timestamp!='Incident still active' and self.current_incident_end_timestamp!='N/A':
+            elif self.current_incident_end_timestamp != 'Incident still active' and self.current_incident_end_timestamp != 'N/A':
                 self.current_incident_end_timestamp = 'N/A'
                 
             if config.alert_config and config.alert_config.count_thresholds:
                 threshold = config.alert_config.count_thresholds.get("all", 15)
                 intensity = min(10.0, (total_detections / threshold) * 10)
-
                 if intensity >= 9:
                     level = "critical"
                     self._ascending_alert_list.append(3)
@@ -386,29 +374,34 @@ class CropWeedDetectionUseCase(BaseProcessor):
                     intensity = min(10.0, total_detections / 3.0)
                     self._ascending_alert_list.append(0)
 
-             # 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_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'],
+                    "alert_type": getattr(config.alert_config, 'alert_type', ['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']) 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'])
-                                }
+                    "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
+                                                     getattr(config.alert_config, 'alert_value', ['JSON']))}
                 })
         
-            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})
+            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}
+            )
             incidents.append(event)
-
         else:
             self._ascending_alert_list.append(0)
             incidents.append({})
@@ -425,80 +418,50 @@ class CropWeedDetectionUseCase(BaseProcessor):
     ) -> List[Dict]:
         """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
+        total_detections = counting_summary.get("total_count", 0)
+        total_counts_dict = counting_summary.get("total_counts", {})
+        cumulative_total = sum(total_counts_dict.values()) if total_counts_dict else 0
+        per_category_count = counting_summary.get("per_category_count", {})
 
         current_timestamp = self._get_current_timestamp_str(stream_info, precision=False)
         start_timestamp = self._get_start_timestamp_str(stream_info, precision=False)
-        
-        # Create high precision timestamps for input_timestamp and reset_timestamp
         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 array in expected format
-        total_counts = []
-        for cat, count in total_counts_dict.items():
-            if count > 0:
-                total_counts.append({
-                    "category": cat,
-                    "count": count
-                })
-
-        # Build current_counts array in expected format  
-        current_counts = []
-        for cat, count in per_category_count.items():
-            if count > 0 or total_detections > 0:  # Include even if 0 when there are detections
-                current_counts.append({
-                    "category": cat,
-                    "count": count
-                })
-
-        # Prepare detections without confidence scores (as per eg.json)
-        detections = []
+        total_counts = [
+            {"category": cat, "count": count}
+            for cat, count in total_counts_dict.items() if count > 0
+        ]
 
-        # DEBUG
-        print(f"Model detections: {counting_summary.get('detections', [])}")
+        current_counts = [
+            {"category": cat, "count": count}
+            for cat, count in per_category_count.items() if count > 0 or total_detections > 0
+        ]
 
-        for detection in counting_summary.get("detections", []):
-            detection_data = {
+        detections = [
+            {
                 "category": detection.get("category"),
-                "bounding_box": detection.get("bounding_box", {})
+                "bounding_box": detection.get("bounding_box", {}),
+                "masks": detection.get("masks", []) if detection.get("masks") else None,
+                "segmentation": detection.get("segmentation") if detection.get("segmentation") else None,
+                "mask": detection.get("mask") if detection.get("mask") else None
             }
-            # Include segmentation if available (like in eg.json)
-            if detection.get("masks"):
-                detection_data["masks"] = detection.get("masks", [])
-            if detection.get("segmentation"):
-                detection_data["segmentation"] = detection.get("segmentation")
-            if detection.get("mask"):
-                detection_data["mask"] = detection.get("mask")
-            detections.append(detection_data)
-
-        # Build alert_settings array in expected format
+            for detection in counting_summary.get("detections", [])
+        ]
+
         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'],
+                "alert_type": getattr(config.alert_config, 'alert_type', ['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']) 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'])
-                            }
+                "settings": {t: v for t, v in zip(getattr(config.alert_config, 'alert_type', ['Default']),
+                                                 getattr(config.alert_config, 'alert_value', ['JSON']))}
             })
 
-        # DEBUG
-        print(f"Detections for tracking stats: {detections}")
-
-        # Generate human_text in expected format
         human_text_lines = [f"Tracking Statistics:"]
         human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}")
         
@@ -517,40 +480,38 @@ class CropWeedDetectionUseCase(BaseProcessor):
             human_text_lines.append("Alerts: None")
 
         human_text = "\n".join(human_text_lines)
-        reset_settings=[
-                {
-                    "interval_type": "daily",
-                    "reset_time": {
-                        "value": 9,
-                        "time_unit": "hour"
-                    }
-                }
-            ]
-
-        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)
+        reset_settings = [
+            {
+                "interval_type": "daily",
+                "reset_time": {"value": 9, "time_unit": "hour"}
+            }
+        ]
 
-        # DEBUG
-        print(f"Generated tracking stat: {tracking_stat}")
+        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
+        )
 
         tracking_stats.append(tracking_stat)
         return tracking_stats
-    
-    def _generate_business_analytics(self, counting_summary: Dict, alerts:Any, config: CropWeedDetectionConfig, stream_info: Optional[Dict[str, Any]] = None, is_empty=False) -> List[Dict]:
+
+    def _generate_business_analytics(self, counting_summary: Dict, alerts: Any, config: CropWeedDetectionConfig,
+                                    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 []
+        # Implement if needed
+        return []
 
-        #-----IF YOUR USECASE NEEDS BUSINESS ANALYTICS, YOU CAN USE THIS FUNCTION------#
-        #camera_info = self.get_camera_info_from_stream(stream_info)
-        # business_analytics = self.create_business_analytics(nalysis_name, statistics,
-        #                          human_text, camera_info=camera_info, alerts=alerts, alert_settings=alert_settings,
-        #                          reset_settings)
-        # return business_analytics
-
-    def _generate_summary(self, summary: dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[str]:
+    def _generate_summary(self, summary: dict, incidents: List, tracking_stats: List, business_analytics: List, alerts: List) -> List[dict]:
         """
         Generate a human_text string for the tracking_stat, incident, business analytics and alerts.
         """
@@ -558,11 +519,11 @@ class CropWeedDetectionUseCase(BaseProcessor):
         lines["Application Name"] = self.CASE_TYPE
         lines["Application Version"] = self.CASE_VERSION
         if len(incidents) > 0:
-            lines["Incidents:"]=f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
+            lines["Incidents:"] = f"\n\t{incidents[0].get('human_text', 'No incidents detected')}\n"
         if len(tracking_stats) > 0:
-            lines["Tracking Statistics:"]=f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
+            lines["Tracking Statistics:"] = f"\t{tracking_stats[0].get('human_text', 'No tracking statistics detected')}\n"
         if len(business_analytics) > 0:
-            lines["Business Analytics:"]=f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}\n"
+            lines["Business Analytics:"] = f"\t{business_analytics[0].get('human_text', 'No business analytics detected')}\n"
 
         if len(incidents) == 0 and len(tracking_stats) == 0 and len(business_analytics) == 0:
             lines["Summary"] = "No Summary Data"
@@ -573,13 +534,11 @@ class CropWeedDetectionUseCase(BaseProcessor):
         """
         Get detailed information about track IDs (per frame).
         """
-        # Collect all track_ids in this frame
         frame_track_ids = set()
         for det in detections:
             tid = det.get('track_id')
             if tid is not None:
                 frame_track_ids.add(tid)
-        # Use persistent total set for unique counting
         total_track_ids = set()
         for s in getattr(self, '_per_category_total_track_ids', {}).values():
             total_track_ids.update(s)
@@ -595,10 +554,7 @@ class CropWeedDetectionUseCase(BaseProcessor):
     def _update_tracking_state(self, detections: list):
         """
         Track unique categories track_ids per category for total count after tracking.
-        Applies canonical ID merging to avoid duplicate counting when the underlying
-        tracker loses an object temporarily and assigns a new ID.
         """
-        # Lazily initialise storage dicts
         if not hasattr(self, "_per_category_total_track_ids"):
             self._per_category_total_track_ids = {cat: set() for cat in self.target_categories}
         self._current_frame_track_ids = {cat: set() for cat in self.target_categories}
@@ -610,9 +566,7 @@ class CropWeedDetectionUseCase(BaseProcessor):
                 continue
             bbox = det.get("bounding_box", det.get("bbox"))
             canonical_id = self._merge_or_register_track(raw_track_id, bbox)
-            # Propagate canonical ID back to detection so downstream logic uses it
             det["track_id"] = canonical_id
-
             self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
             self._current_frame_track_ids[cat].add(canonical_id)
 
@@ -622,7 +576,6 @@ class CropWeedDetectionUseCase(BaseProcessor):
         """
         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)
@@ -632,45 +585,40 @@ class CropWeedDetectionUseCase(BaseProcessor):
         """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)
+        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("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)
+                    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)
-                stream_time_str = self._format_timestamp_for_video(start_time)
-                return stream_time_str
+            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())
@@ -686,41 +634,32 @@ class CropWeedDetectionUseCase(BaseProcessor):
                 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 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("input_settings", {}).get("stream_info", {}).get("stream_time", "")
                 if stream_time_str:
                     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")
                         self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
                     except:
-                        # Fallback to current time if parsing fails
                         self._tracking_start_time = time.time()
                 else:
                     self._tracking_start_time = time.time()
 
             dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
-            # Reset minutes and seconds to 00:00 for "TOTAL SINCE" format
             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: CropWeedDetectionConfig) -> 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', etc.
-        Output structure will include 'track_id' for each detection as per AdvancedTracker output.
         """
         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,
@@ -736,7 +675,6 @@ class CropWeedDetectionUseCase(BaseProcessor):
             ]
         }
 
-
     def _extract_predictions(self, detections: list) -> List[Dict[str, Any]]:
         """
         Extract prediction details for output (category, confidence, bounding box).
@@ -750,14 +688,8 @@ class CropWeedDetectionUseCase(BaseProcessor):
             for det in detections
         ]
 
-    # ------------------------------------------------------------------ #
-    # Canonical ID helpers                                               #
-    # ------------------------------------------------------------------ #
     def _compute_iou(self, box1: Any, box2: Any) -> float:
-        """Compute IoU between two bounding boxes which may be dicts or lists.
-        Falls back to 0 when insufficient data is available."""
-
-        # Helper to convert bbox (dict or list) to [x1, y1, x2, y2]
+        """Compute IoU between two bounding boxes which may be dicts or lists."""
         def _bbox_to_list(bbox):
             if bbox is None:
                 return []
@@ -768,7 +700,6 @@ class CropWeedDetectionUseCase(BaseProcessor):
                     return [bbox["xmin"], bbox["ymin"], bbox["xmax"], bbox["ymax"]]
                 if "x1" in bbox:
                     return [bbox["x1"], bbox["y1"], bbox["x2"], bbox["y2"]]
-                # Fallback: first four numeric values
                 values = [v for v in bbox.values() if isinstance(v, (int, float))]
                 return values[:4] if len(values) >= 4 else []
             return []
@@ -780,7 +711,6 @@ class CropWeedDetectionUseCase(BaseProcessor):
         x1_min, y1_min, x1_max, y1_max = l1
         x2_min, y2_min, x2_max, y2_max = l2
 
-        # Ensure correct order
         x1_min, x1_max = min(x1_min, x1_max), max(x1_min, x1_max)
         y1_min, y1_max = min(y1_min, y1_max), max(y1_min, y1_max)
         x2_min, x2_max = min(x2_min, x2_max), max(x2_min, x2_max)
@@ -802,16 +732,11 @@ class CropWeedDetectionUseCase(BaseProcessor):
         return (inter_area / union_area) if union_area > 0 else 0.0
 
     def _merge_or_register_track(self, raw_id: Any, bbox: Any) -> Any:
-        """Return a stable canonical ID for a raw tracker ID, merging fragmented
-        tracks when IoU and temporal constraints indicate they represent the
-        same physical."""
+        """Return a stable canonical ID for a raw tracker ID."""
         if raw_id is None or bbox is None:
-            # Nothing to merge
             return raw_id
 
         now = time.time()
-
-        # Fast path – raw_id already mapped
         if raw_id in self._track_aliases:
             canonical_id = self._track_aliases[raw_id]
             track_info = self._canonical_tracks.get(canonical_id)
@@ -821,21 +746,17 @@ class CropWeedDetectionUseCase(BaseProcessor):
                 track_info["raw_ids"].add(raw_id)
             return canonical_id
 
-        # Attempt to merge with an existing canonical track
         for canonical_id, info in self._canonical_tracks.items():
-            # Only consider recently updated tracks
             if now - info["last_update"] > self._track_merge_time_window:
                 continue
             iou = self._compute_iou(bbox, info["last_bbox"])
             if iou >= self._track_merge_iou_threshold:
-                # Merge
                 self._track_aliases[raw_id] = canonical_id
                 info["last_bbox"] = bbox
                 info["last_update"] = now
                 info["raw_ids"].add(raw_id)
                 return canonical_id
 
-        # No match – register new canonical track
         canonical_id = raw_id
         self._track_aliases[raw_id] = canonical_id
         self._canonical_tracks[canonical_id] = {

{matrice-1.0.99286.dist-info → matrice-1.0.99287.dist-info}/METADATA

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

{matrice-1.0.99286.dist-info → matrice-1.0.99287.dist-info}/RECORD

@@ -173,7 +173,7 @@ matrice/deploy/utils/post_processing/usecases/child_monitoring.py,sha256=z3oymoq
 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=pxhOH_hG4hq9yytNepbGMdk2W_lTG8D1_2RAagaPBkg,40252
-matrice/deploy/utils/post_processing/usecases/crop_weed_detection.py,sha256=GUfbdZmaZfBAwceaSBwJaXzIVlIo3KMqry8LHO4diLU,40697
+matrice/deploy/utils/post_processing/usecases/crop_weed_detection.py,sha256=uATIX4ox7IfIkwhTXr8QGJHq45bJU7X33WKqewK1eJA,35680
 matrice/deploy/utils/post_processing/usecases/customer_service.py,sha256=UWS83qxguyAyhh8a0JF5QH9DtKxO8I-gI2BPOjLPxBw,44642
 matrice/deploy/utils/post_processing/usecases/defect_detection_products.py,sha256=blvo4wmak-wlvPSZOcmRsV1FoZSeGX_dUAX5A1WheBE,45949
 matrice/deploy/utils/post_processing/usecases/distracted_driver_detection.py,sha256=rkyYHbmcYUAfKbmmKyKxHlk47vJ_fogHWKhQjrERsok,40316
@@ -244,8 +244,8 @@ matrice/deployment/camera_manager.py,sha256=e1Lc81RJP5wUWRdTgHO6tMWF9BkBdHOSVyx3
 matrice/deployment/deployment.py,sha256=HFt151eWq6iqIAMsQvurpV2WNxW6Cx_gIUVfnVy5SWE,48093
 matrice/deployment/inference_pipeline.py,sha256=6b4Mm3-qt-Zy0BeiJfFQdImOn3FzdNCY-7ET7Rp8PMk,37911
 matrice/deployment/streaming_gateway_manager.py,sha256=ifYGl3g25wyU39HwhPQyI2OgF3M6oIqKMWt8RXtMxY8,21401
-matrice-1.0.99286.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
-matrice-1.0.99286.dist-info/METADATA,sha256=2cKToW_ZvMOC-aDa_ZyzU05PYxIEWJeAfoZJIx-Khu4,14624
-matrice-1.0.99286.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-matrice-1.0.99286.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
-matrice-1.0.99286.dist-info/RECORD,,
+matrice-1.0.99287.dist-info/licenses/LICENSE.txt,sha256=2bm9uFabQZ3Ykb_SaSU_uUbAj2-htc6WJQmS_65qD00,1073
+matrice-1.0.99287.dist-info/METADATA,sha256=U7NyO0Ia_YH0saRsGMknFF5DmQ6xJzy50kI7d69joFg,14624
+matrice-1.0.99287.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+matrice-1.0.99287.dist-info/top_level.txt,sha256=P97js8ur6o5ClRqMH3Cjoab_NqbJ6sOQ3rJmVzKBvMc,8
+matrice-1.0.99287.dist-info/RECORD,,