supervisely 6.73.427__py3-none-any.whl → 6.73.429__py3-none-any.whl

supervisely/convert/pointcloud_episodes/nuscenes_conv/nuscenes_converter.py

@@ -1,7 +1,7 @@
 import os
 from os import path as osp
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 import supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_helper as helpers
 import supervisely.io.fs as fs
@@ -9,6 +9,7 @@ from supervisely._utils import is_development
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.annotation.tag_meta import TagMeta, TagValueType
 from supervisely.api.api import Api, ApiField
+from supervisely.api.dataset_api import DatasetInfo
 from supervisely.convert.base_converter import AvailablePointcloudConverters
 from supervisely.convert.pointcloud_episodes.pointcloud_episodes_converter import (
     PointcloudEpisodeConverter,
@@ -49,7 +50,6 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
         remote_files_map: Optional[Dict[str, str]] = None,
     ):
         super().__init__(input_data, labeling_interface, upload_as_links, remote_files_map)
-        self._nuscenes = None
 
     def __str__(self) -> str:
         return AvailablePointcloudConverters.NUSCENES
@@ -83,8 +83,7 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
         version = osp.basename(ann_dir)
         try:
             t = TinyTimer()
-            nuscenes = NuScenes(version=version, dataroot=input_path, verbose=False)
-            self._nuscenes: NuScenes = nuscenes
+            self._nuscenes: NuScenes = NuScenes(version=version, dataroot=input_path, verbose=False)
             logger.debug(f"NuScenes initialization took {t.get_sec():.3f} sec")
         except Exception as e:
             logger.debug(f"Failed to initialize NuScenes: {e}")
