class RandAffined(Randomizable, MapTransform):
"""
Dictionary-based wrapper of :py:class:`monai.transforms.RandAffine`.
"""
def __init__(
self,
keys: KeysCollection,
spatial_size: Optional[Union[Sequence[int], int]] = None,
prob: float = 0.1,
rotate_range: Optional[Union[Sequence[float], float]] = None,
shear_range: Optional[Union[Sequence[float], float]] = None,
translate_range: Optional[Union[Sequence[float], float]] = None,
scale_range: Optional[Union[Sequence[float], float]] = None,
mode: GridSampleModeSequence = GridSampleMode.BILINEAR,
padding_mode: GridSamplePadModeSequence = GridSamplePadMode.REFLECTION,
as_tensor_output: bool = True,
device: Optional[torch.device] = None,
) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
spatial_size: output image spatial size.
if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,
the transform will use the spatial size of `img`.
if the 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`.
prob: probability of returning a randomized affine grid.
defaults to 0.1, with 10% chance returns a randomized grid.
rotate_range: angle range in radians. rotate_range[0] with be used to generate the 1st rotation
parameter from `uniform[-rotate_range[0], rotate_range[0])`. Similarly, `rotate_range[1]` and
`rotate_range[2]` are used in 3D affine for the range of 2nd and 3rd axes.
shear_range: shear_range[0] with be used to generate the 1st shearing parameter from
`uniform[-shear_range[0], shear_range[0])`. Similarly, `shear_range[1]` to
`shear_range[N]` controls the range of the uniform distribution used to generate the 2nd to
N-th parameter.
translate_range : translate_range[0] with be used to generate the 1st shift parameter from
`uniform[-translate_range[0], translate_range[0])`. Similarly, `translate_range[1]`
to `translate_range[N]` controls the range of the uniform distribution used to generate
the 2nd to N-th parameter.
scale_range: scaling_range[0] with be used to generate the 1st scaling factor from
`uniform[-scale_range[0], scale_range[0]) + 1.0`. Similarly, `scale_range[1]` to
`scale_range[N]` controls the range of the uniform distribution used to generate the 2nd to
N-th parameter.
mode: {``"bilinear"``, ``"nearest"``}
Interpolation mode to calculate output values. Defaults to ``"bilinear"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}
Padding mode for outside grid values. Defaults to ``"reflection"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
as_tensor_output: the computation is implemented using pytorch tensors, this option specifies
whether to convert it back to numpy arrays.
device: device on which the tensor will be allocated.
See also:
- :py:class:`monai.transforms.compose.MapTransform`
- :py:class:`RandAffineGrid` for the random affine parameters configurations.
"""
super().__init__(keys)
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,
as_tensor_output=as_tensor_output,
device=device,
)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
def set_random_state(
self, seed: Optional[int] = None, state: Optional[np.random.RandomState] = None
) -> "RandAffined":
self.rand_affine.set_random_state(seed, state)
super().set_random_state(seed, state)
return self
def randomize(self, data: Optional[Any] = None) -> None:
self.rand_affine.randomize()
def __call__(
self, data: Mapping[Hashable, Union[np.ndarray, torch.Tensor]]
) -> Dict[Hashable, Union[np.ndarray, torch.Tensor]]:
d = dict(data)
self.randomize()
sp_size = fall_back_tuple(self.rand_affine.spatial_size, data[self.keys[0]].shape[1:])
if self.rand_affine.do_transform:
grid = self.rand_affine.rand_affine_grid(spatial_size=sp_size)
else:
grid = create_grid(spatial_size=sp_size)
for idx, key in enumerate(self.keys):
d[key] = self.rand_affine.resampler(d[key], grid, mode=self.mode[idx], padding_mode=self.padding_mode[idx])
return d
class RandAffined(Randomizable, MapTransform):
"""
Dictionary-based wrapper of :py:class:`monai.transforms.RandAffine`.
"""
def __init__(
self,
keys: KeysCollection,
spatial_size,
prob: float = 0.1,
rotate_range=None,
shear_range=None,
translate_range=None,
scale_range=None,
mode="bilinear",
padding_mode="zeros",
as_tensor_output: bool = True,
device: Optional[torch.device] = None,
):
"""
Args:
keys: 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: probability of returning a randomized affine grid.
defaults to 0.1, with 10% chance returns a randomized grid.
mode (str or sequence of str): interpolation order.
Available options are 'nearest', 'bilinear'. 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 (str or sequence of str): mode of handling out of range indices.
Available options are 'zeros', 'border', 'reflection'. Defaults to ``'zeros'``.
as_tensor_output: 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 parameters configurations.
"""
super().__init__(keys)
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,
as_tensor_output=as_tensor_output,
device=device,
)
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
self.mode = ensure_tuple_rep(mode, len(self.keys))
def set_random_state(self, seed=None, state=None):
self.rand_affine.set_random_state(seed, state)
super().set_random_state(seed, state)
return self
def randomize(self):
self.rand_affine.randomize()
def __call__(self, data):
d = dict(data)
self.randomize()
spatial_size = self.rand_affine.spatial_size
if self.rand_affine.do_transform:
grid = self.rand_affine.rand_affine_grid(spatial_size=spatial_size)
else:
grid = create_grid(spatial_size=spatial_size)
for idx, key in enumerate(self.keys):
d[key] = self.rand_affine.resampler(
d[key],
grid,
padding_mode=self.padding_mode[idx],
mode=self.mode[idx])
return d
class RandAffined(Randomizable, MapTransform):
"""
Dictionary-based wrapper of :py:class:`monai.transforms.RandAffine`.
"""
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 parameters configurations.
"""
super().__init__(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 set_random_state(self, seed=None, state=None):
self.rand_affine.set_random_state(seed, state)
super().set_random_state(seed, state)
return self
def randomize(self):
self.rand_affine.randomize()
def __call__(self, data):
d = dict(data)
self.randomize()
spatial_size = self.rand_affine.spatial_size
if self.rand_affine.do_transform:
grid = self.rand_affine.rand_affine_grid(spatial_size=spatial_size)
else:
grid = create_grid(spatial_size)
if isinstance(self.mode, (tuple, list)):
for key, m in zip(self.keys, self.mode):
d[key] = self.rand_affine.resampler(d[key], grid, mode=m)
return d
for key in self.keys: # same interpolation mode
d[key] = self.rand_affine.resampler(d[key], grid,
self.rand_affine.mode)
return d
class RandAffined(Randomizable, MapTransform):
"""
Dictionary-based wrapper of :py:class:`monai.transforms.RandAffine`.
"""
def __init__(
self,
keys: KeysCollection,
spatial_size,
prob: float = 0.1,
rotate_range=None,
shear_range=None,
translate_range=None,
scale_range=None,
mode: GridSampleModeSequence = GridSampleMode.BILINEAR,
padding_mode: GridSamplePadModeSequence = GridSamplePadMode.REFLECTION,
as_tensor_output: bool = True,
device: Optional[torch.device] = None,
):
"""
Args:
keys: keys of the corresponding items to be transformed.
spatial_size (list or tuple of int): output image spatial size.
if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,
the transform will use the spatial size of `img`.
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: probability of returning a randomized affine grid.
defaults to 0.1, with 10% chance returns a randomized grid.
mode: {``"bilinear"``, ``"nearest"``}
Interpolation mode to calculate output values. Defaults to ``"bilinear"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``}
Padding mode for outside grid values. Defaults to ``"reflection"``.
See also: https://pytorch.org/docs/stable/nn.functional.html#grid-sample
It also can be a sequence of string, each element corresponds to a key in ``keys``.
as_tensor_output: 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 parameters configurations.
"""
super().__init__(keys)
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,
as_tensor_output=as_tensor_output,
device=device,
)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.padding_mode = ensure_tuple_rep(padding_mode, len(self.keys))
def set_random_state(self, seed=None, state=None):
self.rand_affine.set_random_state(seed, state)
super().set_random_state(seed, state)
return self
def randomize(self) -> None: # type: ignore # see issue #495
self.rand_affine.randomize()
def __call__(self, data):
d = dict(data)
self.randomize()
sp_size = fall_back_tuple(self.rand_affine.spatial_size,
data[self.keys[0]].shape[1:])
if self.rand_affine.do_transform:
grid = self.rand_affine.rand_affine_grid(spatial_size=sp_size)
else:
grid = create_grid(spatial_size=sp_size)
for idx, key in enumerate(self.keys):
d[key] = self.rand_affine.resampler(
d[key],
grid,
mode=self.mode[idx],
padding_mode=self.padding_mode[idx])
return d