supervisely 6.73.368__tar.gz → 6.73.370__tar.gz

{supervisely-6.73.368/supervisely.egg-info → supervisely-6.73.370}/PKG-INFO

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

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/api/volume/volume_figure_api.py

@@ -2,7 +2,6 @@
 import os
 import re
 import tempfile
-from collections import OrderedDict
 from typing import Dict, List
 from uuid import UUID
 
@@ -470,7 +469,7 @@ class VolumeFigureApi(FigureApi):
                 for figure in figures:
                     if figure.key() == key:
                         geometry_data = figure.geometry.data
-                        header = self._create_header_for_geometry(figure.geometry)
+                        header = figure.geometry.create_header()
                         geometry_bytes = encode(geometry_data.astype(uint8), header)
                         self.upload_sf_geometries([key], {key: geometry_bytes}, key_id_map)
 
@@ -625,19 +624,6 @@ class VolumeFigureApi(FigureApi):
             geometry = Mask3D.create_from_file(figure_path)
             spatial_figure._set_3d_geometry(geometry)
 
-    def _create_header_for_geometry(self, geometry: Mask3D) -> OrderedDict:
-        """
-        Create header for encoding Mask3D to NRRD bytes
-        """
-        header = OrderedDict()
-        if geometry._space is not None:
-            header["space"] = geometry._space
-        if geometry._space_directions is not None:
-            header["space directions"] = geometry._space_directions
-        if geometry._space_origin is not None:
-            header["space origin"] = geometry._space_origin.to_json()["space_origin"]
-        return header
-
     def download(
         self, dataset_id: int, volume_ids: List[int] = None, skip_geometry: bool = False, **kwargs
     ) -> Dict[int, List[FigureInfo]]:

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/app/widgets/experiment_selector/experiment_selector.py

@@ -52,7 +52,7 @@ class ExperimentSelector(Widget):
             self._experiment_info = experiment_info
 
             task_id = experiment_info.task_id
-            if task_id == "debug-session":
+            if task_id == "debug-session" or task_id == -1:
                 pass
             elif type(task_id) is str:
                 if task_id.isdigit():
@@ -392,7 +392,7 @@ class ExperimentSelector(Widget):
                 if result:
                     task_type, model_row = result
                     if task_type is not None and model_row is not None:
-                        if model_row.task_id == "debug-session":
+                        if model_row.task_id == "debug-session" or model_row.task_id == -1:
                             self.__debug_row = (task_type, model_row)
                             continue
                         table_rows[task_type].append(model_row)

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/convert/volume/nii/nii_volume_helper.py

@@ -1,10 +1,10 @@
 import os
+from collections import defaultdict, namedtuple
+from pathlib import Path
 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
@@ -107,13 +107,13 @@ def nifti_to_nrrd(nii_file_path: str, converted_dir: str) -> str:
 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)
+    data, header = 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)
+        mask = Mask3D(data == class_id, volume_header=header)
         yield mask, class_id
 
 

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/geometry/constants.py

@@ -12,6 +12,8 @@ INTERIOR = "interior"
 MULTICHANNEL_BITMAP = "multichannelBitmap"
 ORIGIN = "origin"
 SPACE_ORIGIN = "space_origin"
+SPACE = "space"
+SPACE_DIRECTIONS = "space_directions"
 POINTS = "points"
 ROWS = "rows"
 TYPE = "type"

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/geometry/mask_3d.py

@@ -6,9 +6,9 @@ from __future__ import annotations
 import base64
 import gzip
 import tempfile
+from collections import OrderedDict
 from typing import Dict, List, Literal, Optional, Tuple, Union
 
-import nrrd
 import numpy as np
 
 from supervisely import logger
@@ -22,6 +22,8 @@ from supervisely.geometry.constants import (
     ID,
     LABELER_LOGIN,
     MASK_3D,
+    SPACE,
+    SPACE_DIRECTIONS,
     SPACE_ORIGIN,
     UPDATED_AT,
 )
@@ -183,6 +185,10 @@ class Mask3D(Geometry):
     :type updated_at: str, optional
     :param created_at: Date and Time when Mask 3D was created. Date Format is the same as in "updated_at" parameter.
     :type created_at: str, optional
