Updates (#74)

* add remove_to_label_for_cc_filter

* add remove_to

* add itk global_cord support

* add referecne for loading POI (POI.load)

* enable loading via Path

* add set_above_3_point_plane

* make an internal function to make vert-seg

* do not corp when empty instead of failing

* fix issue with empty images and cropout

* bug fixes

* ruff

* remove deprecated function

* x

* move assert_affine ot has_grid to avoid duplicat code in NII and POI

* add is_segmentation_in_border

* add support for itk_cords in Global poi

* add new POI definition

* add saving, refactor point reg

* prepare save and load global coords with POI

* enable selection of cuda,mps and cpu for reg

* refactor move save load poi in its separate  file

* add save / load for global POI

* bug fix saving

* change default Enum for POI

* ruff

---------

Co-authored-by: ga84mun <robert.graf@tum.de>

Author: robert-graf

TPTBox/__init__.py

@@ -21,12 +21,11 @@
     to_nii_interpolateable,
     to_nii_optional,
     to_nii_seg,
+    Has_Grid,
 )
 from TPTBox.core.poi import AX_CODES, POI, POI_Reference, calc_centroids, calc_poi_from_subreg_vert
 from TPTBox.core.poi import calc_poi_from_two_segs
 from TPTBox.core.poi import calc_poi_from_two_segs as calc_poi_labeled_buffered
-from TPTBox.core.poi import load_poi
-from TPTBox.core.poi import load_poi as load_centroids
 from TPTBox.core.poi_fun.poi_global import POI_Global
 from TPTBox.core.vert_constants import ZOOMS, Location, Vertebra_Instance, v_idx2name, v_idx_order, v_name2idx
 

TPTBox/core/__init__.py

@@ -9,7 +9,7 @@
 
 # NII
 from .nii_wrapper import NII, Image_Reference, Interpolateable_Image_Reference, to_nii, to_nii_interpolateable, to_nii_optional, to_nii_seg
-from .poi import AX_CODES, POI, POI_Reference, calc_centroids, calc_poi_from_subreg_vert, calc_poi_from_two_segs, load_poi
+from .poi import AX_CODES, POI, POI_Reference, calc_centroids, calc_poi_from_subreg_vert, calc_poi_from_two_segs
 from .poi_fun.poi_global import POI_Global
 from .vert_constants import ZOOMS, Location, v_idx2name, v_idx_order, v_name2idx
 

TPTBox/core/internal/deep_learning_utils.py

@@ -0,0 +1,25 @@
+from typing import Literal
+
+import torch
+
+from TPTBox.core.vert_constants import never_called
+
+DEVICES = Literal["cpu", "cuda", "mps"]
+
+
+def get_device(ddevice: DEVICES, gpu_id: int):
+    if ddevice == "cpu":
+        # import multiprocessing
+
+        # try:
+        #    torch.set_num_threads(multiprocessing.cpu_count())
+        # except Exception:
+        #    pass
+        device = torch.device("cpu")
+    elif ddevice == "cuda":
+        device = torch.device(type="cuda", index=gpu_id)
+    elif ddevice == "mps":
+        device = torch.device("mps")
+    else:
+        never_called(ddevice)
+    return device

TPTBox/core/nii_poi_abstract.py

@@ -71,8 +71,11 @@ def spacing(self, value: ZOOMS):
         self.zoom = value
 
     def __str__(self) -> str:
-        #origin={tuple(np.around(self.origin, decimals=2))}
-        return f"shape={self.shape},spacing={tuple(np.around(self.zoom, decimals=2))}, origin={self.origin}, ori={self.orientation}"  # type: ignore
+        try:
+            origin = {tuple(np.around(self.origin, decimals=2))}
+        except Exception:
+            origin = self.origin
+        return f"shape={self.shape},spacing={tuple(np.around(self.zoom, decimals=2))}, origin={origin}, ori={self.orientation}"  # type: ignore
 
     @property
     def affine(self):
@@ -95,15 +98,22 @@ def affine(self, affine: np.ndarray):
         self.rotation = rotation
         self.origin = origin.tolist()
 
-    def _extract_affine(self: Has_Grid, rm_key=()):
-        out = {"zoom": self.spacing, "origin": self.origin, "shape": self.shape, "rotation": self.rotation, "orientation": self.orientation}
+    def _extract_affine(self: Has_Grid, rm_key=(), **args):
+        out = {
+            "zoom": self.spacing,
+            "origin": self.origin,
+            "shape": self.shape,
+            "rotation": self.rotation,
+            "orientation": self.orientation,
+            **args,
+        }
         for k in rm_key:
             out.pop(k)
         return out
 
     def assert_affine(
         self,
-        other: Self | NII | POI | None = None,
+        other: Self | Has_Grid | None = None,
         ignore_missing_values: bool = False,
         affine: AFFINE | None = None,
         zoom: ZOOMS | None = None,
@@ -121,7 +131,7 @@ def assert_affine(
         """Checks if the different metadata is equal to some comparison entries
 
         Args:
-            other (Self | POI | None, optional): If set, will assert each entry of that object instead. Defaults to None.
+            other (Has_Grid | None, optional): If set, will assert each entry of that object instead. Defaults to None.
             affine (AFFINE | None, optional): Affine matrix to compare against. If none, will not assert affine. Defaults to None.
             zms (Zooms | None, optional): Zoom to compare against. If none, will not assert zoom. Defaults to None.
             orientation (Ax_Codes | None, optional): Orientation to compare against. If none, will not assert orientation. Defaults to None.
@@ -251,21 +261,26 @@ def make_empty_POI(self, points: dict | None = None):
         from TPTBox import POI
 
         p = {} if points is None else points
-        return POI(p, orientation=self.orientation, zoom=self.zoom, shape=self.shape, rotation=self.rotation, origin=self.origin)
+        args = {}
+        if isinstance(self, POI):
+            args["level_one_info"] = self.level_one_info
+            args["level_two_info"] = self.level_two_info
+
+        return POI(p, orientation=self.orientation, zoom=self.zoom, shape=self.shape, rotation=self.rotation, origin=self.origin, **args)
 
     def make_empty_nii(self, seg=False, _arr=None):
         from TPTBox import NII
 
         if _arr is None:
             _arr = np.zeros(self.shape_int)
         else:
-            assert (
-                _arr.shape == self.shape_int
-            ), f"Expected the correct shape for generating a image from Grid; Got {_arr.shape}, expected {self.shape_int}"
+            assert _arr.shape == self.shape_int, (
+                f"Expected the correct shape for generating a image from Grid; Got {_arr.shape}, expected {self.shape_int}"
+            )
         nii = nib.Nifti1Image(_arr, affine=self.affine)
         return NII(nii, seg=seg)
 
-    def make_nii(self, arr: np.ndarray, seg=False):
+    def make_nii(self, arr: np.ndarray | None = None, seg=False):
         """Make a nii with the same grid as object. Shape must fit the Grid.
 
         Args:
@@ -275,6 +290,8 @@ def make_nii(self, arr: np.ndarray, seg=False):
         Returns:
             NII
         """
+        if arr is None:
+            arr = np.zeros(self.shape_int)
         return self.make_empty_nii(_arr=arr, seg=seg)
 
     def global_to_local(self, x: COORDINATE):

TPTBox/core/nii_wrapper.py

@@ -234,8 +234,7 @@ def load_nrrd(cls, path: str | Path, seg: bool):
             raise KeyError(f"Missing expected header field: {e}") from None
         ref_orientation = header.get("ref_orientation")
         for i in ["ref_orientation","dimension","space directions","space origin""space","type","endian"]:
-            if i in header :
-                del header[i]
+            header.pop(i, None)
         for key in list(header.keys()):
             if "_Extent" in key:
                 del header[key]
@@ -696,9 +695,9 @@ def apply_center_crop(self, center_shape: tuple[int,int,int], inplace=False, ver
         else:
             arr_padded = arr
 
-        crop_rel_x = int(round((shp_x - crop_x) / 2.0))
-        crop_rel_y = int(round((shp_y - crop_y) / 2.0))
-        crop_rel_z = int(round((shp_z - crop_z) / 2.0))
+        crop_rel_x = round((shp_x - crop_x) / 2.0)
+        crop_rel_y = round((shp_y - crop_y) / 2.0)
+        crop_rel_z = round((shp_z - crop_z) / 2.0)
 
         crop_slices = (slice(crop_rel_x, crop_rel_x + crop_x),slice(crop_rel_y, crop_rel_y + crop_y),slice(crop_rel_z, crop_rel_z + crop_z))
         arr_cropped = arr_padded[crop_slices]
@@ -1427,6 +1426,27 @@ def get_overlapping_labels_to(
         assert self.seg and mask_other.seg
         return np_calc_overlapping_labels(self.get_seg_array(), mask_other.get_seg_array())
 
+    def is_segmentation_in_border(self,minimum=0, voxel_tolerance: int = 2,use_mm=False):
+        """
+        Checks if the segmentation is touching the border of the image volume.
+
+        Parameters:
+        - minimum (int, optional): Minimum intensity threshold for segmentation. Defaults to 0.
+        - voxel_tolerance (int, optional): Number of voxels allowed as tolerance from the border. Defaults to 2.
+        - use_mm (bool, optional): Whether to use millimeter units instead of voxels. Defaults to False.
+
+        Returns:
+        - bool: True if the segmentation is within the defined voxel tolerance of the border, False otherwise.
+        """
+        slices = self.compute_crop(minimum,dist=0,use_mm=use_mm)
+        shp = self.shape
+        seg_at_border = False
+        for d in range(3):
+            if slices[d].start <= voxel_tolerance or slices[d].stop - 1 >= shp[d] - voxel_tolerance:
+                seg_at_border = True
+                break
+        return seg_at_border
+
     def truncate_labels_beyond_reference_(
         self, idx: int | list[int] = 1, not_beyond: int | list[int] = 1, fill: int = 0,  axis: DIRECTIONS = "S", inclusion: bool = False, inplace: bool = True
     ):
@@ -1618,8 +1638,7 @@ def save_nrrd(self:Self, file: str | Path|bids_files.BIDS_FILE,make_parents=True
             'encoding': 'gzip',
             **_header,**self.info
         }
-        if "Segmentation_ConversionParameters" in header:
-            del header["Segmentation_ConversionParameters"]
+        header.pop("Segmentation_ConversionParameters", None)
         # Save NRRD file
 
         log.print(f"Saveing {file}",verbose=verbose,ltype=Log_Type.SAVE,end='\r')