batchgeneratorsv2 0.3.2__py3-none-any.whl

batchgeneratorsv2/transforms/intensity/contrast.py

@@ -0,0 +1,123 @@
+import torch
+
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+import numpy as np
+
+
+class BGContrast():
+    def __init__(self, contrast_range):
+        self.contrast_range = contrast_range
+
+    def sample_contrast(self, *args, **kwargs):
+        if callable(self.contrast_range):
+            factor = self.contrast_range()
+        else:
+            if np.random.random() < 0.5 and self.contrast_range[0] < 1:
+                factor = np.random.uniform(self.contrast_range[0], 1)
+            else:
+                factor = np.random.uniform(max(self.contrast_range[0], 1), self.contrast_range[1])
+        return factor
+
+    def __call__(self, *args, **kwargs):
+        return self.sample_contrast(*args, **kwargs)
+
+    def __repr__(self):
+        return self.__class__.__name__ + f"(contrast_range={self.contrast_range})"
+
+
+import torch
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+
+
+class ContrastTransform(ImageOnlyTransform):
+    def __init__(self, contrast_range: RandomScalar, preserve_range: bool, synchronize_channels: bool, p_per_channel: float = 1.0):
+        super().__init__()
+        self.contrast_range = contrast_range
+        self.preserve_range = preserve_range
+        self.synchronize_channels = synchronize_channels
+        self.p_per_channel = float(p_per_channel)
+
+    def get_parameters(self, **data_dict) -> dict:
+        img = data_dict["image"]
+        c = img.shape[0]
+
+        # sample on correct device
+        apply_idx = (torch.rand(c, device=img.device) < self.p_per_channel).nonzero(as_tuple=False).flatten()
+        n = apply_idx.numel()
+
+        if n == 0:
+            multipliers = None
+        elif self.synchronize_channels:
+            m = float(sample_scalar(self.contrast_range, image=img, channel=None))
+            multipliers = torch.full((n,), m, device=img.device, dtype=img.dtype)
+        else:
+            # Still a Python loop because sample_scalar is scalar-by-scalar
+            # Use .tolist() to avoid iterating tensor scalars in Python
+            ms = [sample_scalar(self.contrast_range, image=img, channel=int(ch)) for ch in apply_idx.tolist()]
+            multipliers = torch.as_tensor(ms, device=img.device, dtype=img.dtype)
+
+        return {"apply_to_channel": apply_idx, "multipliers": multipliers}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        idx = params["apply_to_channel"]
+        multipliers = params["multipliers"]
+        if multipliers is None or idx.numel() == 0:
+            return img
+
+        if self.preserve_range:
+            for i in range(idx.numel()):
+                c = int(idx[i])
+                m = multipliers[i]
+
+                x = img[c]
+                mean = x.mean()
+                minm = x.min()
+                maxm = x.max()
+
+                x.sub_(mean)
+                x.mul_(m)
+                x.add_(mean)
+                x.clamp_(minm, maxm)
+        else:
+            for i in range(idx.numel()):
+                c = int(idx[i])
+                m = multipliers[i]
+
+                x = img[c]
+                mean = x.mean()
+                x.sub_(mean)
+                x.mul_(m)
+                x.add_(mean)
+
+        return img
+
+
+if __name__ == '__main__':
+    from time import time
+    import os
+
+    os.environ['OMP_NUM_THREADS'] = '1'
+    torch.set_num_threads(1)
+
+    mbt = ContrastTransform(BGContrast((0.75, 1.25)).sample_contrast, True, False, p_per_channel=1)
+
+    times_torch = []
+    for _ in range(100):
+        data_dict = {'image': torch.ones((2, 128, 192, 64))}
+        st = time()
+        out = mbt(**data_dict)
+        times_torch.append(time() - st)
+    print('torch', np.mean(times_torch))
+
+    from batchgenerators.transforms.color_transforms import ContrastAugmentationTransform
+
+    gnt_bg = ContrastAugmentationTransform((0.75, 1.25), preserve_range=True, per_channel=True, p_per_channel=1)
+    times_bg = []
+    for _ in range(100):
+        data_dict = {'data': np.ones((1, 2, 128, 192, 64))}
+        st = time()
+        out = gnt_bg(**data_dict)
+        times_bg.append(time() - st)
+    print('bg', np.mean(times_bg))

batchgeneratorsv2/transforms/intensity/gamma.py

