supervisely 6.73.428__py3-none-any.whl → 6.73.430__py3-none-any.whl

supervisely/nn/tracker/__init__.py

@@ -1,9 +1,8 @@
-from supervisely.sly_logger import logger
-
 try:
     from supervisely.nn.tracker.botsort_tracker import BotSortTracker
+    from supervisely.nn.tracker.calculate_metrics import TrackingEvaluator, evaluate
+    TRACKING_LIBS_INSTALLED = True
 except ImportError:
-    logger.error(
-        "Failed to import tracker modules. Please try install extras with 'pip install supervisely[tracking]'"
-    )
-    raise
+    TRACKING_LIBS_INSTALLED = False
+
+from supervisely.nn.tracker.visualize import TrackingVisualizer, visualize

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

@@ -426,8 +426,8 @@ class BoTSORT(object):
             if track.score < self.new_track_thresh:
                 continue
             # Fill track_id for new detection
-            detection_track_map[orig_idx]["track_id"] = int(track.track_id)
             track.activate(self.kalman_filter, self.frame_id)
+            detection_track_map[orig_idx]["track_id"] = int(track.track_id)
             activated_starcks.append(track)
 
         """ Step 5: Update state"""

supervisely/nn/tracker/botsort_tracker.py

@@ -1,6 +1,5 @@
 import supervisely as sly
 from supervisely.nn.tracker.base_tracker import BaseTracker
-from supervisely.nn.tracker.botsort.tracker.mc_bot_sort import BoTSORT
 from supervisely import Annotation, VideoAnnotation
 
 from dataclasses import dataclass
@@ -11,6 +10,7 @@ import yaml
 import os
 from pathlib import Path
 from supervisely import logger
+from supervisely.nn.tracker.botsort.tracker.mc_bot_sort import BoTSORT
 
 
 @dataclass
@@ -38,6 +38,13 @@ class BotSortTracker(BaseTracker):
     
     def __init__(self, settings: dict = None, device: str = None):
         super().__init__(settings=settings, device=device)
+
+        from supervisely.nn.tracker import TRACKING_LIBS_INSTALLED
+        if not TRACKING_LIBS_INSTALLED:
+            raise ImportError(
+                "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()
@@ -232,7 +239,7 @@ class BotSortTracker(BaseTracker):
                 
                 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))
+                frame_figures.append(sly.VideoFigure(video_object, rect, frame_idx, track_id=str(track_id)))
             
             frames.append(sly.Frame(frame_idx, frame_figures))
 

supervisely/nn/tracker/calculate_metrics.py

@@ -0,0 +1,264 @@
+import numpy as np
+from collections import defaultdict
+from typing import Dict, List, Union
+
+from scipy.optimize import linear_sum_assignment  # pylint: disable=import-error
+
+import supervisely as sly
+from supervisely.video_annotation.video_annotation import VideoAnnotation
+
+import motmetrics as mm  # pylint: disable=import-error
+
+class TrackingEvaluator:
+    """
+    Evaluator for video tracking metrics including MOTA, MOTP, IDF1.
+    """
+
+    def __init__(self, iou_threshold: float = 0.5):
+        """Initialize evaluator with IoU threshold for matching."""
+        from supervisely.nn.tracker import TRACKING_LIBS_INSTALLED
+        if not TRACKING_LIBS_INSTALLED:
+            raise ImportError(
+                "Tracking dependencies are not installed. "
+                "Please install supervisely with `pip install supervisely[tracking]`."
+            )
+            
+        if not 0.0 <= iou_threshold <= 1.0:
+            raise ValueError("iou_threshold must be in [0.0, 1.0]")
+        self.iou_threshold = iou_threshold
+
+    def evaluate(
+        self,
+        gt_annotation: VideoAnnotation,
+        pred_annotation: VideoAnnotation,
+    ) -> Dict[str, Union[float, int]]:
+        """Main entry: extract tracks from annotations, compute basic and MOT metrics, return results."""
+        self._validate_annotations(gt_annotation, pred_annotation)
+        self.img_height, self.img_width = gt_annotation.img_size
+
+        gt_tracks = self._extract_tracks(gt_annotation)
+        pred_tracks = self._extract_tracks(pred_annotation)
+
+        basic = self._compute_basic_metrics(gt_tracks, pred_tracks)
+        mot = self._compute_mot_metrics(gt_tracks, pred_tracks)
+
+        results = {
+            # basic detection
+            "precision": basic["precision"],
+            "recall": basic["recall"],
+            "f1": basic["f1"],
+            "avg_iou": basic["avg_iou"],
+            "true_positives": basic["tp"],
+            "false_positives": basic["fp"],
+            "false_negatives": basic["fn"],
+            "total_gt_objects": basic["total_gt"],
+            "total_pred_objects": basic["total_pred"],
+
+            # motmetrics
+            "mota": mot["mota"],
+            "motp": mot["motp"],
+            "idf1": mot["idf1"],
+            "id_switches": mot["id_switches"],
+            "fragmentations": mot["fragmentations"],
+            "num_misses": mot["num_misses"],
+            "num_false_positives": mot["num_false_positives"],
+
+            # config
+            "iou_threshold": self.iou_threshold,
+        }
+        return results
+
+    def _validate_annotations(self, gt: VideoAnnotation, pred: VideoAnnotation):
+        """Minimal type validation for annotations."""
+        if not isinstance(gt, VideoAnnotation) or not isinstance(pred, VideoAnnotation):
+            raise TypeError("gt_annotation and pred_annotation must be VideoAnnotation instances")
+
+    def _extract_tracks(self, annotation: VideoAnnotation) -> Dict[int, List[Dict]]:
+        """
+        Extract tracks from a VideoAnnotation into a dict keyed by frame index.
+        Each element is a dict: {'track_id': int, 'bbox': [x1,y1,x2,y2], 'confidence': float, 'class_name': str}
+        """
+        frames_to_tracks = defaultdict(list)
+
+        for frame in annotation.frames:
+            frame_idx = frame.index
+            for figure in frame.figures:
+                # use track_id if present, otherwise fallback to object's key int
+                track_id = int(figure.track_id) if figure.track_id is not None else figure.video_object.key().int
+
+                bbox = figure.geometry
+                if not isinstance(bbox, sly.Rectangle):
+                    bbox = bbox.to_bbox()
+
+                x1 = float(bbox.left)
+                y1 = float(bbox.top)
+                x2 = float(bbox.right)
+                y2 = float(bbox.bottom)
+
+                frames_to_tracks[frame_idx].append({
+                    "track_id": track_id,
+                    "bbox": [x1, y1, x2, y2],
+                    "confidence": float(getattr(figure, "confidence", 1.0)),
+                    "class_name": figure.video_object.obj_class.name
+                })
+
+        return dict(frames_to_tracks)
+
+    def _compute_basic_metrics(self, gt_tracks: Dict[int, List[Dict]], pred_tracks: Dict[int, List[Dict]]):
+        """
+        Compute per-frame true positives / false positives / false negatives and average IoU.
+        Matching is performed with Hungarian algorithm (scipy). Matches with IoU < threshold are discarded.
+        """
+        tp = fp = fn = 0
+        total_iou = 0.0
+        iou_count = 0
+
+        frames = sorted(set(list(gt_tracks.keys()) + list(pred_tracks.keys())))
+        for f in frames:
+            gts = gt_tracks.get(f, [])
+            preds = pred_tracks.get(f, [])
+
+            if not gts and not preds:
+                continue
+            if not gts:
+                fp += len(preds)
+                continue
+            if not preds:
+                fn += len(gts)
+                continue
+
+            gt_boxes = np.array([g["bbox"] for g in gts])
+            pred_boxes = np.array([p["bbox"] for p in preds])
+
+            # get cost matrix from motmetrics (cost = 1 - IoU)
+            cost_mat = mm.distances.iou_matrix(gt_boxes, pred_boxes, max_iou=1.0)
+            # replace NaNs (if any) with a large cost so Hungarian will avoid them
+            cost_for_assignment = np.where(np.isnan(cost_mat), 1e6, cost_mat)
+
+            # Hungarian assignment (minimize cost -> maximize IoU)
+            row_idx, col_idx = linear_sum_assignment(cost_for_assignment)
+
+            matched_gt = set()
+            matched_pred = set()
+            for r, c in zip(row_idx, col_idx):
+                if r < cost_mat.shape[0] and c < cost_mat.shape[1]:
+                    # IoU = 1 - cost
+                    cost_val = cost_mat[r, c]
+                    if np.isnan(cost_val):
+                        continue
+                    iou_val = 1.0 - float(cost_val)
+                    if iou_val >= self.iou_threshold:
+                        matched_gt.add(r)
+                        matched_pred.add(c)
+                        total_iou += iou_val
+                        iou_count += 1
+
+            frame_tp = len(matched_gt)
+            frame_fp = len(preds) - len(matched_pred)
+            frame_fn = len(gts) - len(matched_gt)
+
+            tp += frame_tp
+            fp += frame_fp
+            fn += frame_fn
+
+        precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0.0
+        avg_iou = total_iou / iou_count if iou_count > 0 else 0.0
+
+        total_gt = sum(len(v) for v in gt_tracks.values())
+        total_pred = sum(len(v) for v in pred_tracks.values())
+
+        return {
+            "precision": precision,
+            "recall": recall,
+            "f1": f1,
+            "avg_iou": avg_iou,
+            "tp": tp,
+            "fp": fp,
+            "fn": fn,
+            "total_gt": total_gt,
+            "total_pred": total_pred,
+        }
+
+    def _compute_mot_metrics(self, gt_tracks: Dict[int, List[Dict]], pred_tracks: Dict[int, List[Dict]]):
+        """
+        Use motmetrics.MOTAccumulator to collect associations per frame and compute common MOT metrics.
+        Distance matrix is taken directly from motmetrics.distances.iou_matrix (which returns 1 - IoU).
+        Pairs with distance > (1 - iou_threshold) are set to infinity to exclude them from matching.
+        """
+        acc = mm.MOTAccumulator(auto_id=True)
+
+        frames = sorted(set(list(gt_tracks.keys()) + list(pred_tracks.keys())))
+        for f in frames:
+            gts = gt_tracks.get(f, [])
+            preds = pred_tracks.get(f, [])
+
+            gt_ids = [g["track_id"] for g in gts]
+            pred_ids = [p["track_id"] for p in preds]
+
+            if gts and preds:
+                gt_boxes = np.array([g["bbox"] for g in gts])
+                pred_boxes = np.array([p["bbox"] for p in preds])
+
+                # motmetrics provides a distance matrix (1 - IoU)
+                dist_mat = mm.distances.iou_matrix(gt_boxes, pred_boxes, max_iou=1.0)
+                # exclude pairs with IoU < threshold => distance > 1 - threshold
+                dist_mat = np.array(dist_mat, dtype=float)
+                dist_mat[np.isnan(dist_mat)] = np.inf
+                dist_mat[dist_mat > (1.0 - self.iou_threshold)] = np.inf
+            else:
+                dist_mat = np.full((len(gts), len(preds)), np.inf)
+
+            acc.update(gt_ids, pred_ids, dist_mat)
+
+        mh = mm.metrics.create()
+        summary = mh.compute(
+            acc,
+            metrics=[
+                "mota",
+                "motp",
+                "idf1",
+                "num_switches",
+                "num_fragmentations",
+                "num_misses",
+                "num_false_positives",
+            ],
+            name="eval",
+        )
+
+        def get_val(col: str, default=0.0):
+            if summary.empty or col not in summary.columns:
+                return float(default)
+            v = summary.iloc[0][col]
+            return float(v) if not np.isnan(v) else float(default)
+
+        return {
+            "mota": get_val("mota", 0.0),
+            "motp": get_val("motp", 0.0),
+            "idf1": get_val("idf1", 0.0),
+            "id_switches": int(get_val("num_switches", 0.0)),
+            "fragmentations": int(get_val("num_fragmentations", 0.0)),
+            "num_misses": int(get_val("num_misses", 0.0)),
+            "num_false_positives": int(get_val("num_false_positives", 0.0)),
+        }
+
+
+def evaluate(
+    gt_annotation: VideoAnnotation,
+    pred_annotation: VideoAnnotation,
+    iou_threshold: float = 0.5,
+) -> Dict[str, Union[float, int]]:
+    """
+    Evaluate tracking predictions against ground truth.
+
+    Args:
+        gt_annotation: Ground-truth annotation, an object of class supervisely VideoAnnotation containing reference object tracks.
+        pred_annotation: Predicted annotation, an object of class supervisely VideoAnnotation to be compared against the ground truth.
+        iou_threshold: Minimum Intersection-over-Union required for a detection to be considered a valid match.
+
+    Returns:
+        dict: json with evaluation metrics.
+    """
+    evaluator = TrackingEvaluator(iou_threshold=iou_threshold)
+    return evaluator.evaluate(gt_annotation, pred_annotation)

supervisely/nn/tracker/utils.py

