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

supervisely/nn/model/prediction_session.py

@@ -71,7 +71,7 @@ class PredictionSession:
         tracking_config: dict = None,
         **kwargs: dict,
     ): 
-                  
+
         extra_input_args = ["image_ids", "video_ids", "dataset_ids", "project_ids"]
         assert (
             sum(
@@ -90,7 +90,6 @@ class PredictionSession:
             == 1
         ), "Exactly one of input, image_ids, video_id, dataset_id, project_id or image_id must be provided."
 
-        
         self._iterator = None
         self._base_url = url
         self.inference_request_uuid = None
@@ -115,12 +114,12 @@ class PredictionSession:
         self.inference_settings = {
             k: v for k, v in kwargs.items() if isinstance(v, (str, int, float))
         }
-        
+
         if tracking is True:
             model_info = self._get_session_info()
             if not model_info.get("tracking_on_videos_support", False):
                 raise ValueError("Tracking is not supported by this model")
-            
+
             if tracking_config is None:
                 self.tracker = "botsort"
                 self.tracker_settings = {}
@@ -286,7 +285,7 @@ class PredictionSession:
         if self.api is not None:
             return self.api.token
         return env.api_token(raise_not_found=False)
-    
+
     def _get_json_body(self):
         body = {"state": {}, "context": {}}
         if self.inference_request_uuid is not None:
@@ -298,7 +297,7 @@ class PredictionSession:
         if "model_prediction_suffix" in self.kwargs:
             body["state"]["model_prediction_suffix"] = self.kwargs["model_prediction_suffix"]
         return body
-    
+
     def _post(self, method, *args, retries=5, **kwargs) -> requests.Response:
         if kwargs.get("headers") is None:
             kwargs["headers"] = {}
@@ -336,7 +335,7 @@ class PredictionSession:
         method = "get_session_info"
         r = self._post(method, json=self._get_json_body())
         return r.json()
-    
+
     def _get_inference_progress(self):
         method = "get_inference_progress"
         r = self._post(method, json=self._get_json_body())
@@ -365,9 +364,21 @@ class PredictionSession:
         logger.info("Inference request will be cleared on the server")
         return r.json()
 
+    def _get_final_result(self):
+        method = "get_inference_result"
+        r = self._post(
+            method,
+            json=self._get_json_body(),
+        )
+        return r.json()
+
     def _on_infernce_end(self):
         if self.inference_request_uuid is None:
             return
+        try:
+            self.final_result = self._get_final_result()
+        except Exception as e:
+            logger.debug("Failed to get final result:", exc_info=True)
         self._clear_inference_request()
 
     @property
@@ -512,18 +523,16 @@ class PredictionSession:
                 "Inference is already running. Please stop it before starting a new one."
             )
         resp = self._post(method, **kwargs).json()
-
         self.inference_request_uuid = resp["inference_request_uuid"]
-
-        logger.info(
-            "Inference has started:",
-            extra={"inference_request_uuid": resp.get("inference_request_uuid")},
-        )
         try:
             resp, has_started = self._wait_for_inference_start(tqdm=self.tqdm)
         except:
             self.stop()
             raise
+        logger.info(
+            "Inference has started:",
+            extra={"inference_request_uuid": resp.get("inference_request_uuid")},
+        )
         frame_iterator = self.Iterator(resp["progress"]["total"], self, tqdm=self.tqdm)
         return frame_iterator
 
@@ -636,8 +645,11 @@ class PredictionSession:
                 encoder = MultipartEncoder(fields)
                 if self.tqdm is not None:
 
+                    bytes_read = 0
                     def _callback(monitor):
-                        self.tqdm.update(monitor.bytes_read)
+                        nonlocal bytes_read
+                        self.tqdm.update(monitor.bytes_read - bytes_read)
+                        bytes_read = monitor.bytes_read
 
                     video_size = get_file_size(video_path)
                     self._update_progress(self.tqdm, "Uploading video", 0, video_size, is_size=True)

supervisely/nn/prediction_dto.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 import numpy as np
 
 from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.geometry.polyline_3d import Polyline3D
 
 
 class Prediction:
@@ -24,10 +25,21 @@ class PredictionMask(Prediction):
 
 
 class PredictionBBox(Prediction):
-    def __init__(self, class_name: str, bbox_tlbr: List[int], score: Optional[float]):
+    def __init__(self, class_name: str, bbox_tlbr: List[int], score: Optional[float], angle: Optional[float] = None):
+        """
+        :param class_name: Predicted class name.
+        :type class_name: str
+        :param bbox_tlbr: Bounding box in (top, left, bottom, right) format.
+        :type bbox_tlbr: list of 4 ints
+        :param score: Confidence score.
+        :type score: float, optional
+        :param angle: Angle of rotation in radians. Positive values mean clockwise rotation.
+        :type angle: int or float, optional
+        """
         super(PredictionBBox, self).__init__(class_name=class_name)
         self.bbox_tlbr = bbox_tlbr
         self.score = score
+        self.angle = angle
 
 
 class PredictionSegmentation(Prediction):
@@ -81,3 +93,9 @@ class PredictionCuboid3d(Prediction):
         super(PredictionCuboid3d, self).__init__(class_name=class_name)
         self.cuboid_3d = cuboid_3d
         self.score = score
+
+
+class PredictionPolyline3D(Prediction):
+    def __init__(self, class_name: str, polyline_3d: Polyline3D):
+        super(PredictionPolyline3D, self).__init__(class_name=class_name)
+        self.polyline_3d = polyline_3d

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
-
+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)))
-            
+                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)

supervisely/nn/tracker/utils.py

@@ -1,4 +1,3 @@
-
 from typing import List, Union, Dict, Tuple
 from pathlib import Path
 from collections import defaultdict
@@ -6,6 +5,7 @@ import numpy as np
 
 import supervisely as sly
 from supervisely.nn.model.prediction import Prediction
+from supervisely.annotation.label import LabelingStatus
 from supervisely import VideoAnnotation
 from supervisely import logger
 
@@ -73,12 +73,11 @@ def predictions_to_video_annotation(
             
             video_object = video_objects[track_id]
             rect = sly.Rectangle(top=top, left=left, bottom=bottom, right=right)
-            frame_figures.append(sly.VideoFigure(video_object, rect, frame_idx, track_id=str(track_id)))
+            frame_figures.append(sly.VideoFigure(video_object, rect, frame_idx, track_id=str(track_id), status=LabelingStatus.AUTO))
         
         frames.append(sly.Frame(frame_idx, frame_figures))
 
-    objects = list(video_objects.values())
-    
+    objects = list(video_objects.values()) 
     return VideoAnnotation(
         img_size=frame_shape,
         frames_count=len(predictions),
@@ -271,4 +270,4 @@ def mot_to_video_annotation(
     
     logger.info(f"Created VideoAnnotation with {len(objects)} tracks and {frames_count} frames")
     
-    return annotation
+    return annotation