supervisely 6.73.377__py3-none-any.whl → 6.73.379__py3-none-any.whl

supervisely/__init__.py

@@ -314,4 +314,4 @@ except Exception as e:
 # If new changes in Supervisely Python SDK require upgrade of the Supervisely instance
 # set a new value for the environment variable MINIMUM_INSTANCE_VERSION_FOR_SDK, otherwise
 # users can face compatibility issues, if the instance version is lower than the SDK version.
-os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.12.44"
+os.environ["MINIMUM_INSTANCE_VERSION_FOR_SDK"] = "6.13.00"

supervisely/api/entity_annotation/tag_api.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-from typing import List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 from supervisely._utils import batched
 from supervisely.api.module_api import ApiField, ModuleApi
@@ -210,11 +210,13 @@ class TagApi(ModuleApi):
             raise RuntimeError("SDK error: len(tags_keys) != len(tags_to_add)")
         if len(tags_keys) == 0:
             return
-        ids = self.append_to_objects_json(entity_id, tags_to_add)
+        ids = self.append_to_objects_json(entity_id, tags_to_add, project_id)
         KeyIdMap.add_tags_to(key_id_map, tags_keys, ids)
         return ids
 
-    def append_to_objects_json(self, entity_id: int, tags_json: dict) -> list:
+    def append_to_objects_json(
+        self, entity_id: int, tags_json: List[Dict], project_id: Optional[int] = None
+    ) -> List[int]:
         """
         Add Tags to Annotation Objects for specific entity (image etc.).
 
@@ -224,14 +226,50 @@ class TagApi(ModuleApi):
         :type tags_json: dict
         :return: List of tags IDs
         :rtype: list
+
+        :Usage example:
+
+             .. code-block:: python
+
+                import supervisely as sly
+
+                api = sly.Api(server_address, token)
+
+                tags_list = [
+                    {
+                        "tagId": 25926,
+                        "objectId": 652959,
+                        "value": None
+                    },
+                    {
+                        "tagId": 25927,
+                        "objectId": 652959,
+                        "value": "v1"
+                    },
+                    {
+                        "tagId": 25927,
+                        "objectId": 652958,
+                        "value": "v2"
+                    }
+                ]
+                response = api.video.tag.append_to_objects_json(12345, tags_list)
+
+                print(response)
+                # Output:
+                #    [
+                #        80421101,
+                #        80421102,
+                #        80421103
+                #    ]
         """
 
         if len(tags_json) == 0:
             return []
-        response = self._api.post(
-            "annotation-objects.tags.bulk.add",
-            {ApiField.ENTITY_ID: entity_id, ApiField.TAGS: tags_json},
-        )
+        if project_id is not None:
+            json_data = {ApiField.PROJECT_ID: project_id, ApiField.TAGS: tags_json}
+        else:
+            json_data = {ApiField.ENTITY_ID: entity_id, ApiField.TAGS: tags_json}
+        response = self._api.post("annotation-objects.tags.bulk.add", json_data)
         ids = [obj[ApiField.ID] for obj in response.json()]
         return ids
 
@@ -242,11 +280,21 @@ class TagApi(ModuleApi):
         batch_size: int = 100,
         log_progress: bool = False,
         progress: Optional[tqdm_sly] = None,
-    ) -> List[dict]:
+    ) -> List[Dict[str, Union[str, int, None]]]:
         """
-        Add Tags to existing Annotation Figures.
-        All figures must belong to entities of the same project.
-        Applies only to images project.
+        For images project:
+            Add Tags to existing Annotation Figures (labels).
+            The `tags_list` example:
+                [{"tagId": 12345, "figureId": 54321, "value": "tag_value"}, ...].
+        For video, pointcloud, volume and pointcloud episodes projects:
+            Add Tags to existing Annotation Objects.
+            The `frameRange` field is optional and is supported only for video and pointcloud episodes projects.
+            The `tags_list`` example:
+                [{"tagId": 12345, "objectId": 54321, "value": "tag_value"}, ...].
+            or with frameRange:
+                [{"tagId": 12345, "objectId": 54321, "value": "tag_value", "frameRange": [1, 10]}, ...].
+
+        All objects must belong to entities of the same project.
 
         :param project_id: Project ID in Supervisely.
         :type project_id: int
@@ -259,7 +307,7 @@ class TagApi(ModuleApi):
         :param progress: Progress bar object to display progress.
         :type progress: Optional[tqdm_sly]
         :return: List of tags infos as dictionaries.
-        :rtype: List[dict]
+        :rtype: List[Dict[str, Union[str, int, None]]]
 
         Usage example:
         .. code-block:: python
@@ -272,7 +320,8 @@ class TagApi(ModuleApi):
                 {
                     "tagId": 25926,
                     "figureId": 652959,
-                    "value": None # value is optional for tag with type 'None'
+                    "value": None # optional for tag with type 'None'
+                    "frameRange": [1, 10] # optional (supported only for video and pointcloud episodes projects)
                 },
                 {
                     "tagId": 25927,
@@ -282,7 +331,7 @@ class TagApi(ModuleApi):
                 {
                     "tagId": 25927,
                     "figureId": 652958,
-                    "value": "v2"
+                    "value": "v2",
                 }
             ]
             response = api.image.tag.add_to_figures(12345, tag_list)
@@ -310,16 +359,14 @@ class TagApi(ModuleApi):
             #        }
             #    ]
         """
