# Copyright 2020 - 2021 MONAI Consortium

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

# http://www.apache.org/licenses/LICENSE-2.0

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

"""

A collection of "vanilla" transforms for spatial operations

https://github.com/Project-MONAI/MONAI/wiki/MONAI_Design

"""

import warnings

from typing import Any, List, Optional, Sequence, Tuple, Union

import numpy as np

import torch

from monai.config import USE_COMPILED, DtypeLike

from monai.config.type_definitions import NdarrayOrTensor

from monai.data.utils import compute_shape_offset, to_affine_nd, zoom_affine

from monai.networks.layers import AffineTransform, GaussianFilter, grid_pull

from monai.transforms.croppad.array import CenterSpatialCrop, Pad

from monai.transforms.transform import Randomizable, RandomizableTransform, ThreadUnsafe, Transform

from monai.transforms.utils import (

create_control_grid,

create_grid,

create_rotate,

create_scale,

create_shear,

create_translate,

map_spatial_axes,

)

from monai.utils import (

GridSampleMode,

GridSamplePadMode,

InterpolateMode,

NumpyPadMode,

PytorchPadMode,

ensure_tuple,

ensure_tuple_rep,

ensure_tuple_size,

fall_back_tuple,

issequenceiterable,

optional_import,

)

from monai.utils.deprecated import deprecated_arg

from monai.utils.enums import TransformBackends

from monai.utils.module import look_up_option

from monai.utils.type_conversion import convert_data_type, convert_to_dst_type

nib, _ = optional_import("nibabel")

__all__ = [

"Spacing",

"Orientation",

"Flip",

"Resize",

"Rotate",

"Zoom",

"Rotate90",

"RandRotate90",

"RandRotate",

"RandFlip",

"RandAxisFlip",

"RandZoom",

"AffineGrid",

"RandAffineGrid",

"RandDeformGrid",

"Resample",

"Affine",

"RandAffine",

"Rand2DElastic",

"Rand3DElastic",

"AddCoordinateChannels",

]

RandRange = Optional[Union[Sequence[Union[Tuple[float, float], float]], float]]

class Spacing(Transform):

"""

Resample input image into the specified `pixdim`.

"""

def __init__(

self,

pixdim: Union[Sequence[float], float],

diagonal: bool = False,

mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,

padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,

align_corners: bool = False,

dtype: DtypeLike = np.float64,

) -> None:

"""

Args:

pixdim: output voxel spacing. if providing a single number, will use it for the first dimension.

items of the pixdim sequence map to the spatial dimensions of input image, if length

of pixdim sequence is longer than image spatial dimensions, will ignore the longer part,

if shorter, will pad with `1.0`.

if the components of the `pixdim` are non-positive values, the transform will use the

corresponding components of the original pixdim, which is computed from the `affine`

matrix of input image.

diagonal: whether to resample the input to have a diagonal affine matrix.

If True, the input data is resampled to the following affine::

np.diag((pixdim_0, pixdim_1, ..., pixdim_n, 1))

This effectively resets the volume to the world coordinate system (RAS+ in nibabel).

The original orientation, rotation, shearing are not preserved.

If False, this transform preserves the axes orientation, orthogonal rotation and

translation components from the original affine. This option will not flip/swap axes

of the original data.

mode: {``"bilinear"``, ``"nearest"``}

Interpolation mode to calculate output values. Defaults to ``"bilinear"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}

Padding mode for outside grid values. Defaults to ``"border"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Geometrically, we consider the pixels of the input as squares rather than points.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

dtype: data type for resampling computation. Defaults to ``np.float64`` for best precision.

If None, use the data type of input data. To be compatible with other modules,

the output data type is always ``np.float32``.

"""

self.pixdim = np.array(ensure_tuple(pixdim), dtype=np.float64)

self.diagonal = diagonal

self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)

self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)

self.align_corners = align_corners

self.dtype = dtype

def __call__(

self,

data_array: np.ndarray,

affine: Optional[np.ndarray] = None,

mode: Optional[Union[GridSampleMode, str]] = None,

padding_mode: Optional[Union[GridSamplePadMode, str]] = None,

align_corners: Optional[bool] = None,

dtype: DtypeLike = None,

output_spatial_shape: Optional[np.ndarray] = None,

) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:

