supervisely 6.73.393__py3-none-any.whl → 6.73.395__py3-none-any.whl

supervisely/api/entity_annotation/entity_annotation_api.py

@@ -1,8 +1,10 @@
 # coding: utf-8
 
 # docs
+from typing import Callable, Dict, List, Optional, Union
+
 from tqdm import tqdm
-from typing import List, Dict, Union, Optional, Callable
+
 from supervisely._utils import batched
 from supervisely.api.module_api import ApiField, ModuleApi
 from supervisely.video_annotation.key_id_map import KeyIdMap

supervisely/api/entity_annotation/figure_api.py

@@ -69,6 +69,7 @@ class FigureInfo(NamedTuple):
     meta: dict
     area: str
     priority: Optional[int] = None
+    custom_data: Optional[dict] = None
 
     @property
     def bbox(self) -> Optional[Rectangle]:
@@ -135,6 +136,7 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.META,
             ApiField.AREA,
             ApiField.PRIORITY,
+            ApiField.CUSTOM_DATA,
         ]
 
     @staticmethod
@@ -229,7 +231,8 @@ class FigureApi(RemoveableBulkModuleApi):
         meta: Dict,
         geometry_json: Dict,
         geometry_type: str,
-        track_id: int = None,
+        track_id: Optional[int] = None,
+        custom_data: Optional[dict] = None,
     ) -> int:
         """"""
         input_figure = {
@@ -242,6 +245,9 @@ class FigureApi(RemoveableBulkModuleApi):
         if track_id is not None:
             input_figure[ApiField.TRACK_ID] = track_id
 
+        if custom_data is not None:
+            input_figure[ApiField.CUSTOM_DATA] = custom_data
+
         body = {ApiField.ENTITY_ID: entity_id, ApiField.FIGURES: [input_figure]}
 
         response = self._api.post("figures.bulk.add", body)
@@ -354,21 +360,22 @@ class FigureApi(RemoveableBulkModuleApi):
         """
         filters = [{"field": "id", "operator": "in", "value": ids}]
         fields = [
-            "id",
-            "createdAt",
-            "updatedAt",
-            "imageId",
-            "objectId",
-            "classId",
-            "projectId",
-            "datasetId",
-            "geometry",
-            "geometryType",
-            "geometryMeta",
-            "tags",
-            "meta",
-            "area",
-            "priority",
+            ApiField.ID,
+            ApiField.CREATED_AT,
+            ApiField.UPDATED_AT,
+            ApiField.IMAGE_ID,
+            ApiField.OBJECT_ID,
+            ApiField.CLASS_ID,
+            ApiField.PROJECT_ID,
+            ApiField.DATASET_ID,
+            ApiField.GEOMETRY,
+            ApiField.GEOMETRY_TYPE,
+            ApiField.GEOMETRY_META,
+            ApiField.TAGS,
+            ApiField.META,
+            ApiField.AREA,
+            ApiField.PRIORITY,
+            ApiField.CUSTOM_DATA,
         ]
         figures_infos = self.get_list_all_pages(
             "figures.list",
@@ -488,6 +495,7 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.META,
             ApiField.AREA,
             ApiField.PRIORITY,
+            ApiField.CUSTOM_DATA,
         ]
         if skip_geometry is True:
             fields = [x for x in fields if x != ApiField.GEOMETRY]
@@ -840,6 +848,7 @@ class FigureApi(RemoveableBulkModuleApi):
             ApiField.META,
             ApiField.AREA,
             ApiField.PRIORITY,
+            ApiField.CUSTOM_DATA,
         ]
         if skip_geometry is True:
             fields = [x for x in fields if x != ApiField.GEOMETRY]

supervisely/api/module_api.py

@@ -663,6 +663,8 @@ class ApiField:
     """"""
     QUALITY_CHECK_USER_IDS = "qualityCheckUserIds"
     """"""
+    UPDATE_STRATEGY = "updateStrategy"
+    """"""
 
 
 def _get_single_item(items):

supervisely/api/volume/volume_annotation_api.py

@@ -312,11 +312,13 @@ class VolumeAnnotationAPI(EntityAnnotationAPI):
 
         for nrrd_path in nrrd_paths:
             object_key = None
+            custom_data = None
 
             # searching connection between interpolation and spatial figure in annotations and set its object_key
             for sf in ann.spatial_figures:
                 if sf.key().hex == get_file_name(nrrd_path):
                     object_key = sf.parent_object.key()
+                    custom_data = sf.custom_data
                     break
 
             if object_key:
@@ -341,12 +343,12 @@ class VolumeAnnotationAPI(EntityAnnotationAPI):
             geometry = Mask3D(np.zeros((3, 3, 3), dtype=np.bool_))
 
             if transfer_type == "download":
-                new_object = VolumeObject(new_obj_class, mask_3d=geometry)
+                new_object = VolumeObject(new_obj_class, mask_3d=geometry, custom_data=custom_data)
             elif transfer_type == "upload":
                 if class_created:
                     self._api.project.update_meta(project_id, project_meta)
                 new_object = VolumeObject(new_obj_class)
-                new_object.figure = VolumeFigure(new_object, geometry, key=sf.key())
+                new_object.figure = VolumeFigure(new_object, geometry, key=sf.key(), custom_data=custom_data)
 
             # add new Volume object to VolumeAnnotation with spatial figure
             ann = ann.add_objects([new_object])

supervisely/api/volume/volume_figure_api.py

@@ -2,7 +2,7 @@
 import os
 import re
 import tempfile
-from typing import Dict, List
+from typing import Dict, List, Literal, Optional
 from uuid import UUID
 
 from numpy import uint8
@@ -33,7 +33,8 @@ class VolumeFigureApi(FigureApi):
         plane_name: str,
         slice_index: int,
         geometry_json: dict,
-        geometry_type,
+        geometry_type: str,
+        custom_data: Optional[dict] = None,
         # track_id=None,
     ):
         """
@@ -98,6 +99,7 @@ class VolumeFigureApi(FigureApi):
             },
             geometry_json,
             geometry_type,
