def __init__(
self,
keys: KeysCollection,
degree: int = 3,
coeff_range: Tuple[float, float] = (0.0, 0.1),
dtype: DtypeLike = np.float32,
prob: float = 1.0,
allow_missing_keys: bool = False,
) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
degree: degree of freedom of the polynomials. The value should be no less than 1.
Defaults to 3.
coeff_range: range of the random coefficients. Defaults to (0.0, 0.1).
dtype: output data type, defaut to float32.
prob: probability to do random bias field.
allow_missing_keys: don't raise exception if key is missing.
"""
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, prob)
self.rand_bias_field = RandBiasField(degree, coeff_range, dtype, prob)
def __init__(
self,
keys: KeysCollection,
factors: Union[Tuple[float, float], float],
prob: float = 0.1,
allow_missing_keys: bool = False,
) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
factors: factor range to randomly scale by ``v = v * (1 + factor)``.
if single number, factor value is picked from (-factors, factors).
prob: probability of rotating.
(Default 0.1, with 10% probability it returns a rotated array.)
allow_missing_keys: don't raise exception if key is missing.
"""
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, prob)
if isinstance(factors, (int, float)):
self.factors = (min(-factors, factors), max(-factors, factors))
else:
if len(factors) != 2:
raise AssertionError(
"factors should be a number or pair of numbers.")
self.factors = (min(factors), max(factors))
def __init__(
self,
keys: KeysCollection,
spatial_size: Sequence[int],
rand_size: Sequence[int],
pad: int = 0,
mode: Union[InterpolateModeType,
Sequence[InterpolateModeType]] = InterpolateMode.AREA,
align_corners: Optional[bool] = None,
prob: float = 0.1,
gamma: Union[Sequence[float], float] = (0.5, 4.5),
device: Optional[torch.device] = None,
):
RandomizableTransform.__init__(self, prob)
MapTransform.__init__(self, keys)
self.mode = ensure_tuple_rep(mode, len(self.keys))
self.trans = RandSmoothFieldAdjustContrast(
spatial_size=spatial_size,
rand_size=rand_size,
pad=pad,
mode=self.mode[0],
align_corners=align_corners,
prob=1.0,
gamma=gamma,
device=device,
)
def __init__(
self,
keys: KeysCollection,
prob: float = 0.1,
width: Tuple[int, int] = (1450, 1550),
level: Tuple[int, int] = (-550, -650),
nonzero: bool = True,
dtype: DtypeLike = np.float32,
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, prob)
self.nonzero = nonzero
self.dtype = dtype
if isinstance(width, tuple):
self.width = (min(width), max(width))
else:
AssertionError("width is not a touple")
if isinstance(level, tuple):
self.level = (min(level), max(level))
else:
AssertionError("level is not a touple")
self.width_value: Optional[int] = None
self.level_value: Optional[int] = None
def __init__(
self,
keys: KeysCollection,
factors: Union[Tuple[float, float], float],
prob: float = 0.1,
nonzero: bool = False,
channel_wise: bool = False,
allow_missing_keys: bool = False,
) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
factors: if tuple, the randomly picked range is (min(factors), max(factors)).
If single number, the range is (-factors, factors).
prob: probability of std shift.
nonzero: whether only count non-zero values.
channel_wise: if True, calculate on each channel separately.
allow_missing_keys: don't raise exception if key is missing.
"""
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, prob)
if isinstance(factors, (int, float)):
self.factors = (min(-factors, factors), max(-factors, factors))
else:
if len(factors) != 2:
raise AssertionError(
"factors should be a number or pair of numbers.")
self.factors = (min(factors), max(factors))
self.nonzero = nonzero
self.channel_wise = channel_wise
def __init__(
self,
keys: KeysCollection,
label_key: str,
spatial_size: Union[Sequence[int], int],
pos: float = 1.0,
neg: float = 1.0,
num_samples: int = 1,
image_key: Optional[str] = None,
image_threshold: float = 0.0,
fg_indices_key: Optional[str] = None,
bg_indices_key: Optional[str] = None,
allow_missing_keys: bool = False,
) -> None:
RandomizableTransform.__init__(self)
MapTransform.__init__(self, keys, allow_missing_keys)
self.label_key = label_key
self.spatial_size: Union[Tuple[int, ...], Sequence[int],
int] = spatial_size
if pos < 0 or neg < 0:
raise ValueError(
f"pos and neg must be nonnegative, got pos={pos} neg={neg}.")
if pos + neg == 0:
raise ValueError("Incompatible values: pos=0 and neg=0.")
self.pos_ratio = pos / (pos + neg)
self.num_samples = num_samples
self.image_key = image_key
self.image_threshold = image_threshold
self.fg_indices_key = fg_indices_key
self.bg_indices_key = bg_indices_key
self.centers: Optional[List[List[np.ndarray]]] = None
def __init__(
self, keys: KeysCollection, prob: float = 0.1, mean: Union[Sequence[float], float] = 0.0, std: float = 0.1
) -> None:
MapTransform.__init__(self, keys)
RandomizableTransform.__init__(self, prob)
self.mean = ensure_tuple_rep(mean, len(self.keys))
self.std = std
self._noise: List[np.ndarray] = []
def __init__(self,
keys: KeysCollection,
alpha: float = 0.5,
as_tensor_output: bool = True,
allow_missing_keys: bool = False) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
self.transform = GibbsNoise(alpha, as_tensor_output)
def __init__(
self,
keys: KeysCollection,
roi_size: Union[Sequence[int], int],
random_center: bool = True,
random_size: bool = True,
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
self.roi_size = roi_size
self.random_center = random_center
self.random_size = random_size
self._slices: Optional[Tuple[slice, ...]] = None
self._size: Optional[Sequence[int]] = None
def __init__(
self,
keys: KeysCollection,
prob: float = 0.1,
alpha: Sequence[float] = (0.0, 1.0),
as_tensor_output: bool = True,
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, prob=prob)
self.alpha = alpha
self.sampled_alpha = -1.0 # stores last alpha sampled by randomize()
self.as_tensor_output = as_tensor_output
def __init__(
self,
keys: KeysCollection,
roi_size: Union[Sequence[int], int],
num_samples: int,
random_center: bool = True,
random_size: bool = True,
allow_missing_keys: bool = False,
) -> None:
RandomizableTransform.__init__(self)
MapTransform.__init__(self, keys, allow_missing_keys)
if num_samples < 1:
raise ValueError(f"num_samples must be positive, got {num_samples}.")
self.num_samples = num_samples
self.cropper = RandSpatialCropd(keys, roi_size, random_center, random_size, allow_missing_keys)
def __init__(
self, keys: KeysCollection, num_control_points: Union[Tuple[int, int], int] = 10, prob: float = 0.1
) -> None:
MapTransform.__init__(self, keys)
RandomizableTransform.__init__(self, prob)
if isinstance(num_control_points, int):
if num_control_points <= 2:
raise AssertionError("num_control_points should be greater than or equal to 3")
self.num_control_points = (num_control_points, num_control_points)
else:
if len(num_control_points) != 2:
raise AssertionError("num_control points should be a number or a pair of numbers")
if min(num_control_points) <= 2:
raise AssertionError("num_control_points should be greater than or equal to 3")
self.num_control_points = (min(num_control_points), max(num_control_points))
def __init__(
self,
keys: KeysCollection,
w_key: str,
spatial_size: Union[Sequence[int], int],
num_samples: int = 1,
center_coord_key: Optional[str] = None,
allow_missing_keys: bool = False,
):
MapTransform.__init__(self, keys, allow_missing_keys)
self.spatial_size = ensure_tuple(spatial_size)
self.w_key = w_key
self.num_samples = int(num_samples)
self.center_coord_key = center_coord_key
self.centers: List[np.ndarray] = []
def __init__(
self,
keys: KeysCollection,
sigma_x: Tuple[float, float] = (0.25, 1.5),
sigma_y: Tuple[float, float] = (0.25, 1.5),
sigma_z: Tuple[float, float] = (0.25, 1.5),
approx: str = "erf",
prob: float = 0.1,
) -> None:
MapTransform.__init__(self, keys)
RandomizableTransform.__init__(self, prob)
self.sigma_x = sigma_x
self.sigma_y = sigma_y
self.sigma_z = sigma_z
self.approx = approx
def __init__(
self,
keys: KeysCollection,
global_prob: float = 0.1,
prob: float = 1.0,
mean: Union[Sequence[float], float] = 0.0,
std: Union[Sequence[float], float] = 1.0,
channel_wise: bool = False,
relative: bool = False,
sample_std: bool = True,
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, global_prob)
self.rand_rician_noise = RandRicianNoise(prob, mean, std, channel_wise,
relative, sample_std)
def __init__(
self,
keys: KeysCollection,
sigma_x: Tuple[float, float] = (0.25, 1.5),
sigma_y: Tuple[float, float] = (0.25, 1.5),
sigma_z: Tuple[float, float] = (0.25, 1.5),
approx: str = "erf",
prob: float = 0.1,
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
RandomizableTransform.__init__(self, prob)
self.sigma_x, self.sigma_y, self.sigma_z = sigma_x, sigma_y, sigma_z
self.approx = approx
self.x, self.y, self.z = self.sigma_x[0], self.sigma_y[0], self.sigma_z[0]
def __init__(
self,
keys: KeysCollection,
center_fractions: Sequence[float],
accelerations: Sequence[float],
spatial_dims: int = 2,
is_complex: bool = True,
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
self.masker = RandomKspaceMask(
center_fractions=center_fractions,
accelerations=accelerations,
spatial_dims=spatial_dims,
is_complex=is_complex,
)
def __init__(
self,
keys: KeysCollection,
roi_size: Union[Sequence[int], int],
num_samples: int,
max_roi_size: Optional[Union[Sequence[int], int]] = None,
random_center: bool = True,
random_size: bool = True,
meta_key_postfix: str = "meta_dict",
allow_missing_keys: bool = False,
) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
if num_samples < 1:
raise ValueError(f"num_samples must be positive, got {num_samples}.")
self.num_samples = num_samples
self.cropper = RandSpatialCropd(keys, roi_size, max_roi_size, random_center, random_size, allow_missing_keys)
self.meta_key_postfix = meta_key_postfix
def __init__(
self,
keys: KeysCollection,
dtype: Union[Sequence[Union[DtypeLike, torch.dtype]], DtypeLike, torch.dtype] = np.float32,
) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
dtype: convert image to this data type, default is `np.float32`.
it also can be a sequence of dtypes or torch.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: KeysCollection, prob: float = 0.1, gamma: Union[Tuple[float, float], float] = (0.5, 4.5)
) -> None:
MapTransform.__init__(self, keys)
RandomizableTransform.__init__(self, prob)
if isinstance(gamma, (int, float)):
if gamma <= 0.5:
raise AssertionError(
"if gamma is single number, must greater than 0.5 and value is picked from (0.5, gamma)"
)
self.gamma = (0.5, gamma)
else:
if len(gamma) != 2:
raise AssertionError("gamma should be a number or pair of numbers.")
self.gamma = (min(gamma), max(gamma))
self.gamma_value: Optional[float] = None
def __init__(
self,
keys: KeysCollection,
label_key: str,
background: int = 0,
pert: float = 0.0,
sigma: Union[Sequence[float], float, Sequence[torch.Tensor], torch.Tensor] = 3.0,
rescale_min: float = -1.0,
rescale_max: float = 1.0,
):
MapTransform.__init__(self, keys)
self.background = background
self.pert = pert
self.points: List[Tuple[int, ...]] = []
self.label_key = label_key
self.sigma = sigma
self.rescale_min = rescale_min
self.rescale_max = rescale_max
def __init__(self, keys: KeysCollection, offsets: Union[Tuple[float, float], float], prob: float = 0.1) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
offsets: offset range to randomly shift.
if single number, offset value is picked from (-offsets, offsets).
prob: probability of rotating.
(Default 0.1, with 10% probability it returns a rotated array.)
"""
MapTransform.__init__(self, keys)
RandomizableTransform.__init__(self, prob)
if isinstance(offsets, (int, float)):
self.offsets = (min(-offsets, offsets), max(-offsets, offsets))
else:
if len(offsets) != 2:
raise AssertionError("offsets should be a number or pair of numbers.")
self.offsets = (min(offsets), max(offsets))
def __init__(
self,
keys: KeysCollection,
name: str,
allow_missing_keys: bool = False,
*args,
**kwargs,
) -> None:
"""
Args:
keys: keys of the corresponding items to be transformed.
See also: :py:class:`monai.transforms.compose.MapTransform`
name: The transform name in TorchVision package.
allow_missing_keys: don't raise exception if key is missing.
args: parameters for the TorchVision transform.
kwargs: parameters for the TorchVision transform.
"""
MapTransform.__init__(self, keys, allow_missing_keys)
self.trans = TorchVision(name, *args, **kwargs)
def __init__(
self,
keys: KeysCollection,
spatial_size: Sequence[int],
rand_size: Sequence[int],
pad: int = 0,
field_mode: Union[
InterpolateModeType,
Sequence[InterpolateModeType]] = InterpolateMode.AREA,
align_corners: Optional[bool] = None,
prob: float = 0.1,
def_range: Union[Sequence[float], float] = 1.0,
grid_dtype=torch.float32,
grid_mode: Union[
GridSampleModeType,
Sequence[GridSampleModeType]] = GridSampleMode.NEAREST,
grid_padding_mode: Union[GridSamplePadMode,
str] = GridSamplePadMode.BORDER,
grid_align_corners: Optional[bool] = False,
device: Optional[torch.device] = None,
):
RandomizableTransform.__init__(self, prob)
MapTransform.__init__(self, keys)
self.field_mode = ensure_tuple_rep(field_mode, len(self.keys))
self.grid_mode = ensure_tuple_rep(grid_mode, len(self.keys))
self.trans = RandSmoothDeform(
rand_size=rand_size,
spatial_size=spatial_size,
pad=pad,
field_mode=self.field_mode[0],
align_corners=align_corners,
prob=1.0,
def_range=def_range,
grid_dtype=grid_dtype,
grid_mode=self.grid_mode[0],
grid_padding_mode=grid_padding_mode,
grid_align_corners=grid_align_corners,
device=device,
)
def __init__(
self,
keys: KeysCollection,
sigma1_x: Tuple[float, float] = (0.5, 1.0),
sigma1_y: Tuple[float, float] = (0.5, 1.0),
sigma1_z: Tuple[float, float] = (0.5, 1.0),
sigma2_x: Union[Tuple[float, float], float] = 0.5,
sigma2_y: Union[Tuple[float, float], float] = 0.5,
sigma2_z: Union[Tuple[float, float], float] = 0.5,
alpha: Tuple[float, float] = (10.0, 30.0),
approx: str = "erf",
prob: float = 0.1,
):
MapTransform.__init__(self, keys)
RandomizableTransform.__init__(self, prob)
self.sigma1_x = sigma1_x
self.sigma1_y = sigma1_y
self.sigma1_z = sigma1_z
self.sigma2_x = sigma2_x
self.sigma2_y = sigma2_y
self.sigma2_z = sigma2_z
self.alpha = alpha
self.approx = approx
def __init__(self, keys: KeysCollection, meta_key: str, allow_missing_keys: bool = False) -> None:
MapTransform.__init__(self, keys, allow_missing_keys)
self.meta_key = meta_key
