supervisely 6.73.324__tar.gz → 6.73.326__tar.gz

{supervisely-6.73.324/supervisely.egg-info → supervisely-6.73.326}/PKG-INFO

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

{supervisely-6.73.324 → supervisely-6.73.326}/supervisely/api/file_api.py

@@ -25,6 +25,7 @@ import supervisely.io.env as env
 import supervisely.io.fs as sly_fs
 from supervisely._utils import batched, rand_str, run_coroutine
 from supervisely.api.module_api import ApiField, ModuleApiBase
+from supervisely.api.remote_storage_api import RemoteStorageApi
 from supervisely.io.fs import (
     ensure_base_path,
     get_file_ext,
@@ -1420,7 +1421,8 @@ class FileApi(ModuleApiBase):
             api.file.upload_directory(9, local_path, path_to_dir)
         """
         if not remote_dir.startswith("/"):
-            remote_dir = "/" + remote_dir
+            if not RemoteStorageApi.is_bucket_url(remote_dir):
+                remote_dir = "/" + remote_dir
 
         if self.dir_exists(team_id, remote_dir):
             if change_name_if_conflict is True:

{supervisely-6.73.324 → supervisely-6.73.326}/supervisely/convert/converter.py

@@ -57,12 +57,12 @@ class ImportManager:
         self._labeling_interface = labeling_interface
         self._upload_as_links = upload_as_links
         self._remote_files_map = {}
+        self._modality = project_type
 
         self._input_data = self._prepare_input_data(input_data)
         self._unpack_archives(self._input_data)
         remove_junk_from_dir(self._input_data)
 
-        self._modality = project_type
         self._converter = self.get_converter()
         if isinstance(self._converter, (HighColorDepthImageConverter, CSVConverter)):
             self._converter.team_id = self._team_id
@@ -112,17 +112,27 @@ class ImportManager:
             logger.info(f"Input data is a local file: {input_data}. Will use its directory")
             return os.path.dirname(input_data)
         elif self._api.storage.exists(self._team_id, input_data):
-            if self._upload_as_links:
+            if self._upload_as_links and str(self._modality) in [
+                ProjectType.IMAGES.value,
+                ProjectType.VIDEOS.value,
+            ]:
                 logger.info(f"Input data is a remote file: {input_data}. Scanning...")
-                return self._scan_remote_files(input_data)
+                return self._reproduce_remote_files(input_data)
             else:
+                if self._upload_as_links and str(self._modality) == ProjectType.VOLUMES.value:
+                    self._scan_remote_files(input_data)
                 logger.info(f"Input data is a remote file: {input_data}. Downloading...")
                 return self._download_input_data(input_data)
         elif self._api.storage.dir_exists(self._team_id, input_data):
-            if self._upload_as_links:
+            if self._upload_as_links and str(self._modality) in [
+                ProjectType.IMAGES.value,
+                ProjectType.VIDEOS.value,
+            ]:
                 logger.info(f"Input data is a remote directory: {input_data}. Scanning...")
-                return self._scan_remote_files(input_data, is_dir=True)
+                return self._reproduce_remote_files(input_data, is_dir=True)
             else:
+                if self._upload_as_links and str(self._modality) == ProjectType.VOLUMES.value:
+                    self._scan_remote_files(input_data, is_dir=True)
                 logger.info(f"Input data is a remote directory: {input_data}. Downloading...")
                 return self._download_input_data(input_data, is_dir=True)
         else:
@@ -160,7 +170,35 @@ class ImportManager:
         return local_path
 
     def _scan_remote_files(self, remote_path, is_dir=False):
-        """Scan remote directory and create dummy structure locally"""
+        """
+        Scan remote directory. Collect local-remote paths mapping
+        Will be used to save relations between uploaded files and remote files (for volumes).
+        """
+
+        dir_path = remote_path.rstrip("/") if is_dir else os.path.dirname(remote_path)
+        dir_name = os.path.basename(dir_path)
+
+        local_path = os.path.join(get_data_dir(), dir_name)
+
+        if is_dir:
+            files = self._api.storage.list(self._team_id, remote_path, include_folders=False)
+        else:
+            files = [self._api.storage.get_info_by_path(self._team_id, remote_path)]
+
+        unique_directories = set()
+        for file in files:
+            new_path = file.path.replace(dir_path, local_path)
+            self._remote_files_map[new_path] = file.path
+            unique_directories.add(str(Path(file.path).parent))
+
+        logger.info(f"Scanned remote directories:\n   - " + "\n   - ".join(unique_directories))
+        return local_path
+
+    def _reproduce_remote_files(self, remote_path, is_dir=False):
+        """
+        Scan remote directory and create dummy structure locally.
+        Will be used to detect annotation format (by dataset structure) remotely.
+        """
 
         dir_path = remote_path.rstrip("/") if is_dir else os.path.dirname(remote_path)
         dir_name = os.path.basename(dir_path)

{supervisely-6.73.324 → supervisely-6.73.326}/supervisely/convert/volume/__init__.py

@@ -2,3 +2,6 @@
 from supervisely.convert.volume.sly.sly_volume_converter import SLYVolumeConverter
 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,
+)

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

@@ -0,0 +1,162 @@
+import os
+from collections import defaultdict
+from pathlib import Path
+
+from supervisely import ProjectMeta, logger
+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
+from supervisely.volume.volume import is_nifti_file
+from supervisely.volume_annotation.volume_annotation import VolumeAnnotation
+from supervisely.volume_annotation.volume_object import VolumeObject
+
+
+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
+
+        @property
+        def is_semantic(self) -> bool:
+            return self._is_semantic
+
+        @is_semantic.setter
+        def is_semantic(self, value: bool):
+            self._is_semantic = value
+
+    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
+                    name = full_name.split("_")[1]
+                    if name in helper.LABEL_NAME or name[:-1] 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()

supervisely-6.73.326/supervisely/convert/volume/nii/nii_volume_converter.py

@@ -0,0 +1,219 @@
+import os
+from pathlib import Path
+
+from supervisely import ProjectMeta, generate_free_name, logger
+from supervisely._utils import batched, is_development
+from supervisely.annotation.obj_class import ObjClass
+from supervisely.api.api import Api
+from supervisely.convert.base_converter import AvailableVolumeConverters
+from supervisely.convert.volume.nii import nii_volume_helper as helper
+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,
+    get_file_name_with_ext,
+    list_files,
+)
+from supervisely.task.progress import tqdm_sly
+from supervisely.volume.volume import is_nifti_file, read_nrrd_serie_volume_np
+from supervisely.volume_annotation.volume_annotation import VolumeAnnotation
+from supervisely.volume_annotation.volume_object import VolumeObject
+
+
+class NiiConverter(VolumeConverter):
+    """
+    Convert NIfTI 3D volume file to Supervisely format.
+    Supports .nii and .nii.gz files.
+
+    The NIfTI file should be structured as follows:
+    - <volume_name>.nii
+    - <volume_name>/
+        - <cls_name_1>.nii
+        - <cls_name_2>.nii
+        - ...
+    - ...
+
+    where   <volume_name> is the name of the volume
+            If the volume has annotations, they should be in the corresponding directory
+                with the same name as the volume (without extension)
+            <cls_name> is the name of the annotation class
+                <cls_name>.nii:
+                    - represent objects of the single class
+                    - should be unique for the current volume (e.g. tumor.nii.gz, lung.nii.gz)
+                    - can contain multiple objects of the class (each object should be represented by a different value in the mask)
+
+    Example:
+    📂 .
+    ├── 📂 CTChest
+    │   ├── 🩻 lung.nii.gz
+    │   └── 🩻 tumor.nii.gz
+    ├── 🩻 CTChest.nii.gz
+    └── 🩻 Spine.nii.gz
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._supports_links = True
+        self._meta_changed = False
+
+    def __str__(self) -> str:
+        return AvailableVolumeConverters.NII
+
+    def validate_format(self) -> bool:
+        # create Items
+        converted_dir_name = "converted"
+        # nrrds_dict = {}
+        nifti_dict = {}
+        nifti_dirs = {}
+
+        planes_detected = {p: False for p in helper.PlanePrefix.values()}
+
+        for root, _, files in os.walk(self._input_data):
+            dir_name = os.path.basename(root)
+            nifti_dirs[dir_name] = root
+            if converted_dir_name in root:
+                continue
+            for file in files:
+                path = os.path.join(root, file)
+                if is_nifti_file(path):  # is nifti
+                    name = get_file_name(path)
+                    if name.endswith(".nii"):
+                        name = get_file_name(name)
+                    nifti_dict[name] = path
+                    for prefix in planes_detected.keys():
+                        if name.startswith(prefix):
+                            planes_detected[prefix] = True
+
+        if any(planes_detected.values()):
+            return False
+
+        self._items = []
+        skip_files = []
+        for name, nrrd_path in nifti_dict.items():
+            if name in nifti_dirs:
+                item = self.Item(item_path=nrrd_path)
+                ann_dir = nifti_dirs[name]
+                item.ann_data = list_files(ann_dir, [".nii", ".nii.gz", ".gz"], None, True)
+                self._items.append(item)
+                skip_files.extend(item.ann_data)
+                skip_files.append(nrrd_path)
+
+        for name, nrrd_path in nifti_dict.items():
+            if nrrd_path in skip_files:
+                continue
+            item = self.Item(item_path=nrrd_path)
+            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 ann_path in item.ann_data:
+                ann_name = get_file_name(ann_path)
+                if ann_name.endswith(".nii"):
+                    ann_name = get_file_name(ann_name)
+
+                ann_name = renamed_classes.get(ann_name, ann_name)
+                for mask, _ in helper.get_annotation_from_nii(ann_path):
+                    obj_class = meta.get_obj_class(ann_name)
+                    if obj_class is None:
+                        obj_class = ObjClass(ann_name, Mask3D)
+                        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()
+
+    def upload_dataset(
+        self,
+        api: Api,
+        dataset_id: int,
+        batch_size: int = 1,
+        log_progress=True,
+    ):
+        """Upload converted data to Supervisely"""
+
+        meta, renamed_classes, _ = self.merge_metas_with_conflicts(api, dataset_id)
+
+        existing_names = set([vol.name for vol in api.volume.get_list(dataset_id)])
+
+        if log_progress:
+            progress, progress_cb = self.get_progress(
+                self.items_count, "Converting and uploading volumes..."
+            )
+        else:
+            progress_cb = None
+
+        converted_dir_name = "converted"
+        converted_dir = os.path.join(self._input_data, converted_dir_name)
+
+        for batch in batched(self._items, batch_size=batch_size):
+            item_names = []
+            item_paths = []
+
+            for item in batch:
+                # if self._upload_as_links:
+                #     remote_path = self.remote_files_map.get(item.path)
+                #     if remote_path is not None:
+                #         item.custom_data = {"remote_path": remote_path}
+
+                item.path = helper.nifti_to_nrrd(item.path, converted_dir)
+                ext = get_file_ext(item.path)
+                if ext.lower() != ext:
+                    new_volume_path = Path(item.path).with_suffix(ext.lower()).as_posix()
+                    os.rename(item.path, new_volume_path)
+                    item.path = new_volume_path
+                item.name = get_file_name_with_ext(item.path)
+                item.name = generate_free_name(
+                    existing_names, item.name, with_ext=True, extend_used_names=True
+                )
+                item_names.append(item.name)
+                item_paths.append(item.path)
+
+                # upload volume
+                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),
+                    leave=True if progress_cb is None else False,
+                    position=1,
+                )
+                # if item.custom_data is not None:
+                #     volume_meta.update(item.custom_data)
+                api.volume.upload_np(dataset_id, item.name, volume_np, volume_meta, progress_nrrd)
+                info = api.volume.get_info_by_name(dataset_id, item.name)
+                item.volume_meta = info.meta
+
+                # create and upload annotation
+                if item.ann_data is not None:
+                    ann = self.to_supervisely(item, meta, renamed_classes, None)
+
+                    if self._meta_changed:
+                        meta, renamed_classes, _ = self.merge_metas_with_conflicts(api, dataset_id)
+
+                    api.volume.annotation.append(info.id, ann)
+
+            if log_progress:
+                progress_cb(len(batch))
+
+        if log_progress:
+            if is_development():
+                progress.close()
+        logger.info(f"Dataset ID:{dataset_id} has been successfully uploaded.")

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