"""

Args:

data_array: in shape (num_channels, H[, W, ...]).

affine (matrix): (N+1)x(N+1) original affine matrix for spatially ND `data_array`. Defaults to identity.

mode: {``"bilinear"``, ``"nearest"``}

Interpolation mode to calculate output values. Defaults to ``self.mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}

Padding mode for outside grid values. Defaults to ``self.padding_mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Geometrically, we consider the pixels of the input as squares rather than points.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

dtype: data type for resampling computation. Defaults to ``self.dtype``.

If None, use the data type of input data. To be compatible with other modules,

the output data type is always ``np.float32``.

output_spatial_shape: specify the shape of the output data_array. This is typically useful for

the inverse of `Spacingd` where sometimes we could not compute the exact shape due to the quantization

error with the affine.

Raises:

ValueError: When ``data_array`` has no spatial dimensions.

ValueError: When ``pixdim`` is nonpositive.

Returns:

data_array (resampled into `self.pixdim`), original affine, current affine.

"""

data_array, *_ = convert_data_type(data_array, np.ndarray) # type: ignore

_dtype = dtype or self.dtype or data_array.dtype

sr = data_array.ndim - 1

if sr <= 0:

raise ValueError("data_array must have at least one spatial dimension.")

if affine is None:

# default to identity

affine = np.eye(sr + 1, dtype=np.float64)

affine_ = np.eye(sr + 1, dtype=np.float64)

else:

affine_ = to_affine_nd(sr, affine)

out_d = self.pixdim[:sr]

if out_d.size < sr:

out_d = np.append(out_d, [1.0] * (sr - out_d.size))

# compute output affine, shape and offset

new_affine = zoom_affine(affine_, out_d, diagonal=self.diagonal)

output_shape, offset = compute_shape_offset(data_array.shape[1:], affine_, new_affine)

new_affine[:sr, -1] = offset[:sr]

transform = np.linalg.inv(affine_) @ new_affine

# adapt to the actual rank

transform = to_affine_nd(sr, transform)

# no resampling if it's identity transform

if np.allclose(transform, np.diag(np.ones(len(transform))), atol=1e-3):

output_data = data_array.copy().astype(np.float32)

new_affine = to_affine_nd(affine, new_affine)

return output_data, affine, new_affine

# resample

affine_xform = AffineTransform(

normalized=False,

mode=look_up_option(mode or self.mode, GridSampleMode),

padding_mode=look_up_option(padding_mode or self.padding_mode, GridSamplePadMode),

align_corners=self.align_corners if align_corners is None else align_corners,

reverse_indexing=True,

)

output_data = affine_xform(

# AffineTransform requires a batch dim

torch.as_tensor(np.ascontiguousarray(data_array).astype(_dtype)).unsqueeze(0),

torch.as_tensor(np.ascontiguousarray(transform).astype(_dtype)),

spatial_size=output_shape if output_spatial_shape is None else output_spatial_shape,

)

output_data = np.asarray(output_data.squeeze(0).detach().cpu().numpy(), dtype=np.float32) # type: ignore

new_affine = to_affine_nd(affine, new_affine)

return output_data, affine, new_affine

class Orientation(Transform):

"""

Change the input image's orientation into the specified based on `axcodes`.

"""

def __init__(

self,

axcodes: Optional[str] = None,

as_closest_canonical: bool = False,

labels: Optional[Sequence[Tuple[str, str]]] = tuple(zip("LPI", "RAS")),

) -> None:

"""

Args:

axcodes: N elements sequence for spatial ND input's orientation.

e.g. axcodes='RAS' represents 3D orientation:

(Left, Right), (Posterior, Anterior), (Inferior, Superior).

default orientation labels options are: 'L' and 'R' for the first dimension,

'P' and 'A' for the second, 'I' and 'S' for the third.

as_closest_canonical: if True, load the image as closest to canonical axis format.

labels: optional, None or sequence of (2,) sequences

(2,) sequences are labels for (beginning, end) of output axis.

Defaults to ``(('L', 'R'), ('P', 'A'), ('I', 'S'))``.

Raises:

ValueError: When ``axcodes=None`` and ``as_closest_canonical=True``. Incompatible values.

See Also: `nibabel.orientations.ornt2axcodes`.

"""

if axcodes is None and not as_closest_canonical:

raise ValueError("Incompatible values: axcodes=None and as_closest_canonical=True.")

if axcodes is not None and as_closest_canonical:

warnings.warn("using as_closest_canonical=True, axcodes ignored.")

self.axcodes = axcodes

self.as_closest_canonical = as_closest_canonical

self.labels = labels

def __call__(

self, data_array: np.ndarray, affine: Optional[np.ndarray] = None

) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:

"""

original orientation of `data_array` is defined by `affine`.

Args:

data_array: in shape (num_channels, H[, W, ...]).

affine (matrix): (N+1)x(N+1) original affine matrix for spatially ND `data_array`. Defaults to identity.

Raises:

ValueError: When ``data_array`` has no spatial dimensions.

ValueError: When ``axcodes`` spatiality differs from ``data_array``.

Returns:

data_array (reoriented in `self.axcodes`), original axcodes, current axcodes.

"""

data_array, *_ = convert_data_type(data_array, np.ndarray) # type: ignore

sr = data_array.ndim - 1

if sr <= 0:

raise ValueError("data_array must have at least one spatial dimension.")

if affine is None:

affine = np.eye(sr + 1, dtype=np.float64)

affine_ = np.eye(sr + 1, dtype=np.float64)

else:

affine_ = to_affine_nd(sr, affine)

src = nib.io_orientation(affine_)

if self.as_closest_canonical:

spatial_ornt = src

else:

if self.axcodes is None:

raise AssertionError

dst = nib.orientations.axcodes2ornt(self.axcodes[:sr], labels=self.labels)

if len(dst) < sr:

raise ValueError(

f"axcodes must match data_array spatially, got axcodes={len(self.axcodes)}D data_array={sr}D"

)

spatial_ornt = nib.orientations.ornt_transform(src, dst)

ornt = spatial_ornt.copy()

ornt[:, 0] += 1 # skip channel dim

ornt = np.concatenate([np.array([[0, 1]]), ornt])

shape = data_array.shape[1:]

data_array = np.ascontiguousarray(nib.orientations.apply_orientation(data_array, ornt))

new_affine = affine_ @ nib.orientations.inv_ornt_aff(spatial_ornt, shape)

new_affine = to_affine_nd(affine, new_affine)

return data_array, affine, new_affine

class Flip(Transform):

"""

Reverses the order of elements along the given spatial axis. Preserves shape.

Uses ``np.flip`` in practice. See numpy.flip for additional details:

https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html.

Args:

spatial_axis: spatial axes along which to flip over. Default is None.

The default `axis=None` will flip over all of the axes of the input array.

If axis is negative it counts from the last to the first axis.

If axis is a tuple of ints, flipping is performed on all of the axes

specified in the tuple.

"""

backend = [TransformBackends.TORCH, TransformBackends.NUMPY]

def __init__(self, spatial_axis: Optional[Union[Sequence[int], int]] = None) -> None:

self.spatial_axis = spatial_axis

def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]),

"""

if isinstance(img, np.ndarray):

return np.ascontiguousarray(np.flip(img, map_spatial_axes(img.ndim, self.spatial_axis)))

return torch.flip(img, map_spatial_axes(img.ndim, self.spatial_axis))

class Resize(Transform):

"""

Resize the input image to given spatial size (with scaling, not cropping/padding).

Implemented using :py:class:`torch.nn.functional.interpolate`.

Args:

spatial_size: expected shape of spatial dimensions after resize operation.

if some components of the `spatial_size` are non-positive values, the transform will use the

corresponding components of img size. For example, `spatial_size=(32, -1)` will be adapted

to `(32, 64)` if the second spatial dimension size of img is `64`.

size_mode: should be "all" or "longest", if "all", will use `spatial_size` for all the spatial dims,

if "longest", rescale the image so that only the longest side is equal to specified `spatial_size`,

which must be an int number in this case, keeping the aspect ratio of the initial image, refer to:

https://albumentations.ai/docs/api_reference/augmentations/geometric/resize/

#albumentations.augmentations.geometric.resize.LongestMaxSize.

mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}

The interpolation mode. Defaults to ``"area"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

align_corners: This only has an effect when mode is

'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

"""

backend = [TransformBackends.TORCH]

def __init__(

self,

spatial_size: Union[Sequence[int], int],

size_mode: str = "all",

mode: Union[InterpolateMode, str] = InterpolateMode.AREA,

align_corners: Optional[bool] = None,

) -> None:

self.size_mode = look_up_option(size_mode, ["all", "longest"])

self.spatial_size = spatial_size

self.mode: InterpolateMode = look_up_option(mode, InterpolateMode)

self.align_corners = align_corners

def __call__(

self,

img: NdarrayOrTensor,

mode: Optional[Union[InterpolateMode, str]] = None,

align_corners: Optional[bool] = None,

) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]).

mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}

The interpolation mode. Defaults to ``self.mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

align_corners: This only has an effect when mode is

'linear', 'bilinear', 'bicubic' or 'trilinear'. Defaults to ``self.align_corners``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

Raises:

ValueError: When ``self.spatial_size`` length is less than ``img`` spatial dimensions.

"""

img_, *_ = convert_data_type(img, torch.Tensor, dtype=torch.float) # type: ignore

if self.size_mode == "all":

input_ndim = img_.ndim - 1 # spatial ndim

output_ndim = len(ensure_tuple(self.spatial_size))

if output_ndim > input_ndim:

input_shape = ensure_tuple_size(img_.shape, output_ndim + 1, 1)

img_ = img_.reshape(input_shape)

elif output_ndim < input_ndim:

raise ValueError(

"len(spatial_size) must be greater or equal to img spatial dimensions, "

f"got spatial_size={output_ndim} img={input_ndim}."

)

spatial_size_ = fall_back_tuple(self.spatial_size, img_.shape[1:])

else: # for the "longest" mode

img_size = img_.shape[1:]

if not isinstance(self.spatial_size, int):

raise ValueError("spatial_size must be an int number if size_mode is 'longest'.")

scale = self.spatial_size / max(img_size)

spatial_size_ = tuple(int(round(s * scale)) for s in img_size)

resized = torch.nn.functional.interpolate( # type: ignore

input=img_.unsqueeze(0), # type: ignore

size=spatial_size_,

mode=look_up_option(self.mode if mode is None else mode, InterpolateMode).value,

align_corners=self.align_corners if align_corners is None else align_corners,

)

out, *_ = convert_to_dst_type(resized.squeeze(0), img)

return out

class Rotate(Transform, ThreadUnsafe):

"""

Rotates an input image by given angle using :py:class:`monai.networks.layers.AffineTransform`.

Args:

angle: Rotation angle(s) in radians. should a float for 2D, three floats for 3D.

keep_size: If it is True, the output shape is kept the same as the input.

If it is False, the output shape is adapted so that the

input array is contained completely in the output. Default is True.

mode: {``"bilinear"``, ``"nearest"``}

Interpolation mode to calculate output values. Defaults to ``"bilinear"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}

Padding mode for outside grid values. Defaults to ``"border"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Defaults to False.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

dtype: data type for resampling computation. Defaults to ``np.float64`` for best precision.

If None, use the data type of input data. To be compatible with other modules,

the output data type is always ``np.float32``.

"""

backend = [TransformBackends.TORCH]

def __init__(

self,

angle: Union[Sequence[float], float],

keep_size: bool = True,

mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,

padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,

align_corners: bool = False,

dtype: Union[DtypeLike, torch.dtype] = np.float64,

) -> None:

self.angle = angle

self.keep_size = keep_size

self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)

self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)

self.align_corners = align_corners

self.dtype = dtype

self._rotation_matrix: Optional[NdarrayOrTensor] = None

def __call__(

self,

img: NdarrayOrTensor,

mode: Optional[Union[GridSampleMode, str]] = None,

padding_mode: Optional[Union[GridSamplePadMode, str]] = None,

align_corners: Optional[bool] = None,

dtype: Union[DtypeLike, torch.dtype] = None,

) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: [chns, H, W] or [chns, H, W, D].

mode: {``"bilinear"``, ``"nearest"``}

Interpolation mode to calculate output values. Defaults to ``self.mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}

Padding mode for outside grid values. Defaults to ``self.padding_mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Defaults to ``self.align_corners``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Defaults to ``self.align_corners``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

dtype: data type for resampling computation. Defaults to ``self.dtype``.

If None, use the data type of input data. To be compatible with other modules,

the output data type is always ``np.float32``.

Raises:

ValueError: When ``img`` spatially is not one of [2D, 3D].

