supervisely 6.73.378__tar.gz → 6.73.379__tar.gz

{supervisely-6.73.378/supervisely.egg-info → supervisely-6.73.379}/PKG-INFO

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

{supervisely-6.73.378 → supervisely-6.73.379}/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-6.73.378 → supervisely-6.73.379}/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-6.73.378 → supervisely-6.73.379}/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-6.73.378 → supervisely-6.73.379}/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
 

{supervisely-6.73.378 → supervisely-6.73.379}/supervisely/convert/pointcloud_episodes/pointcloud_episodes_converter.py

@@ -1,6 +1,7 @@
 import imghdr
 import os
 from typing import Dict, List, Optional, Set, Tuple, Union
+from uuid import UUID
 
 from supervisely import (
     Api,
@@ -16,7 +17,9 @@ 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.project.project_settings import LabelingInterface
+from supervisely.video_annotation.key_id_map import KeyIdMap
 
 
 class PointcloudEpisodeConverter(BaseConverter):
@@ -47,7 +50,14 @@ class PointcloudEpisodeConverter(BaseConverter):
         def create_empty_annotation(self) -> PointcloudEpisodeAnnotation:
             return PointcloudEpisodeAnnotation()
 
-        def set_related_images(self, related_images: dict) -> 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)
 
     def __init__(
@@ -104,7 +114,10 @@ class PointcloudEpisodeConverter(BaseConverter):
         else:
             progress_cb = None
 
-        frame_to_pointcloud_ids = {}
+        frame_to_pointcloud_ids: Dict[int, int] = {}
+        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 batch in batched(self._items, batch_size=batch_size):
             item_names = []
             item_paths = []
@@ -129,12 +142,21 @@ class PointcloudEpisodeConverter(BaseConverter):
                 rimg_infos = []
                 camera_names = []
                 if len(item._related_images) > 0:
-                    img_paths, rimg_ann_paths = list(zip(*item._related_images))
+                    img_paths: List[str] = []
+                    ann_paths: List[str] = []
+                    fig_paths: List[Optional[str]] = []
+
+                    for triple in item._related_images:
+                        img_paths.append(triple[0])
+                        ann_paths.append(triple[1])
+                        fig_paths.append(triple[2] if len(triple) > 2 else None)
+
                     rimg_hashes = api.pointcloud_episode.upload_related_images(img_paths)
-                    for img_ind, (img_hash, rimg_ann_path) in enumerate(
-                        zip(rimg_hashes, rimg_ann_paths)
+
+                    for img_ind, (img_hash, ann_path, fig_path) in enumerate(
+                        zip(rimg_hashes, ann_paths, fig_paths)
                     ):
-                        meta_json = load_json_file(rimg_ann_path)
+                        meta_json = load_json_file(ann_path)
                         try:
                             if ApiField.META not in meta_json:
                                 raise ValueError("Related image meta not found in json file.")
@@ -152,19 +174,102 @@ class PointcloudEpisodeConverter(BaseConverter):
                                     ApiField.META: meta_json[ApiField.META],
                                 }
                             )
-                            api.pointcloud.add_related_images(rimg_infos, camera_names)
+
+                            if fig_path is not None:
+                                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.warning(
-                                f"Failed to upload related image or add it to pointcloud episo: {repr(e)}"
+                                f"Failed to process related image meta '{ann_path}': {repr(e)}"
                             )
                             continue
 
+                    uploaded_rimgs = api.pointcloud.add_related_images(rimg_infos, camera_names)
+                    try:
+                        # 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 build hash->ID mapping for related images: {repr(e)}"
+                        )
+
             if log_progress:
                 progress_cb(len(batch))
 
         if self.items_count > 0:
             ann = self.to_supervisely(self._items[0], meta, renamed_classes, renamed_tags)