@@ -0,0 +1,99 @@
+import os
+from typing import Generator
+
+import nrrd
+import numpy as np
+
+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 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

{supervisely-6.73.324 → supervisely-6.73.326}/supervisely/volume/volume.py

@@ -816,30 +816,28 @@ def convert_3d_nifti_to_nrrd(path: str) -> Tuple[np.ndarray, dict]:
         path = "/home/admin/work/volumes/vol_01.nii"
         data, header = sly.volume.convert_nifti_to_nrrd(path)
     """
+    import SimpleITK as sitk
 
-    import nibabel as nib  # pylint: disable=import-error
+    nifti_image = sitk.ReadImage(path)
+    nifti_image = _sitk_image_orient_ras(nifti_image)
+    data = sitk.GetArrayFromImage(nifti_image)
+    data = np.transpose(data, (2, 1, 0))
+
+    direction = np.array(nifti_image.GetDirection()).reshape(3, 3)
+    spacing = np.array(nifti_image.GetSpacing())
+    origin = np.array(nifti_image.GetOrigin())
+
+    space_directions = (direction.T * spacing[:, None]).tolist()
 
-    orientation_map = {
-        ('R', 'A', 'S'): "right-anterior-superior",
-        ('L', 'P', 'S'): "left-posterior-superior",
-        ('R', 'P', 'I'): "right-posterior-inferior",
-        ('L', 'A', 'I'): "left-anterior-inferior"
-    }
-    nifti = nib.load(path)
-    reordered_to_ras_nifti = nib.as_closest_canonical(nifti)
-    data = reordered_to_ras_nifti.get_fdata()
-    affine = reordered_to_ras_nifti.affine
-    orientation = nib.aff2axcodes(affine)
-    space_directions = affine[:3, :3].tolist()
-    space_origin = affine[:3, 3].tolist()
     header = {
-        "space": orientation_map.get(orientation, "unknown"),
-        "space directions": space_directions,
-        "space origin": space_origin,
-        "sizes": data.shape,
-        "type": str(data.dtype),
-        "dimension": len(data.shape),
-    }
+            "dimension": 3,
+            "space": "right-anterior-superior",
+            "sizes": list(data.shape),
+            "space directions": space_directions,
+            "endian": "little",
+            "encoding": "gzip",
+            "space origin": origin
+        }
     return data, header
 
 

{supervisely-6.73.324 → supervisely-6.73.326/supervisely.egg-info}/PKG-INFO

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

{supervisely-6.73.324 → supervisely-6.73.326}/supervisely.egg-info/SOURCES.txt

@@ -674,6 +674,7 @@ supervisely/convert/volume/dicom/__init__.py
 supervisely/convert/volume/dicom/dicom_converter.py
 supervisely/convert/volume/dicom/dicom_helper.py
 supervisely/convert/volume/nii/__init__.py
+supervisely/convert/volume/nii/nii_planes_volume_converter.py
 supervisely/convert/volume/nii/nii_volume_converter.py
 supervisely/convert/volume/nii/nii_volume_helper.py
 supervisely/convert/volume/sly/__init__.py