"""

_dtype = dtype or self.dtype or img.dtype

img_t: torch.Tensor

img_t, *_ = convert_data_type(img, torch.Tensor, dtype=_dtype) # type: ignore

im_shape = np.asarray(img_t.shape[1:]) # spatial dimensions

input_ndim = len(im_shape)

if input_ndim not in (2, 3):

raise ValueError(f"Unsupported img dimension: {input_ndim}, available options are [2, 3].")

_angle = ensure_tuple_rep(self.angle, 1 if input_ndim == 2 else 3)

transform = create_rotate(input_ndim, _angle)

shift = create_translate(input_ndim, ((im_shape - 1) / 2).tolist())

if self.keep_size:

output_shape = im_shape

else:

corners = np.asarray(np.meshgrid(*[(0, dim) for dim in im_shape], indexing="ij")).reshape(

(len(im_shape), -1)

)

corners = transform[:-1, :-1] @ corners # type: ignore

output_shape = np.asarray(corners.ptp(axis=1) + 0.5, dtype=int)

shift_1 = create_translate(input_ndim, (-(output_shape - 1) / 2).tolist())

transform = shift @ transform @ shift_1

transform_t: torch.Tensor

transform_t, *_ = convert_to_dst_type(transform, img_t) # type: ignore

xform = AffineTransform(

normalized=False,

mode=look_up_option(mode or self.mode, GridSampleMode),

padding_mode=look_up_option(padding_mode or self.padding_mode, GridSamplePadMode),

align_corners=self.align_corners if align_corners is None else align_corners,

reverse_indexing=True,

)

output: torch.Tensor = xform(img_t.unsqueeze(0), transform_t, spatial_size=output_shape).float().squeeze(0)

self._rotation_matrix = transform

out: NdarrayOrTensor

out, *_ = convert_to_dst_type(output, dst=img, dtype=output.dtype)

return out

def get_rotation_matrix(self) -> Optional[NdarrayOrTensor]:

"""

Get the most recently applied rotation matrix

This is not thread-safe.

"""

return self._rotation_matrix

class Zoom(Transform):

"""

Zooms an ND image using :py:class:`torch.nn.functional.interpolate`.

For details, please see https://pytorch.org/docs/stable/nn.functional.html#interpolate.

Different from :py:class:`monai.transforms.resize`, this transform takes scaling factors

as input, and provides an option of preserving the input spatial size.

Args:

zoom: The zoom factor along the spatial axes.

If a float, zoom is the same for each spatial axis.

If a sequence, zoom should contain one value for each spatial axis.

mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}

The interpolation mode. Defaults to ``"area"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

padding_mode: available modes for numpy array:{``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``,

``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}

available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.

One of the listed string values or a user supplied function. Defaults to ``"constant"``.

The mode to pad data after zooming.

See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html

https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html

align_corners: This only has an effect when mode is

'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

keep_size: Should keep original size (padding/slicing if needed), default is True.

kwargs: other arguments for the `np.pad` or `torch.pad` function.

note that `np.pad` treats channel dimension as the first dimension.

"""

backend = [TransformBackends.TORCH]

def __init__(

self,

zoom: Union[Sequence[float], float],

mode: Union[InterpolateMode, str] = InterpolateMode.AREA,

padding_mode: Union[NumpyPadMode, PytorchPadMode, str] = NumpyPadMode.EDGE,

align_corners: Optional[bool] = None,

keep_size: bool = True,

**kwargs,

) -> None:

self.zoom = zoom

self.mode: InterpolateMode = InterpolateMode(mode)

self.padding_mode = padding_mode

self.align_corners = align_corners

self.keep_size = keep_size

self.kwargs = kwargs

def __call__(

self,

img: NdarrayOrTensor,

mode: Optional[Union[InterpolateMode, str]] = None,

padding_mode: Optional[Union[NumpyPadMode, PytorchPadMode, str]] = None,

align_corners: Optional[bool] = None,

) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]).

mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}

The interpolation mode. Defaults to ``self.mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

padding_mode: available modes for numpy array:{``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``,

``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}

available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.

One of the listed string values or a user supplied function. Defaults to ``"constant"``.

The mode to pad data after zooming.

See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html

https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html

align_corners: This only has an effect when mode is

'linear', 'bilinear', 'bicubic' or 'trilinear'. Defaults to ``self.align_corners``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

"""

img_t: torch.Tensor

img_t, *_ = convert_data_type(img, torch.Tensor, dtype=torch.float32) # type: ignore

_zoom = ensure_tuple_rep(self.zoom, img.ndim - 1) # match the spatial image dim

zoomed: NdarrayOrTensor = torch.nn.functional.interpolate( # type: ignore

recompute_scale_factor=True,

input=img_t.unsqueeze(0),

scale_factor=list(_zoom),

mode=look_up_option(self.mode if mode is None else mode, InterpolateMode).value,

align_corners=self.align_corners if align_corners is None else align_corners,

)

zoomed = zoomed.squeeze(0)

if self.keep_size and not np.allclose(img_t.shape, zoomed.shape):

pad_vec = [(0, 0)] * len(img_t.shape)

slice_vec = [slice(None)] * len(img_t.shape)

for idx, (od, zd) in enumerate(zip(img_t.shape, zoomed.shape)):

diff = od - zd

half = abs(diff) // 2

if diff > 0: # need padding

pad_vec[idx] = (half, diff - half)

elif diff < 0: # need slicing

slice_vec[idx] = slice(half, half + od)

padder = Pad(pad_vec, padding_mode or self.padding_mode)

zoomed = padder(zoomed)

zoomed = zoomed[tuple(slice_vec)]

out, *_ = convert_to_dst_type(zoomed, dst=img)

return out

class Rotate90(Transform):

"""

Rotate an array by 90 degrees in the plane specified by `axes`.

See np.rot90 for additional details:

https://numpy.org/doc/stable/reference/generated/numpy.rot90.html.

"""

backend = [TransformBackends.TORCH, TransformBackends.NUMPY]

def __init__(self, k: int = 1, spatial_axes: Tuple[int, int] = (0, 1)) -> None:

"""

Args:

k: number of times to rotate by 90 degrees.

spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.

Default: (0, 1), this is the first two axis in spatial dimensions.

If axis is negative it counts from the last to the first axis.

"""

self.k = k

spatial_axes_: Tuple[int, int] = ensure_tuple(spatial_axes) # type: ignore

if len(spatial_axes_) != 2:

raise ValueError("spatial_axes must be 2 int numbers to indicate the axes to rotate 90 degrees.")

self.spatial_axes = spatial_axes_

def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]),

"""

rot90 = torch.rot90 if isinstance(img, torch.Tensor) else np.rot90

out: NdarrayOrTensor = rot90(img, self.k, map_spatial_axes(img.ndim, self.spatial_axes))

out, *_ = convert_data_type(out, dtype=img.dtype)

return out

class RandRotate90(RandomizableTransform):

"""

With probability `prob`, input arrays are rotated by 90 degrees

in the plane specified by `spatial_axes`.

"""

backend = Rotate90.backend

def __init__(self, prob: float = 0.1, max_k: int = 3, spatial_axes: Tuple[int, int] = (0, 1)) -> None:

"""

Args:

prob: probability of rotating.

(Default 0.1, with 10% probability it returns a rotated array)

max_k: number of rotations will be sampled from `np.random.randint(max_k) + 1`, (Default 3).

spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.

Default: (0, 1), this is the first two axis in spatial dimensions.

"""

RandomizableTransform.__init__(self, prob)

self.max_k = max_k

self.spatial_axes = spatial_axes

self._rand_k = 0

def randomize(self, data: Optional[Any] = None) -> None:

self._rand_k = self.R.randint(self.max_k) + 1

super().randomize(None)

def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]),

"""

self.randomize()

if not self._do_transform:

return img

rotator = Rotate90(self._rand_k, self.spatial_axes)

return rotator(img)

class RandRotate(RandomizableTransform):

"""

Randomly rotate the input arrays.

Args:

range_x: Range of rotation angle in radians in the plane defined by the first and second axes.

If single number, angle is uniformly sampled from (-range_x, range_x).

range_y: Range of rotation angle in radians in the plane defined by the first and third axes.

If single number, angle is uniformly sampled from (-range_y, range_y).

range_z: Range of rotation angle in radians in the plane defined by the second and third axes.

If single number, angle is uniformly sampled from (-range_z, range_z).

prob: Probability of rotation.

keep_size: If it is False, the output shape is adapted so that the

input array is contained completely in the output.

If it is True, the output shape is the same as the input. Default is True.

mode: {``"bilinear"``, ``"nearest"``}

Interpolation mode to calculate output values. Defaults to ``"bilinear"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}

Padding mode for outside grid values. Defaults to ``"border"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Defaults to False.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

dtype: data type for resampling computation. Defaults to ``np.float64`` for best precision.

If None, use the data type of input data. To be compatible with other modules,

the output data type is always ``np.float32``.

"""