-            api.pointcloud_episode.annotation.append(dataset_id, ann, frame_to_pointcloud_ids)
+            api.pointcloud_episode.annotation.append(
+                dataset_id, ann, frame_to_pointcloud_ids, key_id_map
+            )
+
+        # ---- upload figures for processed batch ----
+        if len(pcl_to_rimg_figures) > 0:
+            if log_progress:
+                progress, progress_cb = self.get_progress(
+                    self.items_count, "Uploading figures for related images..."
+                )
+            else:
+                progress_cb = None
+
+            try:
+                dataset_info = api.dataset.get_info_by_id(dataset_id)
+                project_id = dataset_info.project_id
+
+                figures_to_upload: 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
+                        img_id = hash_to_ids[img_hash]
+
+                        for fig in figs_json:
+                            try:
+                                fig[ApiField.ENTITY_ID] = img_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_to_upload.extend(figs_json)
+
+                if len(figures_to_upload) > 0:
+                    try:
+                        api.image.figure.create_bulk(
+                            figures_json=figures_to_upload, dataset_id=dataset_id
+                        )
+                    except Exception as e:
+                        logger.debug(f"Failed to upload figures for related images: {repr(e)}")
+
+                if log_progress:
+                    progress_cb(len(pcl_to_rimg_figures))
+
+            except Exception as e:
+                logger.debug(f"Unexpected error during figures upload: {repr(e)}")
 
         if log_progress:
             if is_development():
@@ -177,7 +282,7 @@ class PointcloudEpisodeConverter(BaseConverter):
         pcd_dict = {}
         frames_pcd_map = None
         used_img_ext = set()
-        rimg_dict, rimg_json_dict = {}, {}
+        rimg_dict, rimg_json_dict, rimg_fig_dict = {}, {}, {}
         for root, _, files in os.walk(self._input_data):
             for file in files:
                 full_path = os.path.join(root, file)
@@ -187,7 +292,9 @@ class PointcloudEpisodeConverter(BaseConverter):
 
                 ext = get_file_ext(full_path)
                 recognized_ext = imghdr.what(full_path)
-                if ext == ".json":
+                if file.endswith(".figures.json"):
+                    rimg_fig_dict[file] = full_path
+                elif ext == ".json":
                     rimg_json_dict[file] = full_path
                 elif recognized_ext:
                     if ext.lower() == ".pcd":
@@ -226,9 +333,12 @@ class PointcloudEpisodeConverter(BaseConverter):
                     if rimg_name in rimg_dict:
                         rimg_path = rimg_dict[rimg_name]
                         rimg_ann_name = f"{rimg_name}.json"
+                        rimg_fig_name = f"{rimg_name}.figures.json"
+                        rimg_fig_path = rimg_fig_dict.get(rimg_fig_name)
+
                         if rimg_ann_name in rimg_json_dict:
                             rimg_ann_path = rimg_json_dict[rimg_ann_name]
-                            item.set_related_images((rimg_path, rimg_ann_path))
+                            item.set_related_images((rimg_path, rimg_ann_path, rimg_fig_path))
                 items.append(item)
             else:
                 logger.warning(f"Pointcloud file {pcd_name} not found. Skipping frame.")

{supervisely-6.73.378 → supervisely-6.73.379}/supervisely/convert/pointcloud_episodes/sly/sly_pointcloud_episodes_converter.py

@@ -127,7 +127,11 @@ class SLYPointcloudEpisodesConverter(PointcloudEpisodeConverter):
                         rimg_ann_name = f"{rimg_name}.json"
                         if rimg_ann_name in rimg_json_dict:
                             rimg_ann_path = rimg_json_dict[rimg_ann_name]
-                            item.set_related_images((rimg_path, rimg_ann_path))
+                            rimg_fig_name = f"{rimg_name}.figures.json"
+                            rimg_fig_path = os.path.join(os.path.dirname(rimg_ann_path), rimg_fig_name)
+                            if not os.path.exists(rimg_fig_path):
+                                rimg_fig_path = None
+                            item.set_related_images((rimg_path, rimg_ann_path, rimg_fig_path))
                 self._items.append(item)
             else:
                 logger.warning(f"Pointcloud file {pcd_name} not found. Skipping frame.")

{supervisely-6.73.378 → supervisely-6.73.379}/supervisely/project/pointcloud_episode_project.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import os
 import random
 from typing import Callable, Dict, List, NamedTuple, Optional, Tuple, Union
+from uuid import UUID
 
 from tqdm import tqdm
 
@@ -17,6 +18,7 @@ from supervisely.api.pointcloud.pointcloud_api import PointcloudInfo
 from supervisely.collection.key_indexed_collection import KeyIndexedCollection
 from supervisely.io.fs import dir_exists, get_file_name, list_files, mkdir, touch
 from supervisely.io.json import dump_json_file, load_json_file
