matrice 1.0.99120__tar.gz → 1.0.99122__tar.gz

{matrice-1.0.99120/src/matrice.egg-info → matrice-1.0.99122}/PKG-INFO

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

{matrice-1.0.99120 → matrice-1.0.99122}/setup.py

@@ -14,7 +14,7 @@ long_description = (here / "README.md").read_text(encoding="utf-8")
 setup(
     name="matrice",
 
-    version = "1.0.99120",
+    version = "1.0.99122",
     
     description="SDK for connecting to matrice.ai services",
     long_description=long_description,

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/assembly_line_detection.py

@@ -164,11 +164,24 @@ class AssemblyLineUseCase(BaseProcessor):
             from ..advanced_tracker.config import TrackerConfig
 
             # Create tracker instance if it doesn't exist (preserves state across frames)
+            
             if self.tracker is None:
-                tracker_config = TrackerConfig()
+                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)
@@ -590,11 +603,12 @@ class AssemblyLineUseCase(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)
         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)."""
         hours = int(timestamp // 3600)

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/crop_weed_detection.py

@@ -152,12 +152,24 @@ class CropWeedDetectionUseCase(BaseProcessor):
             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:
-                tracker_config = TrackerConfig()
+                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)
@@ -581,38 +593,45 @@ class CropWeedDetectionUseCase(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:
@@ -631,23 +650,20 @@ class CropWeedDetectionUseCase(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
@@ -665,6 +681,7 @@ class CropWeedDetectionUseCase(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: CropWeedDetectionConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/emergency_vehicle_detection.py

@@ -151,12 +151,24 @@ class EmergencyVehicleUseCase(BaseProcessor):
             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:
-                tracker_config = TrackerConfig()
+                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)
@@ -578,11 +590,12 @@ class EmergencyVehicleUseCase(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)
         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)."""
         hours = int(timestamp // 3600)

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/fashion_detection.py

@@ -156,12 +156,24 @@ class FashionDetectionUseCase(BaseProcessor):
             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:
-                tracker_config = TrackerConfig()
+                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)
@@ -585,38 +597,45 @@ class FashionDetectionUseCase(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:
@@ -635,23 +654,20 @@ class FashionDetectionUseCase(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
@@ -669,6 +685,7 @@ class FashionDetectionUseCase(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: FashionDetectionConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/gender_detection.py

@@ -152,11 +152,24 @@ class GenderDetectionUseCase(BaseProcessor):
             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:
-                tracker_config = TrackerConfig()
+                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
@@ -581,38 +594,45 @@ class GenderDetectionUseCase(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:
@@ -631,23 +651,20 @@ class GenderDetectionUseCase(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
@@ -665,6 +682,7 @@ class GenderDetectionUseCase(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: GenderDetectionConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/price_tag_detection.py

@@ -143,12 +143,24 @@ class PriceTagUseCase(BaseProcessor):
             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:
-                tracker_config = TrackerConfig()
+                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)
@@ -572,38 +584,45 @@ class PriceTagUseCase(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:
@@ -622,23 +641,20 @@ class PriceTagUseCase(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
@@ -656,6 +672,7 @@ class PriceTagUseCase(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: PriceTagConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.

{matrice-1.0.99120 → matrice-1.0.99122}/src/matrice/deploy/utils/post_processing/usecases/windmill_maintenance.py

@@ -595,6 +595,8 @@ class WindmillMaintenanceUseCase(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)
@@ -681,7 +683,8 @@ class WindmillMaintenanceUseCase(BaseProcessor):
             # 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: WindmillMaintenanceConfig) -> dict:
         """
         Count the number of detections per category and return a summary dict.

{matrice-1.0.99120 → matrice-1.0.99122/src/matrice.egg-info}/PKG-INFO

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