supervisely 6.73.273__py3-none-any.whl → 6.73.275__py3-none-any.whl

supervisely/convert/__init__.py

@@ -38,7 +38,7 @@ from supervisely.convert.pointcloud.las.las_converter import LasConverter
 from supervisely.convert.pointcloud.ply.ply_converter import PlyConverter
 from supervisely.convert.pointcloud.bag.bag_converter import BagConverter
 from supervisely.convert.pointcloud.lyft.lyft_converter import LyftConverter
-
+from supervisely.convert.pointcloud.nuscenes_conv.nuscenes_converter import NuscenesConverter
 
 # Pointcloud Episodes
 from supervisely.convert.pointcloud_episodes.sly.sly_pointcloud_episodes_converter import (
@@ -46,6 +46,9 @@ from supervisely.convert.pointcloud_episodes.sly.sly_pointcloud_episodes_convert
 )
 from supervisely.convert.pointcloud_episodes.bag.bag_converter import BagEpisodesConverter
 from supervisely.convert.pointcloud_episodes.lyft.lyft_converter import LyftEpisodesConverter
+from supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_converter import (
+    NuscenesEpisodesConverter,
+)
 
 # Video
 from supervisely.convert.video.mot.mot_converter import MOTConverter

supervisely/convert/base_converter.py

@@ -55,6 +55,7 @@ class AvailablePointcloudConverters:
     PLY = "ply"
     BAG = "rosbag"
     LYFT = "lyft"
+    NUSCENES = "nuscenes"
 
 
 class AvailablePointcloudEpisodesConverters:
@@ -301,23 +302,15 @@ class BaseConverter:
             return found_formats[0]
 
     def _collect_items_if_format_not_detected(self):
-        from supervisely.convert.pointcloud_episodes.pointcloud_episodes_converter import (
-            PointcloudEpisodeConverter,
-        )
-
         only_modality_items = True
         unsupported_exts = set()
         items = []
-        is_episode = isinstance(self, PointcloudEpisodeConverter)
         for root, _, files in os.walk(self._input_data):
             for file in files:
                 full_path = os.path.join(root, file)
                 ext = get_file_ext(full_path)
                 if ext.lower() in self.allowed_exts:  # pylint: disable=no-member
-                    if is_episode:
-                        items.append(self.Item(full_path, len(items)))  # pylint: disable=no-member
-                    else:
-                        items.append(self.Item(full_path))  # pylint: disable=no-member
+                    items.append(self.Item(full_path))  # pylint: disable=no-member
                     continue
                 only_modality_items = False
                 if ext.lower() in self.unsupported_exts:

supervisely/convert/pointcloud/nuscenes_conv/nuscenes_converter.py

