def __init__(self, keys, prob=0.1, spatial_axis=None):
MapTransform.__init__(self, keys)
self.spatial_axis = spatial_axis
self.prob = prob
self._do_transform = False
self.flipper = Flip(spatial_axis=spatial_axis)
def __init__(self,
keys,
affine_key,
pixdim,
interp_order=2,
keep_shape=False,
output_key='spacing'):
"""
Args:
affine_key (hashable): the key to the original affine.
The affine will be used to compute input data's pixdim.
pixdim (sequence of floats): output voxel spacing.
interp_order (int or sequence of ints): int: the same interpolation order
for all data indexed by `self,keys`; sequence of ints, should
correspond to an interpolation order for each data item indexed
by `self.keys` respectively.
keep_shape (bool): whether to maintain the original spatial shape
after resampling. Defaults to False.
output_key (hashable): key to be added to the output dictionary to track
the pixdim status.
"""
MapTransform.__init__(self, keys)
self.affine_key = affine_key
self.spacing_transform = Spacing(pixdim, keep_shape=keep_shape)
interp_order = ensure_tuple(interp_order)
self.interp_order = interp_order \
if len(interp_order) == len(self.keys) else interp_order * len(self.keys)
self.output_key = output_key
def __init__(self, keys,
spatial_size, prob=0.1,
rotate_range=None, shear_range=None, translate_range=None, scale_range=None,
mode='bilinear', padding_mode='zeros', as_tensor_output=True, device=None):
"""
Args:
keys (Hashable items): keys of the corresponding items to be transformed.
spatial_size (list or tuple of int): output image spatial size.
if ``data`` component has two spatial dimensions, ``spatial_size`` should have 2 elements [h, w].
if ``data`` component has three spatial dimensions, ``spatial_size`` should have 3 elements [h, w, d].
prob (float): probability of returning a randomized affine grid.
defaults to 0.1, with 10% chance returns a randomized grid.
mode ('nearest'|'bilinear'): interpolation order. Defaults to ``'bilinear'``.
if mode is a tuple of interpolation mode strings, each string corresponds to a key in ``keys``.
this is useful to set different modes for different data items.
padding_mode ('zeros'|'border'|'reflection'): mode of handling out of range indices.
Defaults to ``'zeros'``.
as_tensor_output (bool): the computation is implemented using pytorch tensors, this option specifies
whether to convert it back to numpy arrays.
device (torch.device): device on which the tensor will be allocated.
See also:
- :py:class:`monai.transforms.compose.MapTransform`
- :py:class:`RandAffineGrid` for the random affine paramters configurations.
"""
MapTransform.__init__(self, keys)
default_mode = 'bilinear' if isinstance(mode, (tuple, list)) else mode
self.rand_affine = RandAffine(prob=prob,
rotate_range=rotate_range, shear_range=shear_range,
translate_range=translate_range, scale_range=scale_range,
spatial_size=spatial_size,
mode=default_mode, padding_mode=padding_mode,
as_tensor_output=as_tensor_output, device=device)
self.mode = mode
def __init__(self,
keys,
affine_key,
axcodes,
labels=None,
output_key='orientation'):
"""
Args:
affine_key (hashable): the key to the original affine.
The affine will be used to compute input data's orientation.
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.
labels : optional, None or sequence of (2,) sequences
(2,) sequences are labels for (beginning, end) of output axis.
See Also:
`nibabel.orientations.ornt2axcodes`.
"""
MapTransform.__init__(self, keys)
self.affine_key = affine_key
self.orientation_transform = Orientation(axcodes=axcodes,
labels=labels)
self.output_key = output_key
def __init__(self,
keys,
degrees,
prob=0.1,
spatial_axes=(0, 1),
reshape=True,
order=1,
mode='constant',
cval=0,
prefilter=True):
MapTransform.__init__(self, keys)
self.prob = prob
self.degrees = degrees
self.reshape = reshape
self.order = order
self.mode = mode
self.cval = cval
self.prefilter = prefilter
self.spatial_axes = spatial_axes
if not hasattr(self.degrees, '__iter__'):
self.degrees = (-self.degrees, self.degrees)
assert len(self.degrees
) == 2, "degrees should be a number or pair of numbers."
self._do_transform = False
self.angle = None
def __init__(self,
keys,
prob=0.1,
min_zoom=0.9,
max_zoom=1.1,
order=3,
mode='constant',
cval=0,
prefilter=True,
use_gpu=False,
keep_size=False):
MapTransform.__init__(self, keys)
if hasattr(min_zoom, '__iter__') and \
hasattr(max_zoom, '__iter__'):
assert len(min_zoom) == len(
max_zoom), "min_zoom and max_zoom must have same length."
self.min_zoom = min_zoom
self.max_zoom = max_zoom
self.prob = prob
self.order = order
self.mode = mode
self.cval = cval
self.prefilter = prefilter
self.use_gpu = use_gpu
self.keep_size = keep_size
self._do_transform = False
self._zoom = None
def __init__(self, keys):
"""
Args:
keys (hashable items): keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
"""
MapTransform.__init__(self, keys)
def __init__(self, keys,
spatial_size, spacing, magnitude_range, prob=0.1,
rotate_range=None, shear_range=None, translate_range=None, scale_range=None,
mode='bilinear', padding_mode='zeros', as_tensor_output=False, device=None):
"""
Args:
keys (Hashable items): keys of the corresponding items to be transformed.
spatial_size (2 ints): specifying output image spatial size [h, w].
spacing (2 ints): distance in between the control points.
magnitude_range (2 ints): the random offsets will be generated from
``uniform[magnitude[0], magnitude[1])``.
prob (float): probability of returning a randomized affine grid.
defaults to 0.1, with 10% chance returns a randomized grid,
otherwise returns a ``spatial_size`` centered area extracted from the input image.
mode ('nearest'|'bilinear'): interpolation order. Defaults to ``'bilinear'``.
if mode is a tuple of interpolation mode strings, each string corresponds to a key in ``keys``.
this is useful to set different modes for different data items.
padding_mode ('zeros'|'border'|'reflection'): mode of handling out of range indices.
Defaults to ``'zeros'``.
as_tensor_output (bool): the computation is implemented using pytorch tensors, this option specifies
whether to convert it back to numpy arrays.
device (torch.device): device on which the tensor will be allocated.
See also:
- :py:class:`RandAffineGrid` for the random affine paramters configurations.
- :py:class:`Affine` for the affine transformation parameters configurations.
"""
MapTransform.__init__(self, keys)
default_mode = 'bilinear' if isinstance(mode, (tuple, list)) else mode
self.rand_2d_elastic = Rand2DElastic(spacing=spacing, magnitude_range=magnitude_range, prob=prob,
rotate_range=rotate_range, shear_range=shear_range,
translate_range=translate_range, scale_range=scale_range,
spatial_size=spatial_size,
mode=default_mode, padding_mode=padding_mode,
as_tensor_output=as_tensor_output, device=device)
self.mode = mode
def __init__(self,
keys,
label_key,
size,
pos=1,
neg=1,
num_samples=1,
image_key=None,
image_threshold=0):
MapTransform.__init__(self, keys)
assert isinstance(label_key, str), 'label_key must be a string.'
assert isinstance(size, (list, tuple)), 'size must be list or tuple.'
assert all(
isinstance(x, int) and x > 0
for x in size), 'all elements of size must be positive integers.'
assert float(pos) >= 0 and float(
neg) >= 0, "pos and neg must be greater than or equal to 0."
assert float(pos) + float(neg) > 0, "pos and neg cannot both be 0."
assert isinstance(num_samples, int), \
"invalid samples number: {}. num_samples must be an integer.".format(num_samples)
assert num_samples >= 0, 'num_samples must be greater than or equal to 0.'
self.label_key = label_key
self.size = size
self.pos_ratio = float(pos) / (float(pos) + float(neg))
self.num_samples = num_samples
self.image_key = image_key
self.image_threshold = image_threshold
self.centers = None
def __init__(self, keys, channel_dim=-1):
"""
Args:
keys (hashable items): keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
channel_dim (int): which dimension of input image is the channel, default is the last dimension.
"""
MapTransform.__init__(self, keys)
self.converter = AsChannelFirst(channel_dim=channel_dim)
def __init__(self, keys: KeysCollection, dtype: np.dtype = np.float32):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
dtype (np.dtype): convert image to this data type, default is `np.float32`.
"""
MapTransform.__init__(self, keys)
self.converter = CastToType(dtype)
def __init__(self, keys, k=1, spatial_axes=(0, 1)):
"""
Args:
k (int): number of times to rotate by 90 degrees.
spatial_axes (2 ints): defines the plane to rotate with 2 spatial axes.
Default: (0, 1), this is the first two axis in spatial dimensions.
"""
MapTransform.__init__(self, keys)
self.k = k
self.spatial_axes = spatial_axes
self.rotator = Rotate90(self.k, self.spatial_axes)
def __init__(self, keys: KeysCollection, dtype: np.dtype = np.float32):
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
dtype (np.dtype): convert image to this data type, default is `np.float32`.
it also can be a sequence of np.dtype, each element corresponds to a key in ``keys``.
"""
MapTransform.__init__(self, keys)
self.dtype = ensure_tuple_rep(dtype, len(self.keys))
self.converter = CastToType()
def __init__(self,
keys,
output_spatial_shape,
order=1,
mode='reflect',
cval=0,
clip=True,
preserve_range=True,
anti_aliasing=True,
anti_aliasing_sigma=None):
MapTransform.__init__(self, keys)
self.resizer = Resize(output_spatial_shape, order, mode, cval, clip,
preserve_range, anti_aliasing,
anti_aliasing_sigma)
def __init__(self, keys, as_closest_canonical=False, dtype=None, meta_key_format='{}.{}', overwriting_keys=False):
"""
Args:
keys (hashable items): keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
as_closest_canonical (bool): if True, load the image as closest to canonical axis format.
dtype (np.dtype, optional): if not None convert the loaded image to this data type.
meta_key_format (str): key format to store meta data of the nifti image.
it must contain 2 fields for the key of this image and the key of every meta data item.
overwriting_keys (bool): whether allow to overwrite existing keys of meta data.
default is False, which will raise exception if encountering existing key.
"""
MapTransform.__init__(self, keys)
self.loader = LoadNifti(as_closest_canonical, False, dtype)
self.meta_key_format = meta_key_format
self.overwriting_keys = overwriting_keys
def __init__(self,
keys,
zoom,
order=3,
mode='constant',
cval=0,
prefilter=True,
use_gpu=False,
keep_size=False):
MapTransform.__init__(self, keys)
self.zoomer = Zoom(zoom=zoom,
order=order,
mode=mode,
cval=cval,
prefilter=prefilter,
use_gpu=use_gpu,
keep_size=keep_size)
def __init__(self,
keys,
angle,
spatial_axes=(0, 1),
reshape=True,
order=1,
mode='constant',
cval=0,
prefilter=True):
MapTransform.__init__(self, keys)
self.rotator = Rotate(angle=angle,
spatial_axes=spatial_axes,
reshape=reshape,
order=order,
mode=mode,
cval=cval,
prefilter=prefilter)
def __init__(self, keys, prob=0.1, max_k=3, spatial_axes=(0, 1)):
"""
Args:
keys (hashable items): keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
prob (float): probability of rotating.
(Default 0.1, with 10% probability it returns a rotated array.)
max_k (int): number of rotations will be sampled from `np.random.randint(max_k) + 1`.
(Default 3)
spatial_axes (2 ints): defines the plane to rotate with 2 spatial axes.
Default: (0, 1), this is the first two axis in spatial dimensions.
"""
MapTransform.__init__(self, keys)
self.prob = min(max(prob, 0.0), 1.0)
self.max_k = max_k
self.spatial_axes = spatial_axes
self._do_transform = False
self._rand_k = 0
def __init__(self, keys, patch_spatial_size):
MapTransform.__init__(self, keys)
self.patch_spatial_size = (None, ) + tuple(patch_spatial_size)
self._slices = None
def __init__(self, keys, minv=0.0, maxv=1.0, dtype=np.float32):
MapTransform.__init__(self, keys)
self.rescaler = Rescale(minv, maxv, dtype)
def __init__(self, keys, subtrahend=None, divisor=None):
MapTransform.__init__(self, keys)
self.normalizer = NormalizeIntensity(subtrahend, divisor)
def __init__(self, keys, spatial_axis=None):
MapTransform.__init__(self, keys)
self.flipper = Flip(spatial_axis=spatial_axis)
def __init__(self, keys, a_min, a_max, b_min, b_max, clip=False):
MapTransform.__init__(self, keys)
self.scaler = ScaleIntensityRange(a_min, a_max, b_min, b_max, clip)