@@ -0,0 +1,135 @@
+from typing import Optional
+import torch
+
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+
+
+class GammaTransform(ImageOnlyTransform):
+    def __init__(self,
+                 gamma: RandomScalar,
+                 p_invert_image: float,
+                 synchronize_channels: bool,
+                 p_per_channel: float,
+                 p_retain_stats: float):
+        super().__init__()
+        self.gamma = gamma
+        self.p_invert_image = float(p_invert_image)
+        self.synchronize_channels = synchronize_channels
+        self.p_per_channel = float(p_per_channel)
+        self.p_retain_stats = float(p_retain_stats)
+
+    def get_parameters(self, **data_dict) -> dict:
+        img: torch.Tensor = data_dict["image"]
+        c = img.shape[0]
+        device = img.device
+        dtype = img.dtype
+
+        apply_idx = (torch.rand(c, device=device) < self.p_per_channel).nonzero(as_tuple=False).flatten()
+        n = apply_idx.numel()
+        if n == 0:
+            return {"apply_to_channel": apply_idx,
+                    "retain_stats": None,
+                    "invert_image": None,
+                    "gamma": None}
+
+        retain_stats = (torch.rand(n, device=device) < self.p_retain_stats)
+        invert_image = (torch.rand(n, device=device) < self.p_invert_image)
+
+        if self.synchronize_channels:
+            g = float(sample_scalar(self.gamma, image=img, channel=None))
+            gamma = torch.full((n,), g, device=device, dtype=dtype)
+        else:
+            # sample_scalar is scalar-based; keep loop but avoid tensor scalar iteration
+            gs = [float(sample_scalar(self.gamma, image=img, channel=int(ch))) for ch in apply_idx.tolist()]
+            gamma = torch.as_tensor(gs, device=device, dtype=dtype)
+
+        return {
+            "apply_to_channel": apply_idx,
+            "retain_stats": retain_stats,
+            "invert_image": invert_image,
+            "gamma": gamma,
+        }
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        idx: torch.Tensor = params["apply_to_channel"]
+        if idx.numel() == 0:
+            return img
+
+        retain_stats: torch.Tensor = params["retain_stats"]
+        invert_image: torch.Tensor = params["invert_image"]
+        gamma: torch.Tensor = params["gamma"]
+
+        # constants
+        eps = 1e-7
+
+        # Loop over selected channels (good for small C)
+        for k in range(idx.numel()):
+            c = int(idx[k])
+            r = bool(retain_stats[k])
+            inv = bool(invert_image[k])
+            g = gamma[k]
+
+            x = img[c]
+
+            if inv:
+                x.mul_(-1)
+
+            if r:
+                mean = x.mean()
+                std = x.std()
+
+            minm = x.min()
+            maxm = x.max()
+            rnge = maxm - minm
+            denom = torch.clamp(rnge, min=eps)
+
+            # In-place gamma: x = (((x - min) / denom) ** g) * rnge + min
+            x.sub_(minm)
+            x.div_(denom)
+            x.pow_(g)
+            x.mul_(rnge)
+            x.add_(minm)
+
+            if r:
+                mn_here = x.mean()
+                std_here = x.std()
+                x.sub_(mn_here)
+                x.mul_(std / torch.clamp(std_here, min=eps))
+                x.add_(mean)
+
+            if inv:
+                x.mul_(-1)
+
+        return img
+
+
+
+if __name__ == '__main__':
+    from time import time
+    import numpy as np
+    import os
+
+    os.environ['OMP_NUM_THREADS'] = '1'
+    torch.set_num_threads(1)
+
+    mbt = GammaTransform((0.7, 1.5), 0, False, 1, 1)
+
+    times_torch = []
+    for _ in range(100):
+        data_dict = {'image': torch.ones((2, 128, 192, 64))}
+        st = time()
+        out = mbt(**data_dict)
+        times_torch.append(time() - st)
+    print('torch', np.mean(times_torch))
+
+    from batchgenerators.transforms.color_transforms import GammaTransform as BGGamma
+
+    gnt_bg = BGGamma((0.7, 1.5), False, True, retain_stats=True, p_per_sample=1)
+    times_bg = []
+    for _ in range(100):
+        data_dict = {'data': np.ones((1, 2, 128, 192, 64))}
+        st = time()
+        out = gnt_bg(**data_dict)
+        times_bg.append(time() - st)
+    print('bg', np.mean(times_bg))

batchgeneratorsv2/transforms/intensity/gaussian_noise.py