+    :param volume_header: NRRD header dictionary. Optional.
+    :type volume_header: dict, optional
+    :param convert_to_ras: If True, converts the mask to RAS orientation. Default is True.
+    :type convert_to_ras: bool, optional
     :raises: :class:`ValueError`, if data is not bool or no pixels set to True in data
     :Usage example:
 
@@ -219,6 +225,8 @@ class Mask3D(Geometry):
         labeler_login: Optional[str] = None,
         updated_at: Optional[str] = None,
         created_at: Optional[str] = None,
+        volume_header: Optional[Dict] = None,
+        convert_to_ras: bool = True,
     ):
         super().__init__(
             sly_id=sly_id,
@@ -253,6 +261,98 @@ class Mask3D(Geometry):
         self._space = None
         self._space_directions = None
 
+        if volume_header is not None:
+            self.set_volume_space_meta(volume_header)
+            if self.space is not None and self.space != "right-anterior-superior":
+                if convert_to_ras:
+                    self.orient_ras()
+                else:
+                    logger.debug(
+                        "Mask3D is not in RAS orientation. It is recommended to use RAS orientation for 3D masks."
+                    )
+
+    @property
+    def space_origin(self) -> Optional[List[float]]:
+        """
+        Get the space origin of the Mask3D as a list of floats.
+
+        :return: Space origin of the Mask3D.
+        :rtype: List[float] or None
+        """
+        if self._space_origin is not None:
+            return [self._space_origin.x, self._space_origin.y, self._space_origin.z]
+        return None
+
+    @space_origin.setter
+    def space_origin(self, value: Union[PointVolume, List[float], np.array]):
+        """
+        Set the space origin of the Mask3D.
+
+        :param value: Space origin of the Mask3D. If provided as a list or array, it should contain 3 floats in the order [x, y, z].
+        :type value: :class:`PointVolume<PointVolume>` or List[float]
+        """
+        if isinstance(value, PointVolume):
+            self._space_origin = value
+        elif isinstance(value, list) and len(value) == 3:
+            self._space_origin = PointVolume(x=value[0], y=value[1], z=value[2])
+        elif isinstance(value, np.ndarray) and value.shape == (3,):
+            self._space_origin = PointVolume(x=value[0], y=value[1], z=value[2])
+        else:
+            raise ValueError("Space origin must be a PointVolume or a list of 3 floats.")
+
+    @property
+    def space(self) -> Optional[str]:
+        """
+        Get the space of the Mask3D.
+
+        :return: Space of the Mask3D.
+        :rtype: :class:`str`
+        """
+        return self._space
+
+    @space.setter
+    def space(self, value: str):
+        """
+        Set the space of the Mask3D.
+
+        :param value: Space of the Mask3D.
+        :type value: str
+        """
+        if not isinstance(value, str):
+            raise ValueError("Space must be a string.")
+        self._space = value
+
+    @property
+    def space_directions(self) -> Optional[List[List[float]]]:
+        """
+        Get the space directions of the Mask3D.
+
+        :return: Space directions of the Mask3D.
+        :rtype: :class:`List[List[float]]`
+        """
+        return self._space_directions
+
+    @space_directions.setter
+    def space_directions(self, value: Union[List[List[float]], np.ndarray]):
+        """
+        Set the space directions of the Mask3D.
+
+        :param value: Space directions of the Mask3D. Should be a 3x3 array-like structure.
+        :type value: List[List[float]] or np.ndarray
+        """
+        if isinstance(value, np.ndarray):
+            if value.shape != (3, 3):
+                raise ValueError("Space directions must be a 3x3 array.")
+            self._space_directions = value.tolist()
+        elif (
+            isinstance(value, list)
+            and len(value) == 3
+            and all(isinstance(row, (list, np.ndarray)) and len(row) == 3 for row in value)
+        ):
+            self._space_directions = [list(row) for row in value]
+        else:
+            raise ValueError("Space directions must be a 3x3 array or list of lists.")
+
     @staticmethod
     def geometry_name():
         """Return geometry name"""
@@ -268,22 +368,8 @@ class Mask3D(Geometry):
         :param file_path: Path to nrrd file with data
         :type file_path: str
         """
-        mask3d_data, mask3d_header = nrrd.read(file_path)
-        figure.geometry.data = mask3d_data
-        try:
-            figure.geometry._space_origin = PointVolume(
-                x=mask3d_header["space origin"][0],
-                y=mask3d_header["space origin"][1],
-                z=mask3d_header["space origin"][2],
-            )
-            figure.geometry._space = mask3d_header["space"]
-            figure.geometry._space_directions = mask3d_header["space directions"]
-        except KeyError as e:
-            header_keys = ["'space'", "'space directions'", "'space origin'"]
-            if str(e) in header_keys:
-                logger.warning(
-                    f"The Mask3D geometry for figure ID '{get_file_name(file_path)}' doesn't contain optional space attributes that have similar names to {', '.join(header_keys)}. To set the values for these attributes, you can use information from the Volume associated with this figure object."
-                )
+        mask3d = Mask3D.create_from_file(file_path)
+        figure._set_3d_geometry(mask3d)
         path_without_filename = "/".join(file_path.split("/")[:-1])
         remove_dir(path_without_filename)
 
@@ -295,22 +381,26 @@ class Mask3D(Geometry):
         :param file_path: Path to nrrd file with data
         :type file_path: str
         """
-        mask3d_data, mask3d_header = nrrd.read(file_path)
-        geometry = cls(data=mask3d_data)
-        try:
-            geometry._space_origin = PointVolume(
-                x=mask3d_header["space origin"][0],
-                y=mask3d_header["space origin"][1],
-                z=mask3d_header["space origin"][2],
-            )
-            geometry._space = mask3d_header["space"]
-            geometry._space_directions = mask3d_header["space directions"]
-        except KeyError as e:
+        from supervisely.volume.volume import read_nrrd_serie_volume_np
+
+        mask3d_data, meta = read_nrrd_serie_volume_np(file_path)
+        direction = np.array(meta["directions"]).reshape(3, 3)
+        spacing = np.array(meta["spacing"])
+        space_directions = (direction.T * spacing[:, None]).tolist()
+        mask3d_header = {
+            "space": "right-anterior-superior",
+            "space directions": space_directions,
+            "space origin": meta.get("origin", None),
+        }
+
+        geometry = cls(data=mask3d_data, volume_header=mask3d_header)
+
+        fields_to_check = ["space", "space_directions", "space_origin"]
+        if any([getattr(geometry, value) is None for value in fields_to_check]):
             header_keys = ["'space'", "'space directions'", "'space origin'"]
-            if str(e) in header_keys:
-                logger.debug(
-                    f"The Mask3D geometry created from the file '{file_path}' doesn't contain optional space attributes that have similar names to {', '.join(header_keys)}. To set the values for these attributes, you can use information from the Volume associated with this figure object."
-                )
+            logger.debug(
+                f"The Mask3D geometry created from the file '{file_path}' doesn't contain optional space attributes that have similar names to {', '.join(header_keys)}. To set the values for these attributes, you can use information from the Volume associated with this figure object."
+            )
         return geometry
 
     @classmethod
@@ -323,7 +413,7 @@ class Mask3D(Geometry):
         :return: A Mask3D geometry object.
         :rtype: Mask3D
         """
-        with tempfile.NamedTemporaryFile(delete=True) as temp_file:
+        with tempfile.NamedTemporaryFile(delete=True, suffix=".nrrd") as temp_file:
             temp_file.write(geometry_bytes)
             return cls.create_from_file(temp_file.name)
 
@@ -368,12 +458,14 @@ class Mask3D(Geometry):
             GEOMETRY_TYPE: self.name(),
         }
 
-        if self._space_origin:
-            res[f"{self._impl_json_class_name()}"][f"{SPACE_ORIGIN}"] = [
-                self._space_origin.x,
-                self._space_origin.y,
-                self._space_origin.z,
-            ]
+        if self.space_origin:
+            res[f"{self._impl_json_class_name()}"][f"{SPACE_ORIGIN}"] = self.space_origin
+
+        if self.space:
+            res[f"{self._impl_json_class_name()}"][f"{SPACE}"] = self.space
+
+        if self.space_directions:
+            res[f"{self._impl_json_class_name()}"][f"{SPACE_DIRECTIONS}"] = self.space_directions
 
         self._add_creation_info(res)
         return res
@@ -426,18 +518,30 @@ class Mask3D(Geometry):
         created_at = json_data.get(CREATED_AT, None)
         sly_id = json_data.get(ID, None)
         class_id = json_data.get(CLASS_ID, None)
-        instance = cls(
+
+        header = {}
+
+        space_origin = json_data[json_root_key].get(SPACE_ORIGIN, None)
+        if space_origin is not None:
+            header["space origin"] = space_origin
+
+        space = json_data[json_root_key].get(SPACE, None)
+        if space is not None:
+            header["space"] = space
+
+        space_directions = json_data[json_root_key].get(SPACE_DIRECTIONS, None)
+        if space_directions is not None:
+            header["space directions"] = space_directions
+
+        return cls(
             data=data.astype(np.bool_),
             sly_id=sly_id,
             class_id=class_id,
             labeler_login=labeler_login,
             updated_at=updated_at,
             created_at=created_at,
+            volume_header=header,
         )
-        if SPACE_ORIGIN in json_data[json_root_key]:
-            x, y, z = json_data[json_root_key][SPACE_ORIGIN]
-            instance._space_origin = PointVolume(x=x, y=y, z=z)
-        return instance
 
     @classmethod
     def _impl_json_class_name(cls):
@@ -474,7 +578,7 @@ class Mask3D(Geometry):
             path_for_mesh = f"meshes/{figure_id}.nrrd"
             api.volume.figure.download_stl_meshes([figure_id], [path_for_mesh])
 
-            mask3d_data, _ = nrrd.read(path_for_mesh)
+            mask3d_data, _ = sly.volume.volume.read_nrrd_serie_volume_np(path_for_mesh)
             encoded_string = sly.Mask3D.data_2_base64(mask3d_data)
 
             print(encoded_string)
@@ -619,3 +723,73 @@ class Mask3D(Geometry):
                 continue
             geometries_dict[key] = geometry_bytes
         return geometries_dict
+
+    def set_volume_space_meta(self, header: Dict):
+        """
+        Set space, space directions, and space origin attributes from a NRRD header dictionary.
+
+        :param header: NRRD header dictionary.
+        :type header: dict
+        """
+        if "space" in header:
+            self.space = header["space"]
+        if "space directions" in header:
+            self.space_directions = header["space directions"]
+        if "space origin" in header:
+            self.space_origin = PointVolume(
+                x=header["space origin"][0],
+                y=header["space origin"][1],
+                z=header["space origin"][2],
+            )
+
+    def create_header(self) -> OrderedDict:
+        """
+        Create header for encoding Mask3D to NRRD bytes
+
+        :return: Header for NRRD file
+        :rtype: OrderedDict
+        """
+        header = OrderedDict()
+        if self.space is not None:
+            header["space"] = self.space
+        if self.space_directions is not None:
+            header["space directions"] = self.space_directions
+        if self.space_origin is not None:
+            header["space origin"] = self.space_origin
+        return header
+
+    def orient_ras(self) -> None:
+        """
+        Transforms the mask data and updates spatial metadata (origin, directions, spacing)
+        to align with the RAS coordinate system using SimpleITK.
+
+        :rtype: None
+        """
+        import SimpleITK as sitk
+
+        from supervisely.volume.volume import _sitk_image_orient_ras
+
+        sitk_volume = sitk.GetImageFromArray(self.data)
+        if self.space_origin is not None:
+            sitk_volume.SetOrigin(self.space_origin)
+        if self.space_directions is not None:
+            # Convert space directions to spacing and direction
+            space_directions = np.array(self.space_directions)
+            spacing = np.linalg.norm(space_directions, axis=1)
+            direction = space_directions / spacing[:, np.newaxis]
+            sitk_volume.SetSpacing(spacing)
+            sitk_volume.SetDirection(direction.flatten())
+
+        sitk_volume = _sitk_image_orient_ras(sitk_volume)
+
+        # Extract transformed data and update object
+        self.data = sitk.GetArrayFromImage(sitk_volume)
+        new_direction = np.array(sitk_volume.GetDirection()).reshape(3, 3)
+        new_spacing = np.array(sitk_volume.GetSpacing())
+        new_space_directions = (new_direction.T * new_spacing[:, None]).tolist()
+        new_header = {
+            "space": "right-anterior-superior",
+            "space directions": new_space_directions,
+            "space origin": sitk_volume.GetOrigin(),
+        }
+        self.set_volume_space_meta(new_header)

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/nn/inference/inference.py

@@ -878,10 +878,16 @@ class Inference:
 
         try:
             if is_production():
-                self._add_workflow_input(model_source, model_files, model_info)
+                without_workflow = deploy_params.get("without_workflow", False)
+                if without_workflow is False:
+                    self._add_workflow_input(model_source, model_files, model_info)
         except Exception as e:
             logger.warning(f"Failed to add input to the workflow: {repr(e)}")
 
+        # remove is_benchmark from deploy_params
+        if "without_workflow" in deploy_params:
+            deploy_params.pop("without_workflow")
+
         self._load_model(deploy_params)
         if self._model_meta is None:
             self._set_model_meta_from_classes()
@@ -3709,17 +3715,20 @@ class Inference:
             )
 
         app_name = sly_env.app_name()
-        meta = WorkflowMeta(node_settings=WorkflowSettings(title=f"Serve {app_name}"))
+        meta = WorkflowMeta(node_settings=WorkflowSettings(title=app_name))
 
         logger.debug(
             f"Workflow Input: Checkpoint URL - {checkpoint_url}, Checkpoint Name - {checkpoint_name}"
         )
-        if checkpoint_url and self.api.file.exists(sly_env.team_id(), checkpoint_url):
-            self.api.app.workflow.add_input_file(checkpoint_url, model_weight=True, meta=meta)
-        else:
-            logger.debug(
-                f"Checkpoint {checkpoint_url} not found in Team Files. Cannot set workflow input"
-            )
+        if model_source == ModelSource.CUSTOM:
+            if checkpoint_url and self.api.file.exists(sly_env.team_id(), checkpoint_url):
+                # self.api.app.workflow.add_input_file(checkpoint_url, model_weight=True, meta=meta)
+                remote_checkpoint_dir = os.path.dirname(checkpoint_url)
+                self.api.app.workflow.add_input_folder(remote_checkpoint_dir, meta=meta)
+            else:
+                logger.debug(
+                    f"Checkpoint {checkpoint_url} not found in Team Files. Cannot set workflow input"
+                )
 
 
 def _exclude_duplicated_predictions(

{supervisely-6.73.368 → supervisely-6.73.370}/supervisely/nn/training/gui/gui.py

@@ -242,7 +242,7 @@ class TrainGUI:
         else:
             self.task_id = sly_env.task_id(raise_not_found=False)
             if self.task_id is None:
-                self.task_id = "debug-session"
+                self.task_id = -1
 
         self.framework_name = framework_name
         self.models = models
@@ -257,7 +257,7 @@ class TrainGUI:
         self.project_info = self._api.project.get_info_by_id(self.project_id)
         if self.project_info.type is None:
             raise ValueError(f"Project with ID: '{self.project_id}' does not exist or was archived")
-        
+
         self.project_meta = ProjectMeta.from_json(self._api.project.get_meta(self.project_id))
 
         if self.workspace_id is None:
@@ -350,7 +350,10 @@ class TrainGUI:
             if model_name is None:
                 experiment_name = "Enter experiment name"
             else:
-                experiment_name = f"{self.task_id}_{self.project_info.name}_{model_name}"
+                if self.task_id == -1:
+                    experiment_name = f"debug_{self.project_info.name}_{model_name}"
+                else:
+                    experiment_name = f"{self.task_id}_{self.project_info.name}_{model_name}"
 
             if experiment_name == self.training_process.get_experiment_name():
                 return