@@ -0,0 +1,274 @@
+
+from typing import List, Union, Dict, Tuple
+from pathlib import Path
+from collections import defaultdict
+import numpy as np
+
+import supervisely as sly
+from supervisely.nn.model.prediction import Prediction
+from supervisely import VideoAnnotation
+from supervisely import logger
+
+
+def predictions_to_video_annotation(
+    predictions: List[Prediction],
+) -> VideoAnnotation:
+    """
+    Convert list of Prediction objects to VideoAnnotation.
+    
+    Args:
+        predictions: List of Prediction objects, one per frame
+        
+    Returns:
+        VideoAnnotation object with tracked objects
+
+    """
+    
+    if not predictions:
+        raise ValueError("Empty predictions list provided")
+    
+    frame_shape = predictions[0].annotation.img_size
+    img_h, img_w = frame_shape
+    video_objects = {}  
+    frames = []
+    
+    for pred in predictions:
+        frame_figures = []
+        frame_idx = pred.frame_index
+        
+        # Get data using public properties
+        boxes = pred.boxes          # Public property - np.array (N, 4) in tlbr format
+        classes = pred.classes      # Public property - list of class names
+        track_ids = pred.track_ids  # Public property - can be None
+        
+        # Skip frame if no detections
+        if len(boxes) == 0:
+            frames.append(sly.Frame(frame_idx, []))
+            continue
+        
+        for bbox, class_name, track_id in zip(boxes, classes, track_ids):
+            # Clip bbox to image boundaries
+            # Note: pred.boxes returns tlbr format (top, left, bottom, right)
+            top, left, bottom, right = bbox
+            dims = np.array([img_h, img_w, img_h, img_w]) - 1
+            top, left, bottom, right = np.clip([top, left, bottom, right], 0, dims)
+            
+            # Convert to integer coordinates
+            top, left, bottom, right = int(top), int(left), int(bottom), int(right)
+            
+            # Get or create VideoObject
+            if track_id not in video_objects:
+                # Find obj_class from prediction annotation
+                obj_class = None
+                for label in pred.annotation.labels:
+                    if label.obj_class.name == class_name:
+                        obj_class = label.obj_class
+                        break
+                
+                if obj_class is None:
+                    # Create obj_class if not found (fallback)
+                    obj_class = sly.ObjClass(class_name, sly.Rectangle)
+                    
+                video_objects[track_id] = sly.VideoObject(obj_class)
+            
+            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)))
+        
+        frames.append(sly.Frame(frame_idx, frame_figures))
+
+    objects = list(video_objects.values())
+    
+    return VideoAnnotation(
+        img_size=frame_shape,
+        frames_count=len(predictions),
+        objects=sly.VideoObjectCollection(objects),
+        frames=sly.FrameCollection(frames)
+    )
+    
+def video_annotation_to_mot(
+    annotation: VideoAnnotation,
+    output_path: Union[str, Path] = None,
+    class_to_id_mapping: Dict[str, int] = None
+) -> Union[str, List[str]]:
+    """
+    Convert Supervisely VideoAnnotation to MOT format.
+    MOT format: frame_id,track_id,left,top,width,height,confidence,class_id,visibility
+    """
+    mot_lines = []
+    
+    # Create default class mapping if not provided
+    if class_to_id_mapping is None:
+        unique_classes = set()
+        for frame in annotation.frames:
+            for figure in frame.figures:
+                unique_classes.add(figure.video_object.obj_class.name)
+        class_to_id_mapping = {cls_name: idx + 1 for idx, cls_name in enumerate(sorted(unique_classes))}
+    
+    # Extract tracks
+    for frame in annotation.frames:
+        frame_id = frame.index + 1  # MOT uses 1-based frame indexing
+        
+        for figure in frame.figures:
+            # Get track ID from VideoFigure.track_id (official API)
+            if figure.track_id is not None:
+                track_id = int(figure.track_id)
+            else:
+                track_id = figure.video_object.key().int
+            
+            # Get bounding box
+            if isinstance(figure.geometry, sly.Rectangle):
+                bbox = figure.geometry
+            else:
+                bbox = figure.geometry.to_bbox()
+            
+            left = bbox.left
+            top = bbox.top
+            width = bbox.width
+            height = bbox.height
+            
+            # Get class ID
+            class_name = figure.video_object.obj_class.name
+            class_id = class_to_id_mapping.get(class_name, 1)
+            
+            # Get confidence (default)
+            confidence = 1.0
+            
+            # Visibility (assume visible)
+            visibility = 1
+            
+            # Create MOT line
+            mot_line = f"{frame_id},{track_id},{left:.2f},{top:.2f},{width:.2f},{height:.2f},{confidence:.3f},{class_id},{visibility}"
+            mot_lines.append(mot_line)
+    
+    # Save to file if path provided
+    if output_path:
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with open(output_path, 'w') as f:
+            for line in mot_lines:
+                f.write(line + '\n')
+        
+        logger.info(f"Saved MOT format to: {output_path} ({len(mot_lines)} detections)")
+        return str(output_path)
+    
+    return mot_lines
+
+def mot_to_video_annotation(
+    mot_file_path: Union[str, Path],
+    img_size: Tuple[int, int] = (1080, 1920),
+    class_mapping: Dict[int, str] = None,
+    default_class_name: str = "person"
+) -> VideoAnnotation:
+    """
+    Convert MOT format tracking data to Supervisely VideoAnnotation.
+    MOT format: frame_id,track_id,left,top,width,height,confidence,class_id,visibility
+    """
+    mot_file_path = Path(mot_file_path)
+    
+    if not mot_file_path.exists():
+        raise FileNotFoundError(f"MOT file not found: {mot_file_path}")
+    
+    logger.info(f"Loading MOT data from: {mot_file_path}")
+    logger.info(f"Image size: {img_size} (height, width)")
+    
+    # Default class mapping
+    if class_mapping is None:
+        class_mapping = {1: default_class_name}
+    
+    # Parse MOT file
+    video_objects = {}  # track_id -> VideoObject
+    frames_data = defaultdict(list)  # frame_idx -> list of figures
+    max_frame_idx = 0
+    img_h, img_w = img_size
+    
+    with open(mot_file_path, 'r') as f:
+        for line_num, line in enumerate(f, 1):
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+                
+            try:
+                parts = line.split(',')
+                if len(parts) < 6:  # Minimum required fields
+                    continue
+                
+                frame_id = int(parts[0])
+                track_id = int(parts[1])
+                left = float(parts[2])
+                top = float(parts[3])
+                width = float(parts[4])
+                height = float(parts[5])
+                
+                # Optional fields
+                confidence = float(parts[6]) if len(parts) > 6 and parts[6] != '-1' else 1.0
+                class_id = int(parts[7]) if len(parts) > 7 and parts[7] != '-1' else 1
+                visibility = float(parts[8]) if len(parts) > 8 and parts[8] != '-1' else 1.0
+                
+                frame_idx = frame_id - 1  # Convert to 0-based indexing
+                max_frame_idx = max(max_frame_idx, frame_idx)
+                
+                # Skip low confidence detections
+                if confidence < 0.1:
+                    continue
+                
+                # Calculate coordinates with safer clipping
+                right = left + width
+                bottom = top + height
+                
+                # Clip to image boundaries
+                left = max(0, int(left))
+                top = max(0, int(top))
+                right = min(int(right), img_w - 1)
+                bottom = min(int(bottom), img_h - 1)
+                
+                # Skip invalid boxes
+                if right <= left or bottom <= top:
+                    continue
+                
+                # Get class name
+                class_name = class_mapping.get(class_id, default_class_name)
+                
+                # Create VideoObject if not exists
+                if track_id not in video_objects:
+                    obj_class = sly.ObjClass(class_name, sly.Rectangle)
+                    video_objects[track_id] = sly.VideoObject(obj_class)
+                
+                video_object = video_objects[track_id]
+                
+                # Create rectangle and figure with track_id
+                rect = sly.Rectangle(top=top, left=left, bottom=bottom, right=right)
+                figure = sly.VideoFigure(video_object, rect, frame_idx, track_id=str(track_id))
+                
+                frames_data[frame_idx].append(figure)
+                
+            except (ValueError, IndexError) as e:
+                logger.warning(f"Skipped invalid MOT line {line_num}: {line} - {e}")
+                continue
+    
+    # Create frames
+    frames = []
+    if frames_data:
+        frames_count = max(frames_data.keys()) + 1
+        
+        for frame_idx in range(frames_count):
+            figures = frames_data.get(frame_idx, [])
+            frames.append(sly.Frame(frame_idx, figures))
+    else:
+        frames_count = 1
+        frames = [sly.Frame(0, [])]
+    
+    # Create VideoAnnotation
+    objects = list(video_objects.values())
+    
+    annotation = VideoAnnotation(
+        img_size=img_size,
+        frames_count=frames_count,
+        objects=sly.VideoObjectCollection(objects),
+        frames=sly.FrameCollection(frames)
+    )
+    
+    logger.info(f"Created VideoAnnotation with {len(objects)} tracks and {frames_count} frames")
+    
+    return annotation

