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

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