backend = Rotate.backend

def __init__(

self,

range_x: Union[Tuple[float, float], float] = 0.0,

range_y: Union[Tuple[float, float], float] = 0.0,

range_z: Union[Tuple[float, float], float] = 0.0,

prob: float = 0.1,

keep_size: bool = True,

mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,

padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,

align_corners: bool = False,

dtype: Union[DtypeLike, torch.dtype] = np.float64,

) -> None:

RandomizableTransform.__init__(self, prob)

self.range_x = ensure_tuple(range_x)

if len(self.range_x) == 1:

self.range_x = tuple(sorted([-self.range_x[0], self.range_x[0]]))

self.range_y = ensure_tuple(range_y)

if len(self.range_y) == 1:

self.range_y = tuple(sorted([-self.range_y[0], self.range_y[0]]))

self.range_z = ensure_tuple(range_z)

if len(self.range_z) == 1:

self.range_z = tuple(sorted([-self.range_z[0], self.range_z[0]]))

self.keep_size = keep_size

self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)

self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)

self.align_corners = align_corners

self.dtype = dtype

self.x = 0.0

self.y = 0.0

self.z = 0.0

def randomize(self, data: Optional[Any] = None) -> None:

super().randomize(None)

self.x = self.R.uniform(low=self.range_x[0], high=self.range_x[1])

self.y = self.R.uniform(low=self.range_y[0], high=self.range_y[1])

self.z = self.R.uniform(low=self.range_z[0], high=self.range_z[1])

def __call__(

self,

img: NdarrayOrTensor,

mode: Optional[Union[GridSampleMode, str]] = None,

padding_mode: Optional[Union[GridSamplePadMode, str]] = None,

align_corners: Optional[bool] = None,

dtype: Union[DtypeLike, torch.dtype] = None,

) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape 2D: (nchannels, H, W), or 3D: (nchannels, H, W, D).

mode: {``"bilinear"``, ``"nearest"``}

Interpolation mode to calculate output values. Defaults to ``self.mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}

Padding mode for outside grid values. Defaults to ``self.padding_mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

align_corners: Defaults to ``self.align_corners``.

See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample

dtype: data type for resampling computation. Defaults to ``self.dtype``.

If None, use the data type of input data. To be compatible with other modules,

the output data type is always ``np.float32``.

"""

self.randomize()

if not self._do_transform:

img_t: torch.Tensor

img_t, *_ = convert_data_type(img, torch.Tensor) # type: ignore

return img_t

rotator = Rotate(

angle=self.x if img.ndim == 3 else (self.x, self.y, self.z),

keep_size=self.keep_size,

mode=look_up_option(mode or self.mode, GridSampleMode),

padding_mode=look_up_option(padding_mode or self.padding_mode, GridSamplePadMode),

align_corners=self.align_corners if align_corners is None else align_corners,

dtype=dtype or self.dtype or img.dtype,

)

return rotator(img)

class RandFlip(RandomizableTransform):

"""

Randomly flips the image along axes. Preserves shape.

See numpy.flip for additional details.

https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html

Args:

prob: Probability of flipping.

spatial_axis: Spatial axes along which to flip over. Default is None.

"""

backend = Flip.backend

def __init__(self, prob: float = 0.1, spatial_axis: Optional[Union[Sequence[int], int]] = None) -> None:

RandomizableTransform.__init__(self, prob)

self.flipper = Flip(spatial_axis=spatial_axis)

def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]),

"""

self.randomize(None)

if not self._do_transform:

return img

return self.flipper(img)

class RandAxisFlip(RandomizableTransform):

"""

Randomly select a spatial axis and flip along it.

See numpy.flip for additional details.

https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html

Args:

prob: Probability of flipping.

"""

backend = Flip.backend

def __init__(self, prob: float = 0.1) -> None:

RandomizableTransform.__init__(self, prob)

self._axis: Optional[int] = None

def randomize(self, data: NdarrayOrTensor) -> None:

super().randomize(None)

self._axis = self.R.randint(data.ndim - 1)

def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape: (num_channels, H[, W, ..., ]),

"""

self.randomize(data=img)

if not self._do_transform:

return img

flipper = Flip(spatial_axis=self._axis)

return flipper(img)

class RandZoom(RandomizableTransform):

"""