@@ -94,7 +93,7 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
 
     def to_supervisely(
         self,
-        scene_samples,
+        scene_samples: List[helpers.Sample],
         meta: ProjectMeta,
         renamed_classes: dict = {},
         renamed_tags: dict = {},
@@ -142,23 +141,14 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
         obj_classes = []
         for category in nuscenes.category:
             color = nuscenes.colormap[category["name"]]
-            description = category["description"]
-            if len(description) > 255:
-                # * Trim description to fit into 255 characters limit
-                sentences = description.split(".")
-                trimmed_description = ""
-                for sentence in sentences:
-                    if len(trimmed_description) + len(sentence) + 1 > 255:
-                        break
-                    trimmed_description += sentence + "."
-                description = trimmed_description.strip()
+            description = helpers.trim_description(category.get("description", ""))
             obj_classes.append(ObjClass(category["name"], Cuboid3d, color, description=description))
 
         self._meta = ProjectMeta(obj_classes, tag_metas)
         meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
 
         dataset_info = api.dataset.get_info_by_id(dataset_id)
-        scene_name_to_dataset = {}
+        scene_name_to_dataset: Dict[str, DatasetInfo] = {}
 
         scene_names = [scene["name"] for scene in nuscenes.scene]
         scene_cnt = len(scene_names)
@@ -193,7 +183,7 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
             sample_token = scene["first_sample_token"]
 
             # * Extract scene's samples
-            scene_samples = []
+            scene_samples: List[helpers.Sample] = []
             for i in range(scene["nbr_samples"]):
                 sample = nuscenes.get("sample", sample_token)
                 lidar_path, boxes, _ = nuscenes.get_sample_data(sample["data"]["LIDAR_TOP"])
@@ -207,7 +197,6 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
                     current_instance_token = inst_token["token"]
                     parent_token = inst_token["prev"]
 
-                    # get category, attributes and visibility
                     ann = nuscenes.get("sample_annotation", current_instance_token)
                     category = ann["category_name"]
                     attributes = [
@@ -215,17 +204,16 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
                     ]
                     visibility = nuscenes.get("visibility", ann["visibility_token"])["level"]
 
-                    anns.append(
-                        helpers.AnnotationObject(
-                            name,
-                            box,
-                            current_instance_token,
-                            parent_token,
-                            category,
-                            attributes,
-                            visibility,
-                        )
+                    ann = helpers.AnnotationObject(
+                        name=name,
+                        bbox=box,
+                        instance_token=current_instance_token,
+                        parent_token=parent_token,
+                        category=category,
+                        attributes=attributes,
+                        visibility=visibility,
                     )
+                    anns.append(ann)
 
                 # get camera data
                 sample_data = nuscenes.get("sample_data", sample["data"]["LIDAR_TOP"])
@@ -247,7 +235,7 @@ class NuscenesEpisodesConverter(PointcloudEpisodeConverter):
             for idx, sample in enumerate(scene_samples):
                 pcd_path = sample.convert_lidar_to_supervisely()
 
-                pcd_name = fs.get_file_name(pcd_path)
+                pcd_name = fs.get_file_name_with_ext(pcd_path)
                 pcd_meta = {
                     "frame": idx,
                     "vehicle": log["vehicle"],

supervisely/convert/pointcloud_episodes/nuscenes_conv/nuscenes_helper.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from os import path as osp
 from pathlib import Path
-from typing import List
+from typing import Dict, Generator, List, Tuple
 
 import numpy as np
 
@@ -40,91 +40,36 @@ TABLE_NAMES = [
 ]
 
 
-class Sample:
-    """
-    A class to represent a sample from the NuScenes dataset.
-    """
-
-    def __init__(self, timestamp, lidar_path, anns, cam_data):
-        self.timestamp = datetime.utcfromtimestamp(timestamp / 1e6).isoformat()
-        self.lidar_path = lidar_path
-        self.anns = anns
-        self.cam_data = cam_data
-
-    @staticmethod
-    def generate_boxes(nuscenes, boxes):
-        """
-        Generate ground truth boxes for a given set of boxes.
-
-        Yields:
-            tuple: A tuple containing:
-                - gt_box (np.ndarray): A numpy array representing the ground truth box with concatenated location,
-                                       dimensions, and rotation.
-                - name (str): The name of the object.
-                - instance_token (str): The instance token associated with the box.
-        """
-        locs = np.array([b.center for b in boxes]).reshape(-1, 3)
-        dims = np.array([b.wlh for b in boxes]).reshape(-1, 3)
-        rots = np.array([b.orientation.yaw_pitch_roll[0] for b in boxes]).reshape(-1, 1)
-
-        gt_boxes = np.concatenate([locs, dims, -rots - np.pi / 2], axis=1)
-        names = np.array([b.name for b in boxes])
-        instance_tokens = [nuscenes.get("sample_annotation", box.token) for box in boxes]
-
-        yield from zip(gt_boxes, names, instance_tokens)
-
-    def convert_lidar_to_supervisely(self):
-        """
-        Converts a LiDAR point cloud file to the Supervisely format and saves it as a .pcd file.
-
-        Returns:
-            str: The file path of the saved .pcd file.
-        """
-        import open3d as o3d  # pylint: disable=import-error
-
-        bin_file = Path(self.lidar_path)
-        save_path = str(bin_file.with_suffix(".pcd"))
-
-        b = np.fromfile(bin_file, dtype=np.float32).reshape(-1, 5)
-        points = b[:, 0:3]
-        intensity = b[:, 3]
-        ring_index = b[:, 4]
-        intensity_fake_rgb = np.zeros((intensity.shape[0], 3))
-        intensity_fake_rgb[:, 0] = (
-            intensity  # red The intensity measures the reflectivity of the objects
-        )
-        intensity_fake_rgb[:, 1] = (
-            ring_index  # green ring index is the index of the laser ranging from 0 to 31
-        )
-        try:
-            pc = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(points))
-            pc.colors = o3d.utility.Vector3dVector(intensity_fake_rgb)
-            o3d.io.write_point_cloud(save_path, pc)
-        except Exception as e:
-            logger.warning(f"Error converting lidar to supervisely format: {e}")
-        return save_path
+def trim_description(description: str, max_length: int = 255) -> str:
+    if len(description) > max_length:
+        sentences = description.split(".")
+        trimmed_description = ""
+        for sentence in sentences:
+            if len(trimmed_description) + len(sentence) + 1 > max_length:
+                break
+            trimmed_description += sentence + "."
+        description = trimmed_description.strip()
+    return description
 
 
 class AnnotationObject:
     """
     A class to represent an annotation object in the NuScenes dataset.
 
-    Attributes:
-    -----------
-    name : str
-        The name of the annotation object.
-    bbox : np.ndarray
-        The bounding box coordinates.
-    instance_token : str
-        The instance token associated with the annotation object.
-    parent_token : str
-        The token of instance preceding the current object instance.
-    category : str
-        The class name of the annotation object.
-    attributes : List[str]
-        The attribute names associated with the annotation object.
-    visibility : str
-        The visibility level of the annotation object.
+    :param name: The name of the annotation object
+    :type name: str
+    :param bbox: The bounding box coordinates in NuScenes format
+    :type bbox: np.ndarray
+    :param instance_token: The instance token associated with the annotation object
+    :type instance_token: str
+    :param parent_token: The token of instance preceding the current object instance
+    :type parent_token: str
+    :param category: The class name of the annotation object
+    :type category: str
+    :param attributes: The attribute names associated with the annotation object
+    :type attributes: List[str]
+    :param visibility: The visibility level of the annotation object
+    :type visibility: str
     """
 
     def __init__(
@@ -146,7 +91,7 @@ class AnnotationObject:
         self.attributes = attributes
         self.visibility = visibility
 
-    def to_supervisely(self):
+    def to_supervisely(self) -> Cuboid3d:
         box = self.convert_nuscenes_to_BEVBox3D()
 
         bbox = box.to_xyzwhlr()
@@ -176,29 +121,33 @@ class AnnotationObject:
 
 class CamData:
     """
-    A class to represent camera data and perform transformations between different coordinate systems.
-
-    Attributes:
-    -----------
-    name : str
-        The name of the sensor.
-    path : str
-        The path to the image file.
-    imsize : tuple
-        The size of the image (width, height).
-    extrinsic : np.ndarray
-        The extrinsic matrix (4x4) representing the transformation from the lidar to the camera coordinate system.
-    intrinsic : np.ndarray
-        The intrinsic matrix (3x3) representing the camera's intrinsic parameters.
+    This class handles camera sensor data from the nuScenes dataset, including coordinate system
+    transformations from lidar to camera space and extraction of camera calibration parameters.
+
+    :param nuscenes: The nuScenes dataset instance
+    :type nuscenes: NuScenes
+    :param sensor_name: The name of the camera sensor
+    :type sensor_name: str
+    :param sensor_token: The token identifying the specific sensor sample
+    :type sensor_token: str
+    :param cs_record: The calibrated sensor record for the lidar
+    :type cs_record: dict
+    :param ego_record: The ego pose record for the lidar
+    :type ego_record: dict
     """
 
-    def __init__(self, nuscenes, sensor_name, sensor_token, cs_record, ego_record):
+    def __init__(
+        self, nuscenes, sensor_name: str, sensor_token: str, cs_record: dict, ego_record: dict
+    ):
+        from nuscenes import NuScenes  # pylint: disable=import-error
         from nuscenes.utils.data_classes import (  # pylint: disable=import-error
             transform_matrix,
         )
         from pyquaternion import Quaternion  # pylint: disable=import-error
 
-        img_path, boxes, cam_intrinsic = nuscenes.get_sample_data(sensor_token)
+        nuscenes: NuScenes = nuscenes
+
+        img_path, _, _ = nuscenes.get_sample_data(sensor_token)
         if not osp.exists(img_path):
             return None
 
@@ -237,15 +186,14 @@ class CamData:
         self.extrinsic = np.hstack((velo_to_cam_rot, velo_to_cam_trans.reshape(3, 1)))
         self.intrinsic = np.asarray(cs_record_cam["camera_intrinsic"])
 
-    def get_info(self, timestamp):
+    def get_info(self, timestamp: str) -> Tuple[str, Dict]:
         """
-        Retrieves information about the image and its metadata.
+        Generates image info based on the camera data.
 
-        Args:
-            timestamp (int): The timestamp associated with the image.
-
-        Returns:
-            tuple: A tuple containing the image path and a dictionary with image metadata.
+        :param timestamp: The timestamp associated with the image
+        :type timestamp: str
+        :return: A tuple containing the image path and a dictionary with image metadata.
+        :rtype: tuple
         """
         sensors_to_skip = ["_intrinsic", "_extrinsic", "_imsize"]
         if not any([self.name.endswith(s) for s in sensors_to_skip]):
@@ -263,3 +211,94 @@ class CamData:
                 },
             }
             return (sly_path_img, img_info)
+
+
+class Sample:
+    """
+    A class to represent a sample from the NuScenes dataset.
+    """
+
+    def __init__(
+        self,
+        timestamp: float,
+        lidar_path: str,
+        anns: List[AnnotationObject],
+        cam_data: List[CamData],
+    ):
+        self._timestamp = datetime.utcfromtimestamp(timestamp / 1e6).isoformat()
+        self._lidar_path = lidar_path
+        self._anns = anns
+        self._cam_data = cam_data
+
+    @property
+    def timestamp(self) -> str:
+        return self._timestamp
+
+    @property
+    def lidar_path(self) -> str:
+        return self._lidar_path
+
+    @property
+    def anns(self) -> List[AnnotationObject]:
+        return self._anns
+
+    @property
+    def cam_data(self) -> List[CamData]:
+        return self._cam_data
+
+    @staticmethod
+    def generate_boxes(nuscenes, boxes: List) -> Generator:
+        """
+        Generate ground truth boxes for a given set of boxes.
+
+        :param nuscenes: The nuScenes dataset instance
+        :type nuscenes: NuScenes
+        :param boxes: A list of boxes to generate ground truth for
+        :type boxes: List
+        :return: A generator that yields tuples containing the ground truth box, name, and instance token.
+        :rtype: generator
+        """
+        from nuscenes.utils.data_classes import Box  # pylint: disable=import-error
+
+        boxes: List[Box] = boxes
+
+        locs = np.array([b.center for b in boxes]).reshape(-1, 3)
+        dims = np.array([b.wlh for b in boxes]).reshape(-1, 3)
+        rots = np.array([b.orientation.yaw_pitch_roll[0] for b in boxes]).reshape(-1, 1)
+
+        gt_boxes = np.concatenate([locs, dims, -rots - np.pi / 2], axis=1)
+        names = np.array([b.name for b in boxes])
+        instance_tokens = [nuscenes.get("sample_annotation", box.token) for box in boxes]
+
+        yield from zip(gt_boxes, names, instance_tokens)
+
+    def convert_lidar_to_supervisely(self) -> str:
+        """
+        Converts a LiDAR point cloud file to the Supervisely format and saves it as a .pcd file.
+
+        :return: The file path of the saved .pcd file.
+        :rtype: str
+        """
+        import open3d as o3d  # pylint: disable=import-error
+
+        bin_file = Path(self.lidar_path)
+        save_path = str(bin_file.with_suffix(".pcd"))
+
+        b = np.fromfile(bin_file, dtype=np.float32).reshape(-1, 5)
+        points = b[:, 0:3]
+        intensity = b[:, 3]
+        ring_index = b[:, 4]
+        intensity_fake_rgb = np.zeros((intensity.shape[0], 3))
+        intensity_fake_rgb[:, 0] = (
+            intensity  # red The intensity measures the reflectivity of the objects
+        )
+        intensity_fake_rgb[:, 1] = (
+            ring_index  # green ring index is the index of the laser ranging from 0 to 31
+        )
+        try:
+            pc = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(points))
+            pc.colors = o3d.utility.Vector3dVector(intensity_fake_rgb)
+            o3d.io.write_point_cloud(save_path, pc)
+        except Exception as e:
+            logger.warning(f"Error converting lidar to supervisely format: {e}")
+        return save_path

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