+            custom_data=custom_data,
             # track_id,
         )
 
@@ -420,7 +422,7 @@ class VolumeFigureApi(FigureApi):
     def _append_bulk_mask3d(
         self,
         entity_id: int,
-        figures: List,
+        figures: List[VolumeFigure],
         figures_keys: List,
         key_id_map: KeyIdMap,
         field_name=ApiField.ENTITY_ID,
@@ -449,10 +451,11 @@ class VolumeFigureApi(FigureApi):
         for figure in figures:
             empty_figures.append(
                 {
-                    "objectId": key_id_map.get_object_id(figure.volume_object.key()),
-                    "geometryType": Mask3D.name(),
-                    "tool": Mask3D.name(),
-                    "entityId": entity_id,
+                    ApiField.OBJECT_ID: key_id_map.get_object_id(figure.volume_object.key()),
+                    ApiField.GEOMETRY_TYPE: Mask3D.name(),
+                    ApiField.LABELING_TOOL: Mask3D.name(),
+                    ApiField.ENTITY_ID: entity_id,
+                    ApiField.CUSTOM_DATA: figure.custom_data
                 }
             )
         for batch_keys, batch_jsons in zip(
@@ -643,3 +646,29 @@ class VolumeFigureApi(FigureApi):
         if kwargs.get("image_ids", False) is not False:
             volume_ids = kwargs["image_ids"]  # backward compatibility
         return super().download(dataset_id, volume_ids, skip_geometry)
+
+    def update_custom_data(
+        self,
+        figure_id: int,
+        custom_data: Dict[str, str],
+        update_strategy: Literal["replace", "merge"] = "merge",
+    ) -> None:
+        """
+        Update custom data for a specific figure in a volume.
+
+        :param figure_id: ID of the figure to update.
+        :type figure_id: int
+        :param custom_data: Custom data to update.
+        :type custom_data: Dict[str, str]
+        :param update_strategy: Strategy to apply, either "replace" or "merge".
+        :type update_strategy: Literal["replace", "merge"]
+        :return: None
+        :rtype: :class:`NoneType`
+
+        """
+        data = {
+            ApiField.ID: figure_id,
+            ApiField.CUSTOM_DATA: custom_data,
+            ApiField.UPDATE_STRATEGY: update_strategy,
+        }
+        self._api.post("figures.custom-data.update", data)

supervisely/convert/base_converter.py

@@ -83,13 +83,13 @@ class BaseConverter:
             item_path: str,
             ann_data: Union[str, dict] = None,
             shape: Union[Tuple, List] = None,
-            custom_data: dict = {},
+            custom_data: Optional[dict] = None,
         ):
             self._path: str = item_path
             self._name: str = None
             self._ann_data: Union[str, dict, list] = ann_data
             self._shape: Union[Tuple, List] = shape
-            self._custom_data: dict = custom_data
+            self._custom_data: dict = custom_data or {}
 
         @property
         def name(self) -> str:

supervisely/convert/volume/nii/nii_planes_volume_converter.py

@@ -2,7 +2,8 @@ import os
 from collections import defaultdict
 from pathlib import Path
 
-from supervisely import ProjectMeta, logger, Api
+from supervisely import Api, ProjectMeta, logger
+from supervisely._utils import batched, is_development
 from supervisely.annotation.obj_class import ObjClass
 from supervisely.convert.volume.nii import nii_volume_helper as helper
 from supervisely.convert.volume.nii.nii_volume_converter import NiiConverter
@@ -12,7 +13,6 @@ from supervisely.io.fs import get_file_ext, get_file_name, list_files_recursivel
 from supervisely.volume.volume import is_nifti_file
 from supervisely.volume_annotation.volume_annotation import VolumeAnnotation
 from supervisely.volume_annotation.volume_object import VolumeObject
-from supervisely._utils import batched, is_development
 
 
 class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
@@ -83,6 +83,12 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
         ann_dict = defaultdict(list)
         cls_color_map = None
 
+        ann_to_score_path = {}
+        csv_files = list_files_recursively(self._input_data, [".csv"], None, True)
+        csv_nameparts = {
+            helper.parse_name_parts(os.path.basename(file)): file for file in csv_files
+        }
+
         for root, _, files in os.walk(self._input_data):
             if converted_dir_name in root:
                 continue
@@ -91,17 +97,25 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
                 if is_nifti_file(path):
                     name_parts = helper.parse_name_parts(file)
                     if name_parts is None:
-                        logger.warning(
+                        logger.debug(
                             f"File recognized as NIfTI, but failed to parse plane identifier from name. Path: {path}",
                         )
                         continue
-
-                    dict_to_use = ann_dict if name_parts.is_ann else volumes_dict
-                    key = (
-                        name_parts.plane
-                        if name_parts.patient_uuid is None and name_parts.case_uuid is None
-                        else f"{name_parts.plane}_{name_parts.patient_uuid}_{name_parts.case_uuid}"
-                    )
+                    if name_parts.is_ann:
+                        dict_to_use = ann_dict
+                        score_path = helper.find_best_name_match(
+                            name_parts, list(csv_nameparts.keys())
+                        )
+                        if score_path is not None:
+                            full_score_path = csv_nameparts[score_path]
+                            ann_to_score_path[name_parts.full_name] = full_score_path
+                    else:
+                        dict_to_use = volumes_dict
+
+                    if name_parts.patient_uuid is None and name_parts.case_uuid is None:
+                        key = name_parts.plane
+                    else:
+                        key = f"{name_parts.plane}_{name_parts.patient_uuid}_{name_parts.case_uuid}"
                     dict_to_use[key].append(path)
                 ext = get_file_ext(path)
                 if ext == ".txt":
@@ -113,7 +127,17 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
         for key, paths in volumes_dict.items():
             if len(paths) == 1:
                 item = self.Item(item_path=paths[0])
+                name_parts = helper.parse_name_parts(os.path.basename(item.path))
                 item.ann_data = ann_dict.get(key, [])
+
+                ann_path = os.path.basename(item.ann_data[0]) if item.ann_data else None
+                if ann_path in ann_to_score_path:
+                    score_path = ann_to_score_path[ann_path]
+                    try:
+                        scores = helper.get_scores_from_table(score_path, name_parts.plane)
+                        item.custom_data["scores"] = scores
+                    except Exception as e:
+                        logger.warning(f"Failed to read scores from {score_path}: {e}")
                 item.is_semantic = len(item.ann_data) == 1
                 if cls_color_map is not None:
                     item.custom_data["cls_color_map"] = cls_color_map
@@ -123,12 +147,23 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
                     f"Found {len(paths)} volumes with key {key}. Will try to match them by directories."
                 )
                 for path in paths:
+                    name_parts = helper.parse_name_parts(os.path.basename(path))
                     item = self.Item(item_path=path)
                     possible_ann_paths = []
                     for ann_path in ann_dict.get(key, []):
                         if Path(ann_path).parent == Path(path).parent:
                             possible_ann_paths.append(ann_path)
                     item.ann_data = possible_ann_paths
+                    scores_paths = [
+                        ann_to_score_path.get(ann_name, None) for ann_name in possible_ann_paths
+                    ]
+                    scores_paths = [path for path in scores_paths if path is not None]
+                    if scores_paths:
+                        try:
+                            scores = helper.get_scores_from_table(scores_paths[0], name_parts.plane)
+                            item.custom_data["scores"] = scores
+                        except Exception as e:
+                            logger.warning(f"Failed to read scores from {scores_paths[0]}: {e}")
                     item.is_semantic = len(possible_ann_paths) == 1
                     if cls_color_map is not None:
                         item.custom_data["cls_color_map"] = cls_color_map
@@ -149,6 +184,7 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
         try:
             objs = []
             spatial_figures = []
+            scores = item.custom_data.get("scores", {})
             for idx, ann_path in enumerate(item.ann_data, start=1):
                 for mask, pixel_value in helper.get_annotation_from_nii(ann_path):
                     class_id = pixel_value if item.is_semantic else idx
@@ -170,7 +206,9 @@ class NiiPlaneStructuredConverter(NiiConverter, VolumeConverter):
                         meta = meta.add_obj_class(obj_class)
                         self._meta_changed = True
                         self._meta = meta
-                    obj = VolumeObject(obj_class, mask_3d=mask)
+                    obj_scores = scores.get(class_id, {})
+                    obj_scores = {k: v for k, v in obj_scores.items()}
+                    obj = VolumeObject(obj_class, mask_3d=mask, custom_data=obj_scores)
                     spatial_figures.append(obj.figure)
                     objs.append(obj)
             return VolumeAnnotation(item.volume_meta, objects=objs, spatial_figures=spatial_figures)
@@ -210,7 +248,7 @@ class NiiPlaneStructuredAnnotationConverter(NiiConverter, VolumeConverter):
 
     def validate_format(self) -> bool:
         try:
-            from nibabel import load, filebasedimages
+            from nibabel import filebasedimages, load
         except ImportError:
             raise ImportError(
                 "No module named nibabel. Please make sure that module is installed from pip and try again."
@@ -235,8 +273,8 @@ class NiiPlaneStructuredAnnotationConverter(NiiConverter, VolumeConverter):
         for root, _, files in os.walk(self._input_data):
             for file in files:
                 path = os.path.join(root, file)
+                name_parts = helper.parse_name_parts(file)
                 if is_nii(file):
-                    name_parts = helper.parse_name_parts(file)
                     if name_parts is None or not name_parts.is_ann:
                         continue
                     try:

supervisely/convert/volume/nii/nii_volume_converter.py

@@ -193,7 +193,7 @@ class NiiConverter(VolumeConverter):
                 volume_np, volume_meta = read_nrrd_serie_volume_np(item.path)
                 progress_nrrd = tqdm_sly(
                     desc=f"Uploading volume '{item.name}'",
-                    total=sum(volume_np.shape),
+                    total=sum(volume_np.shape) + 1,
                     leave=True if progress_cb is None else False,
                     position=1,
                 )

supervisely/convert/volume/nii/nii_volume_helper.py

@@ -1,7 +1,7 @@
 import os
 from collections import defaultdict, namedtuple
 from pathlib import Path
-from typing import Generator
+from typing import Generator, List, Union
 
 import nrrd
 import numpy as np
@@ -17,6 +17,7 @@ VOLUME_NAME = "anatomic"
 LABEL_NAME = ["inference", "label", "annotation", "mask", "segmentation"]
 MASK_PIXEL_VALUE = "Mask pixel value: "
 
+
 class PlanePrefix(str, StrEnum):
     """Prefix for plane names."""
 
@@ -117,15 +118,79 @@ def get_annotation_from_nii(path: str) -> Generator[Mask3D, None, None]:
         yield mask, class_id
 
 
+def get_scores_from_table(csv_file_path: str, plane: str) -> dict:
+    """Get scores from CSV table and return nested dictionary structure.
+
+    Args:
+        csv_file_path: Path to the CSV file containing layer scores
+
+    Returns:
+        Nested dictionary with structure:
+        {
+            "label_index": {
+                "slice_index": {
+                    "127": {
+                        "score": float_value,
+                        "comment": ""
+                    }
+                }
+            }
+        }
+    """
+    import csv
+
+    if plane == PlanePrefix.CORONAL:
+        plane = "0-1-0"
+    elif plane == PlanePrefix.SAGITTAL:
+        plane = "1-0-0"
+    elif plane == PlanePrefix.AXIAL:
+        plane = "0-0-1"
+
+    result = defaultdict(lambda: defaultdict(dict))
+
+    if not os.path.exists(csv_file_path):
+        logger.warning(f"CSV file not found: {csv_file_path}")
+        return result
+
+    try:
+        with open(csv_file_path, "r") as file:
+            reader = csv.DictReader(file)
+            label_columns = [col for col in reader.fieldnames if col.startswith("Label-")]
+
+            for row in reader:
+                frame_idx = int(row["Layer"]) - 1  # Assuming Layer is 1-indexed in CSV
+
+                for label_col in label_columns:
+                    label_index = int(label_col.split("-")[1])
+                    score = f"{float(row[label_col]):.2f}"
+                    result[label_index][plane][frame_idx] = {"score": score, "comment": None}
+
+    except Exception as e:
+        logger.warning(f"Failed to read CSV file {csv_file_path}: {e}")
+        return {}
+
+    return result
+
+
 class AnnotationMatcher:
     def __init__(self, items, dataset_id):
         self._items = items
         self._ds_id = dataset_id
         self._ann_paths = defaultdict(list)
-
         self._item_by_filename = {}
         self._item_by_path = {}
 
+        self.set_items(items)
+
+        self._project_wide = False
+        self._volumes = None
+
+    def set_items(self, items):
+        self._items = items
+        self._ann_paths.clear()
+        self._item_by_filename.clear()
+        self._item_by_path.clear()
+
         for item in items:
             path = Path(item.ann_data)
             dataset_name = path.parts[-2]
@@ -135,9 +200,6 @@ class AnnotationMatcher:
             self._item_by_filename[filename] = item
             self._item_by_path[(dataset_name, filename)] = item
 
-        self._project_wide = False
-        self._volumes = None
-
     def get_volumes(self, api: Api):
         dataset_info = api.dataset.get_info_by_id(self._ds_id)
         datasets = {dataset_info.name: dataset_info}
@@ -166,11 +228,8 @@ class AnnotationMatcher:
 
     def match_items(self):
         """Match annotation files with corresponding volumes using regex-based matching."""
-        import re
-
         item_to_volume = {}
 
-        # Perform matching
         for dataset_name, volumes in self._volumes.items():
             volume_names = [parse_name_parts(name) for name in list(volumes.keys())]
             _volume_names = [vol for vol in volume_names if vol is not None]
@@ -191,7 +250,7 @@ class AnnotationMatcher:
                 if ann_name is None:
                     logger.warning(f"Failed to parse annotation name: {ann_file}")
                     continue
-                match = find_best_volume_match_for_ann(ann_name, volume_names)
+                match = find_best_name_match(ann_name, volume_names)
                 if match is not None:
                     if match.plane != ann_name.plane:
                         logger.warning(
@@ -200,7 +259,6 @@ class AnnotationMatcher:
                         continue
                     item_to_volume[self._item_by_filename[ann_file]] = volumes[match.full_name]
 
-        # Mark volumes having only one matching item as semantic and validate shape.
         volume_to_items = defaultdict(list)
         for item, volume in item_to_volume.items():
             volume_to_items[volume.id].append(item)
@@ -306,9 +364,11 @@ def parse_name_parts(full_name: str) -> NameParts:
     is_ann = False
     if VOLUME_NAME in full_name:
         type = "anatomic"
-    else:
+    elif any(part in full_name for part in LABEL_NAME):
         type = next((part for part in LABEL_NAME if part in full_name), None)
         is_ann = type is not None
+    elif "score" in name_no_ext or get_file_ext(full_name) == ".csv":
+        type = "score"
 
     if type is None:
         return
@@ -367,58 +427,58 @@ def parse_name_parts(full_name: str) -> NameParts:
     )
 
 
-def find_best_volume_match_for_ann(ann, volumes):
+def find_best_name_match(item: NameParts, pool: List[NameParts]) -> Union[NameParts, None]:
     """
-    Finds the best matching NameParts object from `volumes` for the given annotation NameParts `ann`.
+    Finds the best matching NameParts object from `pool` for the given annotation NameParts `item`.
     Prefers an exact match where all fields except `type` are the same, and `type` is 'anatomic'.
     Returns the matched NameParts object or None if not found.
     """
-    volume_names = [volume.full_name for volume in volumes]
-    ann_name = ann.full_name
+    pool_item_names = [i.full_name for i in pool]
+    item_name = item.full_name
     # Prefer exact match except for type
-    for vol in volumes:
-        if vol.name_no_ext == ann.name_no_ext.replace(ann.type, "anatomic"):
+    for i in pool:
+        if i.name_no_ext == item.name_no_ext.replace(item.type, i.type):
             logger.debug(
-                "Found exact match for annotation.",
-                extra={"ann": ann_name, "vol": vol.full_name},
+                "Found exact match.",
+                extra={"item": item_name, "pool_item": i.full_name},
             )
-            return vol
+            return i
 
     logger.debug(
         "Failed to find exact match, trying to find a fallback match UUIDs.",
-        extra={"ann": ann_name, "volumes": volume_names},
+        extra={"item": item_name, "pool_items": pool_item_names},
     )
 
     # Fallback: match by plane and patient_uuid, type='anatomic'
-    for vol in volumes:
+    for i in pool:
         if (
-            vol.plane == ann.plane
-            and vol.patient_uuid == ann.patient_uuid
-            and vol.case_uuid == ann.case_uuid
+            i.plane == item.plane
+            and i.patient_uuid == item.patient_uuid
+            and i.case_uuid == item.case_uuid
         ):
             logger.debug(
-                "Found fallback match for annotation by UUIDs.",
-                extra={"ann": ann_name, "vol": vol.full_name},
+                "Found fallback match for item by UUIDs.",
+                extra={"item": item_name, "i": i.full_name},
             )
-            return vol
+            return i
 
     logger.debug(
         "Failed to find fallback match, trying to find a fallback match by plane.",
-        extra={"ann": ann_name, "volumes": volume_names},
+        extra={"item": item_name, "pool_items": pool_item_names},
     )
 
     # Fallback: match by plane and type='anatomic'
-    for vol in volumes:
-        if vol.plane == ann.plane:
+    for i in pool:
+        if i.plane == item.plane:
             logger.debug(
-                "Found fallback match for annotation by plane.",
-                extra={"ann": ann_name, "vol": vol.full_name},
+                "Found fallback match for item by plane.",
+                extra={"item": item_name, "i": i.full_name},
             )
-            return vol
+            return i
 
     logger.debug(
-        "Failed to find any match for annotation.",
-        extra={"ann": ann_name, "volumes": volume_names},
+        "Failed to find any match for item.",
+        extra={"item": item_name, "pool_items": pool_item_names},
     )
 
     return None