Add generic kernel transform with support for multiple kernels

docs/source/transforms.rst

@@ -1134,6 +1134,17 @@ Utility
     :members:
     :special-members: __call__
 
+`ImageFilter`
+"""""""""""""
+.. autoclass:: ImageFilter
+    :members:
+    :special-members: __call__
+
+`RandImageFilter`
+"""""""""""""""""
+.. autoclass:: RandImageFilter
+    :members:
+    :special-members: __call__
 
 Dictionary Transforms
 ---------------------
@@ -2124,6 +2135,19 @@ Utility (Dict)
     :members:
     :special-members: __call__
 
+`ImageFilterd`
+""""""""""""""
+.. autoclass:: ImageFilterd
+    :members:
+    :special-members: __call__
+
+`RandImageFilterd`
+""""""""""""""""""
+.. autoclass:: RandImageFilterd
+    :members:
+    :special-members: __call__
+
+
 MetaTensor
 ^^^^^^^^^^
 

monai/networks/layers/__init__.py

@@ -16,13 +16,18 @@
 from .gmm import GaussianMixtureModel
 from .simplelayers import (
     LLTM,
+    ApplyFilter,
     ChannelPad,
+    EllipticalFilter,
     Flatten,
     GaussianFilter,
     HilbertTransform,
+    LaplaceFilter,
+    MeanFilter,
     MedianFilter,
     Reshape,
     SavitzkyGolayFilter,
+    SharpenFilter,
     SkipConnection,
     apply_filter,
     median_filter,

monai/networks/layers/simplelayers.py

@@ -18,6 +18,7 @@
 from torch import nn
 from torch.autograd import Function
 
+from monai.config.type_definitions import NdarrayOrTensor
 from monai.networks.layers.convutils import gaussian_1d
 from monai.networks.layers.factories import Conv
 from monai.utils import (
@@ -658,3 +659,90 @@ def reset_parameters(self):
 
     def forward(self, input, state):
         return LLTMFunction.apply(input, self.weights, self.bias, *state)
+
+
+class ApplyFilter(nn.Module):
+    "Wrapper class to apply a filter to an image."
+
+    def __init__(self, filter: NdarrayOrTensor) -> None:
+        super().__init__()
+
+        self.filter = convert_to_tensor(filter, dtype=torch.float32)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return apply_filter(x, self.filter)  # type: ignore
+
+
+class MeanFilter(ApplyFilter):
+    """
+    Mean filtering can smooth edges and remove aliasing artifacts in an segmentation image.
+    The mean filter used, is a `torch.Tensor` of all ones.
+    """
+
+    def __init__(self, spatial_dims: int, size: int) -> None:
+        """
+        Args:
+            spatial_dims: `int` of either 2 for 2D images and 3 for 3D images
+            size: edge length of the filter
+        """
+        filter = torch.ones([size] * spatial_dims)
+        filter = filter
+        super().__init__(filter=filter)
+
+
+class LaplaceFilter(ApplyFilter):
+    """
+    Laplacian filtering for outline detection in images. Can be used to transform labels to contours.
+    The laplace filter used, is a `torch.Tensor` where all values are -1, except the center value
+    which is `size` ** `spatial_dims`
+    """
+
+    def __init__(self, spatial_dims: int, size: int) -> None:
+        """
+        Args:
+            spatial_dims: `int` of either 2 for 2D images and 3 for 3D images
+            size: edge length of the filter
+        """
+        filter = torch.zeros([size] * spatial_dims).float() - 1  # make all -1
+        center_point = tuple([size // 2] * spatial_dims)
+        filter[center_point] = (size**spatial_dims) - 1
+        super().__init__(filter=filter)
+
+
+class EllipticalFilter(ApplyFilter):
+    """
+    Elliptical filter, can be used to dilate labels or label-contours.
+    The elliptical filter used here, is a `torch.Tensor` with shape (size, ) * ndim containing a circle/sphere of `1`
+    """
+
+    def __init__(self, spatial_dims: int, size: int) -> None:
+        """
+        Args:
+            spatial_dims: `int` of either 2 for 2D images and 3 for 3D images
+            size: edge length of the filter
+        """
+        radius = size // 2
+        grid = torch.meshgrid(*[torch.arange(0, size) for _ in range(spatial_dims)])
+        squared_distances = torch.stack([(axis - radius) ** 2 for axis in grid], 0).sum(0)
+        filter = squared_distances <= radius**2
+        super().__init__(filter=filter)
+
+
+class SharpenFilter(EllipticalFilter):
+    """
+    Convolutional filter to sharpen a 2D or 3D image.
+    The filter used contains a circle/sphere of `-1`, with the center value being
+    the absolute sum of all non-zero elements in the kernel
+    """
+
+    def __init__(self, spatial_dims: int, size: int) -> None:
+        """
+        Args:
+            spatial_dims: `int` of either 2 for 2D images and 3 for 3D images
+            size: edge length of the filter
+        """
+        super().__init__(spatial_dims=spatial_dims, size=size)
+        center_point = tuple([size // 2] * spatial_dims)
+        center_value = self.filter.sum()
+        self.filter *= -1
+        self.filter[center_point] = center_value

monai/transforms/__init__.py

@@ -478,11 +478,13 @@
     EnsureType,
     FgBgToIndices,
     Identity,
+    ImageFilter,
     IntensityStats,
     LabelToMask,
     Lambda,
     MapLabelValue,
     RandCuCIM,
+    RandImageFilter,
     RandLambda,
     RemoveRepeatedChannel,
     RepeatChannel,
@@ -553,6 +555,9 @@
     Identityd,
     IdentityD,
     IdentityDict,
+    ImageFilterd,
+    ImageFilterD,
+    ImageFilterDict,
     IntensityStatsd,
     IntensityStatsD,
     IntensityStatsDict,
@@ -568,6 +573,9 @@
     RandCuCIMd,
     RandCuCIMD,
     RandCuCIMDict,
+    RandImageFilterd,
+    RandImageFilterD,
+    RandImageFilterDict,
     RandLambdad,
     RandLambdaD,
     RandLambdaDict,