supervisely/nn/tracker/visualize.py

@@ -0,0 +1,519 @@
+from typing import Union, Dict, List, Tuple, Iterator, Optional
+import numpy as np
+import cv2
+import ffmpeg
+from pathlib import Path
+from collections import defaultdict
+from dataclasses import dataclass
+import tempfile
+import shutil
+
+import supervisely as sly
+from supervisely import logger
+from supervisely.nn.model.prediction import Prediction
+from supervisely import VideoAnnotation
+from supervisely.nn.tracker.utils import predictions_to_video_annotation
+
+
+class TrackingVisualizer:
+    def __init__(
+        self,
+        show_labels: bool = True,
+        show_classes: bool = True,
+        show_trajectories: bool = True,
+        show_frame_number: bool = False,
+        box_thickness: int = 2,
+        text_scale: float = 0.6,
+        text_thickness: int = 2,
+        trajectory_length: int = 30,
+        codec: str = "mp4",
+        output_fps: float = 30.0,
+        colorize_tracks: bool = True,
+
+    ):
+        """
+        Initialize the visualizer with configuration.
+
+        Args:
+            show_labels: Whether to show track IDs.
+            show_classes: Whether to show class names.
+            show_trajectories: Whether to draw trajectories.
+            show_frame_number: Whether to overlay frame number.
+            box_thickness: Thickness of bounding boxes.
+            text_scale: Scale of label text.
+            text_thickness: Thickness of label text.
+            trajectory_length: How many points to keep in trajectory.
+            codec: Output video codec.
+            output_fps: Output video framerate.
+            colorize_tracks (bool, default=True): if True, ignore colors from project meta and generate new colors for each tracked object; if False, try to use colors from project meta when possible.
+        """
+        # Visualization settings
+        self.show_labels = show_labels
+        self.show_classes = show_classes
+        self.show_trajectories = show_trajectories
+        self.show_frame_number = show_frame_number
+
+        # Style settings
+        self.box_thickness = box_thickness
+        self.text_scale = text_scale
+        self.text_thickness = text_thickness
+        self.trajectory_length = trajectory_length
+        self.colorize_tracks = colorize_tracks
+
+        # Output settings
+        self.codec = codec
+        self.output_fps = output_fps
+
+        # Internal state
+        self.annotation = None
+        self.tracks_by_frame = {}
+        self.track_centers = defaultdict(list)
+        self.track_colors = {}
+        self.color_palette = self._generate_color_palette()
+        self._temp_dir = None
+        
+    def _generate_color_palette(self, num_colors: int = 100) -> List[Tuple[int, int, int]]:
+        """
+        Generate bright, distinct color palette for track visualization.
+        Uses HSV space with random hue and fixed high saturation/value.
+        """
+        np.random.seed(42)
+        colors = []
+        for i in range(num_colors):
+            hue = np.random.randint(0, 180)
+            saturation = 200 + np.random.randint(55)
+            value = 200 + np.random.randint(55)
+
+            hsv_color = np.uint8([[[hue, saturation, value]]])
+            bgr_color = cv2.cvtColor(hsv_color, cv2.COLOR_HSV2BGR)[0][0]
+            colors.append(tuple(map(int, bgr_color)))
+        return colors
+    
+    def _get_track_color(self, track_id: int) -> Tuple[int, int, int]:
+        """Get consistent color for track ID from palette."""
+        return self.color_palette[track_id % len(self.color_palette)]
+    
+    def _get_video_info(self, video_path: Path) -> Tuple[int, int, float, int]:
+        """
+        Get video metadata using ffmpeg.
+        
+        Returns:
+            Tuple of (width, height, fps, total_frames)
+        """
+        try:
+            probe = ffmpeg.probe(str(video_path))
+            video_stream = next((stream for stream in probe['streams'] 
+                               if stream['codec_type'] == 'video'), None)
+            
+            if video_stream is None:
+                raise ValueError(f"No video stream found in: {video_path}")
+            
+            width = int(video_stream['width'])
+            height = int(video_stream['height'])
+            
+            # Extract FPS
+            fps_str = video_stream.get('r_frame_rate', '30/1')
+            if '/' in fps_str:
+                num, den = map(int, fps_str.split('/'))
+                fps = num / den if den != 0 else 30.0
+            else:
+                fps = float(fps_str)
+            
+            # Get total frames
+            total_frames = int(video_stream.get('nb_frames', 0))
+            if total_frames == 0:
+                # Fallback: estimate from duration and fps
+                duration = float(video_stream.get('duration', 0))
+                total_frames = int(duration * fps) if duration > 0 else 0
+            
+            return width, height, fps, total_frames
+            
+        except Exception as e:
+            raise ValueError(f"Could not read video metadata {video_path}: {str(e)}")
+    
+    def _create_frame_iterator(self, source: Union[str, Path]) -> Iterator[Tuple[int, np.ndarray]]:
+        """
+        Create iterator that yields (frame_index, frame) tuples.
+        
+        Args:
+            source: Path to video file or directory with frame images
+            
+        Yields:
+            Tuple of (frame_index, frame_array)
+        """
+        source = Path(source)
+        
+        if source.is_file():
+            yield from self._iterate_video_frames(source)
+        elif source.is_dir():
+            yield from self._iterate_directory_frames(source)
+        else:
+            raise ValueError(f"Source must be a video file or directory, got: {source}")
+    
+    def _iterate_video_frames(self, video_path: Path) -> Iterator[Tuple[int, np.ndarray]]:
+        """Iterate through video frames using ffmpeg."""
+        width, height, fps, total_frames = self._get_video_info(video_path)
+        
+        # Store video info for later use
+        self.source_fps = fps
+        self.frame_size = (width, height)
+        
+        process = (
+            ffmpeg
+            .input(str(video_path))
+            .output('pipe:', format='rawvideo', pix_fmt='bgr24')
+            .run_async(pipe_stdout=True, pipe_stderr=True)
+        )
+        
+        try:
+            frame_size_bytes = width * height * 3
+            frame_idx = 0
+            
+            while True:
+                frame_data = process.stdout.read(frame_size_bytes)
+                if len(frame_data) != frame_size_bytes:
+                    break
+                
+                frame = np.frombuffer(frame_data, np.uint8).reshape([height, width, 3])
+                yield frame_idx, frame
+                frame_idx += 1
+                
+        finally:
+            process.stdout.close()
+            if process.stderr:
+                process.stderr.close()
+            process.wait()
+    
+    def _iterate_directory_frames(self, frames_dir: Path) -> Iterator[Tuple[int, np.ndarray]]:
+        """Iterate through image frames in directory."""
+        if not frames_dir.is_dir():
+            raise ValueError(f"Directory does not exist: {frames_dir}")
+        
+        # Support common image extensions
+        extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff']
+        image_files = []
+        for ext in extensions:
+            image_files.extend(frames_dir.glob(f'*{ext}'))
+            image_files.extend(frames_dir.glob(f'*{ext.upper()}'))
+        
+        image_files = sorted(image_files)
+        if not image_files:
+            raise ValueError(f"No image files found in directory: {frames_dir}")
+        
+        # Set fps from config for image sequences
+        self.source_fps = self.output_fps
+        
+        for frame_idx, img_path in enumerate(image_files):
+            frame = cv2.imread(str(img_path))
+            if frame is not None:
+                if frame_idx == 0:
+                    h, w = frame.shape[:2]
+                    self.frame_size = (w, h)
+                yield frame_idx, frame
+            else:
+                logger.warning(f"Could not read image: {img_path}")
+    
+    def _extract_tracks_from_annotation(self) -> None:
+        """
+        Extract tracking data from Supervisely VideoAnnotation.
+        
+        Populates self.tracks_by_frame with frame-indexed tracking data.
+        """
+        self.tracks_by_frame = defaultdict(list)
+        self.track_colors = {}
+        
+        # Map object keys to track info
+        objects = {}
+        for i, obj in enumerate(self.annotation.objects):
+            objects[obj.key] = (i, obj.obj_class.name)
+        
+        # Extract tracks from frames
+        for frame in self.annotation.frames:
+            frame_idx = frame.index
+            for figure in frame.figures:
+                if figure.geometry.geometry_name() != 'rectangle':
+                    continue
+                    
+                object_key = figure.parent_object.key
+                if object_key not in objects:
+                    continue
+                    
+                track_id, class_name = objects[object_key]
+                
+                # Extract bbox coordinates
+                rect = figure.geometry
+                bbox = (rect.left, rect.top, rect.right, rect.bottom)
+                
+                if track_id not in self.track_colors:
+                    if self.colorize_tracks:
+                        # auto-color override everything
+                        color = self._get_track_color(track_id)
+                    else:
+                        # try to use annotation color
+                        color = figure.video_object.obj_class.color
+                        if color:
+                            # convert rgb → bgr
+                            color = color[::-1]
+                        else:
+                            # fallback to auto-color if annotation missing
+                            color = self._get_track_color(track_id)
+
+                    self.track_colors[track_id] = color
+
+                
+                self.tracks_by_frame[frame_idx].append((track_id, bbox, class_name))
+        
+        logger.info(f"Extracted tracks from {len(self.tracks_by_frame)} frames")
+        
+    def _draw_detection(self, img: np.ndarray, track_id: int, bbox: Tuple[int, int, int, int], 
+                    class_name: str) -> Optional[Tuple[int, int]]:
+        """
+        Draw single detection with track ID and class label.
+        Returns the center point of the bbox for trajectory drawing.
+        """
+        x1, y1, x2, y2 = map(int, bbox)
+
+        if x2 <= x1 or y2 <= y1:
+            return None
+        
+        color = self.track_colors[track_id]
+
+        # Draw bounding box
+        cv2.rectangle(img, (x1, y1), (x2, y2), color, self.box_thickness)
+
+        # Draw label if enabled
+        if self.show_labels:
+            label = f"ID:{track_id}"
+            if self.show_classes:
+                label += f" ({class_name})"
+
+            label_y = y1 - 10 if y1 > 30 else y2 + 25
+            (text_w, text_h), _ = cv2.getTextSize(
+                label, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness
+            )
+
+            cv2.rectangle(img, (x1, label_y - text_h - 5), 
+                        (x1 + text_w, label_y + 5), color, -1)
+            cv2.putText(img, label, (x1, label_y), 
+                    cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, 
+                    (255, 255, 255), self.text_thickness, cv2.LINE_AA)
+
+        # Return center point for trajectory
+        return (x1 + x2) // 2, (y1 + y2) // 2
+
+
+    def _draw_trajectories(self, img: np.ndarray) -> None:
+        """Draw trajectory lines for all tracks, filtering out big jumps."""
+        if not self.show_trajectories:
+            return
+
+        max_jump = 200  
+
+        for track_id, centers in self.track_centers.items():
+            if len(centers) < 2:
+                continue
+
+            color = self.track_colors[track_id]
+            points = centers[-self.trajectory_length:]
+
+            for i in range(1, len(points)):
+                p1, p2 = points[i - 1], points[i]
+                if p1 is None or p2 is None:
+                    continue
+              
+                if np.hypot(p2[0] - p1[0], p2[1] - p1[1]) > max_jump:
+                    continue
+                cv2.line(img, p1, p2, color, 2)
+                cv2.circle(img, p1, 3, color, -1)
+
+        
+    def _process_single_frame(self, frame: np.ndarray, frame_idx: int) -> np.ndarray:
+        """
+        Process single frame: add annotations and return processed frame.
+        
+        Args:
+            frame: Input frame
+            frame_idx: Frame index
+            
+        Returns:
+            Annotated frame
+        """
+        img = frame.copy()
+        active_ids = set()
+        # Draw detections for current frame
+        if frame_idx in self.tracks_by_frame:
+            for track_id, bbox, class_name in self.tracks_by_frame[frame_idx]:
+                center = self._draw_detection(img, track_id, bbox, class_name)
+                self.track_centers[track_id].append(center)
+                if len(self.track_centers[track_id]) > self.trajectory_length:
+                    self.track_centers[track_id].pop(0)
+                active_ids.add(track_id)
+        
+        for tid in self.track_centers.keys():
+            if tid not in active_ids:
+                self.track_centers[tid].append(None)
+                if len(self.track_centers[tid]) > self.trajectory_length:
+                    self.track_centers[tid].pop(0)
+                
+        # Draw trajectories
+        self._draw_trajectories(img)
+        
+        # Add frame number if requested
+        if self.show_frame_number:
+            cv2.putText(img, f"Frame: {frame_idx + 1}", (10, 30),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2, cv2.LINE_AA)
+        
+        return img
+    
+    def _save_processed_frame(self, frame: np.ndarray, frame_idx: int) -> str:
+        """
+        Save processed frame to temporary directory.
+        
+        Args:
+            frame: Processed frame
+            frame_idx: Frame index
+            
+        Returns:
+            Path to saved frame
+        """
+        frame_path = self._temp_dir / f"frame_{frame_idx:08d}.jpg"
+        cv2.imwrite(str(frame_path), frame, [cv2.IMWRITE_JPEG_QUALITY, 95])
+        return str(frame_path)
+    
+    def _create_video_from_frames(self, output_path: Union[str, Path]) -> None:
+        """
+        Create final video from processed frames using ffmpeg.
+        
+        Args:
+            output_path: Path for output video
+        """
+        output_path = Path(output_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Create video from frame sequence
+        input_pattern = str(self._temp_dir / "frame_%08d.jpg")
+        
+        try:
+            (
+                ffmpeg
+                .input(input_pattern, pattern_type='sequence', framerate=self.source_fps)
+                .output(str(output_path), vcodec='libx264', pix_fmt='yuv420p', crf=18)
+                .overwrite_output()
+                .run(capture_stdout=True, capture_stderr=True)
+            )
+            logger.info(f"Video saved to {output_path}")
+            
+        except ffmpeg.Error as e:
+            error_msg = e.stderr.decode() if e.stderr else "Unknown ffmpeg error"
+            raise ValueError(f"Failed to create video: {error_msg}")
+    
+    def _cleanup_temp_directory(self) -> None:
+        """Clean up temporary directory and all its contents."""
+        if self._temp_dir and self._temp_dir.exists():
+            shutil.rmtree(self._temp_dir)
+            self._temp_dir = None
+    
+    def visualize_video_annotation(self, annotation: VideoAnnotation, 
+                                  source: Union[str, Path], 
+                                  output_path: Union[str, Path]) -> None:
+        """
+        Visualize tracking annotations on video using streaming approach.
+        
+        Args:
+            annotation: Supervisely VideoAnnotation object with tracking data
+            source: Path to video file or directory containing frame images
+            output_path: Path for output video file
+            
+        Raises:
+            TypeError: If annotation is not VideoAnnotation
+            ValueError: If source is invalid or annotation is empty
+        """
+        if not isinstance(annotation, VideoAnnotation):
+            raise TypeError(f"Annotation must be VideoAnnotation, got {type(annotation)}")
+        
+        # Store annotation
+        self.annotation = annotation
+        
+        # Create temporary directory for processed frames
+        self._temp_dir = Path(tempfile.mkdtemp(prefix="video_viz_"))
+        
+        try:
+            # Extract tracking data
+            self._extract_tracks_from_annotation()
+            
+            if not self.tracks_by_frame:
+                logger.warning("No tracking data found in annotation")
+            
+            # Reset trajectory tracking
+            self.track_centers = defaultdict(list)
+            
+            # Process frames one by one
+            frame_count = 0
+            for frame_idx, frame in self._create_frame_iterator(source):
+                # Process frame
+                processed_frame = self._process_single_frame(frame, frame_idx)
+                
+                # Save processed frame
+                self._save_processed_frame(processed_frame, frame_idx)
+                
+                frame_count += 1
+                
+                # Progress logging
+                if frame_count % 100 == 0:
+                    logger.info(f"Processed {frame_count} frames")
+            
+            logger.info(f"Finished processing {frame_count} frames")
+            
+            # Create final video from saved frames
+            self._create_video_from_frames(output_path)
+            
+        finally:
+            # Always cleanup temporary files
+            self._cleanup_temp_directory()
+
+    def __del__(self):
+        """Cleanup temporary directory on object destruction."""
+        self._cleanup_temp_directory()
+        
+
+def visualize(
+    predictions: Union[VideoAnnotation, List[Prediction]], 
+    source: Union[str, Path], 
+    output_path: Union[str, Path],
+    show_labels: bool = True,
+    show_classes: bool = True,
+    show_trajectories: bool = True,
+    box_thickness: int = 2,
+    colorize_tracks: bool = True,
+    **kwargs
+) -> None:
+    """
+    Visualize tracking results from either VideoAnnotation or list of Prediction.
+
+    Args:
+        predictions (supervisely.VideoAnnotation | List[Prediction]): Tracking data to render; either a Supervisely VideoAnnotation or a list of Prediction objects.
+        source (str | Path): Path to an input video file or a directory of sequential frames (e.g., frame_000001.jpg).
+        output_path (str | Path): Path to the output video file to be created.
+        show_labels (bool, default=True): Draw per-object labels (track IDs).
+        show_classes (bool, default=True): Draw class names for each object.
+        show_trajectories (bool, default=True): Render object trajectories across frames.
+        box_thickness (int, default=2): Bounding-box line thickness in pixels.
+        colorize_tracks (bool, default=True): if True, ignore colors from project meta and generate new colors for each tracked object; if False, try to use colors from project meta when possible.    
+        """
+    visualizer = TrackingVisualizer(
+        show_labels=show_labels, 
+        show_classes=show_classes, 
+        show_trajectories=show_trajectories,
+        box_thickness=box_thickness,
+        colorize_tracks=colorize_tracks,
+        **kwargs
+    )
+
+    if isinstance(predictions, VideoAnnotation):
+        visualizer.visualize_video_annotation(predictions, source, output_path)
+    elif isinstance(predictions, list):
+        predictions = predictions_to_video_annotation(predictions)
+        visualizer.visualize_video_annotation(predictions, source, output_path)
+    else:
+        raise TypeError(f"Predictions must be VideoAnnotation or list of Prediction, got {type(predictions)}")
+

supervisely/template/experiment/experiment.html.jinja

@@ -174,6 +174,7 @@ can pass them in the terminal before running the script:
     model = api.nn.deploy(
         model="{{ experiment.paths.artifacts_dir.path }}/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}",
         device="cuda:0", # or "cpu"
+        workspace_id={{ experiment.project.workspace_id }}
     )
 
     # 3. Predict
@@ -247,7 +248,7 @@ model = api.nn.deploy(
 {% endtabs %}
 
 > For more information, see [Model
-API](https://docs.supervisely.com/neural-networks/overview-1/model-api){:target="_blank"}
+API](https://docs.supervisely.com/neural-networks/inference-and-deployment/model-api){:target="_blank"}
 documentation.
 
 ### Predict via API
@@ -315,55 +316,47 @@ predictions = model.predict(
 {% endtabs %}
 
 > For more information, see [Prediction
-API](https://docs.supervisely.com/neural-networks/overview-1/prediction-api){:target="_blank"}.
+API](https://docs.supervisely.com/neural-networks/inference-and-deployment/prediction-api){:target="_blank"}.
 
 {% if experiment.model.task_type == "object detection" %}
 
 ## Tracking Objects in Video
 
-You can track objects in video using `boxmot` library.
-[BoxMot](https://github.com/mikel-brostrom/boxmot){:target="_blank"} is a
-third-party library that implements lightweight neural networks for tracking-by-detection task (when the tracking is
-performed on the objects predicted by a separate detector). For `boxmot` models you can use even CPU device.
+Supervisely now supports **tracking-by-detection** out of the box. We leverage a lightweight tracking algorithm (such as [BoT-SORT](https://github.com/NirAharon/BoT-SORT){:target="_blank"}) which identifies the unique objects across video frames and assigns IDs to them. This allows us to connect separate detections from different frames into a single track for each object.
 
-First, install [BoxMot](https://github.com/mikel-brostrom/boxmot){:target="_blank"}:
-
-```bash
-pip install boxmot
-```
-
-Supervisely SDK has the `track()` method from `supervisely.nn.tracking` which allows you to apply `boxmot` models
-together with a detector in a single line of code. This method takes two arguments: a `boxmot` tracker, and a
-`PredictionSession` of a detector. It returns a `sly.VideoAnnotation` with the tracked objects.
+To apply tracking via API, first, deploy your detection model or connect to it, and then use the `predict()` method with `tracking=True` parameter. You can also specify tracking configuration parameters by passing `tracking_config={...}` with your custom settings.
 
 ```python
 import supervisely as sly
-from supervisely.nn.tracking import track
-import boxmot
-from pathlib import Path
-
-# Deploy a detector
-detector = api.nn.deploy(
-    model="{{ experiment.model.framework }}/{{ experiment.model.name }}",
-    device="cuda:0", # Use GPU for detection
-)
 
-# Load BoxMot tracker
-tracker = boxmot.BotSort(
-    reid_weights=Path('osnet_x0_25_msmt17.pt'),
-    device="cpu", # Use CPU for tracking
+api = sly.Api()
+
+# Deploy your model
+model = api.nn.deploy(
+    model="{{ experiment.paths.artifacts_dir.path }}/checkpoints/{{ experiment.training.checkpoints.pytorch.name }}",
+    device="cuda",
+    workspace_id={{ experiment.project.workspace_id }},
 )
 
-# Track objects in a single line
-video_ann: sly.VideoAnnotation = track(
-    video_id=42,
-    detector=detector,
-    tracker=tracker,
+# Apply tracking
+predictions = model.predict(
+    video_id=YOUR_VIDEO_ID,  # Video ID in Supervisely
+    tracking=True,
+    tracking_config={
+        "tracker": "botsort",  # botsort is a powerful tracking algorithm used by default
+        # You can pass other tracking parameters here, see the docs for details
+    }
 )
+
+# Processing results
+for pred in predictions:
+    frame_index = pred.frame_index
+    annotation = pred.annotation
+    track_ids = pred.track_ids
+    print(f"Frame {frame_index}: {len(track_ids)} tracks")
 ```
 
-> For more information, see the section [Tracking Objects in
-Video](https://docs.supervisely.com/neural-networks/overview-1/prediction-api#tracking-objects-in-video){:target="_blank"}.
+> You can also apply trackers in your own code or applications. Read more about this in the docs [Video Object Tracking](https://docs.supervisely.com/neural-networks/inference-and-deployment/video-object-tracking){:target="_blank"}.
 
 {% endif %}
 
@@ -409,7 +402,7 @@ docker image for the corresponding model's framework, and run the `docker run` c
     )
     ```
 
-See the [Model API](https://docs.supervisely.com/neural-networks/overview-1/model-api){:target="_blank"} documentation for more details on how to use the `ModelAPI` class.
+See the [Model API](https://docs.supervisely.com/neural-networks/inference-and-deployment/model-api){:target="_blank"} documentation for more details on how to use the `ModelAPI` class.
 
 Alternatively, you can use `docker run` with the `predict` action to make predictions in a single command. This is a
 quick way to start inference on your local images, videos, or directories without deploying the model. The container will be automatically stopped after the predictions are made.
@@ -427,7 +420,7 @@ docker run \
 ```
 
 > For more information, see [Deploy in Docker
-Container](https://docs.supervisely.com/neural-networks/overview-1/deploy_and_predict_with_supervisely_sdk#deploy-in-docker-container){:target="_blank"}
+Container](https://docs.supervisely.com/neural-networks/inference-and-deployment/deploy_and_predict_with_supervisely_sdk#deploy-in-docker-container){:target="_blank"}
 documentation.
 
 ## Deploy locally with Supervisely SDK
@@ -472,7 +465,7 @@ This approach helps you to quickly set up the environment and run inference with
     )
     ```
 
-> For more information, see [Local Deployment](https://docs.supervisely.com/neural-networks/overview-1/deploy_and_predict_with_supervisely_sdk){:target="_blank"} and [Prediction API](https://docs.supervisely.com/neural-networks/overview-1/prediction-api){:target="_blank"} documentations.
+> For more information, see [Local Deployment](https://docs.supervisely.com/neural-networks/inference-and-deployment/deploy_and_predict_with_supervisely_sdk){:target="_blank"} and [Prediction API](https://docs.supervisely.com/neural-networks/inference-and-deployment/prediction-api){:target="_blank"} documentations.
 
 {% if experiment.training.checkpoints.onnx.name or experiment.training.checkpoints.tensorrt.name %}
 ### Deploy ONNX/TensorRT

{supervisely-6.73.428.dist-info → supervisely-6.73.430.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.428
+Version: 6.73.430
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.428.dist-info → supervisely-6.73.430.dist-info}/RECORD

@@ -994,9 +994,12 @@ supervisely/nn/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 supervisely/nn/model/model_api.py,sha256=tSstGGdzm3cHc81P7IoM447sMVesUYJpspzMqUY70pg,10322
 supervisely/nn/model/prediction.py,sha256=5a-SLvxV3h6dp5KUs1ENZBY-rkWpddShjI8DBWQHhtU,11945
 supervisely/nn/model/prediction_session.py,sha256=W7DKIWvufCUQhIdk8q_fTsIOxW_DuZbkr1j_NVcT5gk,27386
-supervisely/nn/tracker/__init__.py,sha256=fTyXg-q_LuYx9sv6TueDDhxCfwQmDxUkIK4iLZgfBOk,283
+supervisely/nn/tracker/__init__.py,sha256=1Pv1zLedcZaTk1BS3ezscQbVizq7vQABlNbLhEhHkOI,326
 supervisely/nn/tracker/base_tracker.py,sha256=2d23JlHizOqVye324YT20EE8RP52uwoQUkPYvPXJTdw,1668
-supervisely/nn/tracker/botsort_tracker.py,sha256=jNtzhdUMoBYMvvreEV4bFQbYav97koiD4gLU5LvICr8,9817
+supervisely/nn/tracker/botsort_tracker.py,sha256=scQIessMnF9xaBFkAkSDnUfY0jYEftpod1nUxMisZXU,10141
+supervisely/nn/tracker/calculate_metrics.py,sha256=JjXI4VYWYSZ5j2Ed81FNYozkS3v2UAM73ztjLrHGg58,10434
+supervisely/nn/tracker/utils.py,sha256=UxGXcMfFgqh7y26oSk9MIeG_lOECn9kbytQWkiGVL2A,10046
+supervisely/nn/tracker/visualize.py,sha256=DY2cnRm4w6_e47xVuF9fwSnOP27ZWTRfv4MFPCyxsD4,20146
 supervisely/nn/tracker/botsort/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 supervisely/nn/tracker/botsort/botsort_config.yaml,sha256=q_7Gp1-15lGYOLv7JvxVJ69mm6hbCLbUAl_ZBOYNGpw,535
 supervisely/nn/tracker/botsort/osnet_reid/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -1007,7 +1010,7 @@ supervisely/nn/tracker/botsort/tracker/basetrack.py,sha256=oPcXpQWev6YmpjzqWwQKZ
 supervisely/nn/tracker/botsort/tracker/gmc.py,sha256=E6LkkVEYeBUjKaQ7VnYxMAj0fdDDWH8Es_tC1a0Z0rs,11754
 supervisely/nn/tracker/botsort/tracker/kalman_filter.py,sha256=waTArMcbmpHAzb57aJ-IcS1o5-i-TX5U-0N_M_28nlo,9671
 supervisely/nn/tracker/botsort/tracker/matching.py,sha256=bgnheHwWD3XZSI3OJVfdrU5bYJ44rxPHzzSElfg6LZM,6600
-supervisely/nn/tracker/botsort/tracker/mc_bot_sort.py,sha256=AE_yi4pVg_bIsK-6-ZlPziqb98tA-9iWgjT8aRE-8sA,17775
+supervisely/nn/tracker/botsort/tracker/mc_bot_sort.py,sha256=dFjWmubyJLrUP4i-CJaOhPEkQD-WD144deW7Ua5a7Rc,17775
 supervisely/nn/training/__init__.py,sha256=gY4PCykJ-42MWKsqb9kl-skemKa8yB6t_fb5kzqR66U,111
 supervisely/nn/training/train_app.py,sha256=DW9J6qZEebRFdq59sexvEZTWyExisbz7Z2lHXwEkPjY,131937
 supervisely/nn/training/gui/__init__.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
@@ -1075,7 +1078,7 @@ supervisely/template/base_generator.py,sha256=3nesbfRpueyRYljQSTnkMjeC8ERTOfjI88
 supervisely/template/extensions.py,sha256=kTYxu_LrvFyUN3HByCebGq8ra7zUygcEyw4qTUHq3M4,5255
 supervisely/template/template_renderer.py,sha256=SzGxRdbP59uxqcZT8kZbaHN2epK8Vjfh-0jKBpkdCBY,9709
 supervisely/template/experiment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-supervisely/template/experiment/experiment.html.jinja,sha256=ZTdlsPrSBdsOl7yfokJq0n1B2eBnFYUNZ85QvY5L-uM,18750
+supervisely/template/experiment/experiment.html.jinja,sha256=DiprWy6YAE1Gg7fBinZMxEpXSHCbJLbkTZLNKYTUhdw,19045
 supervisely/template/experiment/experiment_generator.py,sha256=b0zqP_dt3bvXxjZx6DxTog2-ih-Q7pj4w_5c70WEfjU,44924
 supervisely/template/experiment/header.html.jinja,sha256=sWGWeoYeixdLUOnQDjzrfGI8K6vL93dOt7fAgNWqkvY,13751
 supervisely/template/experiment/sidebar.html.jinja,sha256=4IxuJzcU1OT93mXMixE7EAMYfcn_lOVfCjS3VkEieSk,9323
@@ -1124,9 +1127,9 @@ supervisely/worker_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 supervisely/worker_proto/worker_api_pb2.py,sha256=VQfi5JRBHs2pFCK1snec3JECgGnua3Xjqw_-b3aFxuM,59142
 supervisely/worker_proto/worker_api_pb2_grpc.py,sha256=3BwQXOaP9qpdi0Dt9EKG--Lm8KGN0C5AgmUfRv77_Jk,28940
 supervisely_lib/__init__.py,sha256=7-3QnN8Zf0wj8NCr2oJmqoQWMKKPKTECvjH9pd2S5vY,159
-supervisely-6.73.428.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.428.dist-info/METADATA,sha256=GzysKJg4nHPCZiWzNZM2cXwAjNfMrlh2HmakZioubeg,35433
-supervisely-6.73.428.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-supervisely-6.73.428.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.428.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.428.dist-info/RECORD,,
+supervisely-6.73.430.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.430.dist-info/METADATA,sha256=WakARGRoin99pVVtAhIE5zrXuM6VygJ1MDezLxlD-hk,35433
+supervisely-6.73.430.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+supervisely-6.73.430.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.430.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.430.dist-info/RECORD,,