+from supervisely.pointcloud_annotation.constants import OBJECT_KEY
 from supervisely.pointcloud_annotation.pointcloud_episode_annotation import (
     PointcloudEpisodeAnnotation,
 )
@@ -354,6 +356,7 @@ class PointcloudEpisodeProject(PointcloudProject):
         def _list_items_for_splits(project) -> List[EpisodeItemInfo]:
             items = []
             for dataset in project.datasets:
+                dataset: PointcloudEpisodeDataset
                 for item_name in dataset:
                     items.append(
                         EpisodeItemInfo(
@@ -745,7 +748,7 @@ def download_pointcloud_episode_project(
         datasets_infos = api.dataset.get_list(project_id)
 
     for dataset in datasets_infos:
-        dataset_fs = project_fs.create_dataset(dataset.name)
+        dataset_fs: PointcloudEpisodeDataset = project_fs.create_dataset(dataset.name)
         pointclouds = api.pointcloud_episode.get_list(dataset.id)
 
         # Download annotation to project_path/dataset_path/annotation.json
@@ -774,6 +777,30 @@ def download_pointcloud_episode_project(
             pc_to_frame = {v: k for k, v in frame_to_pc_map.items()}
             item_to_ann = {name: pc_to_frame[name] for name in pointcloud_names}
 
+            batch_rimg_figures = {}
+            if download_related_images:
+                try:
+                    rimgs = api.pointcloud_episode.get_list_related_images_batch(
+                        dataset.id, pointcloud_ids
+                    )
+                    if len(rimgs) > 0:
+                        rimg_ids = [rimg[ApiField.ID] for rimg in rimgs]
+                        batch_rimg_figures = api.image.figure.download(
+                            dataset_id=dataset.id, image_ids=rimg_ids
+                        )
+                    else:
+                        batch_rimg_figures = []
+                except Exception as e:
+                    logger.info(
+                        "INFO FOR DEBUGGING",
+                        extra={
+                            "project_id": project_id,
+                            "dataset_id": dataset.id,
+                            "pointcloud_ids": pointcloud_ids,
+                        },
+                    )
+                    raise e
+
             for pointcloud_id, pointcloud_name, pointcloud_info in zip(
                 pointcloud_ids, pointcloud_names, batch
             ):
@@ -830,6 +857,7 @@ def download_pointcloud_episode_project(
 
                         path_img = os.path.join(related_images_path, name)
                         path_json = os.path.join(related_images_path, name + ".json")
+                        path_figures = os.path.join(related_images_path, name + ".figures.json")
 
                         try:
                             api.pointcloud_episode.download_related_image(rimage_id, path_img)
@@ -846,9 +874,37 @@ def download_pointcloud_episode_project(
                                 },
                             )
                             raise e
-
                         dump_json_file(rimage_info, path_json)
 
+                        try:
+                            if rimage_id in batch_rimg_figures:
+                                rimg_figures = batch_rimg_figures[rimage_id]
+                                rimg_figures_json = []
+                                for fig in rimg_figures:
+                                    fig_json = fig.to_json()
+                                    if ApiField.OBJECT_ID in fig_json:
+                                        fig_json[OBJECT_KEY] = str(
+                                            key_id_map.get_object_key(fig_json[ApiField.OBJECT_ID])
+                                        )
+                                        fig_json.pop(ApiField.OBJECT_ID, None)
+                                        rimg_figures_json.append(fig_json)
+                                    else:
+                                        raise RuntimeError(f"Figure {fig} has no object id")
+                                dump_json_file(rimg_figures_json, path_figures)
+                        except Exception as e:
+                            logger.info(
+                                "INFO FOR DEBUGGING",
+                                extra={
+                                    "project_id": project_id,
+                                    "dataset_id": dataset.id,
+                                    "pointcloud_id": pointcloud_id,
+                                    "pointcloud_name": pointcloud_name,
+                                    "rimage_id": rimage_id,
+                                    "path_figures": path_figures,
+                                },
+                            )
+                            raise e
+
                 pointcloud_info = pointcloud_info._asdict() if download_pointclouds_info else None
                 try:
                     dataset_fs.add_item_file(
@@ -901,6 +957,7 @@ def upload_pointcloud_episode_project(
 
     key_id_map = KeyIdMap()
     for dataset_fs in project_fs.datasets:
+        dataset_fs: PointcloudEpisodeDataset
         ann_json_path = dataset_fs.get_ann_path()
 
         if os.path.isfile(ann_json_path):
@@ -974,8 +1031,9 @@ def upload_pointcloud_episode_project(
 
         # STEP 3 — upload photo context
         img_infos = {"img_paths": [], "img_metas": []}
-
         # STEP 3.1 — upload images
+        pcl_to_rimg_figures: Dict[int, Dict[str, List[Dict]]] = {}
+        pcl_to_hash_to_id: Dict[int, Dict[str, int]] = {}
         for pcl_info in pcl_infos:
             related_items = dataset_fs.get_related_images(pcl_info.name)
             images_paths_for_frame = [img_path for img_path, _ in related_items]
@@ -1014,6 +1072,7 @@ def upload_pointcloud_episode_project(
                 img_hash = next(images_hashes_iterator)
                 if "deviceId" not in meta_json[ApiField.META].keys():
                     meta_json[ApiField.META]["deviceId"] = f"CAM_{str(img_ind).zfill(2)}"
+
                 img_infos["img_metas"].append(
                     {
                         ApiField.ENTITY_ID: pcl_info.id,
@@ -1022,10 +1081,38 @@ def upload_pointcloud_episode_project(
                         ApiField.META: meta_json[ApiField.META],
                     }
                 )
+                img_name = meta_json[ApiField.NAME]
+                related_images_dir = dataset_fs.get_related_images_path(pcl_info.name)
+                fig_json_path = os.path.join(related_images_dir, img_name + ".figures.json")
+                if os.path.isfile(fig_json_path):
+                    try:
+                        figs_json = load_json_file(fig_json_path)
+                        pcl_to_rimg_figures.setdefault(pcl_info.id, {})[img_hash] = figs_json
+                    except Exception as e:
+                        logger.info(
+                            "INFO FOR DEBUGGING",
+                            extra={
+                                "project_id": project.id,
+                                "dataset_id": dataset.id,
+                                "pointcloud_id": pcl_info.id,
+                                "fig_json_path": fig_json_path,
+                            },
+                        )
+                        raise e
 
         if len(img_infos["img_metas"]) > 0:
             try:
-                api.pointcloud_episode.add_related_images(img_infos["img_metas"])
+                uploaded_rimgs = api.pointcloud_episode.add_related_images(img_infos["img_metas"])
+                # build mapping hash->id
+                for info, uploaded in zip(img_infos["img_metas"], 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[img_hash] = img_id
             except Exception as e:
                 logger.info(
                     "INFO FOR DEBUGGING",
@@ -1037,4 +1124,39 @@ def upload_pointcloud_episode_project(
                 )
                 raise e
 
+        for pcl_info in pcl_infos:
+            rimg_figures = pcl_to_rimg_figures.get(pcl_info.id)
+            if not rimg_figures:
+                continue
+
+            try:
+                for img_hash, figs_json in rimg_figures.items():
+                    if img_hash in pcl_to_hash_to_id:
+                        img_id = pcl_to_hash_to_id[img_hash]
+                        for fig in figs_json:
+                            fig[ApiField.ENTITY_ID] = img_id
+                            fig[ApiField.DATASET_ID] = dataset.id
+                            fig[ApiField.PROJECT_ID] = project.id
+                            fig[ApiField.OBJECT_ID] = key_id_map.get_object_id(
+                                UUID(fig[OBJECT_KEY])
+                            )
+
+                api.image.figure.create_bulk(
+                    figures_json=[fig for figs in rimg_figures.values() for fig in figs],
+                    dataset_id=dataset.id,
+                )
+
+            except Exception as e:
+                logger.info(
+                    "INFO FOR DEBUGGING",
+                    extra={
+                        "project_id": project.id,
+                        "dataset_id": dataset.id,
+                        "pointcloud_id": pcl_info.id,
+                        "pointcloud_name": pcl_info.name,
+                        "rimg_figures": rimg_figures,
+                    },
+                )
+                raise e
+
     return project.id, project.name