-        if type(self) is not TagApi:
-            raise NotImplementedError("This method is not available for classes except TagApi")
-
-        if len(tags_list) == 0:
-            return []
 
         if progress is not None:
             log_progress = False
 
         result = []
+
+        if len(tags_list) == 0:
+            return result
         if log_progress:
             progress = tqdm_sly(
                 desc="Adding tags to figures",
@@ -327,8 +374,164 @@ class TagApi(ModuleApi):
             )
         for batch in batched(tags_list, batch_size):
             data = {ApiField.PROJECT_ID: project_id, ApiField.TAGS: batch}
-            response = self._api.post("figures.tags.bulk.add", data)
+            if type(self) is TagApi:
+                response = self._api.post("figures.tags.bulk.add", data)
+            else:
+                response = self._api.post("annotation-objects.tags.bulk.add", data)
             result.extend(response.json())
             if progress is not None:
                 progress.update(len(batch))
         return result
+
+    def add_to_entities_json(
+        self,
+        project_id: int,
+        tags_list: List[Dict[str, Union[str, int, None]]],
+        batch_size: int = 100,
+        log_progress: bool = False,
+    ) -> List[int]:
+        """
+        Bulk add tags to entities (images, videos, pointclouds, volumes) in a project.
+        Not supported for pointcloud episodes projects.
+        All entities must belong to the same project.
+        The `frameRange` field in a tag object within the tags list is optional and is supported only for video projects.
+
+        The `tags_list` example:
+            [{"tagId": 12345, "entityId": 54321, "value": "tag_value"}, ...].
+        or with frameRange:
+            [{"tagId": 12345, "entityId": 54321, "value": "tag_value", "frameRange": [1, 10]}, ...].
+
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int
+        :param tags_list: List of tag object infos as dictionaries
+                          (e.g. {"tagId": 12345, "entityId": 54321, "value": "tag_value"}).
+        :param batch_size: Number of tags to add in one request.
+        :type batch_size: int
+        :param log_progress: If True, will display a progress bar.
+        :type log_progress: bool
+        :return: List of tags IDs.
+        :rtype: List[int]
+
+        Usage example:
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api(server_address, token)
+
+            tag_list = [
+                {
+                    "tagId": 25926,
+                    "entityId": 652959,
+                    "value": None # optional for tag with type 'None'
+                    "frameRange": [1, 10] # optional (supported only for video projects)
+                },
+                {
+                    "tagId": 25927,
+                    "entityId": 652959,
+                    "value": "v1"
+                },
+                {
+                    "tagId": 25927,
+                    "entityId": 652958,
+                    "value": "v2"
+                }
+            ]
+            api.image.tag.add_to_entities_json(project_id=12345, tag_list=tag_list)
+        """
+
+        result = []
+
+        if len(tags_list) == 0:
+            return result
+
+        if log_progress:
+            ds_progress = tqdm_sly(desc="Adding tags to entities", total=len(tags_list))
+
+        for batch in batched(tags_list, batch_size):
+            data = {ApiField.PROJECT_ID: project_id, ApiField.TAGS: batch}
+            response = self._api.post("tags.entities.bulk.add", data)
+            result.extend([obj[ApiField.ID] for obj in response.json()])
+            if log_progress:
+                ds_progress.update(len(batch))
+
+        return result
+
+    def add_tags_collection_to_objects(
+        self,
+        project_id: int,
+        tags_map: Dict[int, Any],
+        batch_size: int = 100,
+        log_progress: bool = False,
+    ) -> List[Dict[str, Union[str, int, None]]]:
+        """
+        For images project:
+            Add Tags to existing Annotation Figures (labels).
+            The `tags_map` example: {figure_id_1: TagCollection, ...}.
+        For video, pointcloud, volume and pointcloud episodes projects:
+            Add Tags to existing Annotation Objects.
+            The `frameRange` field is optional and is supported only for video and pointcloud episodes projects.
+            The `tags_map` example: {object_id_1: TagCollection, ...}.
+
+        All objects must belong to entities of the same project.
+
+        :param project_id: Project ID in Supervisely.
+        :type project_id: int
+        :param tags_map: Dictionary with mapping figure/object ID to tags collection.
+        :type tags_map: Dict[int, Any]
+        :param batch_size: Number of tags to add in one request.
+        :type batch_size: int
+        :param log_progress: If True, will display a progress bar.
+        :type log_progress: bool
+        :return: List of tags infos as dictionaries.
+        :rtype: List[Dit[str, Union[str, int, None]]]
+
+        Usage example:
+        .. code-block:: python
+
+            import supervisely as sly
+
+            api = sly.Api(server_address, token)
+
+            project_id = 12345
+
+            tag_meta = sly.TagMeta("tag_name", sly.TagValueType.ANY_STRING)
+            meta = sly.ProjectMeta(tag_metas=[tag_meta])
+            meta = sly.ProjectMeta.from_json(api.project.update_meta(project_id, meta))
+            tag_meta = meta.get_tag_meta("tag_name")
+
+            # for images project:
+            tag_map = {
+                652959: sly.TagCollection([sly.Tag(tag_meta, value="v1"), sly.Tag(tag_meta, value="v2"), ...]),
+                652958: sly.TagCollection([sly.Tag(tag_meta, value="v3"), sly.Tag(tag_meta, value="v4"), ...]),
+                ...
+            }
+            api.image.tag.add_tags_to_objects(project_id, tag_map)
+
+            # for videos projects (frameRange is optional):
+            tag_map = {
+                652959: sly.VideoTagCollection([sly.VideoTag(tag_meta, value="v1", frameRange=[1, 10]), ...]),
+                652958: sly.VideoTagCollection([sly.VideoTag(tag_meta, value="v2", frameRange=[4, 12]), ...]),
+                ...
+            }
+            api.video.tag.add_to_objects_json_batch(project_id, tag_map)
+        """
+
+        OBJ_ID_FIELD = ApiField.FIGURE_ID if type(self) is TagApi else ApiField.OBJECT_ID
+
+        data = []
+        for obj_id, tags in tags_map.items():
+            for tag in tags:
+
+                if tag.meta.sly_id is None:
+                    raise ValueError(f"Tag {tag.name} meta has no sly_id")
+
+                data.append(
+                    {
+                        ApiField.TAG_ID: tag.meta.sly_id,
+                        OBJ_ID_FIELD: obj_id,
+                        **tag.to_json()
+                    }
+                )
+
+        return self.add_to_objects(project_id, data, batch_size, log_progress)

supervisely/api/image_api.py

@@ -3601,7 +3601,87 @@ class ImageApi(RemoveableBulkModuleApi):
             if progress_cb is not None:
                 progress_cb(len(batch_ids))
 
-    def update_tag_value(self, tag_id: int, value: Union[str, float]) -> Dict:
+    def add_tags_batch(
+        self,
+        image_ids: List[int],
+        tag_ids: Union[int, List[int]],
+        values: Optional[Union[str, int, List[Union[str, int, None]]]] = None,
+        log_progress: bool = False,
+        batch_size: Optional[int] = 100,
+        tag_metas: Optional[Union[TagMeta, List[TagMeta]]] = None,
+    ) -> List[int]:
+        """
+        Add tag with given ID to Images by IDs with different values.
+
+        :param image_ids: List of Images IDs in Supervisely.
+        :type image_ids: List[int]
+        :param tag_ids: Tag IDs in Supervisely.
+        :type tag_ids: int or List[int]
+        :param values: List of tag values for each image or single value for all images.
+        :type values: List[str] or List[int] or str or int, optional
+        :param log_progress: If True, will log progress.
+        :type log_progress: bool, optional
+        :param batch_size: Batch size
+        :type batch_size: int, optional
+        :param tag_metas: Tag Metas. Needed for values validation, omit to skip validation
+        :type tag_metas: TagMeta or List[TagMeta], optional
+        :return: List of tags IDs.
+        :rtype: List[int]
+        :Usage example:
+
+         .. code-block:: python
+
+            import supervisely as sly
+
+            os.environ['SERVER_ADDRESS'] = 'https://app.supervisely.com'
+            os.environ['API_TOKEN'] = 'Your Supervisely API Token'
+            api = sly.Api.from_env()
+            image_ids = [2389126, 2389127]
+            tag_ids = 277083
+            values = ['value1', 'value2']
+            api.image.add_tags_batch(image_ids, tag_ids, values)
+        """
+        if len(image_ids) == 0:
+            return []
+
+        if isinstance(tag_ids, int):
+            tag_ids = [tag_ids] * len(image_ids)
+
+        if isinstance(tag_metas, TagMeta):
+            tag_metas = [tag_metas] * len(image_ids)
+
+        if values is None:
+            values = [None] * len(image_ids)
+        elif isinstance(values, (str, int)):
+            values = [values] * len(image_ids)
+
+        if len(values) != len(image_ids):
+            raise ValueError("Length of image_ids and values should be the same")
+
+        if len(tag_ids) != len(image_ids):
+            raise ValueError("Length of image_ids and tag_ids should be the same")
+
+        if tag_metas and len(tag_metas) != len(image_ids):
+            raise ValueError("Length of image_ids and tag_metas should be the same")
+
+        if tag_metas:
+            for tag_meta, tag_id, value in zip(tag_metas, tag_ids, values):
+                if not (tag_meta.sly_id == tag_id):
+                    raise ValueError(f"{tag_meta.name = } and {tag_id = } should be same")
+                if not tag_meta.is_valid_value(value):
+                    raise ValueError(f"{tag_meta.name = } can not have value {value = }")
+
+        project_id = self.get_project_id(image_ids[0])
+        data = [
+            {ApiField.ENTITY_ID: image_id, ApiField.TAG_ID: tag_id, ApiField.VALUE: value}
+            for image_id, tag_id, value in zip(image_ids, tag_ids, values)
+        ]
+
+        return self.tag.add_to_entities_json(project_id, data, batch_size, log_progress)
+
+    def update_tag_value(
+        self, tag_id: int, value: Union[str, float]
+    ) -> Dict:
         """
         Update tag value with given ID.
 

supervisely/api/pointcloud/pointcloud_api.py

@@ -421,6 +421,14 @@ class PointcloudApi(RemoveableBulkModuleApi):
             convert_json_info_cb=lambda x: x,
         )
 
+    def get_list_related_images_batch(self, dataset_id: int, ids: List[int]) -> List:
+        filters = [{"field": ApiField.ENTITY_ID, "operator": "in", "value": ids}]
+        return self.get_list_all_pages(
+            "point-clouds.images.list",
+            {ApiField.DATASET_ID: dataset_id, ApiField.FILTER: filters},
+            convert_json_info_cb=lambda x: x,
+        )
+
     def download_related_image(self, id: int, path: str = None) -> Response:
         """
         Download a related context image from Supervisely to local directory by image id.

supervisely/convert/image/sly/sly_image_converter.py

@@ -17,7 +17,7 @@ from supervisely.api.api import Api
 from supervisely.convert.base_converter import AvailableImageConverters
 from supervisely.convert.image.image_converter import ImageConverter
 from supervisely.convert.image.image_helper import validate_image_bounds
-from supervisely.io.fs import dirs_filter, file_exists, get_file_ext
+from supervisely.io.fs import dirs_filter, file_exists, get_file_ext, get_file_name
 from supervisely.io.json import load_json_file
 from supervisely.project.project import find_project_dirs
 from supervisely.project.project import upload_project as upload_project_fs
@@ -122,17 +122,20 @@ class SLYImageConverter(ImageConverter):
         self._items = []
         for image_path in images_list:
             item = self.Item(image_path)
-            ann_name = f"{item.name}.json"
-            if ann_name in ann_dict:
-                ann_path = ann_dict[ann_name]
+            json_name, json_name_noext = f"{item.name}.json", f"{get_file_name(item.name)}.json"
+            ann_path = ann_dict.get(json_name, ann_dict.get(json_name_noext))
+            if ann_path:
                 if self._meta is None:
                     meta = self.generate_meta_from_annotation(ann_path, meta)
                 is_valid = self.validate_ann_file(ann_path, meta)
                 if is_valid:
                     item.ann_data = ann_path
-                    detected_ann_cnt += 1
-            if ann_name in img_meta_dict:
-                item.set_meta_data(img_meta_dict[ann_name])
+            
+            meta_path = img_meta_dict.get(json_name, img_meta_dict.get(json_name_noext))
+            if meta_path:
+                item.set_meta_data(meta_path)
+            if item.ann_data is not None or item.meta is not None:
+                detected_ann_cnt += 1
             self._items.append(item)
         self._meta = meta
         return detected_ann_cnt > 0

supervisely/convert/pointcloud/pointcloud_converter.py

@@ -1,6 +1,7 @@
 import imghdr
 import os
-from typing import List, Optional, Set, Tuple
+from typing import Dict, List, Optional, Set, Tuple
+from uuid import UUID
 
 import supervisely.convert.pointcloud.sly.sly_pointcloud_helper as helpers
 from supervisely import (
@@ -17,6 +18,8 @@ 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
+from supervisely.pointcloud_annotation.constants import OBJECT_KEY
+from supervisely.video_annotation.key_id_map import KeyIdMap
 
 
 class PointcloudConverter(BaseConverter):
@@ -41,7 +44,14 @@ class PointcloudConverter(BaseConverter):
         def create_empty_annotation(self) -> PointcloudAnnotation:
             return PointcloudAnnotation()
 
-        def set_related_images(self, related_images: Tuple[str, str]) -> None:
+        def set_related_images(self, related_images: Tuple[str, str, Optional[str]]) -> None:
+            """Adds related image to the item.
+
+            related_images tuple:
+                - path to image
+                - path to .json with image metadata
+                - path to .figures.json (can be None if no figures)
+            """
             self._related_images.append(related_images)
 
     @property
@@ -98,21 +108,26 @@ class PointcloudConverter(BaseConverter):
                 item_paths,
             )
             pcd_ids = [pcd_info.id for pcd_info in pcd_infos]
-
-            for pcd_id, ann in zip(pcd_ids, anns):
+            pcl_to_rimg_figures: Dict[int, Dict[str, List[Dict]]] = {}
+            pcl_to_hash_to_id: Dict[int, Dict[str, int]] = {}
+            key_id_map = KeyIdMap()
+            for pcd_id, ann, item in zip(pcd_ids, anns, batch):
                 if ann is not None:
-                    api.pointcloud.annotation.append(pcd_id, ann)
+                    api.pointcloud.annotation.append(pcd_id, ann, key_id_map)
 
                 rimg_infos = []
                 camera_names = []
-                for img_ind, (img_path, rimg_ann_path) in enumerate(item._related_images):
+                for img_ind, rel_tuple in enumerate(item._related_images):
+                    img_path = rel_tuple[0]
+                    rimg_ann_path = rel_tuple[1]
+                    fig_path = rel_tuple[2] if len(rel_tuple) > 2 else None
                     meta_json = load_json_file(rimg_ann_path)
                     try:
                         if ApiField.META not in meta_json:
                             raise ValueError("Related image meta not found in json file.")
                         if ApiField.NAME not in meta_json:
                             raise ValueError("Related image name not found in json file.")
-                        img = api.pointcloud.upload_related_image(img_path)
+                        img_hash = api.pointcloud.upload_related_image(img_path)
                         if "deviceId" not in meta_json[ApiField.META].keys():
                             camera_names.append(f"CAM_{str(img_ind).zfill(2)}")
                         else:
@@ -121,17 +136,87 @@ class PointcloudConverter(BaseConverter):
                             {
                                 ApiField.ENTITY_ID: pcd_id,
                                 ApiField.NAME: meta_json[ApiField.NAME],
-                                ApiField.HASH: img,
+                                ApiField.HASH: img_hash,
                                 ApiField.META: meta_json[ApiField.META],
                             }
                         )
-                        api.pointcloud.add_related_images(rimg_infos, camera_names)
+
+                        if fig_path is not None and os.path.isfile(fig_path):
+                            try:
+                                figs_json = load_json_file(fig_path)
+                                pcl_to_rimg_figures.setdefault(pcd_id, {})[img_hash] = figs_json
+                            except Exception as e:
+                                logger.debug(f"Failed to read figures json '{fig_path}': {repr(e)}")
+
                     except Exception as e:
                         logger.warn(
                             f"Failed to upload related image or add it to pointcloud: {repr(e)}"
                         )
                         continue
 
+                # add images for this point cloud
+                if len(rimg_infos) > 0:
+                    try:
+                        uploaded_rimgs = api.pointcloud.add_related_images(rimg_infos, camera_names)
+                        # build mapping hash->id
+                        for info, uploaded in zip(rimg_infos, uploaded_rimgs):
+                            img_hash = info.get(ApiField.HASH)
+                            img_id = (
+                                uploaded.get(ApiField.ID)
+                                if isinstance(uploaded, dict)
+                                else getattr(uploaded, "id", None)
+                            )
+                            if img_hash is not None and img_id is not None:
+                                pcl_to_hash_to_id.setdefault(pcd_id, {})[img_hash] = img_id
+                    except Exception as e:
+                        logger.debug(f"Failed to add related images to pointcloud: {repr(e)}")
+
+            # ---- upload figures for processed batch ----
+            if len(pcl_to_rimg_figures) > 0:
+                try:
+                    dataset_info = api.dataset.get_info_by_id(dataset_id)
+                    project_id = dataset_info.project_id
+
+                    figures_payload: List[Dict] = []
+
+                    for pcl_id, hash_to_figs in pcl_to_rimg_figures.items():
+                        hash_to_ids = pcl_to_hash_to_id.get(pcl_id, {})
+                        if len(hash_to_ids) == 0:
+                            continue
+
+                        for img_hash, figs_json in hash_to_figs.items():
+                            if img_hash not in hash_to_ids:
+                                continue
+                            rimg_id = hash_to_ids[img_hash]
+                            for fig in figs_json:
+                                try:
+                                    fig[ApiField.ENTITY_ID] = rimg_id
+                                    fig[ApiField.DATASET_ID] = dataset_id
+                                    fig[ApiField.PROJECT_ID] = project_id
+                                    if OBJECT_KEY in fig:
+                                        fig[ApiField.OBJECT_ID] = key_id_map.get_object_id(
+                                            UUID(fig[OBJECT_KEY])
+                                        )
+                                except Exception as e:
+                                    logger.debug(
+                                        f"Failed to process figure json for img_hash={img_hash}: {repr(e)}"
+                                    )
+                                    continue
+
+                            figures_payload.extend(figs_json)
+
+                        if len(figures_payload) > 0:
+                            try:
+                                api.image.figure.create_bulk(
+                                    figures_json=figures_payload, dataset_id=dataset_id
+                                )
+                            except Exception as e:
+                                logger.debug(
+                                    f"Failed to upload figures for related images: {repr(e)}"
+                                )
+                except Exception as e:
+                    logger.debug(f"Unexpected error during related image figures upload: {repr(e)}")
+
             if log_progress:
                 progress_cb(len(batch))
 
@@ -143,7 +228,7 @@ class PointcloudConverter(BaseConverter):
     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 = [], {}, {}
+        pcd_list, rimg_dict, rimg_ann_dict, rimg_fig_dict = [], {}, {}, {}
         used_img_ext = set()
         for root, _, files in os.walk(self._input_data):
             for file in files:
@@ -170,6 +255,8 @@ class PointcloudConverter(BaseConverter):
                         pcd_list.append(full_path)
                     except:
                         pass
+                elif file.endswith(".figures.json"):
+                    rimg_fig_dict[file] = full_path
                 else:
                     only_modality_items = False
                     unsupported_exts.add(ext)
@@ -179,9 +266,13 @@ class PointcloudConverter(BaseConverter):
         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
+                item.name, list(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))
+                rimg_ext = get_file_ext(rimg)
+                rimg_fig_path = rimg_fig_dict.get(f"{get_file_name(rimg)}{rimg_ext}.figures.json")
+                if rimg_fig_path is None:
+                    rimg_fig_path = rimg_fig_dict.get(f"{get_file_name(rimg)}.figures.json")
+                item.set_related_images((rimg, rimg_ann, rimg_fig_path))
             items.append(item)
         return items, only_modality_items, unsupported_exts

supervisely/convert/pointcloud/sly/sly_pointcloud_converter.py

@@ -101,7 +101,11 @@ class SLYPointcloudConverter(PointcloudConverter):
                 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))
+                rimg_ext = get_file_ext(rimg)
+                rimg_fig_path = rimg_ann.replace(f"{rimg_ext}.json", f"{rimg_ext}.figures.json")
+                if not os.path.exists(rimg_fig_path):
+                    rimg_fig_path = None
+                item.set_related_images((rimg, rimg_ann, rimg_fig_path))
             self._items.append(item)
         return sly_ann_detected