supervisely 6.73.452__py3-none-any.whl → 6.73.513__py3-none-any.whl

supervisely/nn/tracker/base_tracker.py

@@ -36,9 +36,19 @@ class BaseTracker:
     def video_annotation(self) -> VideoAnnotation:
         """Return the accumulated VideoAnnotation."""
         raise NotImplementedError("This method should be overridden by subclasses.")
+    
+    @classmethod
+    def get_default_params(cls) -> Dict[str, Any]:
+        """
+        Get default configurable parameters for this tracker.
+        Must be implemented in subclass.
+        """
+        raise NotImplementedError(
+            f"Method get_default_params() must be implemented in {cls.__name__}"
+        )
 
     def _validate_device(self) -> None:
         if self.device != 'cpu' and not self.device.startswith('cuda'):
             raise ValueError(
                 f"Invalid device '{self.device}'. Supported devices are 'cpu' or 'cuda'."
-            )
+            )   

supervisely/nn/tracker/botsort/botsort_config.yaml

@@ -1,6 +1,5 @@
 # botsort_default_config.yaml
 
-name: "BotSORT"
 device: "auto" # "cuda" or "cpu", "auto" will use cuda if available
 fp16: false
 

supervisely/nn/tracker/botsort/tracker/mc_bot_sort.py

@@ -1,13 +1,16 @@
-import numpy as np
 from collections import deque
 
+import numpy as np
+
+from supervisely.nn.tracker.botsort.osnet_reid.osnet_reid_interface import (
+    OsnetReIDInterface,
+)
+
 from . import matching
-from .gmc import GMC
 from .basetrack import BaseTrack, TrackState
+from .gmc import GMC
 from .kalman_filter import KalmanFilter
 
-from supervisely.nn.tracker.botsort.osnet_reid.osnet_reid_interface import OsnetReIDInterface
-
 
 class STrack(BaseTrack):
 

supervisely/nn/tracker/botsort_tracker.py

@@ -1,15 +1,16 @@
-import supervisely as sly
-from supervisely.nn.tracker.base_tracker import BaseTracker
-from supervisely import Annotation, VideoAnnotation
-from supervisely.annotation.label import LabelingStatus
+import os
 from dataclasses import dataclass
+from pathlib import Path
 from types import SimpleNamespace
-from typing import List, Dict, Tuple, Any, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
 import numpy as np
 import yaml
-import os
-from pathlib import Path
-from supervisely import logger
+
+import supervisely as sly
+from supervisely import Annotation, VideoAnnotation, logger
+from supervisely.annotation.label import Label, LabelingStatus
+from supervisely.nn.tracker.base_tracker import BaseTracker
 from supervisely.nn.tracker.botsort.tracker.mc_bot_sort import BoTSORT
 
 
@@ -32,10 +33,11 @@ class TrackedObject:
     class_name: str
     class_sly_id: Optional[int]  # Supervisely class ID
     score: float
+    original_label: Optional[sly.Label] = None
 
 
 class BotSortTracker(BaseTracker):
-    
+
     def __init__(self, settings: dict = None, device: str = None):
         super().__init__(settings=settings, device=device)
 
@@ -45,33 +47,30 @@ class BotSortTracker(BaseTracker):
                 "Tracking dependencies are not installed. "
                 "Please install supervisely with `pip install supervisely[tracking]`."
             )
-        
+
         # Load default settings from YAML file
         self.settings = self._load_default_settings()
-        
+
         # Override with user settings if provided
         if settings:
             self.settings.update(settings)
-        
+
         args = SimpleNamespace(**self.settings)
+        args.name = "BotSORT"
         args.device = self.device
-            
+
         self.tracker = BoTSORT(args=args)
-        
+
         # State for accumulating results
-        self.frame_tracks = []
+        self.frame_tracks: List[List[TrackedObject]] = []
         self.obj_classes = {}   # class_id -> ObjClass
         self.current_frame = 0
         self.class_ids = {}  # class_name -> class_id mapping
         self.frame_shape = () 
 
     def _load_default_settings(self) -> dict:
-        """Load default settings from YAML file in the same directory."""
-        current_dir = Path(__file__).parent
-        config_path = current_dir / "botsort/botsort_config.yaml"
-        
-        with open(config_path, 'r', encoding='utf-8') as file:
-            return yaml.safe_load(file)
+        """Internal method: calls classmethod"""
+        return self.get_default_params()
 
     def update(self, frame: np.ndarray, annotation: Annotation) -> List[Dict[str, Any]]:
         """Update tracker and return list of matches for current frame."""
@@ -79,12 +78,12 @@ class BotSortTracker(BaseTracker):
         self._update_obj_classes(annotation)
         detections = self._convert_annotation(annotation)
         output_stracks, detection_track_map = self.tracker.update(detections, frame)
-        tracks = self._stracks_to_tracks(output_stracks, detection_track_map)
-        
+        tracks = self._stracks_to_tracks(output_stracks, detection_track_map, annotation.labels)
+
         # Store tracks for VideoAnnotation creation
         self.frame_tracks.append(tracks)
         self.current_frame += 1
-        
+
         matches = []
         for pair in detection_track_map:
             det_id = pair["det_id"]
@@ -96,9 +95,9 @@ class BotSortTracker(BaseTracker):
                     "label": annotation.labels[det_id]
                 }
                 matches.append(match)
-            
+
         return matches
-    
+
     def reset(self) -> None:
         super().reset()
         self.frame_tracks = []
@@ -109,19 +108,16 @@ class BotSortTracker(BaseTracker):
 
     def track(self, frames: List[np.ndarray], annotations: List[Annotation]) -> VideoAnnotation:
         """Track objects through sequence of frames and return VideoAnnotation."""
-        if len(frames) != len(annotations):
-            raise ValueError("Number of frames and annotations must match")
-        
         self.reset()
-        
+
         # Process each frame
         for frame_idx, (frame, annotation) in enumerate(zip(frames, annotations)):
             self.current_frame = frame_idx
             self.update(frame, annotation)
-        
+
         # Convert accumulated tracks to VideoAnnotation
-        return self._create_video_annotation()
-        
+        return self.create_video_annotation()
+
     def _convert_annotation(self, annotation: Annotation) -> np.ndarray:
         """Convert Supervisely annotation to BoTSORT detection format."""
         detections_list = []
@@ -138,10 +134,10 @@ class BotSortTracker(BaseTracker):
                 )
 
             rectangle = label.geometry.to_bbox()
-            
+
             class_name = label.obj_class.name
             class_id = self.class_ids[class_name]
-            
+
             detection = [
                 rectangle.left,    # x1
                 rectangle.top,     # y1 
@@ -156,103 +152,127 @@ class BotSortTracker(BaseTracker):
             return np.array(detections_list, dtype=np.float32)
         else:
             return np.zeros((0, 6), dtype=np.float32)
-    
-    def _stracks_to_tracks(self, output_stracks, detection_track_map) -> List[TrackedObject]:
+
+    def _stracks_to_tracks(
+        self, output_stracks, detection_track_map, labels: List[Label]
+    ) -> List[TrackedObject]:
         """Convert BoTSORT output tracks to TrackedObject dataclass instances."""
         tracks = []
-        
+
         id_to_name = {v: k for k, v in self.class_ids.items()}
-        
+
         track_id_to_det_id = {}
         for pair in detection_track_map:
             det_id = pair["det_id"]
             track_id = pair["track_id"]
             track_id_to_det_id[track_id] = det_id 
-        
+
         for strack in output_stracks:
+            det_id = track_id_to_det_id.get(strack.track_id)
+            if det_id is None:
+                continue  # Skip tracks without associated detection
+
             # BoTSORT may store class info in different attributes
             # Try to get class_id from various possible sources
             class_id = 0  # default
-            
+
             if hasattr(strack, 'cls') and strack.cls != -1:
                 # cls should contain the numeric ID we passed in
                 class_id = int(strack.cls)
             elif hasattr(strack, 'class_id'):
                 class_id = int(strack.class_id)
-            
+
             class_name = id_to_name.get(class_id, "unknown")
-            
+
             # Get Supervisely class ID from stored ObjClass
             class_sly_id = None
             if class_name in self.obj_classes:
                 obj_class = self.obj_classes[class_name]
                 class_sly_id = obj_class.sly_id
-            
+
+            label = labels[det_id]
             track = TrackedObject(
                 track_id=strack.track_id,
                 det_id=track_id_to_det_id.get(strack.track_id),
                 bbox=strack.tlbr.tolist(),  # [x1, y1, x2, y2]
                 class_name=class_name,
                 class_sly_id=class_sly_id,
-                score=getattr(strack, 'score', 1.0)
+                score=getattr(strack, "score", 1.0),
+                original_label=label,
             )
             tracks.append(track)
-        
+
         return tracks
-        
+
     def _update_obj_classes(self, annotation: Annotation):
         """Extract and store object classes from annotation."""
         for label in annotation.labels:
             class_name = label.obj_class.name
             if class_name not in self.obj_classes:
                 self.obj_classes[class_name] = label.obj_class
-        
+
             if class_name not in self.class_ids:
                 self.class_ids[class_name] = len(self.class_ids)
 
-
-    def _create_video_annotation(self) -> VideoAnnotation:
+    def create_video_annotation(
+        self,
+        video_frames_count: Optional[int] = None,
+        frame_index: Optional[int] = 0,
+        step: Optional[int] = 1,
+        progress_cb: Optional[Callable[[int], None]] = None,
+    ) -> VideoAnnotation:
         """Convert accumulated tracking results to Supervisely VideoAnnotation."""
         img_h, img_w = self.frame_shape
         video_objects = {}  # track_id -> VideoObject
         frames = []
-        
-        for frame_idx, tracks in enumerate(self.frame_tracks):
+        if video_frames_count is None:
+            video_frames_count = len(self.frame_tracks)
+
+        for i, tracks in enumerate(self.frame_tracks, frame_index):
+            frame_idx = frame_index + i * step
             frame_figures = []
-            
+
             for track in tracks:
                 track_id = track.track_id
                 bbox = track.bbox  # [x1, y1, x2, y2]
                 class_name = track.class_name
-                
+
                 # Clip bbox to image boundaries
                 x1, y1, x2, y2 = bbox
                 dims = np.array([img_w, img_h, img_w, img_h]) - 1
                 x1, y1, x2, y2 = np.clip([x1, y1, x2, y2], 0, dims)
-                
+
                 # Get or create VideoObject
                 if track_id not in video_objects:
                     obj_class = self.obj_classes.get(class_name)
                     if obj_class is None:
                         continue  # Skip if class not found
                     video_objects[track_id] = sly.VideoObject(obj_class)
-                
+
                 video_object = video_objects[track_id]
-                rect = sly.Rectangle(top=y1, left=x1, bottom=y2, right=x2)
-                frame_figures.append(sly.VideoFigure(video_object, rect, frame_idx, track_id=str(track_id), status=LabelingStatus.AUTO))
-            
+                frame_figures.append(
+                    sly.VideoFigure(
+                        video_object,
+                        track.original_label.geometry,
+                        frame_idx,
+                        track_id=str(track_id),
+                        status=LabelingStatus.AUTO,
+                    )
+                )
+
             frames.append(sly.Frame(frame_idx, frame_figures))
+            if progress_cb is not None:
+                progress_cb()
 
         objects = list(video_objects.values())
 
-        
         return VideoAnnotation(
             img_size=self.frame_shape,
-            frames_count=len(self.frame_tracks),
+            frames_count=video_frames_count,
             objects=sly.VideoObjectCollection(objects),
-            frames=sly.FrameCollection(frames)
+            frames=sly.FrameCollection(frames),
         )
-        
+
     @property    
     def video_annotation(self) -> VideoAnnotation:
         """Return the accumulated VideoAnnotation."""
@@ -262,5 +282,14 @@ class BotSortTracker(BaseTracker):
                 "Please run tracking first using track() method or process frames with update()."
             )
             raise ValueError(error_msg)
-                
-        return self._create_video_annotation()
+
+        return self.create_video_annotation()
+
+    @classmethod
+    def get_default_params(cls) -> Dict[str, Any]:
+        """Public API: get default params WITHOUT creating instance."""
+        current_dir = Path(__file__).parent
+        config_path = current_dir / "botsort/botsort_config.yaml"
+
+        with open(config_path, 'r', encoding='utf-8') as file:
+            return yaml.safe_load(file)