@@ -0,0 +1,227 @@
+import os
+from typing import Dict, Optional
+
+import supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_helper as helpers
+import supervisely.io.fs as fs
+from supervisely import PointcloudAnnotation, PointcloudObject
+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.convert.base_converter import AvailablePointcloudConverters
+from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
+from supervisely.convert.pointcloud_episodes.nuscenes_conv.nuscenes_converter import (
+    NuscenesEpisodesConverter,
+)
+from supervisely.geometry.cuboid_3d import Cuboid3d
+from supervisely.pointcloud_annotation.pointcloud_figure import PointcloudFigure
+from supervisely.pointcloud_annotation.pointcloud_object_collection import (
+    PointcloudObjectCollection,
+)
+from supervisely.pointcloud_annotation.pointcloud_tag import PointcloudTag
+from supervisely.pointcloud_annotation.pointcloud_tag_collection import (
+    PointcloudTagCollection,
+)
+from supervisely.project.project_meta import ProjectMeta
+from supervisely.sly_logger import logger
+
+
+class NuscenesConverter(NuscenesEpisodesConverter, PointcloudConverter):
+    """Converter for NuScenes pointcloud format."""
+
+    def __init__(
+        self,
+        input_data: str,
+        labeling_interface: str,
+        upload_as_links: bool,
+        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
+
+    def to_supervisely(
+        self,
+        scene_sample,
+        meta: ProjectMeta,
+        renamed_classes: dict = {},
+        renamed_tags: dict = {},
+    ) -> PointcloudAnnotation:
+        bevbox_objs = [obj.convert_nuscenes_to_BEVBox3D() for obj in scene_sample.anns]
+        geoms = [obj.to_supervisely() for obj in scene_sample.anns]
+        attrs = [obj.attributes for obj in scene_sample.anns]
+
+        figures = []
+        objs = []
+        for label, geom, attributes in zip(bevbox_objs, geoms, attrs):
+            class_name = renamed_classes.get(label.label_class, label.label_class)
+            tag_col = None
+            if len(attributes) > 0 and all([tag_name is not None for tag_name in attributes]):
+                tag_meta_names = [renamed_tags.get(name, name) for name in attributes]
+                tag_metas = [meta.get_tag_meta(tag_meta_name) for tag_meta_name in tag_meta_names]
+                tag_col = PointcloudTagCollection([PointcloudTag(meta, None) for meta in tag_metas])
+            pcobj = PointcloudObject(meta.get_obj_class(class_name), tag_col)
+            figures.append(PointcloudFigure(pcobj, geom))
+            objs.append(pcobj)
+        return PointcloudAnnotation(PointcloudObjectCollection(objs), figures)
+
+    def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
+        nuscenes = self._nuscenes
+
+        tag_metas = [TagMeta(attr["name"], TagValueType.NONE) for attr in nuscenes.attribute]
+        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()
+            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_names = [scene["name"] for scene in nuscenes.scene]
+        scene_cnt = len(scene_names)
+        total_sample_cnt = sum([scene["nbr_samples"] for scene in nuscenes.scene])
+
+        multiple_scenes = len(scene_names) > 1
+        if multiple_scenes:
+            logger.info(f"Found {scene_cnt} scenes ({total_sample_cnt} samples) in the input data.")
+            # * Create a nested dataset for each scene
+            for name in scene_names:
+                ds = api.dataset.create(
+                    dataset_info.project_id,
+                    name,
+                    change_name_if_conflict=True,
+                    parent_id=dataset_id,
+                )
+                scene_name_to_dataset[name] = ds
+        else:
+            scene_name_to_dataset[scene_names[0]] = dataset_info
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(total_sample_cnt, "Converting pointclouds...")
+        else:
+            progress_cb = None
+
+        for scene in nuscenes.scene:
+            current_dataset_id = scene_name_to_dataset[scene["name"]].id
+
+            log = nuscenes.get("log", scene["log_token"])
+            sample_token = scene["first_sample_token"]
+
+            # * Extract scene's samples
+            scene_samples = []
+            for i in range(scene["nbr_samples"]):
+                sample = nuscenes.get("sample", sample_token)
+                lidar_path, boxes, _ = nuscenes.get_sample_data(sample["data"]["LIDAR_TOP"])
+                if not os.path.exists(lidar_path):
+                    logger.warning(f'Scene "{scene["name"]}" has no LIDAR data.')
+                    continue
+
+                timestamp = sample["timestamp"]
+                anns = []
+                for box, name, inst_token in helpers.Sample.generate_boxes(nuscenes, boxes):
+                    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 = [
+                        nuscenes.get("attribute", attr)["name"] for attr in ann["attribute_tokens"]
+                    ]
+                    visibility = nuscenes.get("visibility", ann["visibility_token"])["level"]
+
+                    anns.append(
+                        helpers.AnnotationObject(
+                            name,
+                            box,
+                            current_instance_token,
+                            parent_token,
+                            category,
+                            attributes,
+                            visibility,
+                        )
+                    )
+
+                # get camera data
+                sample_data = nuscenes.get("sample_data", sample["data"]["LIDAR_TOP"])
+                cal_sensor = nuscenes.get(
+                    "calibrated_sensor", sample_data["calibrated_sensor_token"]
+                )
+                ego_pose = nuscenes.get("ego_pose", sample_data["ego_pose_token"])
+
+                camera_data = [
+                    helpers.CamData(nuscenes, sensor, token, cal_sensor, ego_pose)
+                    for sensor, token in sample["data"].items()
+                    if sensor.startswith("CAM")
+                ]
+                scene_samples.append(helpers.Sample(timestamp, lidar_path, anns, camera_data))
+                sample_token = sample["next"]
+
+            # * Convert and upload pointclouds w/ annotations
+            for idx, sample in enumerate(scene_samples):
+                pcd_ann = self.to_supervisely(sample, meta, renamed_classes, renamed_tags)
+
+                pcd_path = sample.convert_lidar_to_supervisely()
+                pcd_name = fs.get_file_name(pcd_path)
+                pcd_meta = {
+                    "frame": idx,
+                    "vehicle": log["vehicle"],
+                    "date": log["date_captured"],
+                    "location": log["location"],
+                    "description": scene["description"],
+                }
+                info = api.pointcloud.upload_path(current_dataset_id, pcd_name, pcd_path, pcd_meta)
+                fs.silent_remove(pcd_path)
+
+                pcd_id = info.id
+                # * Upload pointcloud annotation
+                try:
+                    api.pointcloud.annotation.append(pcd_id, pcd_ann)
+                except Exception as e:
+                    error_msg = getattr(getattr(e, "response", e), "text", str(e))
+                    logger.warning(
+                        f"Failed to upload annotation for scene: {scene['name']}. Message: {error_msg}"
+                    )
+
+                # * Upload related images
+                image_jsons = []
+                camera_names = []
+                for img_path, rimage_info in [
+                    data.get_info(sample.timestamp) for data in sample.cam_data
+                ]:
+                    img = api.pointcloud.upload_related_image(img_path)
+                    image_jsons.append(
+                        {
+                            ApiField.ENTITY_ID: pcd_id,
+                            ApiField.NAME: rimage_info[ApiField.NAME],
+                            ApiField.HASH: img,
+                            ApiField.META: rimage_info[ApiField.META],
+                        }
+                    )
+                    camera_names.append(rimage_info[ApiField.META]["deviceId"])
+                if len(image_jsons) > 0:
+                    api.pointcloud.add_related_images(image_jsons, camera_names)
+
+                if log_progress:
+                    progress_cb(1)
+
+            logger.info(f"Dataset ID:{current_dataset_id} has been successfully uploaded.")
+
+        if log_progress:
+            if is_development():
+                progress.close()

supervisely/convert/pointcloud/pointcloud_converter.py

@@ -1,5 +1,8 @@
-from typing import Optional, Tuple
+import imghdr
+import os
+from typing import List, Optional, Set, Tuple
 
+import supervisely.convert.pointcloud.sly.sly_pointcloud_helper as helpers
 from supervisely import (
     Api,
     PointcloudAnnotation,
@@ -10,8 +13,10 @@ from supervisely import (
 )
 from supervisely.api.module_api import ApiField
 from supervisely.convert.base_converter import BaseConverter
+from supervisely.io.fs import get_file_ext, get_file_name
 from supervisely.io.json import load_json_file
 from supervisely.pointcloud.pointcloud import ALLOWED_POINTCLOUD_EXTENSIONS
+from supervisely.pointcloud.pointcloud import validate_ext as validate_pcd_ext
 
 
 class PointcloudConverter(BaseConverter):
@@ -134,3 +139,49 @@ class PointcloudConverter(BaseConverter):
             if is_development():
                 progress.close()
         logger.info(f"Dataset ID:{dataset_id} has been successfully uploaded.")
+
+    def _collect_items_if_format_not_detected(self) -> Tuple[List[Item], bool, Set[str]]:
+        only_modality_items = True
+        unsupported_exts = set()
+        pcd_list, rimg_dict, rimg_ann_dict = [], {}, {}
+        used_img_ext = set()
+        for root, _, files in os.walk(self._input_data):
+            for file in files:
+                full_path = os.path.join(root, file)
+                if file in ["key_id_map.json", "meta.json"]:
+                    continue
+
+                ext = get_file_ext(full_path)
+                if ext == ".json":
+                    dir_name = os.path.basename(root)
+                    parent_dir_name = os.path.basename(os.path.dirname(root))
+                    if any(
+                        p.replace("_", " ") in ["images", "related images", "photo context"]
+                        for p in [dir_name, parent_dir_name]
+                    ) or dir_name.endswith("_pcd"):
+                        rimg_ann_dict[file] = full_path
+                elif imghdr.what(full_path):
+                    rimg_dict[file] = full_path
+                    if ext not in used_img_ext:
+                        used_img_ext.add(ext)
+                elif ext.lower() in self.allowed_exts:
+                    try:
+                        validate_pcd_ext(ext)
+                        pcd_list.append(full_path)
+                    except:
+                        pass
+                else:
+                    only_modality_items = False
+                    unsupported_exts.add(ext)
+
+        # create Items
+        items = []
+        for pcd_path in pcd_list:
+            item = self.Item(pcd_path)
+            rimg, rimg_ann = helpers.find_related_items(
+                item.name, used_img_ext, rimg_dict, rimg_ann_dict
+            )
+            if rimg is not None and rimg_ann is not None:
+                item.set_related_images((rimg, rimg_ann))
+            items.append(item)
+        return items, only_modality_items, unsupported_exts

supervisely/convert/pointcloud/sly/sly_pointcloud_converter.py

@@ -6,7 +6,7 @@ import supervisely.convert.pointcloud.sly.sly_pointcloud_helper as helpers
 from supervisely import PointcloudAnnotation, ProjectMeta, logger
 from supervisely.convert.base_converter import AvailablePointcloudConverters
 from supervisely.convert.pointcloud.pointcloud_converter import PointcloudConverter
-from supervisely.io.fs import JUNK_FILES, get_file_ext, get_file_name
+from supervisely.io.fs import get_file_ext, get_file_name
 from supervisely.io.json import load_json_file
 from supervisely.pointcloud.pointcloud import validate_ext as validate_pcd_ext
 
@@ -46,7 +46,6 @@ class SLYPointcloudConverter(PointcloudConverter):
             return False
 
     def validate_format(self) -> bool:
-        detected_ann_cnt = 0
         pcd_list, ann_dict, rimg_dict, rimg_ann_dict = [], {}, {}, {}
         used_img_ext = []
         for root, _, files in os.walk(self._input_data):
@@ -60,9 +59,7 @@ class SLYPointcloudConverter(PointcloudConverter):
                         continue
 
                 ext = get_file_ext(full_path)
-                if file in JUNK_FILES:  # add better check
-                    continue
-                elif ext in self.ann_ext:
+                if ext in self.ann_ext:
                     dir_name = os.path.basename(root)
                     parent_dir_name = os.path.basename(os.path.dirname(root))
                     if any(
@@ -83,16 +80,11 @@ class SLYPointcloudConverter(PointcloudConverter):
                     except:
                         continue
 
-        if self._meta is not None:
-            meta = self._meta
-        else:
-            meta = ProjectMeta()
-
         # create Items
         self._items = []
+        sly_ann_detected = False
         for pcd_path in pcd_list:
             name_noext = get_file_name(pcd_path)
-            ann_or_rimg_detected = False
             item = self.Item(pcd_path)
             ann_name = f"{item.name}.json"
             if ann_name not in ann_dict:
@@ -100,23 +92,18 @@ class SLYPointcloudConverter(PointcloudConverter):
             if ann_name in ann_dict:
                 ann_path = ann_dict[ann_name]
                 if self._meta is None:
-                    meta = self.generate_meta_from_annotation(ann_path, meta)
-                is_valid = self.validate_ann_file(ann_path, meta)
+                    self._meta = self.generate_meta_from_annotation(ann_path, self._meta)
+                is_valid = self.validate_ann_file(ann_path, self._meta)
                 if is_valid:
                     item.ann_data = ann_path
-                    ann_or_rimg_detected = True
+                    sly_ann_detected = True
             rimg, rimg_ann = helpers.find_related_items(
                 item.name, used_img_ext, rimg_dict, rimg_ann_dict
             )
             if rimg is not None and rimg_ann is not None:
                 item.set_related_images((rimg, rimg_ann))
-                ann_or_rimg_detected = True
-
-            if ann_or_rimg_detected:
-                detected_ann_cnt += 1
             self._items.append(item)
-        self._meta = meta
-        return detected_ann_cnt > 0
+        return sly_ann_detected
 
     def to_supervisely(
         self,
@@ -140,5 +127,5 @@ class SLYPointcloudConverter(PointcloudConverter):
                 ann_json = helpers.rename_in_json(ann_json, renamed_classes, renamed_tags)
             return PointcloudAnnotation.from_json(ann_json, meta)
         except Exception as e:
-            logger.warn(f"Failed to convert annotation: {repr(e)}")
+            logger.warning(f"Failed to convert annotation: {repr(e)}")
             return item.create_empty_annotation()

supervisely/convert/pointcloud/sly/sly_pointcloud_helper.py

@@ -1,4 +1,4 @@
-from typing import Dict, List
+from typing import Dict, List, Union
 
 from supervisely import (
     AnyGeometry,
@@ -16,7 +16,9 @@ from supervisely.io.json import load_json_file
 SLY_ANN_KEYS = ["figures", "objects", "tags"]
 
 
-def get_meta_from_annotation(ann_path: str, meta: ProjectMeta) -> ProjectMeta:
+def get_meta_from_annotation(ann_path: str, meta: Union[ProjectMeta, None]) -> ProjectMeta:
+    if meta is None:
+        meta = ProjectMeta()
     ann_json = load_json_file(ann_path)
     if "annotation" in ann_json:
         ann_json = ann_json["annotation"]

supervisely/convert/pointcloud_episodes/lyft/lyft_converter.py

@@ -30,8 +30,6 @@ from supervisely import (
     PointcloudEpisodeFrame,
     TagMeta,
     TagValueType,
-    VideoTagCollection,
-    VideoTag,
 )
 from supervisely.io import fs
 from supervisely.convert.pointcloud.lyft import lyft_helper
@@ -40,6 +38,8 @@ from datetime import datetime
 from supervisely.geometry.cuboid_3d import Cuboid3d
 from collections import defaultdict
 
+# from supervisely.annotation.tag_meta import TagTargetType as TagTT
+
 
 class LyftEpisodesConverter(LyftConverter, PointcloudEpisodeConverter):
     """Converter for LYFT pointcloud episodes format."""
@@ -78,7 +78,7 @@ class LyftEpisodesConverter(LyftConverter, PointcloudEpisodeConverter):
         for scene_name, items in scene_name_to_items.items():
             token_to_obj = {}
             frames = []
-            tags = []  # todo tags that belong to the whole scene if any
+            tags = []  # todo tags that belong to the scene if any
             # * Iterate over each sample in the scene
             for i, item in enumerate(items):
                 ann = item.ann_data
@@ -93,23 +93,23 @@ class LyftEpisodesConverter(LyftConverter, PointcloudEpisodeConverter):
                         obj_class_name = renamed_classes.get(class_name, class_name)
                         obj_class = meta.get_obj_class(obj_class_name)
 
-                        # # * Get tags for the object
+                        # * Get tags for the object
                         # tag_names = [
-                        #     lyft.get("attribute", attr_token).get("name", None)
-                        #     for attr_token in instance_token["attribute_tokens"]
+                        # lyft.get("attribute", attr_token).get("name", None)
+                        # for attr_token in instance_token["attribute_tokens"]
                         # ]
                         # if len(tag_names) > 0 and all(
-                        #     [tag_name is not None for tag_name in tag_names]
+                        # [tag_name is not None for tag_name in tag_names]
                         # ):
-                        #     tags = [TagMeta(tag_name, TagValueType.NONE) for tag_name in tag_names]
-                        #     tag_meta_names = [renamed_tags.get(name, name) for name in tag_names]
-                        #     tag_metas = [
-                        #         meta.get_tag_meta(tag_meta_name) for tag_meta_name in tag_meta_names
-                        #     ]
-                        #     obj_tags = PointcloudEpisodeTagCollection(
-                        #         [PointcloudEpisodeTag(tag_meta, None) for tag_meta in tag_metas]
-                        #     )  # todo: implement after fixing
-                        obj_tags = None
+                        # tags = [TagMeta(tag_name, TagValueType.NONE) for tag_name in tag_names]
+                        # tag_meta_names = [renamed_tags.get(name, name) for name in tag_names]
+                        # tag_metas = [
+                        # meta.get_tag_meta(tag_meta_name) for tag_meta_name in tag_meta_names
+                        # ]
+                        # obj_tags = PointcloudEpisodeTagCollection(
+                        # [PointcloudEpisodeTag(tag_meta, None) for tag_meta in tag_metas]
+                        # )
+                        obj_tags = None  # todo remove after fixing tags
                         pcd_ep_obj = PointcloudEpisodeObject(obj_class, obj_tags)
                         # * Assign the object to the starting token
                         token_to_obj[instance_token["token"]] = pcd_ep_obj
@@ -137,9 +137,10 @@ class LyftEpisodesConverter(LyftConverter, PointcloudEpisodeConverter):
     def upload_dataset(self, api: Api, dataset_id: int, batch_size: int = 1, log_progress=True):
         unique_names = {name for item in self._items for name in item.ann_data["names"]}
         tag_names = {tag["name"] for tag in self._lyft.attribute}
+        target_type = None  # TagTT.GLOBAL # todo remove after fixing tags
         self._meta = ProjectMeta(
             [ObjClass(name, Cuboid3d) for name in unique_names],
-            [TagMeta(tag, TagValueType.NONE) for tag in tag_names],
+            [TagMeta(tag, TagValueType.NONE, target_type=target_type) for tag in tag_names],
         )
         meta, renamed_classes, renamed_tags = self.merge_metas_with_conflicts(api, dataset_id)
 
@@ -234,9 +235,7 @@ class LyftEpisodesConverter(LyftConverter, PointcloudEpisodeConverter):
                 )
             except Exception as e:
                 error_msg = getattr(getattr(e, "response", e), "text", str(e))
-                logger.warn(
-                    f"Failed to upload annotation for scene: {scene}. Message: {error_msg}"
-                )
+                logger.warn(f"Failed to upload annotation for scene: {scene}. Message: {error_msg}")
             logger.info(f"Dataset ID:{current_dataset_id} has been successfully uploaded.")
 
         if log_progress: