batchgeneratorsv2 0.2.3__tar.gz → 0.3.0__tar.gz

{batchgeneratorsv2-0.2.3 → batchgeneratorsv2-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: batchgeneratorsv2
-Version: 0.2.3
+Version: 0.3.0
 Summary: Batchgenerators but better
 Author: Helmholtz Imaging Applied Computer Vision Lab
 Author-email: Fabian Isensee <f.isensee@dkfz-heidelberg.de>
@@ -222,6 +222,7 @@ Requires-Dist: torch>=2.0.0
 Requires-Dist: numpy
 Requires-Dist: fft-conv-pytorch
 Requires-Dist: batchgenerators>=0.25
+Dynamic: license-file
 
 # batchgeneratorsv2
 This repository is work in progress. If builds upon the [batchgenerators](https://github.com/MIC-DKFZ/batchgenerators) 

{batchgeneratorsv2-0.2.3 → batchgeneratorsv2-0.3.0}/batchgeneratorsv2/transforms/base/basic_transform.py

@@ -22,7 +22,7 @@ class BasicTransform(abc.ABC):
             data_dict['image'] = self._apply_to_image(data_dict['image'], **params)
 
         if data_dict.get('regression_target') is not None:
-            data_dict['regression_target'] = self._apply_to_segmentation(data_dict['regression_target'], **params)
+            data_dict['regression_target'] = self._apply_to_regr_target(data_dict['regression_target'], **params)
 
         if data_dict.get('segmentation') is not None:
             data_dict['segmentation'] = self._apply_to_segmentation(data_dict['segmentation'], **params)

{batchgeneratorsv2-0.2.3 → batchgeneratorsv2-0.3.0}/batchgeneratorsv2/transforms/intensity/brightness.py

@@ -1,3 +1,4 @@
+import numpy as np
 import torch
 
 from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
@@ -33,9 +34,51 @@ class MultiplicativeBrightnessTransform(ImageOnlyTransform):
         return img
 
 
+class BrightnessAdditiveTransform(ImageOnlyTransform):
+    """
+    Adds random additive brightness noise sampled from a Gaussian distribution (mu, sigma).
+
+    Supports per-channel brightness sampling or shared brightness across all channels.
+
+    Args:
+        mu (float): Mean of the Gaussian used to sample brightness shifts.
+        sigma (float): Standard deviation of the Gaussian.
+        per_channel (bool): If True, brightness shifts are sampled separately per channel.
+        p_per_channel (float): Probability to apply the brightness shift to each channel.
+    """
+
+    def __init__(self,
+                 mu: float,
+                 sigma: float,
+                 per_channel: bool = True,
+                 p_per_channel: float = 1.0):
+        super().__init__()
+        self.mu = mu
+        self.sigma = sigma
+        self.per_channel = per_channel
+        self.p_per_channel = p_per_channel
+
+    def get_parameters(self, image: torch.Tensor, **kwargs) -> dict:
+        C = image.shape[0]
+        apply_channel = [np.random.rand() < self.p_per_channel for _ in range(C)]
+
+        if self.per_channel:
+            brightness = [np.random.normal(self.mu, self.sigma) if apply else None for apply in apply_channel]
+        else:
+            global_brightness = np.random.normal(self.mu, self.sigma)
+            brightness = [global_brightness if apply else None for apply in apply_channel]
+
+        return {'brightness': brightness}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        for c, b in enumerate(params['brightness']):
+            if b is not None:
+                img[c].add_(float(b))
+        return img
+
+
 if __name__ == '__main__':
     from time import time
-    import numpy as np
     import os
 
     os.environ['OMP_NUM_THREADS'] = '1'

{batchgeneratorsv2-0.2.3 → batchgeneratorsv2-0.3.0}/batchgeneratorsv2/transforms/intensity/contrast.py

@@ -25,6 +25,7 @@ class BGContrast():
     def __repr__(self):
         return self.__class__.__name__ + f"(contrast_range={self.contrast_range})"
 
+
 class ContrastTransform(ImageOnlyTransform):
     def __init__(self, contrast_range: RandomScalar, preserve_range: bool, synchronize_channels: bool, p_per_channel: float = 1):
         super().__init__()

batchgeneratorsv2-0.3.0/batchgeneratorsv2/transforms/intensity/random_clip.py

@@ -0,0 +1,102 @@
+import torch
+import numpy as np
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+
+
+class CutOffOutliersTransform(ImageOnlyTransform):
+    """
+    Clamps intensities in the image to percentiles to remove outliers,
+    and optionally rescales the result to retain original standard deviation.
+
+    Args:
+        percentile_lower (RandomScalar): Lower cutoff percentile (0-100).
+        percentile_upper (RandomScalar): Upper cutoff percentile (0-100).
+        p_synchronize_channels (bool): If True, same percentiles are used for all channels.
+        p_per_channel (float): Probability to apply cutoff to each channel.
+        p_retain_std (float): Probability of retaining the original standard deviation after clipping.
+    """
+
+    def __init__(self,
+                 percentile_lower: RandomScalar = 0.2,
+                 percentile_upper: RandomScalar = 99.8,
+                 p_synchronize_channels: bool = False,
+                 p_per_channel: float = 1.0,
+                 p_retain_std: float = 1.0):
+        super().__init__()
+        self.percentile_lower = percentile_lower
+        self.percentile_upper = percentile_upper
+        self.p_synchronize_channels = p_synchronize_channels
+        self.p_per_channel = p_per_channel
+        self.p_retain_std = p_retain_std
+
+    def get_parameters(self, image: torch.Tensor, **kwargs) -> dict:
+        C = image.shape[0]
+        apply_channel = [np.random.rand() < self.p_per_channel for _ in range(C)]
+
+        if self.p_synchronize_channels:
+            lower = float(sample_scalar(self.percentile_lower))
+            upper = float(sample_scalar(self.percentile_upper))
+            percentiles = [(lower, upper) if apply else None for apply in apply_channel]
+        else:
+            percentiles = []
+            for apply in apply_channel:
+                if not apply:
+                    percentiles.append(None)
+                else:
+                    lower = float(sample_scalar(self.percentile_lower))
+                    upper = float(sample_scalar(self.percentile_upper))
+                    percentiles.append((lower, upper))
+
+        retain_std_flags = [
+            np.random.rand() < self.p_retain_std if p is not None else False
+            for p in percentiles
+        ]
+
+        return {'percentiles': percentiles, 'retain_std': retain_std_flags}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        percentiles = params['percentiles']
+        retain_std = params['retain_std']
+
+        for c, perc in enumerate(percentiles):
+            if perc is None:
+                continue
+
+            img_c = img[c]
+            if retain_std[c]:
+                orig_std = img_c.std()
+
+            # Use numpy only to calculate percentiles
+            img_c_np = img_c.detach().cpu().numpy()
+            lower_val = np.percentile(img_c_np, perc[0])
+            upper_val = np.percentile(img_c_np, perc[1])
+
+            img_c_clipped = img_c.clamp(min=float(lower_val), max=float(upper_val))
+
+            if retain_std[c]:
+                clipped_std = img_c_clipped.std()
+                if clipped_std > 1e-8:
+                    img_c_clipped = (img_c_clipped - img_c_clipped.mean()) / clipped_std * orig_std + img_c_clipped.mean()
+
+            img[c] = img_c_clipped
+
+        return img
+
+if __name__ == '__main__':
+    from batchviewer import view_batch
+
+    image = torch.randn(1, 32, 64, 64) * 5
+
+    transform = CutOffOutliersTransform(
+        percentile_lower=(0.5, 5),
+        percentile_upper=(95, 99.5),
+        p_synchronize_channels=True,
+        p_per_channel=1.0,
+        p_retain_std=0.5
+    )
+
+    params = transform.get_parameters(image=image)
+    image_clipped = transform._apply_to_image(image.clone(), **params)
+
+    view_batch(image, image_clipped, image_clipped-image)

batchgeneratorsv2-0.3.0/batchgeneratorsv2/transforms/local/brightness_gradient.py

@@ -0,0 +1,177 @@
+import torch
+import numpy as np
+from typing import List
+
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.local.local_transform import LocalTransform
+
+
+class BrightnessGradientAdditiveTransform(ImageOnlyTransform, LocalTransform):
+    """
+    Applies a localized brightness modulation to an image using a smooth Gaussian gradient.
+
+    This transform creates a spatial Gaussian kernel (in 2D or 3D), optionally zero-centers it,
+    scales its peak intensity, and adds it to the image. This can simulate intensity drift,
+    local contrast changes, or smooth lighting artifacts.
+
+    The effect is applied per channel, and each channel can have a different gradient or share the same one.
+
+    ---
+    Example use cases:
+    - Simulating local contrast shifts in MRI
+    - Adding spatial brightness gradients for robustness
+    - Mimicking smooth scanner inhomogeneity fields
+
+    Args:
+        scale (RandomScalar):
+            Controls the spatial spread of the Gaussian kernel (standard deviation).
+            Can be:
+              - float: fixed spread
+              - (min, max): uniformly sampled per-dimension
+              - callable(image_shape, dim): custom sampling per axis
+
+        loc (RandomScalar):
+            Controls the relative location of the Gaussian kernel (in percentage of image size).
+            Can be:
+              - (min, max): e.g. (-1, 2) allows centers to be far outside the image for smoother edges
+              - callable(image_shape, dim): custom sampling per axis
+
+        max_strength (RandomScalar):
+            Peak value of the additive brightness change (positive or negative depending on the Gaussian).
+            Can be:
+              - float: fixed strength
+              - (min, max): sampled strength
+              - callable(image, kernel): fully custom
+
+        same_for_all_channels (bool):
+            If True, one shared kernel is used across all channels.
+            If False, each channel gets its own random kernel and strength.
+
+        mean_centered (bool):
+            If True, the Gaussian kernel is mean-centered (i.e., ∑kernel = 0),
+            which ensures the overall mean intensity of the image stays constant.
+
+        clip_intensities (bool):
+            If True, clamps image values after modification to their original min/max.
+            Useful to prevent range overflow.
+
+        p_per_channel (float):
+            Probability to apply the transform to each channel independently.
+
+    Returns:
+        Modified image of the same shape with localized brightness modulation applied.
+
+    Example:
+        transform = BrightnessGradientAdditiveTransform(
+            scale=(5, 15),
+            max_strength=(0.1, 0.5),
+            same_for_all_channels=True,
+            mean_centered=True
+        )
+    """
+    def __init__(self,
+                 scale: RandomScalar,
+                 loc: RandomScalar = (-1, 2),
+                 max_strength: RandomScalar = 1.0,
+                 same_for_all_channels: bool = True,
+                 mean_centered: bool = True,
+                 clip_intensities: bool = False,
+                 p_per_channel: float = 1.0):
+        ImageOnlyTransform.__init__(self)
+        LocalTransform.__init__(self, scale, loc)
+
+        self.max_strength = max_strength
+        self.same_for_all_channels = same_for_all_channels
+        self.mean_centered = mean_centered
+        self.clip_intensities = clip_intensities
+        self.p_per_channel = p_per_channel
+
+    def get_parameters(self, image: torch.Tensor, **kwargs) -> dict:
+        C, *spatial = image.shape
+        apply_channel = [np.random.rand() < self.p_per_channel for _ in range(C)]
+
+        # Early exit if nothing will be applied
+        if not any(apply_channel):
+            return {'kernels': [None] * C}
+
+        if self.same_for_all_channels:
+            kernel = self._generate_kernel(spatial)
+            if self.mean_centered:
+                kernel -= kernel.mean()
+
+            max_abs = np.abs(kernel).max()
+            if max_abs < 1e-8:
+                return {'kernels': [None] * C}
+
+            strength = sample_scalar(self.max_strength, image, kernel)
+            if strength == 0.0:
+                return {'kernels': [None] * C}
+
+            kernel /= max_abs
+            kernel *= strength
+
+            kernels = [kernel if apply else None for apply in apply_channel]
+
+        else:
+            kernels = []
+            for apply in apply_channel:
+                if not apply:
+                    kernels.append(None)
+                    continue
+
+                kernel = self._generate_kernel(spatial)
+                if self.mean_centered:
+                    kernel -= kernel.mean()
+                max_abs = np.abs(kernel).max()
+                if max_abs < 1e-8:
+                    kernels.append(None)
+                    continue
+
+                strength = sample_scalar(self.max_strength, image, kernel)
+                if strength == 0.0:
+                    kernels.append(None)
+                    continue
+
+                kernel /= max_abs
+                kernel *= strength
+                kernels.append(kernel)
+
+        return {'kernels': kernels}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        for c, kernel in enumerate(params['kernels']):
+            if kernel is None:
+                continue
+            kernel_tensor = torch.from_numpy(kernel).to(img.device, dtype=img.dtype)
+            img[c].add_(kernel_tensor)
+
+        if self.clip_intensities:
+            img.clamp_(min=img.min(), max=img.max())
+
+        return img
+
+if __name__ == '__main__':
+    import torch
+    from batchviewer import view_batch
+
+    # Create synthetic z-score normalized 3D image (C, D, H, W)
+    image = torch.randn(1, 32, 64, 64)  # single-channel 3D volume
+
+    # Instantiate the transform
+    transform = BrightnessGradientAdditiveTransform(
+        scale=(25, 50),  # controls width of Gaussian
+        loc=(-0.5, 1.5),
+        max_strength=(2, 5),  # how strong the modulation is
+        same_for_all_channels=True,
+        mean_centered=True,
+        clip_intensities=False,
+        p_per_channel=1.0  # always apply
+    )
+
+    # Get transform parameters and apply
+    params = transform.get_parameters(image=image)
+    image_modulated = transform._apply_to_image(image.clone(), **params)
+
+    # Visualize with your preferred viewer
+    view_batch(image, image_modulated)

batchgeneratorsv2-0.3.0/batchgeneratorsv2/transforms/local/local_contrast.py

@@ -0,0 +1,90 @@
+import torch
+import numpy as np
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.local.local_transform import LocalTransform
+
+
+class LocalContrastTransform(ImageOnlyTransform, LocalTransform):
+    """
+    Applies localized contrast modification using a spatial Gaussian mask.
+
+    A contrast-modified version of the image is blended with the original using a kernel-based interpolation.
+
+    Args:
+        scale (RandomScalar): Gaussian spread for the spatial weighting mask.
+        loc (RandomScalar): Relative center position for the Gaussian (in % of image size).
+        new_contrast (RandomScalar): Multiplicative factor for local contrast. 1.0 = no change.
+        same_for_all_channels (bool): Whether to use one kernel/contrast value for all channels.
+        p_per_channel (float): Probability to apply to each channel.
+    """
+
+    def __init__(self,
+                 scale: RandomScalar,
+                 loc: RandomScalar = (-1, 2),
+                 new_contrast: RandomScalar = (0.5, 1.5),
+                 same_for_all_channels: bool = True,
+                 p_per_channel: float = 1.0):
+        ImageOnlyTransform.__init__(self)
+        LocalTransform.__init__(self, scale, loc)
+
+        self.new_contrast = new_contrast
+        self.same_for_all_channels = same_for_all_channels
+        self.p_per_channel = p_per_channel
+
+    def get_parameters(self, image: torch.Tensor, **kwargs) -> dict:
+        C, *spatial = image.shape
+        apply_channel = [np.random.rand() < self.p_per_channel for _ in range(C)]
+
+        if not any(apply_channel):
+            return {'kernels': [None] * C, 'contrasts': [None] * C}
+
+        if self.same_for_all_channels:
+            kernel = self._generate_kernel(spatial).astype(np.float32)
+            contrast = sample_scalar(self.new_contrast)
+
+            kernels = [kernel if apply else None for apply in apply_channel]
+            contrasts = [contrast if apply else None for apply in apply_channel]
+        else:
+            kernels, contrasts = [], []
+            for apply in apply_channel:
+                if not apply:
+                    kernels.append(None)
+                    contrasts.append(None)
+                    continue
+                kernel = self._generate_kernel(spatial).astype(np.float32)
+                contrast = sample_scalar(self.new_contrast)
+                kernels.append(kernel)
+                contrasts.append(contrast)
+
+        return {'kernels': kernels, 'contrasts': contrasts}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        img_np = img.cpu().numpy()
+
+        for c, (kernel, contrast) in enumerate(zip(params['kernels'], params['contrasts'])):
+            if kernel is None:
+                continue
+
+            channel = img_np[c]
+            mean = (channel * kernel).sum() / (kernel.sum() + 1e-8)
+            modified = (channel - mean) * contrast + mean
+            img_np[c] = self.run_interpolation(channel, modified, kernel)
+
+        return torch.from_numpy(img_np).to(img.device, dtype=img.dtype)
+
+
+if __name__ == '__main__':
+    from batchviewer import view_batch
+
+    # Single-channel synthetic volume
+    image = torch.rand(1, 32, 64, 64)
+
+    # Or contrast
+    contrast = LocalContrastTransform(scale=(10, 20), new_contrast=(0.3, 2.0), p_per_channel=1.0)
+
+    # Apply either one
+    params = contrast.get_parameters(image=image)
+    image_aug = contrast._apply_to_image(image.clone(), **params)
+
+    view_batch(image, image_aug)

batchgeneratorsv2-0.3.0/batchgeneratorsv2/transforms/local/local_gamma.py

@@ -0,0 +1,104 @@
+import torch
+import numpy as np
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.local.local_transform import LocalTransform
+
+
+class LocalGammaTransform(ImageOnlyTransform, LocalTransform):
+    """
+    Applies locally varying gamma correction to an image using a spatial Gaussian weighting mask.
+
+    A Gaussian kernel is randomly placed in the image and used to blend between the original image and
+    a gamma-corrected version. This simulates localized nonlinear intensity shifts, useful for data augmentation
+    in medical imaging or general contrast robustness.
+
+    Parameters:
+        scale (RandomScalar): Controls the width of the Gaussian (std dev). Recommend large values (e.g. 10–30).
+        loc (RandomScalar): Controls Gaussian center as a % of image size. E.g. (-1, 2) allows off-canvas kernels.
+        gamma (RandomScalar): The gamma exponent applied locally. Try wild distributions :)
+        same_for_all_channels (bool): If True, one kernel is reused across all channels. Otherwise sampled per-channel.
+        p_per_channel (float): Probability to apply gamma correction to each channel independently.
+    """
+
+    def __init__(self,
+                 scale: RandomScalar,
+                 loc: RandomScalar = (-1, 2),
+                 gamma: RandomScalar = (0.5, 1),
+                 same_for_all_channels: bool = True,
+                 p_per_channel: float = 1.0):
+        ImageOnlyTransform.__init__(self)
+        LocalTransform.__init__(self, scale, loc)
+
+        self.gamma = gamma
+        self.same_for_all_channels = same_for_all_channels
+        self.p_per_channel = p_per_channel
+
+    def get_parameters(self, image: torch.Tensor, **kwargs) -> dict:
+        C, *spatial = image.shape
+        apply_channel = [np.random.rand() < self.p_per_channel for _ in range(C)]
+
+        if not any(apply_channel):
+            return {'kernels': [None] * C, 'gammas': [None] * C}
+
+        if self.same_for_all_channels:
+            kernel = self._generate_kernel(spatial).astype(np.float32)
+            gamma = sample_scalar(self.gamma)
+
+            kernels = [kernel if apply else None for apply in apply_channel]
+            gammas = [gamma if apply else None for apply in apply_channel]
+        else:
+            kernels, gammas = [], []
+            for apply in apply_channel:
+                if not apply:
+                    kernels.append(None)
+                    gammas.append(None)
+                    continue
+                kernel = self._generate_kernel(spatial).astype(np.float32)
+                gamma = sample_scalar(self.gamma)
+                kernels.append(kernel)
+                gammas.append(gamma)
+
+        return {'kernels': kernels, 'gammas': gammas}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        img_np = img.cpu().numpy()
+
+        for c, (kernel, gamma) in enumerate(zip(params['kernels'], params['gammas'])):
+            if kernel is None:
+                continue
+
+            channel = img_np[c]
+            min_val, max_val = channel.min(), channel.max()
+            denom = max(max_val - min_val, 1e-8)
+
+            # Normalize to [0, 1]
+            norm = (channel - min_val) / denom
+            gamma_corrected = np.power(norm, gamma)
+
+            # Blend using kernel
+            blended = self.run_interpolation(norm, gamma_corrected, kernel)
+
+            # Rescale to original range
+            img_np[c] = blended * denom + min_val
+
+        return torch.from_numpy(img_np).to(img.device, dtype=img.dtype)
+
+
+if __name__ == '__main__':
+    import torch
+    from batchviewer import view_batch
+
+    image = torch.rand(1, 32, 64, 64)  # (C, D, H, W)
+
+    transform = LocalGammaTransform(
+        scale=(10, 20),
+        gamma=lambda *_: np.random.uniform(0.01, 1) if np.random.rand() < 0.5 else np.random.uniform(1, 3),
+        same_for_all_channels=False,
+        p_per_channel=1.0
+    )
+
+    params = transform.get_parameters(image=image)
+    image_gamma = transform._apply_to_image(image.clone(), **params)
+
+    view_batch(image, image_gamma)

batchgeneratorsv2-0.3.0/batchgeneratorsv2/transforms/local/local_smoothing.py

@@ -0,0 +1,98 @@
+import torch
+import numpy as np
+from batchgeneratorsv2.transforms.local.local_transform import LocalTransform
+from scipy.ndimage import gaussian_filter
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+
+
+class LocalSmoothingTransform(ImageOnlyTransform, LocalTransform):
+    """
+    Applies localized Gaussian smoothing to parts of the image using a spatial Gaussian mask.
+
+    A blurred copy of the image is interpolated with the original, weighted by a Gaussian kernel.
+    The strength and extent of the blur are both controllable.
+
+    Args:
+        scale (RandomScalar): Gaussian spread for the spatial weighting mask.
+        loc (RandomScalar): Relative center position for the Gaussian (in % of image size).
+        smoothing_strength (RandomScalar): Max weight of the smoothed image in the interpolation [0, 1].
+        kernel_size (RandomScalar): Sigma for the actual Gaussian smoothing of the image.
+        same_for_all_channels (bool): Whether to apply the same kernel to all channels.
+        p_per_channel (float): Probability of applying transform per channel.
+    """
+
+    def __init__(self,
+                 scale: RandomScalar,
+                 loc: RandomScalar = (-1, 2),
+                 smoothing_strength: RandomScalar = (0.5, 1.0),
+                 kernel_size: RandomScalar = (0.5, 1.5),
+                 same_for_all_channels: bool = True,
+                 p_per_channel: float = 1.0):
+        ImageOnlyTransform.__init__(self)
+        LocalTransform.__init__(self, scale, loc)
+
+        self.smoothing_strength = smoothing_strength
+        self.kernel_size = kernel_size
+        self.same_for_all_channels = same_for_all_channels
+        self.p_per_channel = p_per_channel
+
+    def get_parameters(self, image: torch.Tensor, **kwargs) -> dict:
+        C, *spatial = image.shape
+        apply_channel = [np.random.rand() < self.p_per_channel for _ in range(C)]
+
+        if not any(apply_channel):
+            return {'kernels': [None] * C, 'sigma': None, 'strengths': [None] * C}
+
+        sigma = sample_scalar(self.kernel_size)
+
+        if self.same_for_all_channels:
+            kernel = self._generate_kernel(spatial).astype(np.float32)
+            strength = sample_scalar(self.smoothing_strength)
+
+            kernels = [kernel if apply else None for apply in apply_channel]
+            strengths = [strength if apply else None for apply in apply_channel]
+        else:
+            kernels, strengths = [], []
+            for apply in apply_channel:
+                if not apply:
+                    kernels.append(None)
+                    strengths.append(None)
+                    continue
+                kernel = self._generate_kernel(spatial).astype(np.float32)
+                strength = sample_scalar(self.smoothing_strength)
+                kernels.append(kernel)
+                strengths.append(strength)
+
+        return {'kernels': kernels, 'sigma': sigma, 'strengths': strengths}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        img_np = img.cpu().numpy()
+        sigma = params['sigma']
+
+        for c, (kernel, strength) in enumerate(zip(params['kernels'], params['strengths'])):
+            if kernel is None:
+                continue
+
+            kernel = kernel * strength  # scale kernel by smoothing strength
+            smoothed = gaussian_filter(img_np[c], sigma=sigma)
+            img_np[c] = self.run_interpolation(img_np[c], smoothed, kernel)
+
+        return torch.from_numpy(img_np).to(img.device, dtype=img.dtype)
+
+
+if __name__ == '__main__':
+    from batchviewer import view_batch
+
+    # Single-channel synthetic volume
+    image = torch.rand(1, 32, 64, 64)
+
+    # Or contrast
+    smoother = LocalSmoothingTransform(loc=(0, 1), scale=(10, 20), kernel_size=(3, 10), p_per_channel=1.0)
+
+    # Apply either one
+    params = smoother.get_parameters(image=image)
+    image_aug = smoother._apply_to_image(image.clone(), **params)
+
+    view_batch(image, image_aug)
+