supervisely 6.73.345__tar.gz → 6.73.346__tar.gz

{supervisely-6.73.345/supervisely.egg-info → supervisely-6.73.346}/PKG-INFO

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

{supervisely-6.73.345 → supervisely-6.73.346}/supervisely/convert/volume/__init__.py

@@ -3,5 +3,5 @@ from supervisely.convert.volume.sly.sly_volume_converter import SLYVolumeConvert
 from supervisely.convert.volume.dicom.dicom_converter import DICOMConverter
 from supervisely.convert.volume.nii.nii_volume_converter import NiiConverter
 from supervisely.convert.volume.nii.nii_planes_volume_converter import (
-    NiiPlaneStructuredConverter,
+    NiiPlaneStructuredConverter, NiiPlaneStructuredAnnotationConverter
 )

supervisely-6.73.346/supervisely/convert/volume/nii/nii_planes_volume_converter.py

@@ -0,0 +1,344 @@
+import os
+from collections import defaultdict
+from pathlib import Path
+
+from supervisely import ProjectMeta, logger, Api
+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
+from supervisely.convert.volume.volume_converter import VolumeConverter
+from supervisely.geometry.mask_3d import Mask3D
+from supervisely.io.fs import get_file_ext, get_file_name, list_files_recursively
+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):
+    """Convert NIfTI 3D volume file to Supervisely format.
+    The NIfTI file should be structured as follows:
+    - <prefix>_anatomic_<idx>.nii (or .nii.gz)
+    - <prefix>_inference_<idx>.nii (or .nii.gz)
+        where   <prefix> is one of the following: cor, sag, axl
+                <idx> is the index of the volume (to match volumes with annotations)
+
+    Supports .nii and .nii.gz files.
+
+    Example:
+        📂 .
+        ├── 🩻 axl_anatomic_1.nii
+        ├── 🩻 axl_inference_1.nii class 1 (may contain multiple instances of the same class)
+        ├── 🩻 cor_anatomic_1.nii
+        ├── 🩻 cor_inference_1.nii class 1
+        ├── 🩻 sag_anatomic_1.nii
+        ├── 🩻 sag_inference_1.nii class 1
+        ├── 🩻 sag_inference_2.nii class 2
+        └── 🩻 sag_inference_3.nii class 3
+
+    Additionally, if a TXT file with class color map is present, it will be used to
+    create the classes with names and colors corresponding to the pixel values in the NIfTI files.
+    The TXT file should be structured as follows:
+
+    ```txt
+    1 Femur 255 0 0
+    2 Femoral cartilage 0 255 0
+    3 Tibia 0 0 255
+    4 Tibia cartilage 255 255 0
+    5 Patella 0 255 255
+    6 Patellar cartilage 255 0 255
+    7 Miniscus 175 175 175
+    ```
+    where   1, 2, ... are the pixel values in the NIfTI files
+            Femur, Femoral cartilage, ... are the names of the classes
+            255, 0, 0, ... are the RGB colors of the classes
+    The class name will be used to create the corresponding ObjClass in Supervisely.
+    """
+
+    class Item(VolumeConverter.BaseItem):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self._is_semantic = False
+            self.volume_meta = None
+
+        @property
+        def is_semantic(self) -> bool:
+            return self._is_semantic
+
+        @is_semantic.setter
+        def is_semantic(self, value: bool):
+            self._is_semantic = value
+
+        def create_empty_annotation(self):
+            return VolumeAnnotation(self.volume_meta)
+        
+    def __str__(self):
+        return "nii_custom"
+
+    def validate_format(self) -> bool:
+        # create Items
+        converted_dir_name = "converted"
+
+        volumes_dict = defaultdict(list)
+        ann_dict = defaultdict(list)
+        cls_color_map = None
+
+        for root, _, files in os.walk(self._input_data):
+            if converted_dir_name in root:
+                continue
+            for file in files:
+                path = os.path.join(root, file)
+                if is_nifti_file(path):
+                    full_name = get_file_name(path)
+                    if full_name.endswith(".nii"):
+                        full_name = get_file_name(full_name)
+                    prefix = full_name.split("_")[0]
+                    if prefix not in helper.PlanePrefix.values():
+                        continue
+                    if any(label_name in full_name for label_name in helper.LABEL_NAME):
+                        ann_dict[prefix].append(path)
+                    else:
+                        volumes_dict[prefix].append(path)
+                ext = get_file_ext(path)
+                if ext == ".txt":
+                    cls_color_map = helper.read_cls_color_map(path)
+                    if cls_color_map is None:
+                        logger.warning(f"Failed to read class color map from {path}.")
+
+        self._items = []
+        for prefix, paths in volumes_dict.items():
+            if len(paths) == 1:
+                item = self.Item(item_path=paths[0])
+                item.ann_data = ann_dict.get(prefix, [])
+                item.is_semantic = len(item.ann_data) == 1
+                if cls_color_map is not None:
+                    item.custom_data["cls_color_map"] = cls_color_map
+                self._items.append(item)
+            elif len(paths) > 1:
+                logger.info(
+                    f"Found {len(paths)} volumes with prefix {prefix}. Will try to match them by directories."
+                )
+                for path in paths:
+                    item = self.Item(item_path=path)
+                    possible_ann_paths = []
+                    for ann_path in ann_dict.get(prefix, []):
+                        if Path(ann_path).parent == Path(path).parent:
+                            possible_ann_paths.append(ann_path)
+                    item.ann_data = possible_ann_paths
+                    item.is_semantic = len(possible_ann_paths) == 1
+                    if cls_color_map is not None:
+                        item.custom_data["cls_color_map"] = cls_color_map
+                    self._items.append(item)
+        self._meta = ProjectMeta()
+        return self.items_count > 0
+
+    def to_supervisely(
+        self,
+        item: VolumeConverter.Item,
+        meta: ProjectMeta = None,
+        renamed_classes: dict = None,
+        renamed_tags: dict = None,
+    ) -> VolumeAnnotation:
+        """Convert to Supervisely format."""
+
+        try:
+            objs = []
+            spatial_figures = []
+            for idx, ann_path in enumerate(item.ann_data, start=1):
+                for mask, pixel_id in helper.get_annotation_from_nii(ann_path):
+                    class_id = pixel_id if item.is_semantic else idx
+                    class_name = f"Segment_{class_id}"
+                    color = None
+                    if item.custom_data.get("cls_color_map") is not None:
+                        class_info = item.custom_data["cls_color_map"].get(class_id)
+                        if class_info is not None:
+                            class_name, color = class_info
+                    class_name = renamed_classes.get(class_name, class_name)
+                    obj_class = meta.get_obj_class(class_name)
+                    if obj_class is None:
+                        obj_class = ObjClass(class_name, Mask3D, color)
+                        meta = meta.add_obj_class(obj_class)
+                        self._meta_changed = True
+                        self._meta = meta
+                    obj = VolumeObject(obj_class, mask_3d=mask)
+                    spatial_figures.append(obj.figure)
+                    objs.append(obj)
+            return VolumeAnnotation(item.volume_meta, objects=objs, spatial_figures=spatial_figures)
+        except Exception as e:
+            logger.warning(f"Failed to convert {item.path} to Supervisely format: {e}")
+            return item.create_empty_annotation()
+
+
+class NiiPlaneStructuredAnnotationConverter(NiiConverter, VolumeConverter):
+    """
+    Upload NIfTI Annotations
+    """
+
+    class Item(VolumeConverter.BaseItem):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self._is_semantic = False
+            self.volume_meta = None
+
+        @property
+        def is_semantic(self) -> bool:
+            return self._is_semantic
+
+        @is_semantic.setter
+        def is_semantic(self, value: bool):
+            self._is_semantic = value
+
+        def create_empty_annotation(self):
+            return VolumeAnnotation(self.volume_meta)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._json_map = None
+
+    def __str__(self):
+        return "nii_custom_ann"
+
+    def validate_format(self) -> bool:
+        try:
+            from nibabel import load, filebasedimages
+        except ImportError:
+            raise ImportError(
+                "No module named nibabel. Please make sure that module is installed from pip and try again."
+            )
+        cls_color_map = None
+
+        has_volumes = lambda x: helper.VOLUME_NAME in x
+        if list_files_recursively(self._input_data, filter_fn=has_volumes):
+            return False
+
+        txts = list_files_recursively(self._input_data, [".txt"], None, True)
+        cls_color_map = next(iter(txts), None)
+        if cls_color_map is not None:
+            cls_color_map = helper.read_cls_color_map(cls_color_map)
+
+        jsons = list_files_recursively(self._input_data, [".json"], None, True)
+        json_map = next(iter(jsons), None)
+        if json_map is not None:
+            self._json_map = helper.read_json_map(json_map)
+
+        is_ann = lambda x: any(label_name in x for label_name in helper.LABEL_NAME)
+        for root, _, files in os.walk(self._input_data):
+            for file in files:
+                path = os.path.join(root, file)
+                if is_ann(file):
+                    prefix = get_file_name(path).split("_")[0]
+                    if prefix not in helper.PlanePrefix.values():
+                        continue
+                    try:
+                        nii = load(path)
+                    except filebasedimages.ImageFileError:
+                        continue
+                    item = self.Item(item_path=None, ann_data=path)
+                    item.set_shape(nii.shape)
+                    if cls_color_map is not None:
+                        item.custom_data["cls_color_map"] = cls_color_map
+                    self._items.append(item)
+
+        obj_classes = None
+        if cls_color_map is not None:
+            obj_classes = [ObjClass(name, Mask3D, color) for name, color in cls_color_map.values()]
+
+        self._meta = ProjectMeta(obj_classes=obj_classes)
+        return len(self._items) > 0
+
+    def to_supervisely(
+        self,
+        item: VolumeConverter.Item,
+        meta: ProjectMeta = None,
+        renamed_classes: dict = None,
+        renamed_tags: dict = None,
+    ) -> VolumeAnnotation:
+        """Convert to Supervisely format."""
+        import re
+        try:
+            objs = []
+            spatial_figures = []
+            ann_path = item.ann_data
+            ann_idx = 0
+            match = re.search(r"_(\d+)(?:\.[^.]+)+$", ann_path)
+            if match:
+                ann_idx = int(match.group(1))
+            for mask, pixel_id in helper.get_annotation_from_nii(ann_path):
+                class_id = pixel_id if item.is_semantic else ann_idx
+                class_name = f"Segment_{class_id}"
+                color = None
+                if item.custom_data.get("cls_color_map") is not None:
+                    class_info = item.custom_data["cls_color_map"].get(class_id)
+                    if class_info is not None:
+                        class_name, color = class_info
+                class_name = renamed_classes.get(class_name, class_name)
+                obj_class = meta.get_obj_class(class_name)
+                if obj_class is None:
+                    obj_class = ObjClass(class_name, Mask3D, color)
+                    meta = meta.add_obj_class(obj_class)
+                    self._meta_changed = True
+                    self._meta = meta
+                obj = VolumeObject(obj_class, mask_3d=mask)
+                spatial_figures.append(obj.figure)
+                objs.append(obj)
+            return VolumeAnnotation(item.volume_meta, objects=objs, spatial_figures=spatial_figures)
+        except Exception as e:
+            logger.warning(f"Failed to convert {item.ann_data} to Supervisely format: {e}")
+            return item.create_empty_annotation()
+
+    def upload_dataset(
+        self, api: Api, dataset_id: int, batch_size: int = 50, log_progress=True
+    ) -> None:
+        meta, renamed_classes, _ = self.merge_metas_with_conflicts(api, dataset_id)
+
+        matcher = helper.AnnotationMatcher(self._items, dataset_id)
+        if self._json_map is not None:
+            try:
+                matched_dict = matcher.match_from_json(api, self._json_map)
+            except Exception as e:
+                logger.error(f"Failed to match annotations from a json map: {e}")
+                matched_dict = {}
+        else:
+            matcher.get_volumes(api)
+            matched_dict = matcher.match_items()
+            if len(matched_dict) != len(self._items):
+                extra = {
+                    "items count": len(self._items),
+                    "matched count": len(matched_dict),
+                    "unmatched count": len(self._items) - len(matched_dict),
+                }
+                logger.warning(
+                    "Not all items were matched with volumes. Some items may be skipped.",
+                    extra=extra,
+                )
+        if len(matched_dict) == 0:
+            raise RuntimeError(
+                "No items were matched with volumes. Please check the input data and try again."
+            )
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(
+                len(matched_dict), "Uploading volumes annotations..."
+            )
+        else:
+            progress_cb = None
+
+        for item, volume in matched_dict.items():
+            item.volume_meta = volume.meta
+            ann = self.to_supervisely(item, meta, renamed_classes, None)
+            if self._meta_changed:
+                meta, renamed_classes, _ = self.merge_metas_with_conflicts(api, dataset_id)
+                self._meta_changed = False
+            api.volume.annotation.append(volume.id, ann, volume_info=volume)
+            progress_cb(1) if log_progress else None
+
+        res_ds_info = api.dataset.get_info_by_id(dataset_id)
+        if res_ds_info.items_count == 0:
+            logger.info("Resulting dataset is empty. Removing it.")
+            api.dataset.remove(dataset_id)
+
+
+        if log_progress:
+            if is_development():
+                progress.close()
+            logger.info(f"Successfully uploaded {len(matched_dict)} annotations.")

