U PhƯ @sdZddlmZddlZddlmZmZmZddlZ ddl Z ddl m m ZddlmZddlmZddlmZddlmZdd lmZmZmZdd lmZdd lmZdd lm Z dd l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'ddl(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1dddddddddddddg Z2GdddeZ3GdddeZ4Gd ddeZ5Gd!ddeZ6Gd"ddeZ7Gd#ddeZ8Gd$ddeZ9Gd%d&d&Z:Gd'dde:eZ;Gd(dde:eZGd+ddeZ?Gd,ddeZ@dS)-zD A collection of "vanilla" transforms for the model output tensors. ) annotationsN)CallableIterableSequence)NdarrayOrTensor)get_track_meta) MetaTensor)one_hot)GaussianFilter apply_filterseparable_filtering)InvertibleTransform) Transform)ToTensor)convert_applied_interp_modedistance_transform_edt fill_holes$get_largest_connected_component_maskget_unique_labelsremove_small_objects) unravel_index)TransformBackendsconvert_data_typeconvert_to_tensor ensure_tuplelook_up_option)convert_to_dst_type Activations AsDiscrete FillHolesKeepLargestConnectedComponentRemoveSmallObjects LabelFilterLabelToContour MeanEnsembleProbNMSSobelGradients VoteEnsembleInvertDistanceTransformEDTc@sFeZdZdZejgZdddddddd Zdd d d dd d d dZdS)ra Activation operations, typically `Sigmoid` or `Softmax`. Args: sigmoid: whether to execute sigmoid function on model output before transform. Defaults to ``False``. softmax: whether to execute softmax function on model output before transform. Defaults to ``False``. other: callable function to execute other activation layers, for example: `other = lambda x: torch.tanh(x)`. Defaults to ``None``. kwargs: additional parameters to `torch.softmax` (used when ``softmax=True``). Defaults to ``dim=0``, unrecognized parameters will be ignored. Raises: TypeError: When ``other`` is not an ``Optional[Callable]``. FNboolCallable | NoneNone)sigmoidsoftmaxotherreturncKsB||_||_||_|dk r8t|s8tdt|jd||_dS)N&other must be None or callable but is .)r-r.kwargscallable TypeErrortype__name__r/)selfr-r.r/r3r9P/home/dell461/cl/sdc2/HISourceFinder-master-l/src/monai/transforms/post/array.py__init__Rs zActivations.__init__r bool | None)imgr-r.r/r0c Cs|r|rtd|dk r6t|s6tdt|jdt|td}t|tj tj d^}}|sd|j rnt |}|sx|j rtj ||j ddd }|dkr|jn|}|dk r||}t||^}}|S) a Args: sigmoid: whether to execute sigmoid function on model output before transform. Defaults to ``self.sigmoid``. softmax: whether to execute softmax function on model output before transform. Defaults to ``self.softmax``. other: callable function to execute other activation layers, for example: `other = torch.tanh`. Defaults to ``self.other``. Raises: ValueError: When ``sigmoid=True`` and ``softmax=True``. Incompatible values. TypeError: When ``other`` is not an ``Optional[Callable]``. ValueError: When ``self.other=None`` and ``other=None``. Incompatible values. z3Incompatible values: sigmoid=True and softmax=True.Nr1r2 track_metadtypedimrrB) ValueErrorr4r5r6r7rrrtorchTensorfloatr-r.r3getr/r) r8r=r-r.r/img_t_Zact_funcoutr9r9r:__call__Zs   zActivations.__call__)FFN)NNN r7 __module__ __qualname____doc__rTORCHbackendr;rLr9r9r9r:r=s c@sJeZdZdZejgZddddddd d d Zdd d dddd dddZdS)raX Convert the input tensor/array into discrete values, possible operations are: - `argmax`. - threshold input value to binary values. - convert input value to One-Hot format (set ``to_one_hot=N``, `N` is the number of classes). - round the value to the closest integer. Args: argmax: whether to execute argmax function on input data before transform. Defaults to ``False``. to_onehot: if not None, convert input data into the one-hot format with specified number of classes. Defaults to ``None``. threshold: if not None, threshold the float values to int number 0 or 1 with specified threshold. Defaults to ``None``. rounding: if not None, round the data according to the specified option, available options: ["torchrounding"]. kwargs: additional parameters to `torch.argmax`, `monai.networks.one_hot`. currently ``dim``, ``keepdim``, ``dtype`` are supported, unrecognized parameters will be ignored. These default to ``0``, ``True``, ``torch.float`` respectively. Example: >>> transform = AsDiscrete(argmax=True) >>> print(transform(np.array([[[0.0, 1.0]], [[2.0, 3.0]]]))) # [[[1.0, 1.0]]] >>> transform = AsDiscrete(threshold=0.6) >>> print(transform(np.array([[[0.0, 0.5], [0.8, 3.0]]]))) # [[[0.0, 0.0], [1.0, 1.0]]] >>> transform = AsDiscrete(argmax=True, to_onehot=2, threshold=0.5) >>> print(transform(np.array([[[0.0, 1.0]], [[2.0, 3.0]]]))) # [[[0.0, 0.0]], [[1.0, 1.0]]] FNr* int | Nonez float | Nonez str | Noner,)argmax to_onehot thresholdroundingr0cKs4||_t|trtd||_||_||_||_dS)NQ`to_onehot=True/False` is deprecated, please use `to_onehot=num_classes` instead.)rT isinstancer*rDrUrVrWr3)r8rTrUrVrWr3r9r9r:r;s zAsDiscrete.__init__rr<)r=rTrUrVrWr0cCs2t|trtdt|td}t|tj^}}|s:|jr^tj||j dd|j ddd}|dkrl|j n|}|dk rt|t std t |d t|||j dd|j d tjd }|dkr|jn|}|dk r||k}|dkr|jn|}|dk rt|d gt|}t|||j d tjd^}}|S)a Args: img: the input tensor data to convert, if no channel dimension when converting to `One-Hot`, will automatically add it. argmax: whether to execute argmax function on input data before transform. Defaults to ``self.argmax``. to_onehot: if not None, convert input data into the one-hot format with specified number of classes. Defaults to ``self.to_onehot``. threshold: if not None, threshold the float values to int number 0 or 1 with specified threshold value. Defaults to ``self.threshold``. rounding: if not None, round the data according to the specified option, available options: ["torchrounding"]. rXr>rBrkeepdimTrBrZNz:the number of classes for One-Hot must be an integer, got r2rA) num_classesrBrAZ torchroundingr@)rYr*rDrrrrErFrTr3rHrUintr6r rGrVrWrroundr)r8r=rTrUrVrWrIrJr9r9r:rLs2  $     zAsDiscrete.__call__)FNNN)NNNNrMr9r9r9r:rs%csNeZdZdZejejgZdddddd d d fd d ZdddddZ Z S)r a Keeps only the largest connected component in the image. This transform can be used as a post-processing step to clean up over-segment areas in model output. The input is assumed to be a channel-first PyTorch Tensor: 1) For not OneHot format data, the values correspond to expected labels, 0 will be treated as background and the over-segment pixels will be set to 0. 2) For OneHot format data, the values should be 0, 1 on each labels, the over-segment pixels will be set to 0 in its channel. For example: Use with applied_labels=[1], is_onehot=False, connectivity=1:: [1, 0, 0] [0, 0, 0] [0, 1, 1] => [0, 1 ,1] [0, 1, 1] [0, 1, 1] Use with applied_labels=[1, 2], is_onehot=False, independent=False, connectivity=1:: [0, 0, 1, 0 ,0] [0, 0, 1, 0 ,0] [0, 2, 1, 1 ,1] [0, 2, 1, 1 ,1] [1, 2, 1, 0 ,0] => [1, 2, 1, 0 ,0] [1, 2, 0, 1 ,0] [1, 2, 0, 0 ,0] [2, 2, 0, 0 ,2] [2, 2, 0, 0 ,0] Use with applied_labels=[1, 2], is_onehot=False, independent=True, connectivity=1:: [0, 0, 1, 0 ,0] [0, 0, 1, 0 ,0] [0, 2, 1, 1 ,1] [0, 2, 1, 1 ,1] [1, 2, 1, 0 ,0] => [0, 2, 1, 0 ,0] [1, 2, 0, 1 ,0] [0, 2, 0, 0 ,0] [2, 2, 0, 0 ,2] [2, 2, 0, 0 ,0] Use with applied_labels=[1, 2], is_onehot=False, independent=False, connectivity=2:: [0, 0, 1, 0 ,0] [0, 0, 1, 0 ,0] [0, 2, 1, 1 ,1] [0, 2, 1, 1 ,1] [1, 2, 1, 0 ,0] => [1, 2, 1, 0 ,0] [1, 2, 0, 1 ,0] [1, 2, 0, 1 ,0] [2, 2, 0, 0 ,2] [2, 2, 0, 0 ,2] NTSequence[int] | int | Noner<r*rSr]r,)applied_labels is_onehot independent connectivitynum_componentsr0cs<t|dk rt|nd|_||_||_||_||_dS)a1 Args: applied_labels: Labels for applying the connected component analysis on. If given, voxels whose value is in this list will be analyzed. If `None`, all non-zero values will be analyzed. is_onehot: if `True`, treat the input data as OneHot format data, otherwise, not OneHot format data. default to None, which treats multi-channel data as OneHot and single channel data as not OneHot. independent: whether to treat ``applied_labels`` as a union of foreground labels. If ``True``, the connected component analysis will be performed on each foreground label independently and return the intersection of the largest components. If ``False``, the analysis will be performed on the union of foreground labels. default is `True`. connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. If ``None``, a full connectivity of ``input.ndim`` is used. for more details: https://scikit-image.org/docs/dev/api/skimage.measure.html#skimage.measure.label. num_components: The number of largest components to preserve. N)superr;rrarbrcrdre)r8rarbrcrdre __class__r9r:r;s  z&KeepLargestConnectedComponent.__init__rr=r0c Cs~|jdkr|jddkn|j}|jdk r0|j}ntt||dd}t|td}t|dd}|jr|D]V}|rz||dkn |d|k}t||j |j }|rd||||k<qfd|d||k<qft ||ddS|s,t ||dd ^}} |d |k d d}t||j |j }d|d||k<t ||ddS||d fdk d}t||j |j }|D]}d||||k<qVt ||ddS) z Args: img: shape must be (C, spatial_dim1[, spatial_dim2, ...]). Returns: An array with shape (C, spatial_dim1[, spatial_dim2, ...]). Nrr_)discardr>FdstT)rl wrap_sequence).N.) rbshaperatuplerrrrcrrdrerany) r8r=rbraimg_i foregroundmasklabelsrJr9r9r:rL>s2  z&KeepLargestConnectedComponent.__call__)NNTNr_ r7rNrOrPrNUMPYCUPYrRr;rL __classcell__r9r9rgr:r s+ "c@sBeZdZdZejgZdddddd d d d d ZdddddZdS)r!a Use `skimage.morphology.remove_small_objects` to remove small objects from images. See: https://scikit-image.org/docs/dev/api/skimage.morphology.html#remove-small-objects. Data should be one-hotted. Args: min_size: objects smaller than this size (in number of voxels; or surface area/volume value in whatever units your image is if by_measure is True) are removed. connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. If ``None``, a full connectivity of ``input.ndim`` is used. For more details refer to linked scikit-image documentation. independent_channels: Whether or not to consider channels as independent. If true, then conjoining islands from different labels will be removed if they are below the threshold. If false, the overall size islands made from all non-background voxels will be used. by_measure: Whether the specified min_size is in number of voxels. if this is True then min_size represents a surface area or volume value of whatever units your image is in (mm^3, cm^2, etc.) default is False. e.g. if min_size is 3, by_measure is True and the units of your data is mm, objects smaller than 3mm^3 are removed. pixdim: the pixdim of the input image. if a single number, this is used for all axes. If a sequence of numbers, the length of the sequence must be equal to the image dimensions. Example:: .. code-block:: python from monai.transforms import RemoveSmallObjects, Spacing, Compose from monai.data import MetaTensor data1 = torch.tensor([[[0, 0, 0, 0, 0], [0, 1, 1, 0, 1], [0, 0, 0, 1, 1]]]) affine = torch.as_tensor([[2,0,0,0], [0,1,0,0], [0,0,1,0], [0,0,0,1]], dtype=torch.float64) data2 = MetaTensor(data1, affine=affine) # remove objects smaller than 3mm^3, input is MetaTensor trans = RemoveSmallObjects(min_size=3, by_measure=True) out = trans(data2) # remove objects smaller than 3mm^3, input is not MetaTensor trans = RemoveSmallObjects(min_size=3, by_measure=True, pixdim=(2, 1, 1)) out = trans(data1) # remove objects smaller than 3 (in pixel) trans = RemoveSmallObjects(min_size=3) out = trans(data2) # If the affine of the data is not identity, you can also add Spacing before. trans = Compose([ Spacing(pixdim=(1, 1, 1)), RemoveSmallObjects(min_size=3) ]) @r_TFNr]r*z+Sequence[float] | float | np.ndarray | Noner,)min_sizerdindependent_channels by_measurepixdimr0cCs"||_||_||_||_||_dSN)r|rdr}r~r)r8r|rdr}r~rr9r9r:r;s zRemoveSmallObjects.__init__rricCst||j|j|j|j|jS)z Args: img: shape must be (C, spatial_dim1[, spatial_dim2, ...]). Data should be one-hotted. Returns: An array with shape (C, spatial_dim1[, spatial_dim2, ...]). )rr|rdr}r~rr8r=r9r9r:rLs zRemoveSmallObjects.__call__)r{r_TFN r7rNrOrPrrxrRr;rLr9r9r9r:r!ds8c@s<eZdZdZejejgZdddddZdddd d Z d S) r"a This transform filters out labels and can be used as a processing step to view only certain labels. The list of applied labels defines which labels will be kept. Note: All labels which do not match the `applied_labels` are set to the background label (0). For example: Use LabelFilter with applied_labels=[1, 5, 9]:: [1, 2, 3] [1, 0, 0] [4, 5, 6] => [0, 5 ,0] [7, 8, 9] [0, 0, 9] zIterable[int] | intr,)rar0cCst||_dS)z Initialize the LabelFilter class with the labels to filter on. Args: applied_labels: Label(s) to filter on. N)rra)r8rar9r9r:r;szLabelFilter.__init__rricCst|tjtjfs,t|jdt|dt|tjrt|t d}t|dd}t tdrtj |j |j d}tt|||td|}t||dd S||}t||d }|Sttt||j |d S) aQ Filter the image on the `applied_labels`. Args: img: Pytorch tensor or numpy array of any shape. Raises: NotImplementedError: The provided image was not a Pytorch Tensor or numpy array. Returns: Pytorch tensor or numpy array of the same shape as the input. z can not handle data of type r2r>Fisindevicerkr)rYnpndarrayrErFNotImplementedErrorrhr6rrhasattr as_tensorrarwherertensortordetachcpunumpyasarray)r8r=rrZ appl_lblsrKr9r9r:rLs    "zLabelFilter.__call__N) r7rNrOrPrrQrxrRr;rLr9r9r9r:r"s  csDeZdZdZejgZd ddddfdd Zd d d d d ZZ S)ra* This transform fills holes in the image and can be used to remove artifacts inside segments. An enclosed hole is defined as a background pixel/voxel which is only enclosed by a single class. The definition of enclosed can be defined with the connectivity parameter:: 1-connectivity 2-connectivity diagonal connection close-up [ ] [ ] [ ] [ ] [ ] | \ | / | <- hop 2 [ ]--[x]--[ ] [ ]--[x]--[ ] [x]--[ ] | / | \ hop 1 [ ] [ ] [ ] [ ] It is possible to define for which labels the hole filling should be applied. The input image is assumed to be a PyTorch Tensor or numpy array with shape [C, spatial_dim1[, spatial_dim2, ...]]. If C = 1, then the values correspond to expected labels. If C > 1, then a one-hot-encoding is expected where the index of C matches the label indexing. Note: The label 0 will be treated as background and the enclosed holes will be set to the neighboring class label. The performance of this method heavily depends on the number of labels. It is a bit faster if the list of `applied_labels` is provided. Limiting the number of `applied_labels` results in a big decrease in processing time. For example: Use FillHoles with default parameters:: [1, 1, 1, 2, 2, 2, 3, 3] [1, 1, 1, 2, 2, 2, 3, 3] [1, 0, 1, 2, 0, 0, 3, 0] => [1, 1 ,1, 2, 0, 0, 3, 0] [1, 1, 1, 2, 2, 2, 3, 3] [1, 1, 1, 2, 2, 2, 3, 3] The hole in label 1 is fully enclosed and therefore filled with label 1. The background label near label 2 and 3 is not fully enclosed and therefore not filled. NzIterable[int] | int | NonerSr,)rardr0cs&t|rt|nd|_||_dS)a Initialize the connectivity and limit the labels for which holes are filled. Args: applied_labels: Labels for which to fill holes. Defaults to None, that is filling holes for all labels. connectivity: Maximum number of orthogonal hops to consider a pixel/voxel as a neighbor. Accepted values are ranging from 1 to input.ndim. Defaults to a full connectivity of ``input.ndim``. N)rfr;rrard)r8rardrgr9r:r; s zFillHoles.__init__rricCs@t|td}t|tj^}}t||j|j}t||^}}|S)a Fill the holes in the provided image. Note: The value 0 is assumed as background label. Args: img: Pytorch Tensor or numpy array of shape [C, spatial_dim1[, spatial_dim2, ...]]. Raises: NotImplementedError: The provided image was not a Pytorch Tensor or numpy array. Returns: Pytorch Tensor or numpy array of shape [C, spatial_dim1[, spatial_dim2, ...]]. r>) rrrrrrrardr)r8r=img_nprJout_nprKr9r9r:rL-s zFillHoles.__call__)NN) r7rNrOrPrrxrRr;rLrzr9r9rgr:rs' c@s:eZdZdZejgZd dddddZddd d d Zd S)r#a Return the contour of binary input images that only compose of 0 and 1, with Laplacian kernel set as default for edge detection. Typical usage is to plot the edge of label or segmentation output. Args: kernel_type: the method applied to do edge detection, default is "Laplace". Raises: NotImplementedError: When ``kernel_type`` is not "Laplace". Laplacestrr,) kernel_typer0cCs|dkrtd||_dS)Nrz2Currently only kernel_type="Laplace" is supported.)rr)r8rr9r9r:r;SszLabelToContour.__init__rricCst|td}t|dd}t|jd}|d}|dkrdtjdddgdddgdddggtjd}n:|d krd tjd d d tjd}d |d <nt |j d t ||}|j dddt |d|^}}|S)a Args: img: torch tensor data to extract the contour, with shape: [channels, height, width[, depth]] Raises: ValueError: When ``image`` ndim is not one of [3, 4]. Returns: A torch tensor with the same shape as img, note: 1. it's the binary classification result of whether a pixel is edge or not. 2. in order to keep the original shape of mask image, we use padding as default. 3. the edge detection is just approximate because it defects inherent to Laplace kernel, ideally the edge should be thin enough, but now it has a thickness. r>Fr_rrnr@gg:@)r_r_r_z! can only handle 2D or 3D images.rg?)minmax)rrlenro unsqueezerErfloat32onesrDrhr clamp_rsqueeze)r8r=rr spatial_dimskernelZ contour_imgoutputrJr9r9r:rLXs  *  zLabelToContour.__call__N)rrMr9r9r9r:r#Ds c@s6eZdZedddddZedddddd Zd S) Ensemble+Sequence[NdarrayOrTensor] | NdarrayOrTensor torch.TensorricCs\t|tr*t|dtjr*dd|D}nt|tjr@t|}t|trTt|n|}|S)z`Get either a sequence or single instance of np.ndarray/torch.Tensor. Return single torch.Tensor.rcSsg|]}t|qSr9)rEr.0rsr9r9r: sz.Ensemble.get_stacked_torch..)rYrrrrErstack)r=rKr9r9r:get_stacked_torch{s   zEnsemble.get_stacked_torchr)r=orig_imgr0cCs(t|tr|dn|}t||^}}|S)Nr)rYrr)r=rZ orig_img_rKrJr9r9r: post_convertszEnsemble.post_convertN)r7rNrO staticmethodrrr9r9r9r:rys rc@s:eZdZdZejgZd dddddZdd d d d ZdS)r$a Execute mean ensemble on the input data. The input data can be a list or tuple of PyTorch Tensor with shape: [C[, H, W, D]], Or a single PyTorch Tensor with shape: [E, C[, H, W, D]], the `E` dimension represents the output data from different models. Typically, the input data is model output of segmentation task or classification task. And it also can support to add `weights` for the input data. Args: weights: can be a list or tuple of numbers for input data with shape: [E, C, H, W[, D]]. or a Numpy ndarray or a PyTorch Tensor data. the `weights` will be added to input data from highest dimension, for example: 1. if the `weights` only has 1 dimension, it will be added to the `E` dimension of input data. 2. if the `weights` has 2 dimensions, it will be added to `E` and `C` dimensions. it's a typical practice to add weights for different classes: to ensemble 3 segmentation model outputs, every output has 4 channels(classes), so the input data shape can be: [3, 4, H, W, D]. and add different `weights` for different classes, so the `weights` shape can be: [3, 4]. for example: `weights = [[1, 2, 3, 4], [4, 3, 2, 1], [1, 1, 1, 1]]`. Nz(Sequence[float] | NdarrayOrTensor | Noner,)weightsr0cCs"|dk rtj|tjdnd|_dS)Nr@)rErrGr)r8rr9r9r:r;szMeanEnsemble.__init__rrricCs||}|jdk rv|j|j|_t|jj}t||jD] }|d7}qF|jj|}|||j ddd}t j |dd}| ||S)N)r_rTr[rC) rrrrrprorange ndimensionreshapemeanrEr)r8r=rrrorJrout_ptr9r9r:rLs     zMeanEnsemble.__call__)NrMr9r9r9r:r$sc@s:eZdZdZejgZd dddddZdd d d d ZdS)r'af Execute vote ensemble on the input data. The input data can be a list or tuple of PyTorch Tensor with shape: [C[, H, W, D]], Or a single PyTorch Tensor with shape: [E[, C, H, W, D]], the `E` dimension represents the output data from different models. Typically, the input data is model output of segmentation task or classification task. Note: This vote transform expects the input data is discrete values. It can be multiple channels data in One-Hot format or single channel data. It will vote to select the most common data between items. The output data has the same shape as every item of the input data. Args: num_classes: if the input is single channel data instead of One-Hot, we can't get class number from channel, need to explicitly specify the number of classes to vote. NrSr,)r\r0cCs ||_dSr)r\)r8r\r9r9r:r;szVoteEnsemble.__init__rrricCs||}|jdk r^d}|dkr>|jddkr>tdn |dkrNd}t||jdd}tj| dd}|jdk rtj |d|d}n t |}| ||S)NTr_z7no need to specify num_classes for One-Hot format data.FrCrr[) rr\rrowarningswarnr rErrGrTr^r)r8r=rrZ has_ch_dimrr9r9r:rLs      zVoteEnsemble.__call__)NrMr9r9r9r:r'sc@s>eZdZdZejgZddddd d d d d ZddddZdS)r%a- Performs probability based non-maximum suppression (NMS) on the probabilities map via iteratively selecting the coordinate with highest probability and then move it as well as its surrounding values. The remove range is determined by the parameter `box_size`. If multiple coordinates have the same highest probability, only one of them will be selected. Args: spatial_dims: number of spatial dimensions of the input probabilities map. Defaults to 2. sigma: the standard deviation for gaussian filter. It could be a single value, or `spatial_dims` number of values. Defaults to 0.0. prob_threshold: the probability threshold, the function will stop searching if the highest probability is no larger than the threshold. The value should be no less than 0.0. Defaults to 0.5. box_size: the box size (in pixel) to be removed around the pixel with the maximum probability. It can be an integer that defines the size of a square or cube, or a list containing different values for each dimensions. Defaults to 48. Return: a list of selected lists, where inner lists contain probability and coordinates. For example, for 3D input, the inner lists are in the form of [probability, x, y, z]. Raises: ValueError: When ``prob_threshold`` is less than 0.0. ValueError: When ``box_size`` is a list or tuple, and its length is not equal to `spatial_dims`. ValueError: When ``box_size`` has a less than 1 value. rr?0r]z?Sequence[float] | float | Sequence[torch.Tensor] | torch.TensorrGzint | Sequence[int]r,)rsigmaprob_thresholdbox_sizer0cCs||_||_|jdkr$t||d|_|dkr4td||_t|trXt |g||_ n"t ||krntdn t ||_ |j dkrtd|j d|_ |j |j |_dS)Nr)rrz*prob_threshold should be no less than 0.0.zCthe sequence length of box_size should be the same as spatial_dims.z!box_size should be larger than 0.r)rrr filterrDrrYr]rrrrr box_lower_bd box_upper_bd)r8rrrrr9r9r:r; s       zProbNMS.__init__r)prob_mapcs |jdkr>t|tjs&tj|tjd}|j|j||}|j }g}| |j krt | |}|t|}t|tjr|n|}t|tjr|n|}||gt|||jdd||jd|tfddt|jD}d||<qH|S)zZ prob_map: the input probabilities map, it must have shape (H[, W, ...]). rr@Nc3s |]}t||VqdSr)slicerZ idx_max_rangeZ idx_min_ranger9r: :sz#ProbNMS.__call__..)rrYrErFrrGrrrrorrrrTrprritemappendlistrcliprrr)r8rZprob_map_shapeoutputsmax_idxZprob_maxslicesr9rr:rL#s$     zProbNMS.__call__N)rrrrrr9r9r9r:r%sc@s:eZdZdZejgZdddddddd d d Zd d ZdS)r(zV Utility transform to automatically invert the previously applied transforms. NTzInvertibleTransform | Nonezbool | Sequence[bool]zstr | torch.device | Noner+r,) transformnearest_interpr post_func to_tensorr0cCs<t|tstd||_||_||_||_||_t|_ dS)aY Args: transform: the previously applied transform. nearest_interp: whether to use `nearest` interpolation mode when inverting the spatial transforms, default to `True`. If `False`, use the same interpolation mode as the original transform. device: move the inverted results to a target device before `post_func`, default to `None`. post_func: postprocessing for the inverted result, should be a callable function. to_tensor: whether to convert the inverted data into PyTorch Tensor first, default to `True`. zAtransform is not invertible, can't invert transform for the data.N) rYr rDrrrrrr _totensor)r8rrrrrr9r9r:r;Gs zInvert.__init__cCst|ts|S|jr&t|jddd|_|}|j|}|jrTt|tsT| |}t|t j rn|j |j d}t|jr||}|S)Nnearest) trans_infomode align_cornersr)rYrrrapplied_operationsrrinverserrrErFrrr4r)r8datainvertedr9r9r:rLas"      zInvert.__call__)NTNNTrMr9r9r9r:r(@sc sheZdZdZejgZdddddejfddd d d d d d fdd Z ddddZ dddddZ Z S)r&aCalculate Sobel gradients of a grayscale image with the shape of CxH[xWxDx...] or BxH[xWxDx...]. Args: kernel_size: the size of the Sobel kernel. Defaults to 3. spatial_axes: the axes that define the direction of the gradient to be calculated. It calculate the gradient along each of the provide axis. By default it calculate the gradient for all spatial axes. normalize_kernels: if normalize the Sobel kernel to provide proper gradients. Defaults to True. normalize_gradients: if normalize the output gradient to 0 and 1. Defaults to False. padding_mode: the padding mode of the image when convolving with Sobel kernels. Defaults to `"reflect"`. Acceptable values are ``'zeros'``, ``'reflect'``, ``'replicate'`` or ``'circular'``. See ``torch.nn.Conv1d()`` for more information. dtype: kernel data type (torch.dtype). Defaults to `torch.float32`. rNTFreflectr]r`r*rz torch.dtyper,) kernel_size spatial_axesnormalize_kernelsnormalize_gradients padding_moderAr0cs:t||_||_||_||_|||\|_|_dSr) rfr;paddingrrr _get_kernel kernel_diff kernel_smooth)r8rrrrrrArgr9r:r;s zSobelGradients.__init__z!tuple[torch.Tensor, torch.Tensor])r0cCs|dkrtd|d|ddkr4td|dtjdddggg|d }tjdddggg|d }tjdddggg|d }|jr|jstd |d|d }|d }|d }|dd}t|D]$}tj||dd }tj||dd }q||fS)Nrz,Sobel kernel size should be at least three. z was given.rrz+Sobel kernel size should be an odd number. rnr_r@zQ`dtype` for Sobel kernel should be floating point when `normalize_kernel==True`. g@g@)r) rDrErris_floating_pointrFconv1dr)r8sizerArrZkernel_expansionexpandrJr9r9r:rs(    zSobelGradients._get_kernelrr)imager0cs`t|td}|jdtttt d}|jdkrLtt}nNtt|jt|}|rtd|dd|dfdd t|jD}| d}|j |j }|j |j }g}|D]p} |g} || | <t|| |jd } |jr.| } | | kr| | 8} | } | dkr.| | } || qtj|dd }t|d|d}|S) Nr>r_rz5The provide axes to calculate gradient is not valid: z. The image has z% spatial dimensions so it should be: r2cs g|]}|dkr|n|qS)rr9)raxn_spatial_dimsr9r:rsz+SobelGradients.__call__..)rrC)rrndimrrrsetrrDrrrrrr rrrrrrEcatrr)r8rZ image_tensorZvalid_spatial_axesrZ invalid_axisrrZ grad_listrkernelsgradZgrad_minZgrad_maxgradsr9rr:rLs<      zSobelGradients.__call__) r7rNrOrPrrQrRrErr;rrLrzr9r9rgr:r&us csFeZdZdZejejgZd dddfdd Zddd d d Z Z S) r)a Applies the Euclidean distance transform on the input. Either GPU based with CuPy / cuCIM or CPU based with scipy. To use the GPU implementation, make sure cuCIM is available and that the data is a `torch.tensor` on a GPU device. Note that the results of the libraries can differ, so stick to one if possible. For details, check out the `SciPy`_ and `cuCIM`_ documentation and / or :func:`monai.transforms.utils.distance_transform_edt`. .. _SciPy: https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.distance_transform_edt.html .. _cuCIM: https://docs.rapids.ai/api/cucim/nightly/api/#cucim.core.operations.morphology.distance_transform_edt NzNone | float | list[float]r,)samplingr0cst||_dSr)rfr;r)r8rrgr9r:r;s zDistanceTransformEDT.__init__rricCst||jdS)aA Args: img: Input image on which the distance transform shall be run. Has to be a channel first array, must have shape: (num_channels, H, W [,D]). Can be of any type but will be converted into binary: 1 wherever image equates to True, 0 elsewhere. Input gets passed channel-wise to the distance-transform, thus results from this function will differ from directly calling ``distance_transform_edt()`` in CuPy or SciPy. sampling: Spacing of elements along each dimension. If a sequence, must be of length equal to the input rank -1; if a single number, this is used for all axes. If not specified, a grid spacing of unity is implied. Returns: An array with the same shape and data type as img )r=r)rrrr9r9r:rLszDistanceTransformEDT.__call__)Nrwr9r9rgr:r)s )ArP __future__rrcollections.abcrrrrrrEtorch.nn.functionalnn functionalrmonai.config.type_definitionsrmonai.data.meta_objrmonai.data.meta_tensorrmonai.networksr monai.networks.layersr r r monai.transforms.inverser monai.transforms.transformrmonai.transforms.utility.arrayrmonai.transforms.utilsrrrrrr0monai.transforms.utils_pytorch_numpy_unificationr monai.utilsrrrrrmonai.utils.type_conversionr__all__rrr r!r"rr#rr$r'r%r(r&r)r9r9r9r: s\           GjvX:N5+1X5n