|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
""" |
|
|
A collection of "vanilla" transforms for the model output tensors. |
|
|
""" |
|
|
|
|
|
from __future__ import annotations |
|
|
|
|
|
import warnings |
|
|
from collections.abc import Callable, Iterable, Sequence |
|
|
|
|
|
import numpy as np |
|
|
import torch |
|
|
import torch.nn.functional as F |
|
|
|
|
|
from monai.config.type_definitions import NdarrayOrTensor |
|
|
from monai.data.meta_obj import get_track_meta |
|
|
from monai.data.meta_tensor import MetaTensor |
|
|
from monai.networks import one_hot |
|
|
from monai.networks.layers import GaussianFilter, apply_filter, separable_filtering |
|
|
from monai.transforms.inverse import InvertibleTransform |
|
|
from monai.transforms.transform import Transform |
|
|
from monai.transforms.utility.array import ToTensor |
|
|
from monai.transforms.utils import ( |
|
|
convert_applied_interp_mode, |
|
|
distance_transform_edt, |
|
|
fill_holes, |
|
|
get_largest_connected_component_mask, |
|
|
get_unique_labels, |
|
|
remove_small_objects, |
|
|
) |
|
|
from monai.transforms.utils_pytorch_numpy_unification import unravel_index |
|
|
from monai.utils import TransformBackends, convert_data_type, convert_to_tensor, ensure_tuple, look_up_option |
|
|
from monai.utils.type_conversion import convert_to_dst_type |
|
|
|
|
|
__all__ = [ |
|
|
"Activations", |
|
|
"AsDiscrete", |
|
|
"FillHoles", |
|
|
"KeepLargestConnectedComponent", |
|
|
"RemoveSmallObjects", |
|
|
"LabelFilter", |
|
|
"LabelToContour", |
|
|
"MeanEnsemble", |
|
|
"ProbNMS", |
|
|
"SobelGradients", |
|
|
"VoteEnsemble", |
|
|
"Invert", |
|
|
"DistanceTransformEDT", |
|
|
] |
|
|
|
|
|
|
|
|
class Activations(Transform): |
|
|
""" |
|
|
Activation operations, typically `Sigmoid` or `Softmax`. |
|
|
|
|
|
Args: |
|
|
sigmoid: whether to execute sigmoid function on model output before transform. |
|
|
Defaults to ``False``. |
|
|
softmax: whether to execute softmax function on model output before transform. |
|
|
Defaults to ``False``. |
|
|
other: callable function to execute other activation layers, for example: |
|
|
`other = lambda x: torch.tanh(x)`. Defaults to ``None``. |
|
|
kwargs: additional parameters to `torch.softmax` (used when ``softmax=True``). |
|
|
Defaults to ``dim=0``, unrecognized parameters will be ignored. |
|
|
|
|
|
Raises: |
|
|
TypeError: When ``other`` is not an ``Optional[Callable]``. |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__(self, sigmoid: bool = False, softmax: bool = False, other: Callable | None = None, **kwargs) -> None: |
|
|
self.sigmoid = sigmoid |
|
|
self.softmax = softmax |
|
|
self.kwargs = kwargs |
|
|
if other is not None and not callable(other): |
|
|
raise TypeError(f"other must be None or callable but is {type(other).__name__}.") |
|
|
self.other = other |
|
|
|
|
|
def __call__( |
|
|
self, |
|
|
img: NdarrayOrTensor, |
|
|
sigmoid: bool | None = None, |
|
|
softmax: bool | None = None, |
|
|
other: Callable | None = None, |
|
|
) -> NdarrayOrTensor: |
|
|
""" |
|
|
Args: |
|
|
sigmoid: whether to execute sigmoid function on model output before transform. |
|
|
Defaults to ``self.sigmoid``. |
|
|
softmax: whether to execute softmax function on model output before transform. |
|
|
Defaults to ``self.softmax``. |
|
|
other: callable function to execute other activation layers, for example: |
|
|
`other = torch.tanh`. Defaults to ``self.other``. |
|
|
|
|
|
Raises: |
|
|
ValueError: When ``sigmoid=True`` and ``softmax=True``. Incompatible values. |
|
|
TypeError: When ``other`` is not an ``Optional[Callable]``. |
|
|
ValueError: When ``self.other=None`` and ``other=None``. Incompatible values. |
|
|
|
|
|
""" |
|
|
if sigmoid and softmax: |
|
|
raise ValueError("Incompatible values: sigmoid=True and softmax=True.") |
|
|
if other is not None and not callable(other): |
|
|
raise TypeError(f"other must be None or callable but is {type(other).__name__}.") |
|
|
|
|
|
|
|
|
img = convert_to_tensor(img, track_meta=get_track_meta()) |
|
|
img_t, *_ = convert_data_type(img, torch.Tensor, dtype=torch.float) |
|
|
if sigmoid or self.sigmoid: |
|
|
img_t = torch.sigmoid(img_t) |
|
|
if softmax or self.softmax: |
|
|
img_t = torch.softmax(img_t, dim=self.kwargs.get("dim", 0)) |
|
|
|
|
|
act_func = self.other if other is None else other |
|
|
if act_func is not None: |
|
|
img_t = act_func(img_t) |
|
|
out, *_ = convert_to_dst_type(img_t, img) |
|
|
return out |
|
|
|
|
|
|
|
|
class AsDiscrete(Transform): |
|
|
""" |
|
|
Convert the input tensor/array into discrete values, possible operations are: |
|
|
|
|
|
- `argmax`. |
|
|
- threshold input value to binary values. |
|
|
- convert input value to One-Hot format (set ``to_one_hot=N``, `N` is the number of classes). |
|
|
- round the value to the closest integer. |
|
|
|
|
|
Args: |
|
|
argmax: whether to execute argmax function on input data before transform. |
|
|
Defaults to ``False``. |
|
|
to_onehot: if not None, convert input data into the one-hot format with specified number of classes. |
|
|
Defaults to ``None``. |
|
|
threshold: if not None, threshold the float values to int number 0 or 1 with specified threshold. |
|
|
Defaults to ``None``. |
|
|
rounding: if not None, round the data according to the specified option, |
|
|
available options: ["torchrounding"]. |
|
|
kwargs: additional parameters to `torch.argmax`, `monai.networks.one_hot`. |
|
|
currently ``dim``, ``keepdim``, ``dtype`` are supported, unrecognized parameters will be ignored. |
|
|
These default to ``0``, ``True``, ``torch.float`` respectively. |
|
|
|
|
|
Example: |
|
|
|
|
|
>>> transform = AsDiscrete(argmax=True) |
|
|
>>> print(transform(np.array([[[0.0, 1.0]], [[2.0, 3.0]]]))) |
|
|
# [[[1.0, 1.0]]] |
|
|
|
|
|
>>> transform = AsDiscrete(threshold=0.6) |
|
|
>>> print(transform(np.array([[[0.0, 0.5], [0.8, 3.0]]]))) |
|
|
# [[[0.0, 0.0], [1.0, 1.0]]] |
|
|
|
|
|
>>> transform = AsDiscrete(argmax=True, to_onehot=2, threshold=0.5) |
|
|
>>> print(transform(np.array([[[0.0, 1.0]], [[2.0, 3.0]]]))) |
|
|
# [[[0.0, 0.0]], [[1.0, 1.0]]] |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
argmax: bool = False, |
|
|
to_onehot: int | None = None, |
|
|
threshold: float | None = None, |
|
|
rounding: str | None = None, |
|
|
**kwargs, |
|
|
) -> None: |
|
|
self.argmax = argmax |
|
|
if isinstance(to_onehot, bool): |
|
|
raise ValueError("`to_onehot=True/False` is deprecated, please use `to_onehot=num_classes` instead.") |
|
|
self.to_onehot = to_onehot |
|
|
self.threshold = threshold |
|
|
self.rounding = rounding |
|
|
self.kwargs = kwargs |
|
|
|
|
|
def __call__( |
|
|
self, |
|
|
img: NdarrayOrTensor, |
|
|
argmax: bool | None = None, |
|
|
to_onehot: int | None = None, |
|
|
threshold: float | None = None, |
|
|
rounding: str | None = None, |
|
|
) -> NdarrayOrTensor: |
|
|
""" |
|
|
Args: |
|
|
img: the input tensor data to convert, if no channel dimension when converting to `One-Hot`, |
|
|
will automatically add it. |
|
|
argmax: whether to execute argmax function on input data before transform. |
|
|
Defaults to ``self.argmax``. |
|
|
to_onehot: if not None, convert input data into the one-hot format with specified number of classes. |
|
|
Defaults to ``self.to_onehot``. |
|
|
threshold: if not None, threshold the float values to int number 0 or 1 with specified threshold value. |
|
|
Defaults to ``self.threshold``. |
|
|
rounding: if not None, round the data according to the specified option, |
|
|
available options: ["torchrounding"]. |
|
|
|
|
|
""" |
|
|
if isinstance(to_onehot, bool): |
|
|
raise ValueError("`to_onehot=True/False` is deprecated, please use `to_onehot=num_classes` instead.") |
|
|
img = convert_to_tensor(img, track_meta=get_track_meta()) |
|
|
img_t, *_ = convert_data_type(img, torch.Tensor) |
|
|
if argmax or self.argmax: |
|
|
img_t = torch.argmax(img_t, dim=self.kwargs.get("dim", 0), keepdim=self.kwargs.get("keepdim", True)) |
|
|
|
|
|
to_onehot = self.to_onehot if to_onehot is None else to_onehot |
|
|
if to_onehot is not None: |
|
|
if not isinstance(to_onehot, int): |
|
|
raise ValueError(f"the number of classes for One-Hot must be an integer, got {type(to_onehot)}.") |
|
|
img_t = one_hot( |
|
|
img_t, num_classes=to_onehot, dim=self.kwargs.get("dim", 0), dtype=self.kwargs.get("dtype", torch.float) |
|
|
) |
|
|
|
|
|
threshold = self.threshold if threshold is None else threshold |
|
|
if threshold is not None: |
|
|
img_t = img_t >= threshold |
|
|
|
|
|
rounding = self.rounding if rounding is None else rounding |
|
|
if rounding is not None: |
|
|
look_up_option(rounding, ["torchrounding"]) |
|
|
img_t = torch.round(img_t) |
|
|
|
|
|
img, *_ = convert_to_dst_type(img_t, img, dtype=self.kwargs.get("dtype", torch.float)) |
|
|
return img |
|
|
|
|
|
|
|
|
class KeepLargestConnectedComponent(Transform): |
|
|
""" |
|
|
Keeps only the largest connected component in the image. |
|
|
This transform can be used as a post-processing step to clean up over-segment areas in model output. |
|
|
|
|
|
The input is assumed to be a channel-first PyTorch Tensor: |
|
|
1) For not OneHot format data, the values correspond to expected labels, |
|
|
0 will be treated as background and the over-segment pixels will be set to 0. |
|
|
2) For OneHot format data, the values should be 0, 1 on each labels, |
|
|
the over-segment pixels will be set to 0 in its channel. |
|
|
|
|
|
For example: |
|
|
Use with applied_labels=[1], is_onehot=False, connectivity=1:: |
|
|
|
|
|
[1, 0, 0] [0, 0, 0] |
|
|
[0, 1, 1] => [0, 1 ,1] |
|
|
[0, 1, 1] [0, 1, 1] |
|
|
|
|
|
Use with applied_labels=[1, 2], is_onehot=False, independent=False, connectivity=1:: |
|
|
|
|
|
[0, 0, 1, 0 ,0] [0, 0, 1, 0 ,0] |
|
|
[0, 2, 1, 1 ,1] [0, 2, 1, 1 ,1] |
|
|
[1, 2, 1, 0 ,0] => [1, 2, 1, 0 ,0] |
|
|
[1, 2, 0, 1 ,0] [1, 2, 0, 0 ,0] |
|
|
[2, 2, 0, 0 ,2] [2, 2, 0, 0 ,0] |
|
|
|
|
|
Use with applied_labels=[1, 2], is_onehot=False, independent=True, connectivity=1:: |
|
|
|
|
|
[0, 0, 1, 0 ,0] [0, 0, 1, 0 ,0] |
|
|
[0, 2, 1, 1 ,1] [0, 2, 1, 1 ,1] |
|
|
[1, 2, 1, 0 ,0] => [0, 2, 1, 0 ,0] |
|
|
[1, 2, 0, 1 ,0] [0, 2, 0, 0 ,0] |
|
|
[2, 2, 0, 0 ,2] [2, 2, 0, 0 ,0] |
|
|
|
|
|
Use with applied_labels=[1, 2], is_onehot=False, independent=False, connectivity=2:: |
|
|
|
|
|
[0, 0, 1, 0 ,0] [0, 0, 1, 0 ,0] |
|
|
[0, 2, 1, 1 ,1] [0, 2, 1, 1 ,1] |
|
|
[1, 2, 1, 0 ,0] => [1, 2, 1, 0 ,0] |
|
|
[1, 2, 0, 1 ,0] [1, 2, 0, 1 ,0] |
|
|
[2, 2, 0, 0 ,2] [2, 2, 0, 0 ,2] |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.NUMPY, TransformBackends.CUPY] |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
applied_labels: Sequence[int] | int | None = None, |
|
|
is_onehot: bool | None = None, |
|
|
independent: bool = True, |
|
|
connectivity: int | None = None, |
|
|
num_components: int = 1, |
|
|
) -> None: |
|
|
""" |
|
|
Args: |
|
|
applied_labels: Labels for applying the connected component analysis on. |
|
|
If given, voxels whose value is in this list will be analyzed. |
|
|
If `None`, all non-zero values will be analyzed. |
|
|
is_onehot: if `True`, treat the input data as OneHot format data, otherwise, not OneHot format data. |
|
|
default to None, which treats multi-channel data as OneHot and single channel data as not OneHot. |
|
|
independent: whether to treat ``applied_labels`` as a union of foreground labels. |
|
|
If ``True``, the connected component analysis will be performed on each foreground label independently |
|
|
and return the intersection of the largest components. |
|
|
If ``False``, the analysis will be performed on the union of foreground labels. |
|
|
default is `True`. |
|
|
connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. |
|
|
Accepted values are ranging from 1 to input.ndim. If ``None``, a full |
|
|
connectivity of ``input.ndim`` is used. for more details: |
|
|
https://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.label. |
|
|
num_components: The number of largest components to preserve. |
|
|
|
|
|
""" |
|
|
super().__init__() |
|
|
self.applied_labels = ensure_tuple(applied_labels) if applied_labels is not None else None |
|
|
self.is_onehot = is_onehot |
|
|
self.independent = independent |
|
|
self.connectivity = connectivity |
|
|
self.num_components = num_components |
|
|
|
|
|
def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
""" |
|
|
Args: |
|
|
img: shape must be (C, spatial_dim1[, spatial_dim2, ...]). |
|
|
|
|
|
Returns: |
|
|
An array with shape (C, spatial_dim1[, spatial_dim2, ...]). |
|
|
""" |
|
|
is_onehot = img.shape[0] > 1 if self.is_onehot is None else self.is_onehot |
|
|
if self.applied_labels is not None: |
|
|
applied_labels = self.applied_labels |
|
|
else: |
|
|
applied_labels = tuple(get_unique_labels(img, is_onehot, discard=0)) |
|
|
img = convert_to_tensor(img, track_meta=get_track_meta()) |
|
|
img_: torch.Tensor = convert_to_tensor(img, track_meta=False) |
|
|
if self.independent: |
|
|
for i in applied_labels: |
|
|
foreground = img_[i] > 0 if is_onehot else img_[0] == i |
|
|
mask = get_largest_connected_component_mask(foreground, self.connectivity, self.num_components) |
|
|
if is_onehot: |
|
|
img_[i][foreground != mask] = 0 |
|
|
else: |
|
|
img_[0][foreground != mask] = 0 |
|
|
return convert_to_dst_type(img_, dst=img)[0] |
|
|
if not is_onehot: |
|
|
labels, *_ = convert_to_dst_type(applied_labels, dst=img_, wrap_sequence=True) |
|
|
foreground = (img_[..., None] == labels).any(-1)[0] |
|
|
mask = get_largest_connected_component_mask(foreground, self.connectivity, self.num_components) |
|
|
img_[0][foreground != mask] = 0 |
|
|
return convert_to_dst_type(img_, dst=img)[0] |
|
|
|
|
|
foreground = (img_[applied_labels, ...] == 1).any(0) |
|
|
mask = get_largest_connected_component_mask(foreground, self.connectivity, self.num_components) |
|
|
for i in applied_labels: |
|
|
img_[i][foreground != mask] = 0 |
|
|
return convert_to_dst_type(img_, dst=img)[0] |
|
|
|
|
|
|
|
|
class RemoveSmallObjects(Transform): |
|
|
""" |
|
|
Use `skimage.morphology.remove_small_objects` to remove small objects from images. |
|
|
See: https://scikit-image.org/docs/dev/api/skimage.morphology.html#remove-small-objects. |
|
|
|
|
|
Data should be one-hotted. |
|
|
|
|
|
Args: |
|
|
min_size: objects smaller than this size (in number of voxels; or surface area/volume value |
|
|
in whatever units your image is if by_measure is True) are removed. |
|
|
connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. |
|
|
Accepted values are ranging from 1 to input.ndim. If ``None``, a full |
|
|
connectivity of ``input.ndim`` is used. For more details refer to linked scikit-image |
|
|
documentation. |
|
|
independent_channels: Whether or not to consider channels as independent. If true, then |
|
|
conjoining islands from different labels will be removed if they are below the threshold. |
|
|
If false, the overall size islands made from all non-background voxels will be used. |
|
|
by_measure: Whether the specified min_size is in number of voxels. if this is True then min_size |
|
|
represents a surface area or volume value of whatever units your image is in (mm^3, cm^2, etc.) |
|
|
default is False. e.g. if min_size is 3, by_measure is True and the units of your data is mm, |
|
|
objects smaller than 3mm^3 are removed. |
|
|
pixdim: the pixdim of the input image. if a single number, this is used for all axes. |
|
|
If a sequence of numbers, the length of the sequence must be equal to the image dimensions. |
|
|
|
|
|
Example:: |
|
|
|
|
|
.. code-block:: python |
|
|
|
|
|
from monai.transforms import RemoveSmallObjects, Spacing, Compose |
|
|
from monai.data import MetaTensor |
|
|
|
|
|
data1 = torch.tensor([[[0, 0, 0, 0, 0], [0, 1, 1, 0, 1], [0, 0, 0, 1, 1]]]) |
|
|
affine = torch.as_tensor([[2,0,0,0], |
|
|
[0,1,0,0], |
|
|
[0,0,1,0], |
|
|
[0,0,0,1]], dtype=torch.float64) |
|
|
data2 = MetaTensor(data1, affine=affine) |
|
|
|
|
|
# remove objects smaller than 3mm^3, input is MetaTensor |
|
|
trans = RemoveSmallObjects(min_size=3, by_measure=True) |
|
|
out = trans(data2) |
|
|
# remove objects smaller than 3mm^3, input is not MetaTensor |
|
|
trans = RemoveSmallObjects(min_size=3, by_measure=True, pixdim=(2, 1, 1)) |
|
|
out = trans(data1) |
|
|
|
|
|
# remove objects smaller than 3 (in pixel) |
|
|
trans = RemoveSmallObjects(min_size=3) |
|
|
out = trans(data2) |
|
|
|
|
|
# If the affine of the data is not identity, you can also add Spacing before. |
|
|
trans = Compose([ |
|
|
Spacing(pixdim=(1, 1, 1)), |
|
|
RemoveSmallObjects(min_size=3) |
|
|
]) |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.NUMPY] |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
min_size: int = 64, |
|
|
connectivity: int = 1, |
|
|
independent_channels: bool = True, |
|
|
by_measure: bool = False, |
|
|
pixdim: Sequence[float] | float | np.ndarray | None = None, |
|
|
) -> None: |
|
|
self.min_size = min_size |
|
|
self.connectivity = connectivity |
|
|
self.independent_channels = independent_channels |
|
|
self.by_measure = by_measure |
|
|
self.pixdim = pixdim |
|
|
|
|
|
def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
""" |
|
|
Args: |
|
|
img: shape must be (C, spatial_dim1[, spatial_dim2, ...]). Data |
|
|
should be one-hotted. |
|
|
|
|
|
Returns: |
|
|
An array with shape (C, spatial_dim1[, spatial_dim2, ...]). |
|
|
""" |
|
|
|
|
|
return remove_small_objects( |
|
|
img, self.min_size, self.connectivity, self.independent_channels, self.by_measure, self.pixdim |
|
|
) |
|
|
|
|
|
|
|
|
class LabelFilter(Transform): |
|
|
""" |
|
|
This transform filters out labels and can be used as a processing step to view only certain labels. |
|
|
|
|
|
The list of applied labels defines which labels will be kept. |
|
|
|
|
|
Note: |
|
|
All labels which do not match the `applied_labels` are set to the background label (0). |
|
|
|
|
|
For example: |
|
|
|
|
|
Use LabelFilter with applied_labels=[1, 5, 9]:: |
|
|
|
|
|
[1, 2, 3] [1, 0, 0] |
|
|
[4, 5, 6] => [0, 5 ,0] |
|
|
[7, 8, 9] [0, 0, 9] |
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH, TransformBackends.NUMPY] |
|
|
|
|
|
def __init__(self, applied_labels: Iterable[int] | int) -> None: |
|
|
""" |
|
|
Initialize the LabelFilter class with the labels to filter on. |
|
|
|
|
|
Args: |
|
|
applied_labels: Label(s) to filter on. |
|
|
""" |
|
|
self.applied_labels = ensure_tuple(applied_labels) |
|
|
|
|
|
def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
""" |
|
|
Filter the image on the `applied_labels`. |
|
|
|
|
|
Args: |
|
|
img: Pytorch tensor or numpy array of any shape. |
|
|
|
|
|
Raises: |
|
|
NotImplementedError: The provided image was not a Pytorch Tensor or numpy array. |
|
|
|
|
|
Returns: |
|
|
Pytorch tensor or numpy array of the same shape as the input. |
|
|
""" |
|
|
if not isinstance(img, (np.ndarray, torch.Tensor)): |
|
|
raise NotImplementedError(f"{self.__class__} can not handle data of type {type(img)}.") |
|
|
|
|
|
if isinstance(img, torch.Tensor): |
|
|
img = convert_to_tensor(img, track_meta=get_track_meta()) |
|
|
img_ = convert_to_tensor(img, track_meta=False) |
|
|
if hasattr(torch, "isin"): |
|
|
appl_lbls = torch.as_tensor(self.applied_labels, device=img_.device) |
|
|
out = torch.where(torch.isin(img_, appl_lbls), img_, torch.tensor(0.0).to(img_)) |
|
|
return convert_to_dst_type(out, dst=img)[0] |
|
|
out: NdarrayOrTensor = self(img_.detach().cpu().numpy()) |
|
|
out = convert_to_dst_type(out, img)[0] |
|
|
return out |
|
|
return np.asarray(np.where(np.isin(img, self.applied_labels), img, 0)) |
|
|
|
|
|
|
|
|
class FillHoles(Transform): |
|
|
r""" |
|
|
This transform fills holes in the image and can be used to remove artifacts inside segments. |
|
|
|
|
|
An enclosed hole is defined as a background pixel/voxel which is only enclosed by a single class. |
|
|
The definition of enclosed can be defined with the connectivity parameter:: |
|
|
|
|
|
1-connectivity 2-connectivity diagonal connection close-up |
|
|
|
|
|
[ ] [ ] [ ] [ ] [ ] |
|
|
| \ | / | <- hop 2 |
|
|
[ ]--[x]--[ ] [ ]--[x]--[ ] [x]--[ ] |
|
|
| / | \ hop 1 |
|
|
[ ] [ ] [ ] [ ] |
|
|
|
|
|
It is possible to define for which labels the hole filling should be applied. |
|
|
The input image is assumed to be a PyTorch Tensor or numpy array with shape [C, spatial_dim1[, spatial_dim2, ...]]. |
|
|
If C = 1, then the values correspond to expected labels. |
|
|
If C > 1, then a one-hot-encoding is expected where the index of C matches the label indexing. |
|
|
|
|
|
Note: |
|
|
|
|
|
The label 0 will be treated as background and the enclosed holes will be set to the neighboring class label. |
|
|
|
|
|
The performance of this method heavily depends on the number of labels. |
|
|
It is a bit faster if the list of `applied_labels` is provided. |
|
|
Limiting the number of `applied_labels` results in a big decrease in processing time. |
|
|
|
|
|
For example: |
|
|
|
|
|
Use FillHoles with default parameters:: |
|
|
|
|
|
[1, 1, 1, 2, 2, 2, 3, 3] [1, 1, 1, 2, 2, 2, 3, 3] |
|
|
[1, 0, 1, 2, 0, 0, 3, 0] => [1, 1 ,1, 2, 0, 0, 3, 0] |
|
|
[1, 1, 1, 2, 2, 2, 3, 3] [1, 1, 1, 2, 2, 2, 3, 3] |
|
|
|
|
|
The hole in label 1 is fully enclosed and therefore filled with label 1. |
|
|
The background label near label 2 and 3 is not fully enclosed and therefore not filled. |
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.NUMPY] |
|
|
|
|
|
def __init__(self, applied_labels: Iterable[int] | int | None = None, connectivity: int | None = None) -> None: |
|
|
""" |
|
|
Initialize the connectivity and limit the labels for which holes are filled. |
|
|
|
|
|
Args: |
|
|
applied_labels: Labels for which to fill holes. Defaults to None, that is filling holes for all labels. |
|
|
connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. |
|
|
Accepted values are ranging from 1 to input.ndim. Defaults to a full connectivity of ``input.ndim``. |
|
|
""" |
|
|
super().__init__() |
|
|
self.applied_labels = ensure_tuple(applied_labels) if applied_labels else None |
|
|
self.connectivity = connectivity |
|
|
|
|
|
def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
""" |
|
|
Fill the holes in the provided image. |
|
|
|
|
|
Note: |
|
|
The value 0 is assumed as background label. |
|
|
|
|
|
Args: |
|
|
img: Pytorch Tensor or numpy array of shape [C, spatial_dim1[, spatial_dim2, ...]]. |
|
|
|
|
|
Raises: |
|
|
NotImplementedError: The provided image was not a Pytorch Tensor or numpy array. |
|
|
|
|
|
Returns: |
|
|
Pytorch Tensor or numpy array of shape [C, spatial_dim1[, spatial_dim2, ...]]. |
|
|
""" |
|
|
img = convert_to_tensor(img, track_meta=get_track_meta()) |
|
|
img_np, *_ = convert_data_type(img, np.ndarray) |
|
|
out_np: np.ndarray = fill_holes(img_np, self.applied_labels, self.connectivity) |
|
|
out, *_ = convert_to_dst_type(out_np, img) |
|
|
return out |
|
|
|
|
|
|
|
|
class LabelToContour(Transform): |
|
|
""" |
|
|
Return the contour of binary input images that only compose of 0 and 1, with Laplacian kernel |
|
|
set as default for edge detection. Typical usage is to plot the edge of label or segmentation output. |
|
|
|
|
|
Args: |
|
|
kernel_type: the method applied to do edge detection, default is "Laplace". |
|
|
|
|
|
Raises: |
|
|
NotImplementedError: When ``kernel_type`` is not "Laplace". |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__(self, kernel_type: str = "Laplace") -> None: |
|
|
if kernel_type != "Laplace": |
|
|
raise NotImplementedError('Currently only kernel_type="Laplace" is supported.') |
|
|
self.kernel_type = kernel_type |
|
|
|
|
|
def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
""" |
|
|
Args: |
|
|
img: torch tensor data to extract the contour, with shape: [channels, height, width[, depth]] |
|
|
|
|
|
Raises: |
|
|
ValueError: When ``image`` ndim is not one of [3, 4]. |
|
|
|
|
|
Returns: |
|
|
A torch tensor with the same shape as img, note: |
|
|
1. it's the binary classification result of whether a pixel is edge or not. |
|
|
2. in order to keep the original shape of mask image, we use padding as default. |
|
|
3. the edge detection is just approximate because it defects inherent to Laplace kernel, |
|
|
ideally the edge should be thin enough, but now it has a thickness. |
|
|
|
|
|
""" |
|
|
img = convert_to_tensor(img, track_meta=get_track_meta()) |
|
|
img_: torch.Tensor = convert_to_tensor(img, track_meta=False) |
|
|
spatial_dims = len(img_.shape) - 1 |
|
|
img_ = img_.unsqueeze(0) |
|
|
if spatial_dims == 2: |
|
|
kernel = torch.tensor([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], dtype=torch.float32) |
|
|
elif spatial_dims == 3: |
|
|
kernel = -1.0 * torch.ones(3, 3, 3, dtype=torch.float32) |
|
|
kernel[1, 1, 1] = 26.0 |
|
|
else: |
|
|
raise ValueError(f"{self.__class__} can only handle 2D or 3D images.") |
|
|
contour_img = apply_filter(img_, kernel) |
|
|
contour_img.clamp_(min=0.0, max=1.0) |
|
|
output, *_ = convert_to_dst_type(contour_img.squeeze(0), img) |
|
|
return output |
|
|
|
|
|
|
|
|
class Ensemble: |
|
|
|
|
|
@staticmethod |
|
|
def get_stacked_torch(img: Sequence[NdarrayOrTensor] | NdarrayOrTensor) -> torch.Tensor: |
|
|
"""Get either a sequence or single instance of np.ndarray/torch.Tensor. Return single torch.Tensor.""" |
|
|
if isinstance(img, Sequence) and isinstance(img[0], np.ndarray): |
|
|
img = [torch.as_tensor(i) for i in img] |
|
|
elif isinstance(img, np.ndarray): |
|
|
img = torch.as_tensor(img) |
|
|
out: torch.Tensor = torch.stack(img) if isinstance(img, Sequence) else img |
|
|
return out |
|
|
|
|
|
@staticmethod |
|
|
def post_convert(img: torch.Tensor, orig_img: Sequence[NdarrayOrTensor] | NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
orig_img_ = orig_img[0] if isinstance(orig_img, Sequence) else orig_img |
|
|
out, *_ = convert_to_dst_type(img, orig_img_) |
|
|
return out |
|
|
|
|
|
|
|
|
class MeanEnsemble(Ensemble, Transform): |
|
|
""" |
|
|
Execute mean ensemble on the input data. |
|
|
The input data can be a list or tuple of PyTorch Tensor with shape: [C[, H, W, D]], |
|
|
Or a single PyTorch Tensor with shape: [E, C[, H, W, D]], the `E` dimension represents |
|
|
the output data from different models. |
|
|
Typically, the input data is model output of segmentation task or classification task. |
|
|
And it also can support to add `weights` for the input data. |
|
|
|
|
|
Args: |
|
|
weights: can be a list or tuple of numbers for input data with shape: [E, C, H, W[, D]]. |
|
|
or a Numpy ndarray or a PyTorch Tensor data. |
|
|
the `weights` will be added to input data from highest dimension, for example: |
|
|
1. if the `weights` only has 1 dimension, it will be added to the `E` dimension of input data. |
|
|
2. if the `weights` has 2 dimensions, it will be added to `E` and `C` dimensions. |
|
|
it's a typical practice to add weights for different classes: |
|
|
to ensemble 3 segmentation model outputs, every output has 4 channels(classes), |
|
|
so the input data shape can be: [3, 4, H, W, D]. |
|
|
and add different `weights` for different classes, so the `weights` shape can be: [3, 4]. |
|
|
for example: `weights = [[1, 2, 3, 4], [4, 3, 2, 1], [1, 1, 1, 1]]`. |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__(self, weights: Sequence[float] | NdarrayOrTensor | None = None) -> None: |
|
|
self.weights = torch.as_tensor(weights, dtype=torch.float) if weights is not None else None |
|
|
|
|
|
def __call__(self, img: Sequence[NdarrayOrTensor] | NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
img_ = self.get_stacked_torch(img) |
|
|
if self.weights is not None: |
|
|
self.weights = self.weights.to(img_.device) |
|
|
shape = tuple(self.weights.shape) |
|
|
for _ in range(img_.ndimension() - self.weights.ndimension()): |
|
|
shape += (1,) |
|
|
weights = self.weights.reshape(*shape) |
|
|
|
|
|
img_ = img_ * weights / weights.mean(dim=0, keepdim=True) |
|
|
|
|
|
out_pt = torch.mean(img_, dim=0) |
|
|
return self.post_convert(out_pt, img) |
|
|
|
|
|
|
|
|
class VoteEnsemble(Ensemble, Transform): |
|
|
""" |
|
|
Execute vote ensemble on the input data. |
|
|
The input data can be a list or tuple of PyTorch Tensor with shape: [C[, H, W, D]], |
|
|
Or a single PyTorch Tensor with shape: [E[, C, H, W, D]], the `E` dimension represents |
|
|
the output data from different models. |
|
|
Typically, the input data is model output of segmentation task or classification task. |
|
|
|
|
|
Note: |
|
|
This vote transform expects the input data is discrete values. It can be multiple channels |
|
|
data in One-Hot format or single channel data. It will vote to select the most common data |
|
|
between items. |
|
|
The output data has the same shape as every item of the input data. |
|
|
|
|
|
Args: |
|
|
num_classes: if the input is single channel data instead of One-Hot, we can't get class number |
|
|
from channel, need to explicitly specify the number of classes to vote. |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__(self, num_classes: int | None = None) -> None: |
|
|
self.num_classes = num_classes |
|
|
|
|
|
def __call__(self, img: Sequence[NdarrayOrTensor] | NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
img_ = self.get_stacked_torch(img) |
|
|
|
|
|
if self.num_classes is not None: |
|
|
has_ch_dim = True |
|
|
if img_.ndimension() > 1 and img_.shape[1] > 1: |
|
|
warnings.warn("no need to specify num_classes for One-Hot format data.") |
|
|
else: |
|
|
if img_.ndimension() == 1: |
|
|
|
|
|
has_ch_dim = False |
|
|
img_ = one_hot(img_, self.num_classes, dim=1) |
|
|
|
|
|
img_ = torch.mean(img_.float(), dim=0) |
|
|
|
|
|
if self.num_classes is not None: |
|
|
|
|
|
out_pt = torch.argmax(img_, dim=0, keepdim=has_ch_dim) |
|
|
else: |
|
|
|
|
|
out_pt = torch.round(img_) |
|
|
return self.post_convert(out_pt, img) |
|
|
|
|
|
|
|
|
class ProbNMS(Transform): |
|
|
""" |
|
|
Performs probability based non-maximum suppression (NMS) on the probabilities map via |
|
|
iteratively selecting the coordinate with highest probability and then move it as well |
|
|
as its surrounding values. The remove range is determined by the parameter `box_size`. |
|
|
If multiple coordinates have the same highest probability, only one of them will be |
|
|
selected. |
|
|
|
|
|
Args: |
|
|
spatial_dims: number of spatial dimensions of the input probabilities map. |
|
|
Defaults to 2. |
|
|
sigma: the standard deviation for gaussian filter. |
|
|
It could be a single value, or `spatial_dims` number of values. Defaults to 0.0. |
|
|
prob_threshold: the probability threshold, the function will stop searching if |
|
|
the highest probability is no larger than the threshold. The value should be |
|
|
no less than 0.0. Defaults to 0.5. |
|
|
box_size: the box size (in pixel) to be removed around the pixel with the maximum probability. |
|
|
It can be an integer that defines the size of a square or cube, |
|
|
or a list containing different values for each dimensions. Defaults to 48. |
|
|
|
|
|
Return: |
|
|
a list of selected lists, where inner lists contain probability and coordinates. |
|
|
For example, for 3D input, the inner lists are in the form of [probability, x, y, z]. |
|
|
|
|
|
Raises: |
|
|
ValueError: When ``prob_threshold`` is less than 0.0. |
|
|
ValueError: When ``box_size`` is a list or tuple, and its length is not equal to `spatial_dims`. |
|
|
ValueError: When ``box_size`` has a less than 1 value. |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.NUMPY] |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
spatial_dims: int = 2, |
|
|
sigma: Sequence[float] | float | Sequence[torch.Tensor] | torch.Tensor = 0.0, |
|
|
prob_threshold: float = 0.5, |
|
|
box_size: int | Sequence[int] = 48, |
|
|
) -> None: |
|
|
self.sigma = sigma |
|
|
self.spatial_dims = spatial_dims |
|
|
if self.sigma != 0: |
|
|
self.filter = GaussianFilter(spatial_dims=spatial_dims, sigma=sigma) |
|
|
if prob_threshold < 0: |
|
|
raise ValueError("prob_threshold should be no less than 0.0.") |
|
|
self.prob_threshold = prob_threshold |
|
|
if isinstance(box_size, int): |
|
|
self.box_size = np.asarray([box_size] * spatial_dims) |
|
|
elif len(box_size) != spatial_dims: |
|
|
raise ValueError("the sequence length of box_size should be the same as spatial_dims.") |
|
|
else: |
|
|
self.box_size = np.asarray(box_size) |
|
|
if self.box_size.min() <= 0: |
|
|
raise ValueError("box_size should be larger than 0.") |
|
|
|
|
|
self.box_lower_bd = self.box_size // 2 |
|
|
self.box_upper_bd = self.box_size - self.box_lower_bd |
|
|
|
|
|
def __call__(self, prob_map: NdarrayOrTensor): |
|
|
""" |
|
|
prob_map: the input probabilities map, it must have shape (H[, W, ...]). |
|
|
""" |
|
|
if self.sigma != 0: |
|
|
if not isinstance(prob_map, torch.Tensor): |
|
|
prob_map = torch.as_tensor(prob_map, dtype=torch.float) |
|
|
self.filter.to(prob_map.device) |
|
|
prob_map = self.filter(prob_map) |
|
|
|
|
|
prob_map_shape = prob_map.shape |
|
|
|
|
|
outputs = [] |
|
|
while prob_map.max() > self.prob_threshold: |
|
|
max_idx = unravel_index(prob_map.argmax(), prob_map_shape) |
|
|
prob_max = prob_map[tuple(max_idx)] |
|
|
max_idx = max_idx.cpu().numpy() if isinstance(max_idx, torch.Tensor) else max_idx |
|
|
prob_max = prob_max.item() if isinstance(prob_max, torch.Tensor) else prob_max |
|
|
outputs.append([prob_max] + list(max_idx)) |
|
|
|
|
|
idx_min_range = (max_idx - self.box_lower_bd).clip(0, None) |
|
|
idx_max_range = (max_idx + self.box_upper_bd).clip(None, prob_map_shape) |
|
|
|
|
|
slices = tuple(slice(idx_min_range[i], idx_max_range[i]) for i in range(self.spatial_dims)) |
|
|
prob_map[slices] = 0 |
|
|
|
|
|
return outputs |
|
|
|
|
|
|
|
|
class Invert(Transform): |
|
|
""" |
|
|
Utility transform to automatically invert the previously applied transforms. |
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
transform: InvertibleTransform | None = None, |
|
|
nearest_interp: bool | Sequence[bool] = True, |
|
|
device: str | torch.device | None = None, |
|
|
post_func: Callable | None = None, |
|
|
to_tensor: bool | Sequence[bool] = True, |
|
|
) -> None: |
|
|
""" |
|
|
Args: |
|
|
transform: the previously applied transform. |
|
|
nearest_interp: whether to use `nearest` interpolation mode when inverting the spatial transforms, |
|
|
default to `True`. If `False`, use the same interpolation mode as the original transform. |
|
|
device: move the inverted results to a target device before `post_func`, default to `None`. |
|
|
post_func: postprocessing for the inverted result, should be a callable function. |
|
|
to_tensor: whether to convert the inverted data into PyTorch Tensor first, default to `True`. |
|
|
""" |
|
|
if not isinstance(transform, InvertibleTransform): |
|
|
raise ValueError("transform is not invertible, can't invert transform for the data.") |
|
|
self.transform = transform |
|
|
self.nearest_interp = nearest_interp |
|
|
self.device = device |
|
|
self.post_func = post_func |
|
|
self.to_tensor = to_tensor |
|
|
self._totensor = ToTensor() |
|
|
|
|
|
def __call__(self, data): |
|
|
if not isinstance(data, MetaTensor): |
|
|
return data |
|
|
|
|
|
if self.nearest_interp: |
|
|
data.applied_operations = convert_applied_interp_mode( |
|
|
trans_info=data.applied_operations, mode="nearest", align_corners=None |
|
|
) |
|
|
|
|
|
data = data.detach() |
|
|
inverted = self.transform.inverse(data) |
|
|
if self.to_tensor and not isinstance(inverted, MetaTensor): |
|
|
inverted = self._totensor(inverted) |
|
|
if isinstance(inverted, torch.Tensor): |
|
|
inverted = inverted.to(device=self.device) |
|
|
if callable(self.post_func): |
|
|
inverted = self.post_func(inverted) |
|
|
return inverted |
|
|
|
|
|
|
|
|
class SobelGradients(Transform): |
|
|
"""Calculate Sobel gradients of a grayscale image with the shape of CxH[xWxDx...] or BxH[xWxDx...]. |
|
|
|
|
|
Args: |
|
|
kernel_size: the size of the Sobel kernel. Defaults to 3. |
|
|
spatial_axes: the axes that define the direction of the gradient to be calculated. It calculate the gradient |
|
|
along each of the provide axis. By default it calculate the gradient for all spatial axes. |
|
|
normalize_kernels: if normalize the Sobel kernel to provide proper gradients. Defaults to True. |
|
|
normalize_gradients: if normalize the output gradient to 0 and 1. Defaults to False. |
|
|
padding_mode: the padding mode of the image when convolving with Sobel kernels. Defaults to `"reflect"`. |
|
|
Acceptable values are ``'zeros'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. |
|
|
See ``torch.nn.Conv1d()`` for more information. |
|
|
dtype: kernel data type (torch.dtype). Defaults to `torch.float32`. |
|
|
|
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.TORCH] |
|
|
|
|
|
def __init__( |
|
|
self, |
|
|
kernel_size: int = 3, |
|
|
spatial_axes: Sequence[int] | int | None = None, |
|
|
normalize_kernels: bool = True, |
|
|
normalize_gradients: bool = False, |
|
|
padding_mode: str = "reflect", |
|
|
dtype: torch.dtype = torch.float32, |
|
|
) -> None: |
|
|
super().__init__() |
|
|
self.padding = padding_mode |
|
|
self.spatial_axes = spatial_axes |
|
|
self.normalize_kernels = normalize_kernels |
|
|
self.normalize_gradients = normalize_gradients |
|
|
self.kernel_diff, self.kernel_smooth = self._get_kernel(kernel_size, dtype) |
|
|
|
|
|
def _get_kernel(self, size, dtype) -> tuple[torch.Tensor, torch.Tensor]: |
|
|
if size < 3: |
|
|
raise ValueError(f"Sobel kernel size should be at least three. {size} was given.") |
|
|
if size % 2 == 0: |
|
|
raise ValueError(f"Sobel kernel size should be an odd number. {size} was given.") |
|
|
|
|
|
kernel_diff = torch.tensor([[[-1, 0, 1]]], dtype=dtype) |
|
|
kernel_smooth = torch.tensor([[[1, 2, 1]]], dtype=dtype) |
|
|
kernel_expansion = torch.tensor([[[1, 2, 1]]], dtype=dtype) |
|
|
|
|
|
if self.normalize_kernels: |
|
|
if not dtype.is_floating_point: |
|
|
raise ValueError( |
|
|
f"`dtype` for Sobel kernel should be floating point when `normalize_kernel==True`. {dtype} was given." |
|
|
) |
|
|
kernel_diff /= 2.0 |
|
|
kernel_smooth /= 4.0 |
|
|
kernel_expansion /= 4.0 |
|
|
|
|
|
|
|
|
expand = (size - 3) // 2 |
|
|
for _ in range(expand): |
|
|
kernel_diff = F.conv1d(kernel_diff, kernel_expansion, padding=2) |
|
|
kernel_smooth = F.conv1d(kernel_smooth, kernel_expansion, padding=2) |
|
|
|
|
|
return kernel_diff.squeeze(), kernel_smooth.squeeze() |
|
|
|
|
|
def __call__(self, image: NdarrayOrTensor) -> torch.Tensor: |
|
|
image_tensor = convert_to_tensor(image, track_meta=get_track_meta()) |
|
|
|
|
|
|
|
|
n_spatial_dims = image_tensor.ndim - 1 |
|
|
valid_spatial_axes = list(range(n_spatial_dims)) + list(range(-n_spatial_dims, 0)) |
|
|
|
|
|
|
|
|
if self.spatial_axes is None: |
|
|
spatial_axes = list(range(n_spatial_dims)) |
|
|
else: |
|
|
invalid_axis = set(ensure_tuple(self.spatial_axes)) - set(valid_spatial_axes) |
|
|
if invalid_axis: |
|
|
raise ValueError( |
|
|
f"The provide axes to calculate gradient is not valid: {invalid_axis}. " |
|
|
f"The image has {n_spatial_dims} spatial dimensions so it should be: {valid_spatial_axes}." |
|
|
) |
|
|
spatial_axes = [ax % n_spatial_dims if ax < 0 else ax for ax in ensure_tuple(self.spatial_axes)] |
|
|
|
|
|
|
|
|
image_tensor = image_tensor.unsqueeze(0) |
|
|
|
|
|
|
|
|
kernel_diff = self.kernel_diff.to(image_tensor.device) |
|
|
kernel_smooth = self.kernel_smooth.to(image_tensor.device) |
|
|
|
|
|
|
|
|
grad_list = [] |
|
|
for ax in spatial_axes: |
|
|
kernels = [kernel_smooth] * n_spatial_dims |
|
|
kernels[ax] = kernel_diff |
|
|
grad = separable_filtering(image_tensor, kernels, mode=self.padding) |
|
|
if self.normalize_gradients: |
|
|
grad_min = grad.min() |
|
|
if grad_min != grad.max(): |
|
|
grad -= grad_min |
|
|
grad_max = grad.max() |
|
|
if grad_max > 0: |
|
|
grad /= grad_max |
|
|
grad_list.append(grad) |
|
|
|
|
|
grads = torch.cat(grad_list, dim=1) |
|
|
|
|
|
|
|
|
grads = convert_to_dst_type(grads.squeeze(0), image_tensor)[0] |
|
|
|
|
|
return grads |
|
|
|
|
|
|
|
|
class DistanceTransformEDT(Transform): |
|
|
""" |
|
|
Applies the Euclidean distance transform on the input. |
|
|
Either GPU based with CuPy / cuCIM or CPU based with scipy. |
|
|
To use the GPU implementation, make sure cuCIM is available and that the data is a `torch.tensor` on a GPU device. |
|
|
|
|
|
Note that the results of the libraries can differ, so stick to one if possible. |
|
|
For details, check out the `SciPy`_ and `cuCIM`_ documentation and / or :func:`monai.transforms.utils.distance_transform_edt`. |
|
|
|
|
|
.. _SciPy: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.distance_transform_edt.html |
|
|
.. _cuCIM: https://docs.rapids.ai/api/cucim/nightly/api/#cucim.core.operations.morphology.distance_transform_edt |
|
|
""" |
|
|
|
|
|
backend = [TransformBackends.NUMPY, TransformBackends.CUPY] |
|
|
|
|
|
def __init__(self, sampling: None | float | list[float] = None) -> None: |
|
|
super().__init__() |
|
|
self.sampling = sampling |
|
|
|
|
|
def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor: |
|
|
""" |
|
|
Args: |
|
|
img: Input image on which the distance transform shall be run. |
|
|
Has to be a channel first array, must have shape: (num_channels, H, W [,D]). |
|
|
Can be of any type but will be converted into binary: 1 wherever image equates to True, 0 elsewhere. |
|
|
Input gets passed channel-wise to the distance-transform, thus results from this function will differ |
|
|
from directly calling ``distance_transform_edt()`` in CuPy or SciPy. |
|
|
sampling: Spacing of elements along each dimension. If a sequence, must be of length equal to the input rank -1; |
|
|
if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied. |
|
|
|
|
|
Returns: |
|
|
An array with the same shape and data type as img |
|
|
""" |
|
|
return distance_transform_edt(img=img, sampling=self.sampling) |
|
|
|