{supervisely-6.73.345 → supervisely-6.73.346}/supervisely/convert/volume/nii/nii_volume_converter.py

@@ -207,7 +207,7 @@ class NiiConverter(VolumeConverter):
 
                     if self._meta_changed:
                         meta, renamed_classes, _ = self.merge_metas_with_conflicts(api, dataset_id)
-
+                        self._meta_changed = False
                     api.volume.annotation.append(info.id, ann)
 
             if log_progress:

supervisely-6.73.346/supervisely/convert/volume/nii/nii_volume_helper.py

@@ -0,0 +1,306 @@
+import os
+from typing import Generator
+
+import nrrd
+import numpy as np
+from pathlib import Path
+from collections import defaultdict, namedtuple
+
+from supervisely import Api
+from supervisely.collection.str_enum import StrEnum
+from supervisely.geometry.mask_3d import Mask3D
+from supervisely.io.fs import ensure_base_path, get_file_ext, get_file_name
+from supervisely.sly_logger import logger
+from supervisely.volume.volume import convert_3d_nifti_to_nrrd
+
+VOLUME_NAME = "anatomic"
+LABEL_NAME = ["inference", "label", "annotation", "mask", "segmentation"]
+
+
+class PlanePrefix(str, StrEnum):
+    """Prefix for plane names."""
+
+    CORONAL = "cor"
+    SAGITTAL = "sag"
+    AXIAL = "axl"
+
+
+def read_cls_color_map(path: str) -> dict:
+    """Read class color map from TXT file.
+
+    ```txt
+    1 Femur 255 0 0
+    2 Femoral cartilage 0 255 0
+    3 Tibia 0 0 255
+    4 Tibia cartilage 255 255 0
+    5 Patella 0 255 255
+    6 Patellar cartilage 255 0 255
+    7 Miniscus 175 175 175
+    ```
+    """
+
+    cls_color_map = {}
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r") as file:
+            for line in file:
+                parts = line.strip().split()
+                color = None
+                try:
+                    color = list(map(int, parts[-3:]))
+                except:
+                    pass
+                cls_id = int(parts[0])
+                if not color:
+                    cls_name = " ".join(parts[1:])
+                else:
+                    cls_name = " ".join(parts[1:-3])
+                if cls_id in cls_color_map:
+                    logger.warning(f"Duplicate class ID {cls_id} found in color map.")
+                if cls_name in cls_color_map:
+                    logger.warning(f"Duplicate class name {cls_name} found in color map.")
+                if len(color) != 3:
+                    logger.warning(f"Invalid color format for class {cls_name}. Expected 3 values.")
+                if any(c < 0 or c > 255 for c in color):
+                    logger.warning(
+                        f"Invalid color value for class {cls_name}. Expected values between 0 and 255."
+                    )
+                cls_color_map[cls_id] = (cls_name, color)
+    except Exception as e:
+        logger.warning(f"Failed to read class color map from {path}: {e}")
+        return None
+    return cls_color_map
+
+def read_json_map(path: str) -> dict:
+    import json
+
+    """Read JSON map from file."""
+    if not os.path.exists(path):
+        return None
+    try:
+        with open(path, "r") as file:
+            json_map = json.load(file)
+    except Exception as e:
+        logger.warning(f"Failed to read JSON map from {path}: {e}")
+        return None
+    return json_map
+
+
+def nifti_to_nrrd(nii_file_path: str, converted_dir: str) -> str:
+    """Convert NIfTI 3D volume file to NRRD 3D volume file."""
+
+    output_name = get_file_name(nii_file_path)
+    if get_file_ext(output_name) == ".nii":
+        output_name = get_file_name(output_name)
+
+    data, header = convert_3d_nifti_to_nrrd(nii_file_path)
+
+    nrrd_file_path = os.path.join(converted_dir, f"{output_name}.nrrd")
+    ensure_base_path(nrrd_file_path)
+
+    nrrd.write(nrrd_file_path, data, header)
+    return nrrd_file_path
+
+
+def get_annotation_from_nii(path: str) -> Generator[Mask3D, None, None]:
+    """Get annotation from NIfTI 3D volume file."""
+
+    data, _ = convert_3d_nifti_to_nrrd(path)
+    unique_classes = np.unique(data)
+
+    for class_id in unique_classes:
+        if class_id == 0:
+            continue
+        mask = Mask3D(data == class_id)
+        yield mask, class_id
+
+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 = {}
+
+        for item in items:
+            path = Path(item.ann_data)
+            dataset_name = path.parts[-2]
+            filename = path.name
+
+            self._ann_paths[dataset_name].append(filename)
+            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}
+        project_id = dataset_info.project_id
+        if dataset_info.items_count > 0 and len(self._ann_paths.keys()) == 1:
+            self._project_wide = False
+        else:
+            datasets = {dsinfo.name: dsinfo for dsinfo in api.dataset.get_list(project_id, recursive=True)}
+            self._project_wide = True
+
+        volumes = defaultdict(lambda: {})
+        ds_filter = lambda ds_name: ds_name in self._ann_paths if self._project_wide else True
+        for ds_name, ds_info in datasets.items():
+            if ds_filter(ds_name):
+                volumes[ds_name].update(
+                    {info.name: info for info in api.volume.get_list(ds_info.id)}
+                )
+
+        if len(volumes) == 0:
+            err_msg = "Failed to retrieve volumes from the project. Perhaps the input data structure is incorrect."
+            raise RuntimeError(err_msg)
+
+        self._volumes = volumes
+
+    def match_items(self):
+        """Match annotation files with corresponding volumes using regex-based matching."""
+        import re
+
+        def extract_prefix(ann_file):
+            import re
+            pattern = r'^(?P<prefix>cor|sag|axl).*?(?:' + "|".join(LABEL_NAME) + r')'
+            m = re.match(pattern, ann_file, re.IGNORECASE)
+            if m:
+                return m.group("prefix").lower()
+            return None
+
+        def is_volume_match(volume_name, prefix):
+            pattern = r'^' + re.escape(prefix) + r'.*?anatomic'
+            return re.match(pattern, volume_name, re.IGNORECASE) is not None
+
+        def find_best_volume_match(prefix, available_volumes):
+            candidates = {name: volume for name, volume in available_volumes.items() if is_volume_match(name, prefix)}
+            if not candidates:
+                return None, None
+
+            # Prefer an exact candidate
+            ann_name_no_ext = ann_file.split(".")[0]
+            exact_candidate = re.sub(r'(' + '|'.join(LABEL_NAME) + r')', 'anatomic', ann_name_no_ext, flags=re.IGNORECASE)
+            for name in candidates:
+                if re.fullmatch(re.escape(exact_candidate), name, re.IGNORECASE):
+                    return name, candidates[name]
+
+            # Otherwise, choose the candidate with the shortest name
+            best_match = sorted(candidates.keys(), key=len)[0]
+            return best_match, candidates[best_match]
+
+        item_to_volume = {}
+
+        def process_annotation_file(ann_file, dataset_name, volumes):
+            prefix = extract_prefix(ann_file)
+            if prefix is None:
+                logger.warning(f"Failed to extract prefix from annotation file {ann_file}. Skipping.")
+                return
+
+            matched_name, matched_volume = find_best_volume_match(prefix, volumes)
+            if not matched_volume:
+                logger.warning(f"No matching volume found for annotation with prefix '{prefix}' in dataset {dataset_name}.")
+                return
+
+            # Retrieve the correct item based on matching mode.
+            item = (
+                self._item_by_path.get((dataset_name, ann_file))
+                if self._project_wide
+                else self._item_by_filename.get(ann_file)
+            )
+            if not item:
+                logger.warning(f"Item not found for annotation file {ann_file} in {'dataset ' + dataset_name if self._project_wide else 'single dataset mode'}.")
+                return
+
+            item_to_volume[item] = matched_volume
+            ann_file = ann_file.split(".")[0]
+            ann_supposed_match = re.sub(r'(' + '|'.join(LABEL_NAME) + r')', 'anatomic', ann_file, flags=re.IGNORECASE)
+            if matched_name.lower() != ann_supposed_match:
+                logger.debug(f"Fuzzy matched {ann_file} to volume {matched_name} using prefix '{prefix}'.")
+
+        # Perform matching
+        for dataset_name, volumes in self._volumes.items():
+            ann_files = self._ann_paths.get(dataset_name, []) if self._project_wide else list(self._ann_paths.values())[0]
+            for ann_file in ann_files:
+                process_annotation_file(ann_file, dataset_name, volumes)
+
+        # 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)
+        
+        for volume_id, items in volume_to_items.items():
+            if len(items) == 1:
+                items[0].is_semantic = True
+
+        items_to_remove = []
+        for item, volume in item_to_volume.items():
+            volume_shape = tuple(volume.file_meta["sizes"])
+            if item.shape != volume_shape:
+                logger.warning(f"Volume shape mismatch: {item.shape} != {volume_shape}")
+                # items_to_remove.append(item)
+        for item in items_to_remove:
+            del item_to_volume[item]
+
+        return item_to_volume
+
+    def match_from_json(self, api: Api, json_map: dict):
+        """
+        Match annotation files with corresponding volumes based on a JSON map.
+
+        Example json structure:
+        {
+            "cor_inference_1.nii": 123,
+            "sag_mask_2.nii": 456
+        }
+        Where key is the annotation file name and value is the volume ID.
+
+        For project-wide matching, the key should include dataset name:
+        {
+            "dataset1/cor_inference_1.nii": 123,
+            "dataset2/sag_mask_2.nii": 456
+        }
+        """
+        item_to_volume = {}
+
+        for ann_path, volume_id in json_map.items():
+            # Check if it's a project-wide path (contains dataset name)
+            path_parts = Path(ann_path)
+            if len(path_parts.parts) > 1:
+                # Project-wide format: "dataset_name/filename.nii"
+                dataset_name = path_parts.parts[-2]
+                ann_name = path_parts.name
+                item = self._item_by_path.get((dataset_name, ann_name))
+            else:
+                # Single dataset format: "filename.nii"
+                ann_name = path_parts.name
+                item = self._item_by_filename.get(ann_name)
+
+            if item:
+                volume = api.volume.get_info_by_id(volume_id)
+                if volume:
+                    item_to_volume[item] = volume
+
+                    # Validate shape
+                    volume_shape = tuple(volume.file_meta["sizes"])
+                    if item.shape != volume_shape:
+                        logger.warning(
+                            f"Volume shape mismatch: {item.shape} != {volume_shape} for {ann_path}. Using anyway."
+                        )
+                else:
+                    logger.warning(f"Volume {volume_id} not found for {ann_path}.")
+            else:
+                logger.warning(f"Item not found for annotation file {ann_path}.")
+
+        # Set semantic flag for volumes with only one associated item
+        volume_to_items = defaultdict(list)
+        for item, volume in item_to_volume.items():
+            volume_to_items[volume.id].append(item)
+        for volume_id, items in volume_to_items.items():
+            if len(items) == 1:
+                items[0].is_semantic = True
+
+        return item_to_volume

{supervisely-6.73.345 → supervisely-6.73.346/supervisely.egg-info}/PKG-INFO

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