Randomly zooms input arrays with given probability within given zoom range.

Args:

prob: Probability of zooming.

min_zoom: Min zoom factor. Can be float or sequence same size as image.

If a float, select a random factor from `[min_zoom, max_zoom]` then apply to all spatial dims

to keep the original spatial shape ratio.

If a sequence, min_zoom should contain one value for each spatial axis.

If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.

max_zoom: Max zoom factor. Can be float or sequence same size as image.

If a float, select a random factor from `[min_zoom, max_zoom]` then apply to all spatial dims

to keep the original spatial shape ratio.

If a sequence, max_zoom should contain one value for each spatial axis.

If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.

mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}

The interpolation mode. Defaults to ``"area"``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

padding_mode: available modes for numpy array:{``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``,

``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}

available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.

One of the listed string values or a user supplied function. Defaults to ``"constant"``.

The mode to pad data after zooming.

See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html

https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html

align_corners: This only has an effect when mode is

'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

keep_size: Should keep original size (pad if needed), default is True.

kwargs: other arguments for the `np.pad` or `torch.pad` function.

note that `np.pad` treats channel dimension as the first dimension.

"""

backend = Zoom.backend

def __init__(

self,

prob: float = 0.1,

min_zoom: Union[Sequence[float], float] = 0.9,

max_zoom: Union[Sequence[float], float] = 1.1,

mode: Union[InterpolateMode, str] = InterpolateMode.AREA,

padding_mode: Union[NumpyPadMode, PytorchPadMode, str] = NumpyPadMode.EDGE,

align_corners: Optional[bool] = None,

keep_size: bool = True,

**kwargs,

) -> None:

RandomizableTransform.__init__(self, prob)

self.min_zoom = ensure_tuple(min_zoom)

self.max_zoom = ensure_tuple(max_zoom)

if len(self.min_zoom) != len(self.max_zoom):

raise AssertionError("min_zoom and max_zoom must have same length.")

self.mode: InterpolateMode = look_up_option(mode, InterpolateMode)

self.padding_mode = padding_mode

self.align_corners = align_corners

self.keep_size = keep_size

self.kwargs = kwargs

self._zoom: Sequence[float] = [1.0]

def randomize(self, data: Optional[Any] = None) -> None:

super().randomize(None)

self._zoom = [self.R.uniform(l, h) for l, h in zip(self.min_zoom, self.max_zoom)]

def __call__(

self,

img: NdarrayOrTensor,

mode: Optional[Union[InterpolateMode, str]] = None,

padding_mode: Optional[Union[NumpyPadMode, PytorchPadMode, str]] = None,

align_corners: Optional[bool] = None,

) -> NdarrayOrTensor:

"""

Args:

img: channel first array, must have shape 2D: (nchannels, H, W), or 3D: (nchannels, H, W, D).

mode: {``"nearest"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``}

The interpolation mode. Defaults to ``self.mode``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

padding_mode: available modes for numpy array:{``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``,

``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``}

available modes for PyTorch Tensor: {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}.

One of the listed string values or a user supplied function. Defaults to ``"constant"``.

The mode to pad data after zooming.

See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html

https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html

align_corners: This only has an effect when mode is

'linear', 'bilinear', 'bicubic' or 'trilinear'. Defaults to ``self.align_corners``.

See also: https://pytorch.org/docs/stable/nn.functional.html#interpolate

"""

# match the spatial image dim

self.randomize()

if not self._do_transform:

img_t: torch.Tensor

img_t, *_ = convert_data_type(img, dtype=torch.float32) # type: ignore

return img_t

if len(self._zoom) == 1:

# to keep the spatial shape ratio, use same random zoom factor for all dims

self._zoom = ensure_tuple_rep(self._zoom[0], img.ndim - 1)

elif len(self._zoom) == 2 and img.ndim > 3:

# if 2 zoom factors provided for 3D data, use the first factor for H and W dims, second factor for D dim

self._zoom = ensure_tuple_rep(self._zoom[0], img.ndim - 2) + ensure_tuple(self._zoom[-1])

zoomer = Zoom(

self._zoom,

keep_size=self.keep_size,

mode=look_up_option(mode or self.mode, InterpolateMode),

padding_mode=padding_mode or self.padding_mode,

align_corners=align_corners or self.align_corners,