@@ -0,0 +1,104 @@
+from typing import Tuple
+import torch
+
+from batchgeneratorsv2.helpers.scalar_type import RandomScalar, sample_scalar
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+
+
+class GaussianNoiseTransform(ImageOnlyTransform):
+    def __init__(self,
+                 noise_variance: RandomScalar = (0, 0.1),
+                 p_per_channel: float = 1.,
+                 synchronize_channels: bool = False):
+        super().__init__()
+        self.noise_variance = noise_variance
+        self.p_per_channel = p_per_channel
+        self.synchronize_channels = synchronize_channels
+
+    def get_parameters(self, **data_dict) -> dict:
+        img = data_dict["image"]
+        c = img.shape[0]
+
+        # bool mask on same device as image
+        apply = torch.rand(c, device=img.device) < self.p_per_channel
+
+        # store also count / indices to avoid recomputing later
+        idx = apply.nonzero(as_tuple=False).flatten()
+        n = idx.numel()
+
+        if n == 0:
+            sigmas = None
+        elif self.synchronize_channels:
+            sigmas = sample_scalar(self.noise_variance, img)
+        else:
+            # still uses sample_scalar, but avoids list->cat in _apply
+            # if sample_scalar is cheap, this is fine; otherwise see note below
+            sigmas = [sample_scalar(self.noise_variance, img) for _ in range(n)]
+
+        return {"apply_mask": apply, "apply_idx": idx, "num_apply": n, "sigmas": sigmas}
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        n = params["num_apply"]
+        if n == 0:
+            return img
+
+        idx = params["apply_idx"]
+        spatial = img.shape[1:]
+        device = img.device
+        dtype = img.dtype
+
+        sigmas = params["sigmas"]
+
+        if sigmas is None:
+            return img
+
+        # Create noise only for selected channels
+        if not self.synchronize_channels:
+            # vectorize per-channel sigma by creating a tensor of shape (n, 1, 1, ...)
+            # list->tensor is small (n floats), then broadcast
+            sigma_t = torch.as_tensor(sigmas, device=device, dtype=dtype)
+            view_shape = (n,) + (1,) * len(spatial)
+            sigma_t = sigma_t.view(view_shape)
+
+            noise = torch.empty((n, *spatial), device=device, dtype=dtype).normal_()
+            noise.mul_(sigma_t)
+        else:
+            sigma = sigmas
+            noise = torch.empty((n, *spatial), device=device, dtype=dtype).normal_(mean=0.0, std=float(sigma))
+
+        # Advanced indexing (img[idx]) returns a copy, so use indexed assignment
+        # to make sure modifications are written back to img.
+        img[idx] += noise
+        return img
+    
+
+if __name__ == "__main__":
+    from time import time
+    import numpy as np
+
+    os.environ['OMP_NUM_THREADS'] = '1'
+    torch.set_num_threads(1)
+
+    gnt = GaussianNoiseTransform((0, 0.1), 1, False)
+
+    times = []
+    for _ in range(1000):
+        data_dict = {'image': torch.ones((2, 32, 32, 32))}
+        st = time()
+        out = gnt(**data_dict)
+        times.append(time() - st)
+    print('torch', np.mean(times))
+
+    from batchgenerators.transforms.noise_transforms import GaussianNoiseTransform
+
+    gnt_bg = GaussianNoiseTransform((0, 0.1), 1, 1, True)
+
+    times = []
+    for _ in range(1000):
+        data_dict = {'data': np.ones((1, 2, 32, 32, 32))}
+        st = time()
+        out = gnt_bg(**data_dict)
+        times.append(time() - st)
+
+    print('bg', np.mean(times))
+    # torch is 2.5x faster

batchgeneratorsv2/transforms/intensity/inversion.py

@@ -0,0 +1,51 @@
+import numpy as np
+import torch
+
+from batchgeneratorsv2.transforms.base.basic_transform import ImageOnlyTransform
+
+
+class InvertImageTransform(ImageOnlyTransform):
+    def __init__(self, p_invert_image: float, p_synchronize_channels: float = 1, p_per_channel: float = 1):
+        super().__init__()
+        self.p_invert_image = p_invert_image
+        self.p_synchronize_channels = p_synchronize_channels
+        self.p_per_channel = p_per_channel
+
+    def get_parameters(self, **data_dict) -> dict:
+        shape = data_dict['image'].shape
+        apply = np.random.uniform() < self.p_invert_image
+        if apply:
+            if np.random.uniform() < self.p_synchronize_channels:
+                apply_to_channel = torch.arange(0, shape[0])
+            else:
+                apply_to_channel = torch.where(torch.rand(shape[0]) < self.p_per_channel)[0]
+        else:
+            apply_to_channel = []
+        return {
+            'apply_to_channel': apply_to_channel,
+            'apply': apply,
+        }
+
+    def _apply_to_image(self, img: torch.Tensor, **params) -> torch.Tensor:
+        if not params['apply']:
+            return img
+        else:
+            for ch in params['apply_to_channel']:
+                mn = img[ch].mean()
+                img[ch] -= mn
+                img[ch] *= -1
+                img[ch] += mn
+        return img
+
+
+if __name__ == '__main__':
+    mbt = InvertImageTransform(0.5, 0.5, 0.5)
+    from batchviewer import view_batch
+
+    for _ in range(100):
+        data_dict = {'image': torch.ones((2, 20, 192, 64))}
+        data_dict['image'][0, :10] = -1
+        data_dict['image'][1, :5] = -1
+        ret = mbt(**data_dict)
+        print(ret['image'][0, 0, 0, 0], ret['image'][1, 0, 0, 0])
+    view_batch(mbt(**data_dict)['image'])

batchgeneratorsv2/transforms/intensity/random_clip.py

@@ -0,0 +1,101 @@
+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()
+
+            # Percentiles in torch to avoid numpy roundtrip
+            q = torch.tensor([perc[0] / 100.0, perc[1] / 100.0], device=img_c.device, dtype=torch.float32)
+            lower_val, upper_val = torch.quantile(img_c.float(), q)
+
+            img_c_clipped = img_c.clamp(min=lower_val.item(), max=upper_val.item())
+
+            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/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)