o  i @s|dZddlmZddlZddlmZmZmZddlm Z m Z ddl Z ddl Z ddlmZmZmZddlmZddlmZmZdd lmZdd lmZdd lmZdd lmZdd lm Z ddl!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;ddlZ>m?Z?ddl@mAZAddlBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNddlOmPZPePd\ZQZRgdZSGddde>e e=ZTGddde>e e=ZUGddde>e e=ZVGddde>e e=ZWGd d!d!e>e e=ZXGd"d#d#e?e>e e=ZYGd$d%d%e>e e=ZZGd&d'd'e>e e=Z[Gd(d)d)e?e>e e=Z\Gd*d+d+e?e>Z]Gd,d-d-e?e>Z^Gd.d/d/e>e e=Z_Gd0d1d1e?e>e e=Z`Gd2d3d3e?e>e e=ZaGd4d5d5e>e e=ZbGd6d7d7e?e>e e=ZcGd8d9d9e>e e=ZdGd:d;d;e?e>e e=ZeGdZfGd>d?d?e?e>ZgGd@dAdAe>e;ZhGdBdCdCe>e;ZiGdDdEdEe?e>e;ZjGdFdGdGe?e>ZkGdHdIdIe>ZlGdJdKdKe>ZmeTZnZoeUZpZqeVZrZseWZtZueXZvZweYZxZyeZZzZ{e[Z|Z}e\Z~Ze]ZZe^ZZe_ZZe`ZZefZZegZZeaZZebZZecZZedZZeeZZehZZeiZZejZZekZZelZZemZZdS)Lz A collection of dictionary-based wrappers around the "vanilla" transforms for spatial operations defined in :py:class:`monai.transforms.spatial.array`. Class names are ended with 'd' to denote dictionary-based transforms. ) annotationsN)HashableMappingSequence)Anycast) DtypeLikeKeysCollection SequenceStr)NdarrayOrTensor)BoxMode StandardMode)get_track_meta) MetaTensor)GaussianFilter)CenterSpatialCrop)InvertibleTransform)AffineConvertBoxToPointsConvertPointsToBoxesFlipGridDistortion GridPatch GridSplit Orientation Rand2DElastic Rand3DElastic RandAffine RandAxisFlipRandGridDistortion RandGridPatch RandRotateRandSimulateLowResolutionRandZoomResampleToMatchResizeRotateRotate90SpacingSpatialResampleZoom)MultiSampleTrait) LazyTransform MapTransformRandomizableTransform) create_grid)GridSampleModeGridSamplePadModeInterpolateMode NumpyPadModeconvert_to_tensor ensure_tupleensure_tuple_repfall_back_tuple)deprecated_arg_default) TraceKeys)optional_importnibabel)FSpatialResampledResampleToMatchdSpacingd Orientationd Rotate90d RandRotate90dResizedAffined RandAffinedRand2DElasticdRand3DElasticdFlipd RandFlipdGridDistortiondRandGridDistortiond RandAxisFlipdRotated RandRotatedZoomd RandZoomdSpatialResampleDSpatialResampleDictSpacingD SpacingDict OrientationDOrientationDict Rotate90D Rotate90Dict RandRotate90DRandRotate90DictResizeD ResizeDictAffineD AffineDict RandAffineDRandAffineDictRand2DElasticDRand2DElasticDictRand3DElasticDRand3DElasticDictFlipDFlipDict RandFlipD RandFlipDictGridDistortionDGridDistortionDictRandGridDistortionDRandGridDistortionDict RandAxisFlipDRandAxisFlipDictRotateD RotateDict RandRotateDRandRotateDictZoomDZoomDict RandZoomD RandZoomDict GridSplitd GridSplitD GridSplitDict GridPatchd GridPatchD GridPatchDictRandGridPatchdRandGridPatchDRandGridPatchDictRandSimulateLowResolutiondRandSimulateLowResolutionDRandSimulateLowResolutionDictc@s^eZdZdZejZejej de j dddfd"ddZ e jjd#ddZd$d%ddZd&d d!ZdS)'r<a Dictionary-based wrapper of :py:class:`monai.transforms.SpatialResample`. This transform assumes the ``data`` dictionary has a key for the input data's metadata and contains ``src_affine`` and ``dst_affine`` required by `SpatialResample`. The key is formed by ``key_{meta_key_postfix}``. The transform will swap ``src_affine`` and ``dst_affine`` affine (with potential data type changes) in the dictionary so that ``src_affine`` always refers to the current status of affine. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. See also: :py:class:`monai.transforms.SpatialResample` F dst_affinekeysr moder padding_mode align_cornersSequence[bool] | booldtypeSequence[DtypeLike] | DtypeLikedst_keysKeysCollection | Noneallow_missing_keysboollazyreturnNonec Cst|||tj||dt|d|_t|t|j|_t|t|j|_ t|t|j|_ t|t|j|_ t|t|j|_ dS)aN Args: keys: keys of the corresponding items to be transformed. mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``} Padding mode for outside grid values. Defaults to ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. 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 It also can be a sequence of bool, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``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 ``float32``. It also can be a sequence of dtypes, each element corresponds to a key in ``keys``. dst_keys: the key of the corresponding ``dst_affine`` in the metadata dictionary. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False. rN) r-__init__r,r) sp_transformr6lenrrrrrr) selfrrrrrrrrre/home/dell461/cl/sdc2/last_ska_mid/HISourceFinder-master-l/src/monai/transforms/spatial/dictionary.pyrs( zSpatialResampled.__init__valcC||_||j_dSN)_lazyrrrrrrrr zSpatialResampled.lazyNdataMapping[Hashable, torch.Tensor] bool | Nonedict[Hashable, torch.Tensor]c Cst|dur|jn|}t|}|||j|j|j|j|jD]\}}}}} } |j|||| d|||| |d||<q|S) Args: data: a dictionary containing the tensor-like data to be processed. The ``keys`` specified in this dictionary must be tensor like arrays that are channel first and have at most three spatial dimensions lazy: a flag to indicate whether this transform should execute lazily or not during this call. Setting this to False or True overrides the ``lazy`` flag set during initialization for this call. Defaults to None. Returns: a dictionary containing the transformed data, as well as any other data present in the dictionary N)imgr spatial_sizerrrrr) rdict key_iteratorrrrrrr) rrrlazy_dkeyrrrrdst_keyrrr__call__s    zSpatialResampled.__call__cC0t|}||D] }|j||||<q |Sr)rrrinverserrrrrrrrzSpatialResampled.inverse)rr rr rr rrrrrrrrrrrrrrrrrrrrrrrrrrr)__name__ __module__ __qualname____doc__r)backendr0BILINEARr1BORDERnpfloat64rr,rsetterrrrrrrr<s 1  r<c@s\eZdZdZejZejej de j ddfd!ddZ e jjd"ddZd#d$ddZd%dd ZdS)&r=z Dictionary-based wrapper of :py:class:`monai.transforms.ResampleToMatch`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Frr key_dststrrr rrrrrrrrc Cszt|||tj||d||_t|t|j|_t|t|j|_t|t|j|_ t|t|j|_ t |d|_ dS)a' Args: keys: keys of the corresponding items to be transformed. key_dst: key of image to resample to match. mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``} Padding mode for outside grid values. Defaults to ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. 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 It also can be a sequence of bool, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``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 ``float32``. It also can be a sequence of dtypes, each element corresponds to a key in ``keys``. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False rN) r-rr,rr6rrrrrrr$ resampler) rrrrrrrrrrrrrs(zResampleToMatchd.__init__rrrcCrr)rrrrrrrrErzResampleToMatchd.lazyNrrrrc Csn|dur|jn|}t|}|||j|j|j|jD]\}}}}} |j||||j|||| |d||<q|S)rN)rimg_dstrrrrr) rrrrrrrrr) rrrrrrrrrrrrrrJs   zResampleToMatchd.__call__cCrr)rrrrrrrrrgrzResampleToMatchd.inverse)rr rrrr rr rrrrrrrrrrrr)rrrrr$rr0rr1rrrrr,rrrrrrrrr= s 1  r=c @sheZdZdZejZdejej de j dddddddf d+ddZ e jjd,dd Zd-d.d%d&Zd/d)d*ZdS)0r>a] Dictionary-based wrapper of :py:class:`monai.transforms.Spacing`. This transform assumes the ``data`` dictionary has a key for the input data's metadata and contains `affine` field. The key is formed by ``key_{meta_key_postfix}``. After resampling the input array, this transform will write the new affine to the `affine` field of metadata which is formed by ``key_{meta_key_postfix}``. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. see also: :py:class:`monai.transforms.Spacing` FNTrr pixdimSequence[float] | floatdiagonalrrr rrrrr scale_extentrecompute_affine min_pixdimSequence[float] | float | None max_pixdimensure_same_shaperrrrcCst||| tj||dt||| | | |d|_t|t|j|_t|t|j|_ t|t|j|_ t|t|j|_ t|t|j|_ | |_ dS)a 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_2, 1)) This effectively resets the volume to the world coordinate system (RAS+ in nibabel). The original orientation, rotation, shearing are not preserved. If False, the axes orientation, orthogonal rotation and translations components from the original affine will be preserved in the target affine. This option will not flip/swap axes against the original ones. mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``} Padding mode for outside grid values. Defaults to ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. align_corners: Geometrically, we consider the pixels of the input as squares rather than points. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html It also can be a sequence of bool, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``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 ``float32``. It also can be a sequence of dtypes, each element corresponds to a key in ``keys``. scale_extent: whether the scale is computed based on the spacing or the full extent of voxels, default False. The option is ignored if output spatial size is specified when calling this transform. See also: :py:func:`monai.data.utils.compute_shape_offset`. When this is True, `align_corners` should be `True` because `compute_shape_offset` already provides the corner alignment shift/scaling. recompute_affine: whether to recompute affine based on the output shape. The affine computed analytically does not reflect the potential quantization errors in terms of the output shape. Set this flag to True to recompute the output affine based on the actual pixdim. Default to ``False``. min_pixdim: minimal input spacing to be resampled. If provided, input image with a larger spacing than this value will be kept in its original spacing (not be resampled to `pixdim`). Set it to `None` to use the value of `pixdim`. Default to `None`. max_pixdim: maximal input spacing to be resampled. If provided, input image with a smaller spacing than this value will be kept in its original spacing (not be resampled to `pixdim`). Set it to `None` to use the value of `pixdim`. Default to `None`. ensure_same_shape: when the inputs have the same spatial shape, and almost the same pixdim, whether to ensure exactly the same output spatial shape. Default to True. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False r)rrrrrN)r-rr,r(spacing_transformr6rrrrrrrr)rrrrrrrrrrrrrrrrrrrs N zSpacingd.__init__rcCrr)rrrrrrrrrz Spacingd.lazyrrrrc Cs"t|}d\}}}d}|dur|jn|}|||j|j|j|j|jD]k\} } } } } }|jr_t || t r_|durJ|durJ||  || j }}nt |||  o^t j||| j dd}|j|| | | | | ||rm|nd|d|| <|durt || t r||  n|| jdd}q#|S)r)NNFNgMbP?)atol) data_arrayrrrrroutput_spatial_shaper)rrrrrrrrr isinstancerpeek_pending_shaperrallclosershape)rrrr _init_shape_pixdimZ should_matchZoutput_shape_krrrrrrrrrrrs6     ,zSpacingd.__call__"Mapping[Hashable, NdarrayOrTensor]dict[Hashable, NdarrayOrTensor]cCs8t|}||D]}|jttj||||<q |Sr)rrrrrtorchTensorrrrrrszSpacingd.inverse)rr rrrrrr rr rrrrrrrrrrrrrrrrrrrrrrrrrrr)rrrrr(rr0rr1rrrrr,rrrrrrrrr>ns( _  +r>c@sdeZdZdZejZeddddd     d d!ddZej j d"ddZ d#d$ddZ d%ddZ dS)&r?a Dictionary-based wrapper of :py:class:`monai.transforms.Orientation`. This transform assumes the channel-first input format. In the case of using this transform for normalizing the orientations of images, it should be used before any anisotropic spatial transforms. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. labels))LR)PA)ISNzDefault value changed to None meaning that the transform now uses the 'space' of a meta-tensor, if applicable, to determine appropriate axis labels.)name old_default new_default msg_suffixFrr axcodes str | Noneas_closest_canonicalr Sequence[tuple[str, str]] | NonerrrrcCs2t|||tj||dt||||d|_dS)a 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. If ``None``, an appropriate value is chosen depending on the value of the ``"space"`` metadata item of a metatensor: if ``"space"`` is ``"LPS"``, the value used is ``(('R', 'L'), ('A', 'P'), ('I', 'S'))``, if ``"space"`` is ``"RPS"`` or the input is not a meta-tensor or has no ``"space"`` item, the value ``(('L', 'R'), ('P', 'A'), ('I', 'S'))`` is used. If not ``None``, the provided value is always used and the ``"space"`` metadata item (if any) of the input is ignored. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False See Also: `nibabel.orientations.ornt2axcodes`. r)rrrrN)r-rr,rornt_transform)rrrrrrrrrrr%s , zOrientationd.__init__rcCrr)rrrrrrrrWrzOrientationd.lazyrrrrcCDt|}|dur |jn|}||D] }|j|||d||<q|SrNr)rrrrrrrrrrrrrr\  zOrientationd.__call__cCrr)rrrrrrrrrorzOrientationd.inverse)NFNFF)rr rrrrrrrrrrrrrrrr) rrrrrrr8rr,rrrrrrrrr?s&  )  r?c@sReZdZdZejZ    ddddZejj d ddZd!d"ddZ d#ddZ dS)$r@z Dictionary-based wrapper of :py:class:`monai.transforms.Rotate90`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. rrrFrr kint spatial_axestuple[int, int]rrrrrcCs0t|||tj||dt|||d|_dS)a 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. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False rN)r-rr,r'rotator)rrrrrrrrrrszRotate90d.__init__rcCrr)rrrrrrrrrzRotate90d.lazyNrrrrcCrr)rrrrrrrrrrzRotate90d.__call__cCrrrrrrrrrrrrzRotate90d.inverse)rrFF) rr rrrrrrrrrrrrrr) rrrrr'rrr,rrrrrrrrr@vs   r@csXeZdZdZejZ     d!d"ddZd#d$fdd Z d#d%ddZd&dd Z Z S)'rAaA Dictionary-based version :py:class:`monai.transforms.RandRotate90`. With probability `prob`, input arrays are rotated by 90 degrees in the plane specified by `spatial_axes`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. 皙?rFrr probfloatmax_krrrrrrrrcCs>t|||t||tj||d||_||_d|_dS)a  Args: keys: keys of the corresponding items to be transformed. See also: :py:class:`monai.transforms.compose.MapTransform` 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. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False rrN)r-rr.r,rr_rand_k)rrrrrrrrrrrs   zRandRotate90d.__init__Nr Any | Nonecs$|j|jd|_tddS)Nr)rrandintrrsuper randomize)rr __class__rrrszRandRotate90d.randomizerrcCs|t|}|dur|jn|}t|j|j|d}||D] }|jr*|||nt||t d||<|j ||d|dq|SrNr track_metaTreplacer) rrrr'rrr _do_transformr4rpush_transform)rrrrrrrrrrrs(zRandRotate90d.__call__rcCs`t|}||D]$}t||tsq |||}|tjr-t|||tj ||<q |Sr) rrrr pop_transformr9 DO_TRANSFORMr'inverse_transform EXTRA_INFOrrrrxformrrrrs zRandRotate90d.inverse)rrrFF)rr rrrrrrrrrrrrr)rrrr)rrrrrrr) rrrrr'rrrrr __classcell__rrrrrAs    rAc@s^eZdZdZejZdejdddej ddfd'ddZ e j j d(ddZ d)d*d#d$Zd+d%d&ZdS),rBa7 Dictionary-based wrapper of :py:class:`monai.transforms.Resize`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: keys of the corresponding items to be transformed. See also: :py:class:`monai.transforms.compose.MapTransform` 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"``, ``"nearest-exact"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``} The interpolation mode. Defaults to ``"area"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html It also can be a sequence of string, each element corresponds to a key in ``keys``. align_corners: This only has an effect when mode is 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html It also can be a sequence of bool or None, each element corresponds to a key in ``keys``. anti_aliasing: bool Whether to apply a Gaussian filter to smooth the image prior to downsampling. It is crucial to filter when downsampling the image to avoid aliasing artifacts. See also ``skimage.transform.resize`` anti_aliasing_sigma: {float, tuple of floats}, optional Standard deviation for Gaussian filtering used when anti-aliasing. By default, this value is chosen as (s - 1) / 2 where s is the downsampling factor, where s > 1. For the up-size case, s < 1, no anti-aliasing is performed prior to rescaling. dtype: data type for resampling computation. Defaults to ``float32``. If None, use the data type of input data. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False allNFrr rSequence[int] | int size_moderrr r#Sequence[bool | None] | bool | None anti_aliasingranti_aliasing_sigmaISequence[Sequence[float] | float | None] | Sequence[float] | float | Noner;Sequence[DtypeLike | torch.dtype] | DtypeLike | torch.dtyperrrrrc Cst||| tj|| dt|t|j|_t|t|j|_t|t|j|_t|t|j|_ t|t|j|_ t ||| d|_ dS)Nr)rrr) r-rr,r6rrrrrrrr%resizer) rrrrrrrrrrrrrrr7s zResized.__init__rcCrr)rrrrrrrrMrz Resized.lazyrrrrc Csnt|}|dur |jn|}|||j|j|j|j|jD]\}}}}} } |j|||||| | |d||<q|S)rN)rrrrrr) rrrrrrrrr) rrrrrrrrrrrrrrrRs   zResized.__call__cCrr)rrrrrrrrrorzResized.inverse)rr rrrrrr rrrrrrrrrrrrrrrrrr)rrrrr%rr2AREArfloat32rr,rrrrrrrrrB s *   rBc @sjeZdZdZejZddddddejej de j dddf d)ddZ e jjd*dd Zd+d,d%d&Zd-d'd(ZdS).rCz Dictionary-based wrapper of :py:class:`monai.transforms.Affine`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. NFrr rotate_paramsr shear_paramstranslate_params scale_paramsaffineNdarrayOrTensor | NonerSequence[int] | int | Nonerr rdevicetorch.device | NonerDtypeLike | torch.dtyperrrrrrc Csbt||| tj||dt||||||| | | |d |_t|t|j|_t| t|j|_ dS)aS Args: keys: keys of the corresponding items to be transformed. rotate_params: a rotation angle in radians, a scalar for 2D image, a tuple of 3 floats for 3D. Defaults to no rotation. shear_params: shearing factors for affine matrix, take a 3D affine as example:: [ [1.0, params[0], params[1], 0.0], [params[2], 1.0, params[3], 0.0], [params[4], params[5], 1.0, 0.0], [0.0, 0.0, 0.0, 1.0], ] a tuple of 2 floats for 2D, a tuple of 6 floats for 3D. Defaults to no shearing. translate_params: a tuple of 2 floats for 2D, a tuple of 3 floats for 3D. Translation is in pixel/voxel relative to the center of the input image. Defaults to no translation. scale_params: scale factor for every spatial dims. a tuple of 2 floats for 2D, a tuple of 3 floats for 3D. Defaults to `1.0`. affine: if applied, ignore the params (`rotate_params`, etc.) and use the supplied matrix. Should be square with each side = num of image spatial dimensions + 1. 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 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`. mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, 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/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. device: device on which the tensor will be allocated. dtype: data type for resampling computation. Defaults to ``float32``. If ``None``, use the data type of input data. To be compatible with other modules, the output data type is always `float32`. align_corners: Defaults to False. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False See also: - :py:class:`monai.transforms.compose.MapTransform` - :py:class:`RandAffineGrid` for the random affine parameters configurations. r) rrrrrrr!rrrN) r-rr,rrr6rrrr)rrrrrrrrrrr!rrrrrrrrs J zAffined.__init__rcCrr)rrrrrrrrrz Affined.lazyrrrrc CsZ|dur|jn|}t|}|||j|jD]\}}}|j|||||d\||<}q|S)rN)rrr)rrrrrr) rrrrrrrr_rrrrs   zAffined.__call__cCrr)rrrrrrrrrrzAffined.inverse)rr rrrrrrrrrrrr rr rr r!r"rr#rrrrrrrrrrrr)rrrrrrr0rr1 REFLECTIONrrrr,rrrrrrrrrCvs* [  rCc s|eZdZdZejZddddddejej ddddf d.ddZ e j j d/ddZ d0d1fd$d% Z d2d3d*d+Zd4d,d-ZZS)5rDz Dictionary-based wrapper of :py:class:`monai.transforms.RandAffine`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. NrFrr rr rr rotate_range4Sequence[tuple[float, float] | float] | float | None shear_rangetranslate_range scale_rangerr r cache_gridrr!r"rrrrc Cslt||| t||tj|| dtd|||||| | | d |_t|t|j|_ t| t|j|_ dS)a: 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 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`. 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. If element `i` is a pair of (min, max) values, then `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used. This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]` for dim0 and nothing for the remaining dimensions. shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select shearing factors(a tuple of 2 floats for 2D, a tuple of 6 floats for 3D) for affine matrix, take a 3D affine as example:: [ [1.0, params[0], params[1], 0.0], [params[2], 1.0, params[3], 0.0], [params[4], params[5], 1.0, 0.0], [0.0, 0.0, 0.0, 1.0], ] translate_range: translate range with format matching `rotate_range`, it defines the range to randomly select pixel/voxel to translate for every spatial dims. scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select the scale factor to translate for every spatial dims. A value of 1.0 is added to the result. This allows 0 to correspond to no change (i.e., a scaling of 1.0). mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, 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/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. cache_grid: whether to cache the identity sampling grid. If the spatial size is not dynamically defined by input image, enabling this option could accelerate the transform. device: device on which the tensor will be allocated. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False See also: - :py:class:`monai.transforms.compose.MapTransform` - :py:class:`RandAffineGrid` for the random affine parameters configurations. r?) rr&r(r)r*rr+r!rN) r-rr.r,r rand_affiner6rrrr)rrrrr&r(r)r*rrr+r!rrrrrrs L  zRandAffined.__init__rcCrr)rr-rrrrrrarzRandAffined.lazyseed int | Nonestatenp.random.RandomState | Nonec |j||t|||Sr)r-set_random_staterrr.r0rrrr3fzRandAffined.set_random_staterrrrc CsVt|}||}|dkrt|td}|S|d|j||}t|tr-|n|j dd}|dur;|j n|}t |jj |} |j pL| t|k} d} | re|jj| |d} |j re|jj| | |d} | durkdn| } |||j|jD]2\} } }| r|j|| d| |d| |d|| <n t|| ttjd || <| |_ |j|| d|d qv|S) rrrNrr)gridrrTrrr)r first_keyr4rrr-rrrrrr7rrr5get_identity_gridrand_affine_gridrrrrrr)rrrrr8outitemrrsp_size do_resamplingr6rrrrrrrks2    "zRandAffined.__call__cCs~t|}||D]3}|||}tj|tjvrq |tjtjd}|r<||j|tj|j||||<q |S)Nr>) rrrr9r applied_operationsappendr-r)rrrrtrr>rrrrszRandAffined.inverse)rr rr rrr&r'r(r'r)r'r*r'rr rr r+rr!r"rrrrrrrNN)r.r/r0r1rrDr)rrrrrrr)rrrrrrr0rr1r%rr,rrr3rrrrrrrrDs, ]  2rDc sXeZdZdZejZddddddejej ddf d*ddZ d+d,fd#d$ Z d-d(d)Z Z S).rEzQ Dictionary-based wrapper of :py:class:`monai.transforms.Rand2DElastic`. NrFrr spacingtuple[float, float] | floatmagnitude_rangetuple[float, float]rtuple[int, int] | int | Nonerrr&r'r(r)r*rr rr!r"rrrrc C^t||| t||t||d|||| || d |_t| t|j|_t| t|j|_ dS)a Args: keys: keys of the corresponding items to be transformed. spacing: distance in between the control points. magnitude_range: 2 int numbers, the random offsets will be generated from ``uniform[magnitude[0], magnitude[1])``. spatial_size: specifying output image spatial size [h, w]. if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1, the transform will use the spatial size of `img`. 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`. prob: 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. rotate_range: angle range in radians. If element `i` is a pair of (min, max) values, then `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used. This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]` for dim0 and nothing for the remaining dimensions. shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select shearing factors(a tuple of 2 floats for 2D) for affine matrix, take a 2D affine as example:: [ [1.0, params[0], 0.0], [params[1], 1.0, 0.0], [0.0, 0.0, 1.0], ] translate_range: translate range with format matching `rotate_range`, it defines the range to randomly select pixel to translate for every spatial dims. scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select the scale factor to translate for every spatial dims. A value of 1.0 is added to the result. This allows 0 to correspond to no change (i.e., a scaling of 1.0). mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, 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/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. device: device on which the tensor will be allocated. allow_missing_keys: don't raise exception if key is missing. See also: - :py:class:`RandAffineGrid` for the random affine parameters configurations. - :py:class:`Affine` for the affine transformation parameters configurations. r,) rCrErr&r(r)r*rr!N) r-rr.rrand_2d_elasticr6rrrr)rrrCrErrr&r(r)r*rrr!rrrrrsI  zRand2DElasticd.__init__r.r/r0r1cr2r)rIr3rr4rrrr3 r5zRand2DElasticd.set_random_staterrrc Csvt|}||}|dkrt|td}|S|d|jj}|dur6t||tj r6||j}|j |t||t rK||j rKt d|dt|jj||jdd}|j||jr|jj|d}|jj|d}tjjjd |d t|jjjd tjjd d }t|d|d }n ttj t ||dd}|!||j"|j#D]\}} } |jj$|||| | d||<q|S) Args: data: a dictionary containing the tensor-like data to be processed. The ``keys`` specified in this dictionary must be tensor like arrays that are channel first and have at most three spatial dimensions Returns: a dictionary containing the transformed data, as well as any other data present in the dictionary rrNdata['B'] has pending operations, transform may return incorrect results.r)rr6TrF)recompute_scale_factorinput scale_factorrr)roi_sizerrr!rrr)%rr8r4rrrIr!rrr set_devicerpending_operationswarningswarnr7rrr deform_gridr:nn functional interpolate unsqueezer6rCr2BICUBICvaluerrr/rrrr) rrrr8r;r!r=r6rrrrrrrs:     zRand2DElasticd.__call__)rr rCrDrErFrrGrrr&r'r(r'r)r'r*r'rr rr r!r"rrrrrB)r.r/r0r1rrEr)rrrrrrr0rr1r%rr3rrrrrrrEs  YrEc sXeZdZdZejZddddddejej ddf d)ddZ d*d+fd"d# Z d,d'd(Z Z S)-rFzQ Dictionary-based wrapper of :py:class:`monai.transforms.Rand3DElastic`. NrFrr sigma_rangerFrEr!tuple[int, int, int] | int | Nonerrr&r'r(r)r*rr rr!r"rrrrc CrH)a Args: keys: keys of the corresponding items to be transformed. sigma_range: a Gaussian kernel with standard deviation sampled from ``uniform[sigma_range[0], sigma_range[1])`` will be used to smooth the random offset grid. magnitude_range: the random offsets on the grid will be generated from ``uniform[magnitude[0], magnitude[1])``. spatial_size: specifying output image spatial size [h, w, d]. if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1, the transform will use the spatial size of `img`. 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, 32, -1)` will be adapted to `(32, 32, 64)` if the third 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, otherwise returns a ``spatial_size`` centered area extracted from the input image. rotate_range: angle range in radians. If element `i` is a pair of (min, max) values, then `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used. This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]` for dim0 and nothing for the remaining dimensions. shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select shearing factors(a tuple of 6 floats for 3D) for affine matrix, take a 3D affine as example:: [ [1.0, params[0], params[1], 0.0], [params[2], 1.0, params[3], 0.0], [params[4], params[5], 1.0, 0.0], [0.0, 0.0, 0.0, 1.0], ] translate_range: translate range with format matching `rotate_range`, it defines the range to randomly select voxel to translate for every spatial dims. scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select the scale factor to translate for every spatial dims. A value of 1.0 is added to the result. This allows 0 to correspond to no change (i.e., a scaling of 1.0). mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, 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/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. device: device on which the tensor will be allocated. allow_missing_keys: don't raise exception if key is missing. See also: - :py:class:`RandAffineGrid` for the random affine parameters configurations. - :py:class:`Affine` for the affine transformation parameters configurations. r,) r`rErr&r(r)r*rr!N) r-rr.rrand_3d_elasticr6rrrr)rrr`rErrr&r(r)r*rrr!rrrrrGsK  zRand3DElasticd.__init__r.r/r0r1cr2r)rbr3rr4rrrr3r5zRand3DElasticd.set_random_staterrrc Csrt|}||}|dkrt|td}|S|dt||tr0||jr0t d|dt |j j ||j dd}|j ||j j}|dur_t||tjr_||j}|j |t||dd}|jrtd |j jd d |}tj|j j|d d } |dd || d |j j7<|j j|d}|||j|jD]\} } } |j j|| || | d|| <q|S)rJrrNrKrLrrrSrg@) spatial_dimssigma truncated)r!rrMrT) rr8r4rrrrrVrWrXr7rbrrr!rrrUr/rrrdto as_tensor rand_offsetr] magnituder:rrrr) rrrr8r;r=r!r6gaussianoffsetrrrrrrrs.     $zRand3DElasticd.__call__)rr r`rFrErFrrarrr&r'r(r'r)r'r*r'rr rr r!r"rrrrrB)r.r/r0r1rrFr)rrrrrrr0rr1r%rr3rrrrrrrF@s  [rFc@sPeZdZdZejZ   ddd dZejj dddZddddZ dddZ dS) rGa Dictionary-based wrapper of :py:class:`monai.transforms.Flip`. See `numpy.flip` for additional details. https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. spatial_axis: Spatial axes along which to flip over. Default is None. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False NFrr spatial_axisr rrrrrcCs,t|||tj||dt|d|_dS)Nr)rl)r-rr,rflipper)rrrlrrrrrrszFlipd.__init__rcC||j_||_dSrrmrrrrrrr z Flipd.lazyrrrrcCrr)rrrrmrrrrrrzFlipd.__call__cCrr)rrrmrrrrrrrz Flipd.inverse)NFF) rr rlr rrrrrrrrrrr) rrrrrrrr,rrrrrrrrrGs   rGcsfeZdZdZejZ    d#d$ddZejj d%ddZd&d'fdd Z d(d)dd Z d*d!d"Z Z S)+rHa Dictionary-based version :py:class:`monai.transforms.RandFlip`. See `numpy.flip` for additional details. https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. prob: Probability of flipping. spatial_axis: Spatial axes along which to flip over. Default is None. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False rNFrr rrrlr rrrrrcCs:t|||t||tj||dt||d|_dS)Nr)rlr)r-rr.r,rrm)rrrrlrrrrrr#s zRandFlipd.__init__rcCrnrrorrrrr0rpzRandFlipd.lazyr.r/r0r1cst|||Sr)rr3r4rrrr35szRandFlipd.set_random_staterrrrcCst|}|d|dur|jn|}||D]&}|jr(|j|||d||<n t||td||<|j||d|dq|Sr) rrrrrrmr4rrrrrrr9s zRandFlipd.__call__c Cstt|}||D].}|||}|tjsq |jd|||||<Wdn1s2wYq |S)NF)rrrr9r rmtrace_transformr rrrrRs zRandFlipd.inverse)rNFF) rr rrrlr rrrrrrrqrB)r.r/r0r1rrHrrr)rrrrrrrr,rrr3rrrrrrrrHs   rHcs`eZdZdZejZ d!d"d dZejj d#ddZd$d%fdd Z d&d'ddZ d(dd Z Z S))rKae Dictionary-based version :py:class:`monai.transforms.RandAxisFlip`. See `numpy.flip` for additional details. https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. prob: Probability of flipping. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False rFrr rrrrrrrcCs:t|||t||tj||dtd|d|_dS)Nrr,)rr)r-rr.r,rrm)rrrrrrrrrqs zRandAxisFlipd.__init__rcCrnrrorrrrryrpzRandAxisFlipd.lazyNr.r/r0r1c t|||j|||Sr)rr3rmr4rrrr3~r5zRandAxisFlipd.set_random_staterrrrcCst|}||}|dkr|S|d|j|||dur#|jn|}||D]'}|jr<|j||d|d||<n t||td||<|j ||d|dq*|S)rrNF)rrrTr) rr8rrmrrrr4rr)rrrrr8rrrrrrs  zRandAxisFlipd.__call__cC^t|}||D]#}|||}|tjr,||j|tj|j ||||<q |Sr) rrrr9r r?r@r rmrr rrrr zRandAxisFlipd.inverse)rFF) rr rrrrrrrrrqrB)r.r/r0r1rrKrrr)rrrrrrrr,rrr3rrrrrrrrK]s    rKc@s^eZdZdZejZdejej de j ddfd#ddZ e jjd$ddZd%d&dd Zd'd!d"ZdS)(rLa Dictionary-based wrapper of :py:class:`monai.transforms.Rotate`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. angle: Rotation angle(s) in radians. 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/generated/torch.nn.functional.grid_sample.html 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 ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html It also can be a sequence of string, each element corresponds to a key in ``keys``. align_corners: Defaults to False. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html It also can be a sequence of bool, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``float32``. If None, use the data type of input data. To be compatible with other modules, the output data type is always ``float32``. It also can be a sequence of dtype or None, each element corresponds to a key in ``keys``. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False TFrr angler keep_sizerrr rrrrrrrrrc Csxt|||tj|| dt||| d|_t|t|j|_t|t|j|_ t|t|j|_ t|t|j|_ dS)Nr)rvrwr) r-rr,r&rr6rrrrrr) rrrvrwrrrrrrrrrrs zRotated.__init__rcCrnr)rrrrrrrrrpz Rotated.lazyNrrrrc Cft|}|dur |jn|}|||j|j|j|jD]\}}}}} |j|||||| |d||<q|SrN)rrrrr)rrrrrrrr rrrrrrrrrrrrrr  zRotated.__call__cCrrrrrrrrrzRotated.inverse)rr rvrrwrrr rr rrrrrrrrrrrqrrr)rrrrr&rr0rr1rrrrr,rrrrrrrrrLs    rLc szeZdZdZejZdddddejej de j ddf d/ddZ e jjd0ddZd1d2fd%d& Zd3d4d+d,Zd5d-d.ZZS)6rMa5 Dictionary-based version :py:class:`monai.transforms.RandRotate` Randomly rotates the input arrays. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. 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). only work for 3D data. 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). only work for 3D data. 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/generated/torch.nn.functional.grid_sample.html 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 ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html It also can be a sequence of string, each element corresponds to a key in ``keys``. align_corners: Defaults to False. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html It also can be a sequence of bool, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``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 ``float32``. It also can be a sequence of dtype or None, each element corresponds to a key in ``keys``. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False rTFrr range_xrDrange_yrange_zrrrwrrr rrrrrrrrrc Cst||| t||tj|| dt|||d|| d|_t|t|j|_ t|t|j|_ t| t|j|_ t| t|j|_ dS)Nrr,)r}r~rrrwr) r-rr.r,r! rand_rotater6rrrrrr) rrr}r~rrrwrrrrrrrrrr2s  zRandRotated.__init__rcCrnr)rrrrrrrrLrpzRandRotated.lazyNr.r/r0r1crsr)rr3rr4rrrr3Qr5zRandRotated.set_random_staterrrrc Cst|}|d|j|dur|jn|}|||j|j|j|jD]2\}}}}} |j r?|j|||||| d|d||<n t ||t t j d||<|j||d|dq$|S)rNFrrrrrrr7Tr)rrrrrrrrrrr4rrrrrzrrrrVs(    zRandRotated.__call__cCrtr) rrrr9r r?r@r rrr rrrr|ruzRandRotated.inverse)rr r}rDr~rDrrDrrrwrrr rr rrrrrrrrrrrqrB)r.r/r0r1rrMrrr)rrrrr!rr0rr1rrrrr,rrr3rrrrrrrrMs('   &rMc@s^eZdZdZejZejej de j dddfd#ddZ e jjd$ddZd%d&dd Zd'd!d"ZdS)(rNaS Dictionary-based wrapper of :py:class:`monai.transforms.Zoom`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. 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"``, ``"nearest-exact"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``} The interpolation mode. Defaults to ``"area"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html It also can be a sequence of string, each element corresponds to a key in ``keys``. 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 ``"edge"``. 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/generated/torch.nn.functional.interpolate.html It also can be a sequence of bool or None, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``float32``. If None, use the data type of input data. keep_size: Should keep original size (pad if needed), default is True. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False kwargs: other arguments for the `np.pad` or `torch.pad` function. note that `np.pad` treats channel dimension as the first dimension. NTFrr zoomrrr rrrrrrwrrrrrc Kst|||tj|| dt|t|j|_t|t|j|_t|t|j|_t|t|j|_ t d||| d| |_ dS)Nr)rrwrr) r-rr,r6rrrrrrr*zoomer) rrrrrrrrwrrkwargsrrrrs zZoomd.__init__rcCrnr)rrrrrrrrrpz Zoomd.lazyrrrrc Crxry)rrrrrrrrrzrrrrr{zZoomd.__call__cCrr)rrrrrrrrrrz Zoomd.inverse)rr rrrr rr rrrrrwrrrrrrrrqrrr)rrrrr*rr2rr3EDGErrrr,rrrrrrrrrNs%   rNc sxeZdZdZejZdddejej de j dddf d/ddZ e jjd0dd Zd1d2fd%d& Zd3d4d+d,Zd5d-d.ZZS)6rOaJ Dict-based version :py:class:`monai.transforms.RandZoom`. This transform is capable of lazy execution. See the :ref:`Lazy Resampling topic` for more information. Args: keys: Keys to pick data for transformation. 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"``, ``"nearest-exact"``, ``"linear"``, ``"bilinear"``, ``"bicubic"``, ``"trilinear"``, ``"area"``} The interpolation mode. Defaults to ``"area"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html It also can be a sequence of string, each element corresponds to a key in ``keys``. 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 ``"edge"``. 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/generated/torch.nn.functional.interpolate.html It also can be a sequence of bool or None, each element corresponds to a key in ``keys``. dtype: data type for resampling computation. Defaults to ``float32``. If None, use the data type of input data. keep_size: Should keep original size (pad if needed), default is True. allow_missing_keys: don't raise exception if key is missing. lazy: a flag to indicate whether this transform should execute lazily or not. Defaults to False kwargs: other args for `np.pad` API, note that `np.pad` treats channel dimension as the first dimension. more details: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html rg?g?NTFrr rrmin_zoomrmax_zoomrr rrrrrrwrrrrrc Kst||| t||tj|| dtdd||| | d| |_t|t|j|_ t|t|j|_ t|t|j|_ t|t|j|_ dS)Nrr,)rrrrwrr) r-rr.r,r# rand_zoomr6rrrrrr) rrrrrrrrrrwrrrrrrrs  zRandZoomd.__init__rcCrnr)rrrrrrrr0rpzRandZoomd.lazyr.r/r0r1crsr)rr3rr4rrrr35r5zRandZoomd.set_random_staterrrrc Cst|}||}|dkrt|td}|S|d|j|||dur*|jn|}|||j|j |j |j D]2\}}} } } |j rT|j|||| | | d|d||<n t||tt jd||<|j||d|dq9|S) rrrNFrr7Tr)rr8r4rrrrrrrrrrrrr) rrrrr8r;rrrrrrrrrr:s0    zRandZoomd.__call__cCrtr) rrrr9r r?r@r rrr rrrreruzRandZoomd.inverse)rr rrrrrrrr rr rrrrrwrrrrrrrrqrB)r.r/r0r1rrOrrr)rrrrr#rr2rr3rrrrr,rrr3rrrrrrrrOs&,   +rOcs@eZdZdZejZejej ddfdfdd Z dddZ Z S)rIzR Dictionary-based wrapper of :py:class:`monai.transforms.GridDistortion`. NFrr num_cellstuple[int] | int distort_steps list[tuple]rrrr!r"rrrrcsFt||t|||d|_t|t|j|_t|t|j|_dS)a Args: keys: keys of the corresponding items to be transformed. num_cells: number of grid cells on each dimension. distort_steps: This argument is a list of tuples, where each tuple contains the distort steps of the corresponding dimensions (in the order of H, W[, D]). The length of each tuple equals to `num_cells + 1`. Each value in the tuple represents the distort step of the related cell. mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``} Padding mode for outside grid values. Defaults to ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. device: device on which the tensor will be allocated. allow_missing_keys: don't raise exception if key is missing. )rrr!N) rrrgrid_distortionr6rrrr)rrrrrrr!rrrrrvs"zGridDistortiond.__init__rrrcCsBt|}|||j|jD]\}}}|j||||d||<q |S)rJrT)rrrrr)rrrrrrrrrrs zGridDistortiond.__call__)rr rrrrrrrrr!r"rrrrr) rrrrrrr0rr1rrrrrrrrrIos'rIcsTeZdZdZejZdddejej ddfd%ddZ d&d'fdd Z d(d#d$Z Z S))rJzV Dictionary-based wrapper of :py:class:`monai.transforms.RandGridDistortion`. r)gQgQ?NFrr rrrr distort_limitrDrrrr!r"rrrrc CsTt|||t||t|d||d|_t|t|j|_t|t|j|_ dS)a Args: keys: keys of the corresponding items to be transformed. num_cells: number of grid cells on each dimension. prob: probability of returning a randomized grid distortion transform. Defaults to 0.1. distort_limit: range to randomly distort. If single number, distort_limit is picked from (-distort_limit, distort_limit). Defaults to (-0.03, 0.03). mode: {``"bilinear"``, ``"nearest"``} or spline interpolation order 0-5 (integers). Interpolation mode to calculate output values. Defaults to ``"bilinear"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When it's an integer, the numpy (cpu tensor)/cupy (cuda tensor) backends will be used and the value represents the order of the spline interpolation. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. padding_mode: {``"zeros"``, ``"border"``, ``"reflection"``} Padding mode for outside grid values. Defaults to ``"border"``. See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html When `mode` is an integer, using numpy/cupy backends, this argument accepts {'reflect', 'grid-mirror', 'constant', 'grid-constant', 'nearest', 'mirror', 'grid-wrap', 'wrap'}. See also: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.map_coordinates.html It also can be a sequence, each element corresponds to a key in ``keys``. device: device on which the tensor will be allocated. allow_missing_keys: don't raise exception if key is missing. r,)rrrr!N) r-rr.rrand_grid_distortionr6rrrr) rrrrrrrr!rrrrrs% zRandGridDistortiond.__init__r.r/r0r1crsr)rr3rr4rrrr3z$RandGridDistortiond.set_random_staterrrcCst|}|d|jst|td}|S||}|dkr't|td}|St||tr<||jr sz'GridSplitd.__init__..rM) rrr6rrrrrsplitter)rrr6rrrrrr s$zGridSplitd.__init__rrr%list[dict[Hashable, NdarrayOrTensor]]csrt|t|j}fddt|D}|D]}|||j|}t|D] }|||||<q+q|S)rJcsg|]}tqSr)r)rr$rrr / sz'GridSplitd.__call__..)rrprodr6rangerrr)rr n_outputsoutputrresultirrrr# s  zGridSplitd.__call__)rNF)rr r6rrrrr)rrrr) rrrrrrrrrrrrrrv s rvcsBeZdZdZejZ       ddfdd Zd ddZZS)!rya Extract all the patches sweeping the entire image in a row-major sliding-window manner with possible overlaps. It can sort the patches and return all or a subset of them. Args: keys: keys of the corresponding items to be transformed. patch_size: size of patches to generate slices for, 0 or None selects whole dimension offset: starting position in the array, default is 0 for each dimension. np.random.randint(0, patch_size, 2) creates random start between 0 and `patch_size` for a 2D image. num_patches: number of patches (or maximum number of patches) to return. If the requested number of patches is greater than the number of available patches, padding will be applied to provide exactly `num_patches` patches unless `threshold` is set. When `threshold` is set, this value is treated as the maximum number of patches. Defaults to None, which does not limit number of the patches. overlap: amount of overlap between patches in each dimension. Default to 0.0. sort_fn: when `num_patches` is provided, it determines if keep patches with highest values (`"max"`), lowest values (`"min"`), or in their default order (`None`). Default to None. threshold: a value to keep only the patches whose sum of intensities are less than the threshold. Defaults to no filtering. pad_mode: the mode for padding the input image by `patch_size` to include patches that cross boundaries. Available modes: (Numpy) {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} (PyTorch) {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}. One of the listed string values or a user supplied function. Defaults to `None`, which means no padding will be applied. See also: https://numpy.org/doc/stable/reference/generated/numpy.pad.html https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html requires pytorch >= 1.10 for best compatibility. allow_missing_keys: don't raise exception if key is missing. pad_kwargs: other arguments for the `np.pad` or `torch.pad` function. note that `np.pad` treats channel dimension as the first dimension. Returns: dictionary, contains the all the original key/value with the values for `keys` replaced by the patches, a MetaTensor with following metadata: - `PatchKeys.LOCATION`: the starting location of the patch in the image, - `PatchKeys.COUNT`: total number of patches in the image, - "spatial_shape": spatial size of the extracted patch, and - "offset": the amount of offset for the patches in the image (starting position of the first patch) Nr|Frr patch_size Sequence[int]rkSequence[int] | None num_patchesr/overlaprsort_fnr threshold float | Nonepad_moderrc s2t|| td|||||||d| |_dS)N)rrkrrrrrr)rrrpatcher) rrrrkrrrrrr pad_kwargsrrrrd s  zGridPatchd.__init__rrrrcCs.t|}||D] }|||||<q |S)rJ)rrrrrrrr} s zGridPatchd.__call__)NNr|NNNF)rr rrrkrrr/rrrrrrrrrrr) rrrrrrrrrrrrrry7 s*rycsPeZdZdZejZ        d$d%ddZd&d'fdd Zd(d"d#ZZ S))r|a Extract all the patches sweeping the entire image in a row-major sliding-window manner with possible overlaps, and with random offset for the minimal corner of the image, (0,0) for 2D and (0,0,0) for 3D. It can sort the patches and return all or a subset of them. Args: keys: keys of the corresponding items to be transformed. patch_size: size of patches to generate slices for, 0 or None selects whole dimension min_offset: the minimum range of starting position to be selected randomly. Defaults to 0. max_offset: the maximum range of starting position to be selected randomly. Defaults to image size modulo patch size. num_patches: number of patches (or maximum number of patches) to return. If the requested number of patches is greater than the number of available patches, padding will be applied to provide exactly `num_patches` patches unless `threshold` is set. When `threshold` is set, this value is treated as the maximum number of patches. Defaults to None, which does not limit number of the patches. overlap: the amount of overlap of neighboring patches in each dimension (a value between 0.0 and 1.0). If only one float number is given, it will be applied to all dimensions. Defaults to 0.0. sort_fn: when `num_patches` is provided, it determines if keep patches with highest values (`"max"`), lowest values (`"min"`), in random ("random"), or in their default order (`None`). Default to None. threshold: a value to keep only the patches whose sum of intensities are less than the threshold. Defaults to no filtering. pad_mode: the mode for padding the input image by `patch_size` to include patches that cross boundaries. Available modes: (Numpy) {``"constant"``, ``"edge"``, ``"linear_ramp"``, ``"maximum"``, ``"mean"``, ``"median"``, ``"minimum"``, ``"reflect"``, ``"symmetric"``, ``"wrap"``, ``"empty"``} (PyTorch) {``"constant"``, ``"reflect"``, ``"replicate"``, ``"circular"``}. One of the listed string values or a user supplied function. Defaults to `None`, which means no padding will be applied. See also: https://numpy.org/doc/stable/reference/generated/numpy.pad.html https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html requires pytorch >= 1.10 for best compatibility. allow_missing_keys: don't raise exception if key is missing. pad_kwargs: other arguments for the `np.pad` or `torch.pad` function. note that `np.pad` treats channel dimension as the first dimension. Returns: dictionary, contains the all the original key/value with the values for `keys` replaced by the patches, a MetaTensor with following metadata: - `PatchKeys.LOCATION`: the starting location of the patch in the image, - `PatchKeys.COUNT`: total number of patches in the image, - "spatial_shape": spatial size of the extracted patch, and - "offset": the amount of offset for the patches in the image (starting position of the first patch) Nr|Frr rr min_offsetr  max_offsetrr/rrrrrrrrrc Ks4t||| td|||||||| d| |_dS)N)rrrrrrrrr)r-rr r) rrrrrrrrrrrrrrrr s zRandGridPatchd.__init__r.r0r1rcrsr)rr3rr4rrrr3 r5zRandGridPatchd.set_random_staterrrcCsRt|}||D] }|j||||D] }|j||dd||<q|S)rJF)r)rrrrrrrrr s zRandGridPatchd.__call__)NNNr|NNNF)rr rrrr rr rr/rrrrrrrrrrrB)r.r/r0r1rr|r) rrrrr rrr3rrrrrrr| s. r|csTeZdZdZejZdejejddddfd ddZ d!d"fdd Z d#ddZ Z S)$ra) Dictionary-based wrapper of :py:class:`monai.transforms.RandSimulateLowResolution`. Random simulation of low resolution corresponding to nnU-Net's SimulateLowResolutionTransform (https://github.com/MIC-DKFZ/batchgenerators/blob/7651ece69faf55263dd582a9f5cbd149ed9c3ad0/batchgenerators/transforms/resample_transforms.py#L23) First, the array/tensor is resampled at lower resolution as determined by the zoom_factor which is uniformly sampled from the `zoom_range`. Then, the array/tensor is resampled at the original resolution. r)g?r,FNrr rrdownsample_modeInterpolateMode | str upsample_moderrr!r"rrc Cs\t|||t||||_||_||_||_||_td|j|j|j|j|jd|_ dS)a Args: keys: keys of the corresponding items to be transformed. prob: probability of performing this augmentation downsample_mode: interpolation mode for downsampling operation upsample_mode: interpolation mode for upsampling operation zoom_range: range from which the random zoom factor for the downsampling and upsampling operation is sampled. It determines the shape of the downsampled tensor. align_corners: This only has an effect when downsample_mode or upsample_mode is 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: False See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html allow_missing_keys: don't raise exception if key is missing. device: device on which the tensor will be allocated. See also: - :py:class:`monai.transforms.compose.MapTransform` r,)rrr zoom_rangerr!N) r-rr.rrrrr!r"sim_lowres_tfm) rrrrrrrrr!rrrr s  z#RandSimulateLowResolutiond.__init__r.r/r0r1crsr)rr3rr4rrrr3, rz+RandSimulateLowResolutiond.set_random_staterrrcCs~t|}||}|dkrt|td}|S|d||D]}|jr/|||||<q t||ttj d||<q |S)a Args: data: a dictionary containing the tensor-like data to be transformed. The ``keys`` specified in this dictionary must be tensor like arrays that are channel first and have at most three spatial dimensions rrNr7) rr8r4rrrrrrr)rrrr8r;rrrrr3 s  z#RandSimulateLowResolutiond.__call__)rr rrrrrrrrr!r"rrrB)r.r/r0r1rrr) rrrrrrr2NEAREST TRILINEARrr3rrrrrrr s 0rcs8eZdZdZejZdedfdfd d Zd d ZZ S)ConvertBoxToPointsdzV Dictionary-based wrapper of :py:class:`monai.transforms.ConvertBoxToPoints`. pointsFrr r$str | BoxMode | type[BoxMode] | Nonerrcs$t||||_t|d|_dS)a" Args: keys: keys of the corresponding items to be transformed. point_key: key to store the point data. mode: the mode of the input boxes. Defaults to StandardMode. allow_missing_keys: don't raise exception if key is missing. )rN)rr point_keyr converter)rrrrrrrrrR szConvertBoxToPointsd.__init__cC0t|}||D] }|||||j<q |Sr)rrrrrrrrrd rzConvertBoxToPointsd.__call__)rr rrrr) rrrrrrr rrrrrrrrK srcs,eZdZdZd d fdd Zd d ZZS)ConvertPointsToBoxesdzX Dictionary-based wrapper of :py:class:`monai.transforms.ConvertPointsToBoxes`. boxFrr rrcs t||||_t|_dS)z Args: keys: keys of the corresponding items to be transformed. box_key: key to store the box data. allow_missing_keys: don't raise exception if key is missing. N)rrbox_keyrr)rrrrrrrrp s zConvertPointsToBoxesd.__init__cCrr)rrrrrrrrr{ rzConvertPointsToBoxesd.__call__)rF)rr rr)rrrrrrrrrrrrk s r)r __future__rrWcollections.abcrrrtypingrrnumpyrr monai.configrr r monai.config.type_definitionsr monai.data.box_utilsr r monai.data.meta_objrmonai.data.meta_tensorrZ"monai.networks.layers.simplelayersrmonai.transforms.croppad.arrayrmonai.transforms.inversermonai.transforms.spatial.arrayrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*monai.transforms.traitsr+monai.transforms.transformr,r-r.monai.transforms.utilsr/ monai.utilsr0r1r2r3r4r5r6r7monai.utils.deprecate_utilsr8monai.utils.enumsr9monai.utils.moduler:nibr$__all__r<r=r>r?r@rArBrCrDrErFrGrHrKrLrMrNrOrIrJrvryr|rrrrPrQResampleToMatchDResampleToMatchDictrRrSrTrUrVrWrXrYrZr[r\r]r^r_r`rarbrcrdrerfrgrhrirjrkrlrmrnrorprqrrrsrtrurwrxrzr{r}r~rrConvertBoxToPointsDConvertBoxToPointsDictConvertPointsToBoxesDConvertPointsToBoxesDictrrrrs       h  (   Joe*_>Vl2>OP[~a >X2VeY