nrtk-albumentations 2.1.0__py3-none-any.whl

albumentations/augmentations/blur/transforms.py

@@ -0,0 +1,1633 @@
+"""Transform classes for applying various blur operations to images.
+
+This module contains transform classes that implement different blur effects including
+standard blur, motion blur, median blur, Gaussian blur, glass blur, advanced blur, defocus,
+and zoom blur. These transforms are designed to work within the albumentations pipeline
+and support parameters for controlling the intensity and properties of the blur effects.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, Literal, cast
+
+import numpy as np
+from pydantic import (
+    AfterValidator,
+    Field,
+    ValidationInfo,
+    field_validator,
+    model_validator,
+)
+from typing_extensions import Self
+
+from albumentations.augmentations.pixel import functional as fpixel
+from albumentations.core.pydantic import (
+    NonNegativeFloatRangeType,
+    OnePlusFloatRangeType,
+    OnePlusIntRangeType,
+    SymmetricRangeType,
+    check_range_bounds,
+    convert_to_0plus_range,
+    nondecreasing,
+    process_non_negative_range,
+)
+from albumentations.core.transforms_interface import (
+    BaseTransformInitSchema,
+    ImageOnlyTransform,
+)
+from albumentations.core.utils import to_tuple
+
+from . import functional as fblur
+
+__all__ = [
+    "AdvancedBlur",
+    "Blur",
+    "Defocus",
+    "GaussianBlur",
+    "GlassBlur",
+    "MedianBlur",
+    "MotionBlur",
+    "ZoomBlur",
+]
+
+
+HALF = 0.5
+TWO = 2
+
+
+class BlurInitSchema(BaseTransformInitSchema):
+    blur_limit: tuple[int, int] | int
+
+    @field_validator("blur_limit")
+    @classmethod
+    def process_blur(cls, value: tuple[int, int] | int, info: ValidationInfo) -> tuple[int, int]:
+        return fblur.process_blur_limit(value, info, min_value=3)
+
+
+class Blur(ImageOnlyTransform):
+    """Apply uniform box blur to the input image using a randomly sized square kernel.
+
+    This transform uses OpenCV's cv2.blur function, which performs a simple box filter blur.
+    The size of the blur kernel is randomly selected for each application, allowing for
+    varying degrees of blur intensity.
+
+    Args:
+        blur_limit (tuple[int, int] | int): Controls the range of the blur kernel size.
+            - If a single int is provided, the kernel size will be randomly chosen
+              between 3 and that value.
+            - If a tuple of two ints is provided, it defines the inclusive range
+              of possible kernel sizes.
+            The kernel size must be odd and greater than or equal to 3.
+            Larger kernel sizes produce stronger blur effects.
+            Default: (3, 7)
+
+        p (float): Probability of applying the transform. Default: 0.5
+
+    Notes:
+        - The blur kernel is always square (same width and height).
+        - Only odd kernel sizes are used to ensure the blur has a clear center pixel.
+        - Box blur is faster than Gaussian blur but may produce less natural results.
+        - This blur method averages all pixels under the kernel area, which can
+          reduce noise but also reduce image detail.
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize blur effects
+        >>> cv2.rectangle(image, (50, 50), (250, 250), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 60, (0, 255, 0), -1)  # Green circle
+        >>> cv2.line(image, (50, 150), (250, 150), (0, 0, 255), 5)  # Blue line
+        >>>
+        >>> # Example 1: Basic usage with default parameters
+        >>> transform = A.Compose([
+        ...     A.Blur(p=1.0)  # Always apply with default blur_limit=(3, 7)
+        ... ])
+        >>>
+        >>> result = transform(image=image)
+        >>> blurred_image = result["image"]
+        >>> # The image will have a random blur with kernel size between 3 and 7
+        >>>
+        >>> # Example 2: Using a fixed blur kernel size
+        >>> fixed_transform = A.Compose([
+        ...     A.Blur(blur_limit=5, p=1.0)  # Always use kernel size 5x5
+        ... ])
+        >>>
+        >>> fixed_result = fixed_transform(image=image)
+        >>> fixed_blurred_image = fixed_result["image"]
+        >>> # The image will have a consistent 5x5 kernel blur
+        >>>
+        >>> # Example 3: Using a custom range for blur kernel sizes
+        >>> strong_transform = A.Compose([
+        ...     A.Blur(blur_limit=(7, 13), p=1.0)  # Use larger kernel for stronger blur
+        ... ])
+        >>>
+        >>> strong_result = strong_transform(image=image)
+        >>> strong_blurred = strong_result["image"]
+        >>> # The image will have a stronger blur with kernel size between 7 and 13
+        >>>
+        >>> # Example 4: As part of a pipeline with other transforms
+        >>> pipeline = A.Compose([
+        ...     A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.7),
+        ...     A.Blur(blur_limit=(3, 5), p=0.5),  # 50% chance of applying blur
+        ...     A.HorizontalFlip(p=0.5)
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> transformed_image = pipeline_result["image"]
+        >>> # The image may or may not be blurred depending on the random probability
+
+    """
+
+    class InitSchema(BlurInitSchema):
+        pass
+
+    def __init__(
+        self,
+        blur_limit: tuple[int, int] | int = (3, 7),
+        p: float = 0.5,
+    ):
+        super().__init__(p=p)
+        self.blur_limit = cast("tuple[int, int]", blur_limit)
+
+    def apply(self, img: np.ndarray, kernel: int, **params: Any) -> np.ndarray:
+        """Apply blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            kernel (int): Size of the kernel for blur.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Blurred image.
+
+        """
+        return fblur.box_blur(img, kernel)
+
+    def get_params(self) -> dict[str, Any]:
+        """Get parameters for the transform.
+
+        Returns:
+            dict[str, Any]: Dictionary with parameters.
+
+        """
+        kernel = fblur.sample_odd_from_range(
+            self.py_random,
+            self.blur_limit[0],
+            self.blur_limit[1],
+        )
+        return {"kernel": kernel}
+
+
+class MotionBlur(Blur):
+    """Apply motion blur to the input image using a directional kernel.
+
+    This transform simulates motion blur effects that occur during image capture,
+    such as camera shake or object movement. It creates a directional blur using
+    a line-shaped kernel with controllable angle, direction, and position.
+
+    Args:
+        blur_limit (int | tuple[int, int]): Maximum kernel size for blurring.
+            Should be in range [3, inf).
+            - If int: kernel size will be randomly chosen from [3, blur_limit]
+            - If tuple: kernel size will be randomly chosen from [min, max]
+            Larger values create stronger blur effects.
+            Default: (3, 7)
+
+        angle_range (tuple[float, float]): Range of possible angles in degrees.
+            Controls the rotation of the motion blur line:
+            - 0°: Horizontal motion blur →
+            - 45°: Diagonal motion blur ↗
+            - 90°: Vertical motion blur ↑
+            - 135°: Diagonal motion blur ↖
+            Default: (0, 360)
+
+        direction_range (tuple[float, float]): Range for motion bias.
+            Controls how the blur extends from the center:
+            - -1.0: Blur extends only backward (←)
+            -  0.0: Blur extends equally in both directions (←→)
+            -  1.0: Blur extends only forward (→)
+            For example, with angle=0:
+            - direction=-1.0: ←•
+            - direction=0.0:  ←•→
+            - direction=1.0:   •→
+            Default: (-1.0, 1.0)
+
+        allow_shifted (bool): Allow random kernel position shifts.
+            - If True: Kernel can be randomly offset from center
+            - If False: Kernel will always be centered
+            Default: True
+
+        p (float): Probability of applying the transform. Default: 0.5
+
+    Examples of angle vs direction:
+        1. Horizontal motion (angle=0°):
+           - direction=0.0:   ←•→   (symmetric blur)
+           - direction=1.0:    •→   (forward blur)
+           - direction=-1.0:  ←•    (backward blur)
+
+        2. Vertical motion (angle=90°):
+           - direction=0.0:   ↑•↓   (symmetric blur)
+           - direction=1.0:    •↑   (upward blur)
+           - direction=-1.0:  ↓•    (downward blur)
+
+        3. Diagonal motion (angle=45°):
+           - direction=0.0:   ↙•↗   (symmetric blur)
+           - direction=1.0:    •↗   (forward diagonal blur)
+           - direction=-1.0:  ↙•    (backward diagonal blur)
+
+    Note:
+        - angle controls the orientation of the motion line
+        - direction controls the distribution of the blur along that line
+        - Together they can simulate various motion effects:
+          * Camera shake: Small angle range + direction near 0
+          * Object motion: Specific angle + direction=1.0
+          * Complex motion: Random angle + random direction
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize motion blur effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.putText(image, "Motion Blur", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        >>>
+        >>> # Example 1: Horizontal camera shake (symmetric)
+        >>> horizontal_shake = A.Compose([
+        ...     A.MotionBlur(
+        ...         blur_limit=(10, 12),     # Strong blur
+        ...         angle_range=(-5, 5),     # Near-horizontal motion (±5°)
+        ...         direction_range=(0, 0),  # Symmetric blur (equally in both directions)
+        ...         p=1.0                    # Always apply
+        ...     )
+        ... ])
+        >>>
+        >>> horizontal_result = horizontal_shake(image=image)
+        >>> horizontal_blur = horizontal_result["image"]
+        >>> # The image will have a horizontal camera shake effect, blurring equally in both directions
+        >>>
+        >>> # Example 2: Object moving right (directional motion)
+        >>> rightward_motion = A.Compose([
+        ...     A.MotionBlur(
+        ...         blur_limit=(7, 9),         # Medium blur
+        ...         angle_range=(0, 0),        # Exactly horizontal motion (0°)
+        ...         direction_range=(0.8, 1.0), # Strong forward bias (mostly rightward)
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> rightward_result = rightward_motion(image=image)
+        >>> rightward_blur = rightward_result["image"]
+        >>> # The image will simulate an object moving rightward, with blur mostly to the right
+        >>>
+        >>> # Example 3: Object moving diagonally down-right
+        >>> diagonal_motion = A.Compose([
+        ...     A.MotionBlur(
+        ...         blur_limit=(9, 11),       # Stronger blur
+        ...         angle_range=(135, 135),   # 135° motion (down-right diagonal)
+        ...         direction_range=(0.7, 0.9), # Forward bias
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> diagonal_result = diagonal_motion(image=image)
+        >>> diagonal_blur = diagonal_result["image"]
+        >>> # The image will simulate diagonal motion down and to the right
+        >>>
+        >>> # Example 4: Vertical motion (up-down)
+        >>> vertical_motion = A.Compose([
+        ...     A.MotionBlur(
+        ...         blur_limit=9,             # Fixed kernel size
+        ...         angle_range=(90, 90),     # Vertical motion (90°)
+        ...         direction_range=(-0.2, 0.2), # Near-symmetric (slight bias)
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> vertical_result = vertical_motion(image=image)
+        >>> vertical_blur = vertical_result["image"]
+        >>> # The image will simulate vertical motion blur
+        >>>
+        >>> # Example 5: Random motion blur (can be in any direction)
+        >>> random_motion = A.Compose([
+        ...     A.MotionBlur(
+        ...         blur_limit=(5, 12),       # Variable strength
+        ...         angle_range=(0, 360),     # Any angle
+        ...         direction_range=(-1.0, 1.0), # Any direction bias
+        ...         allow_shifted=True,       # Allow kernel to be shifted from center
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> random_result = random_motion(image=image)
+        >>> random_blur = random_result["image"]
+        >>> # The image will have a random motion blur in any direction
+        >>>
+        >>> # Example 6: Multiple random parameters with kernel centered (not shifted)
+        >>> centered_motion = A.Compose([
+        ...     A.MotionBlur(
+        ...         blur_limit=(5, 9),
+        ...         angle_range=(0, 360),
+        ...         direction_range=(-1.0, 1.0),
+        ...         allow_shifted=False,      # Kernel will always be centered
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> centered_result = centered_motion(image=image)
+        >>> centered_blur = centered_result["image"]
+        >>> # The image will have motion blur with the kernel centered (not shifted)
+        >>>
+        >>> # Example 7: In a composition with other transforms
+        >>> pipeline = A.Compose([
+        ...     A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.5),
+        ...     A.MotionBlur(                                   # 30% chance of applying motion blur
+        ...         blur_limit=(3, 7),
+        ...         angle_range=(0, 180),                       # Only horizontal to vertical
+        ...         direction_range=(-0.5, 0.5),                # Moderate direction bias
+        ...         p=0.3
+        ...     ),
+        ...     A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=15, val_shift_limit=10, p=0.3)
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> transformed_image = pipeline_result["image"]
+        >>> # The image may have motion blur applied with 30% probability along with other effects
+
+    References:
+        - Motion blur fundamentals:
+          https://en.wikipedia.org/wiki/Motion_blur
+
+        - Directional blur kernels:
+          https://www.sciencedirect.com/topics/computer-science/directional-blur
+
+        - OpenCV filter2D (used for convolution):
+          https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga27c049795ce870216ddfb366086b5a04
+
+        - Research on motion blur simulation:
+          "Understanding and Evaluating Blind Deconvolution Algorithms" (CVPR 2009)
+          https://doi.org/10.1109/CVPR.2009.5206815
+
+        - Motion blur in photography:
+          "The Manual of Photography", Chapter 7: Motion in Photography
+          ISBN: 978-0240520377
+
+        - Kornia's implementation (similar approach):
+          https://kornia.readthedocs.io/en/latest/augmentation.html#kornia.augmentation.RandomMotionBlur
+
+    See Also:
+        - GaussianBlur: For uniform blur effects
+        - MedianBlur: For noise reduction while preserving edges
+        - RandomRain: Another motion-based effect
+        - Perspective: For geometric motion-like distortions
+
+    """
+
+    class InitSchema(BlurInitSchema):
+        allow_shifted: bool
+        angle_range: Annotated[
+            tuple[float, float],
+            AfterValidator(nondecreasing),
+            AfterValidator(check_range_bounds(0, 360)),
+        ]
+        direction_range: Annotated[
+            tuple[float, float],
+            AfterValidator(nondecreasing),
+            AfterValidator(check_range_bounds(min_val=-1.0, max_val=1.0)),
+        ]
+
+    def __init__(
+        self,
+        blur_limit: tuple[int, int] | int = (3, 7),
+        allow_shifted: bool = True,
+        angle_range: tuple[float, float] = (0, 360),
+        direction_range: tuple[float, float] = (-1.0, 1.0),
+        p: float = 0.5,
+    ):
+        super().__init__(blur_limit=blur_limit, p=p)
+        self.allow_shifted = allow_shifted
+        self.blur_limit = cast("tuple[int, int]", blur_limit)
+        self.angle_range = angle_range
+        self.direction_range = direction_range
+
+    def apply(self, img: np.ndarray, kernel: np.ndarray, **params: Any) -> np.ndarray:
+        """Apply motion blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            kernel (np.ndarray): Kernel for motion blur.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Motion blurred image.
+
+        """
+        return fpixel.convolve(img, kernel=kernel)
+
+    def get_params(self) -> dict[str, Any]:
+        """Get parameters for the transform.
+
+        Returns:
+            dict[str, Any]: Dictionary with parameters.
+
+        """
+        ksize = fblur.sample_odd_from_range(
+            self.py_random,
+            self.blur_limit[0],
+            self.blur_limit[1],
+        )
+
+        angle = self.py_random.uniform(*self.angle_range)
+        direction = self.py_random.uniform(*self.direction_range)
+
+        # Create motion blur kernel
+        kernel = fblur.create_motion_kernel(
+            ksize,
+            angle,
+            direction,
+            allow_shifted=self.allow_shifted,
+            random_state=self.py_random,
+        )
+
+        return {"kernel": kernel.astype(np.float32) / np.sum(kernel)}
+
+
+class MedianBlur(Blur):
+    """Apply median blur to the input image.
+
+    This transform uses a median filter to blur the input image. Median filtering is particularly
+    effective at removing salt-and-pepper noise while preserving edges, making it a popular choice
+    for noise reduction in image processing.
+
+    Args:
+        blur_limit (int | tuple[int, int]): Maximum aperture linear size for blurring the input image.
+            Must be odd and in the range [3, inf).
+            - If a single int is provided, the kernel size will be randomly chosen
+              between 3 and that value.
+            - If a tuple of two ints is provided, it defines the inclusive range
+              of possible kernel sizes.
+            Default: (3, 7)
+
+        p (float): Probability of applying the transform. Default: 0.5
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    Number of channels:
+        Any
+
+    Note:
+        - The kernel size (aperture linear size) must always be odd and greater than 1.
+        - Unlike mean blur or Gaussian blur, median blur uses the median of all pixels under
+          the kernel area, making it more robust to outliers.
+        - This transform is particularly useful for:
+          * Removing salt-and-pepper noise
+          * Preserving edges while smoothing images
+          * Pre-processing images for edge detection algorithms
+        - For color images, the median is calculated independently for each channel.
+        - Larger kernel sizes result in stronger blurring effects but may also remove
+          fine details from the image.
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize blur effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.putText(image, "Sample Text", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        >>>
+        >>> # Add salt and pepper noise to demonstrate median blur's noise removal capability
+        >>> noise = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> noise_points = np.random.random((300, 300)) > 0.95  # 5% of pixels as noise
+        >>> image[noise_points] = 255  # White noise (salt)
+        >>> noise_points = np.random.random((300, 300)) > 0.95  # Another 5% of pixels
+        >>> image[noise_points] = 0    # Black noise (pepper)
+        >>>
+        >>> # Example 1: Minimal median blur (3x3 kernel)
+        >>> minimal_blur = A.Compose([
+        ...     A.MedianBlur(
+        ...         blur_limit=3,  # Fixed 3x3 kernel
+        ...         p=1.0          # Always apply
+        ...     )
+        ... ])
+        >>>
+        >>> minimal_result = minimal_blur(image=image)
+        >>> minimal_blurred = minimal_result["image"]
+        >>> # The image will have minimal median blur, removing most salt and pepper noise
+        >>> # while preserving edges and details
+        >>>
+        >>> # Example 2: Medium median blur
+        >>> medium_blur = A.Compose([
+        ...     A.MedianBlur(
+        ...         blur_limit=5,  # Fixed 5x5 kernel
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> medium_result = medium_blur(image=image)
+        >>> medium_blurred = medium_result["image"]
+        >>> # The image will have a medium median blur, removing noise and small details
+        >>> # while still preserving major edges
+        >>>
+        >>> # Example 3: Strong median blur
+        >>> strong_blur = A.Compose([
+        ...     A.MedianBlur(
+        ...         blur_limit=9,  # Fixed 9x9 kernel
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> strong_result = strong_blur(image=image)
+        >>> strong_blurred = strong_result["image"]
+        >>> # The image will have a strong median blur, potentially removing smaller
+        >>> # features while still preserving major edges better than other blur types
+        >>>
+        >>> # Example 4: Random kernel size range
+        >>> random_kernel = A.Compose([
+        ...     A.MedianBlur(
+        ...         blur_limit=(3, 9),  # Kernel size between 3x3 and 9x9
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> random_result = random_kernel(image=image)
+        >>> random_blurred = random_result["image"]
+        >>> # The image will have a random median blur strength
+        >>>
+        >>> # Example 5: In a pipeline for noise reduction
+        >>> pipeline = A.Compose([
+        ...     A.GaussNoise(var_limit=(10, 50), p=0.5),        # Possibly add some noise
+        ...     A.MedianBlur(blur_limit=(3, 5), p=0.7),         # 70% chance of applying median blur
+        ...     A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.3)
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> processed_image = pipeline_result["image"]
+        >>> # The image may have been denoised with the median blur (70% probability)
+
+    References:
+        - Median filter: https://en.wikipedia.org/wiki/Median_filter
+        - OpenCV medianBlur: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga564869aa33e58769b4469101aac458f9
+
+    """
+
+    def __init__(
+        self,
+        blur_limit: tuple[int, int] | int = (3, 7),
+        p: float = 0.5,
+    ):
+        super().__init__(blur_limit=blur_limit, p=p)
+
+    def apply(self, img: np.ndarray, kernel: int, **params: Any) -> np.ndarray:
+        """Apply median blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            kernel (int): Size of the kernel for blur.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Median blurred image.
+
+        """
+        return fblur.median_blur(img, kernel)
+
+
+class GaussianBlur(ImageOnlyTransform):
+    """Apply Gaussian blur to the input image using a randomly sized kernel.
+
+    This transform blurs the input image using a Gaussian filter with a random kernel size
+    and sigma value. Gaussian blur is a widely used image processing technique that reduces
+    image noise and detail, creating a smoothing effect.
+
+    Args:
+        sigma_limit (tuple[float, float] | float): Range for the Gaussian kernel standard
+            deviation (sigma). Must be more or equal than 0.
+            - If a single float is provided, sigma will be randomly chosen
+              between 0 and that value.
+            - If a tuple of two floats is provided, it defines the inclusive range
+              of possible sigma values.
+            Default: (0.5, 3.0)
+
+        blur_limit (tuple[int, int] | int): Controls the range of the Gaussian kernel size.
+            - If a single int is provided, the kernel size will be randomly chosen
+              between 0 and that value.
+            - If a tuple of two ints is provided, it defines the inclusive range
+              of possible kernel sizes.
+            Must be zero or odd and in range [0, inf). If set to 0 (default), the kernel size
+            will be computed from sigma as `int(sigma * 3.5) * 2 + 1` to exactly match PIL's
+            implementation.
+            Default: 0
+
+        p (float): Probability of applying the transform. Default: 0.5
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    Number of channels:
+        Any
+
+    Note:
+        - When blur_limit=0 (default), this implementation exactly matches PIL's
+          GaussianBlur behavior:
+          * Kernel size is computed as int(sigma * 3.5) * 2 + 1
+          * Gaussian values are computed using the standard formula
+          * Kernel is normalized to preserve image luminance
+        - When blur_limit is specified, the kernel size is randomly sampled from that range
+          regardless of sigma, which might result in inconsistent blur effects.
+        - The default sigma range (0.5, 3.0) provides a good balance between subtle
+          and strong blur effects:
+          * sigma=0.5 results in a subtle blur
+          * sigma=3.0 results in a stronger blur
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize blur effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.putText(image, "Sample Text", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        >>>
+        >>> # Example 1: Default Gaussian blur (automatic kernel size)
+        >>> default_blur = A.Compose([
+        ...     A.GaussianBlur(p=1.0)  # Using default parameters
+        ... ])
+        >>>
+        >>> default_result = default_blur(image=image)
+        >>> default_blurred = default_result["image"]
+        >>> # The image will have a medium Gaussian blur with sigma between 0.5 and 3.0
+        >>>
+        >>> # Example 2: Light Gaussian blur
+        >>> light_blur = A.Compose([
+        ...     A.GaussianBlur(
+        ...         sigma_limit=(0.2, 0.5),  # Small sigma for subtle blur
+        ...         blur_limit=0,            # Auto-compute kernel size
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> light_result = light_blur(image=image)
+        >>> light_blurred = light_result["image"]
+        >>> # The image will have a subtle Gaussian blur effect
+        >>>
+        >>> # Example 3: Strong Gaussian blur
+        >>> strong_blur = A.Compose([
+        ...     A.GaussianBlur(
+        ...         sigma_limit=(3.0, 7.0),  # Larger sigma for stronger blur
+        ...         blur_limit=0,            # Auto-compute kernel size
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> strong_result = strong_blur(image=image)
+        >>> strong_blurred = strong_result["image"]
+        >>> # The image will have a strong Gaussian blur effect
+        >>>
+        >>> # Example 4: Fixed kernel size
+        >>> fixed_kernel = A.Compose([
+        ...     A.GaussianBlur(
+        ...         sigma_limit=(0.5, 2.0),
+        ...         blur_limit=(9, 9),       # Fixed 9x9 kernel size
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> fixed_result = fixed_kernel(image=image)
+        >>> fixed_kernel_blur = fixed_result["image"]
+        >>> # The image will have Gaussian blur with a fixed 9x9 kernel
+        >>>
+        >>> # Example 5: Random kernel size range
+        >>> random_kernel = A.Compose([
+        ...     A.GaussianBlur(
+        ...         sigma_limit=(1.0, 2.0),
+        ...         blur_limit=(5, 9),       # Kernel size between 5x5 and 9x9
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> random_result = random_kernel(image=image)
+        >>> random_kernel_blur = random_result["image"]
+        >>> # The image will have Gaussian blur with a kernel size between 5x5 and 9x9
+        >>>
+        >>> # Example 6: In an augmentation pipeline
+        >>> pipeline = A.Compose([
+        ...     A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),
+        ...     A.GaussianBlur(sigma_limit=(0.5, 1.5), p=0.3),  # 30% chance of applying
+        ...     A.RGBShift(r_shift_limit=10, g_shift_limit=10, b_shift_limit=10, p=0.3)
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> transformed_image = pipeline_result["image"]
+        >>> # The image may have Gaussian blur applied with 30% probability along with other effects
+
+    References:
+        - OpenCV Gaussian Blur: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaabe8c836e97159a9193fb0b11ac52cf1
+        - PIL GaussianBlur: https://pillow.readthedocs.io/en/stable/reference/ImageFilter.html#PIL.ImageFilter.GaussianBlur
+
+    """
+
+    class InitSchema(BaseTransformInitSchema):
+        sigma_limit: Annotated[
+            tuple[float, float] | float,
+            AfterValidator(process_non_negative_range),
+            AfterValidator(nondecreasing),
+        ]
+        blur_limit: Annotated[
+            tuple[int, int] | int,
+            AfterValidator(convert_to_0plus_range),
+            AfterValidator(nondecreasing),
+        ]
+
+    def __init__(
+        self,
+        blur_limit: tuple[int, int] | int = 0,
+        sigma_limit: tuple[float, float] | float = (0.5, 3.0),
+        p: float = 0.5,
+    ):
+        super().__init__(p=p)
+        self.blur_limit = cast("tuple[int, int]", blur_limit)
+        self.sigma_limit = cast("tuple[float, float]", sigma_limit)
+
+    def apply(
+        self,
+        img: np.ndarray,
+        kernel: np.ndarray,
+        **params: Any,
+    ) -> np.ndarray:
+        """Apply Gaussian blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            kernel (np.ndarray): Kernel for Gaussian blur.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Gaussian blurred image.
+
+        """
+        return fpixel.separable_convolve(img, kernel=kernel)
+
+    def get_params_dependent_on_data(self, params: dict[str, Any], data: dict[str, Any]) -> dict[str, float]:
+        """Get parameters that depend on input data.
+
+        Args:
+            params (dict[str, Any]): Parameters.
+            data (dict[str, Any]): Input data.
+
+        Returns:
+            dict[str, float]: Dictionary with parameters.
+
+        """
+        sigma = self.py_random.uniform(*self.sigma_limit)
+        ksize = self.py_random.randint(*self.blur_limit)
+        return {"kernel": fblur.create_gaussian_kernel_1d(sigma, ksize)}
+
+
+class GlassBlur(ImageOnlyTransform):
+    """Apply a glass blur effect to the input image.
+
+    This transform simulates the effect of looking through textured glass by locally
+    shuffling pixels in the image. It creates a distorted, frosted glass-like appearance.
+
+    Args:
+        sigma (float): Standard deviation for the Gaussian kernel used in the process.
+            Higher values increase the blur effect. Must be non-negative.
+            Default: 0.7
+
+        max_delta (int): Maximum distance in pixels for shuffling.
+            Determines how far pixels can be moved. Larger values create more distortion.
+            Must be a positive integer.
+            Default: 4
+
+        iterations (int): Number of times to apply the glass blur effect.
+            More iterations create a stronger effect but increase computation time.
+            Must be a positive integer.
+            Default: 2
+
+        mode (Literal["fast", "exact"]): Mode of computation. Options are:
+            - "fast": Uses a faster but potentially less accurate method.
+            - "exact": Uses a slower but more precise method.
+            Default: "fast"
+
+        p (float): Probability of applying the transform. Should be in the range [0, 1].
+            Default: 0.5
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    Number of channels:
+        Any
+
+    Note:
+        - This transform is particularly effective for creating a 'looking through
+          glass' effect or simulating the view through a frosted window.
+        - The 'fast' mode is recommended for most use cases as it provides a good
+          balance between effect quality and computation speed.
+        - Increasing 'iterations' will strengthen the effect but also increase the
+          processing time linearly.
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize glass blur effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.putText(image, "Text Sample", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        >>>
+        >>> # Example 1: Subtle glass effect (light frosting)
+        >>> subtle_transform = A.Compose([
+        ...     A.GlassBlur(
+        ...         sigma=0.4,           # Lower sigma for gentler blur
+        ...         max_delta=2,         # Small displacement
+        ...         iterations=1,        # Single iteration
+        ...         mode="fast",
+        ...         p=1.0                # Always apply
+        ...     )
+        ... ])
+        >>>
+        >>> subtle_result = subtle_transform(image=image)
+        >>> subtle_glass = subtle_result["image"]
+        >>> # The image will have a subtle glass-like distortion, like light frosting
+        >>>
+        >>> # Example 2: Medium glass effect (typical frosted glass)
+        >>> medium_transform = A.Compose([
+        ...     A.GlassBlur(
+        ...         sigma=0.7,           # Default sigma
+        ...         max_delta=4,         # Default displacement
+        ...         iterations=2,        # Default iterations
+        ...         mode="fast",
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> medium_result = medium_transform(image=image)
+        >>> medium_glass = medium_result["image"]
+        >>> # The image will have a moderate glass-like effect, similar to standard frosted glass
+        >>>
+        >>> # Example 3: Strong glass effect (heavy distortion)
+        >>> strong_transform = A.Compose([
+        ...     A.GlassBlur(
+        ...         sigma=1.0,           # Higher sigma for stronger blur
+        ...         max_delta=6,         # Larger displacement
+        ...         iterations=3,        # More iterations
+        ...         mode="fast",
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> strong_result = strong_transform(image=image)
+        >>> strong_glass = strong_result["image"]
+        >>> # The image will have a strong glass-like distortion, heavily obscuring details
+        >>>
+        >>> # Example 4: Using exact mode for higher quality
+        >>> exact_transform = A.Compose([
+        ...     A.GlassBlur(
+        ...         sigma=0.7,
+        ...         max_delta=4,
+        ...         iterations=2,
+        ...         mode="exact",        # More precise but slower
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> exact_result = exact_transform(image=image)
+        >>> exact_glass = exact_result["image"]
+        >>> # The image will have a similar effect to medium, but with potentially better quality
+        >>>
+        >>> # Example 5: In a pipeline with other transforms
+        >>> pipeline = A.Compose([
+        ...     A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.7),
+        ...     A.GlassBlur(sigma=0.7, max_delta=4, iterations=2, p=0.5),  # 50% chance of applying
+        ...     A.HueSaturationValue(hue_shift_limit=10, sat_shift_limit=15, val_shift_limit=10, p=0.3)
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> transformed_image = pipeline_result["image"]
+        >>> # The image may have glass blur applied with 50% probability along with other effects
+
+    References:
+        - This implementation is based on the technique described in:
+          "ImageNet-trained CNNs are biased towards texture; increasing shape bias improves accuracy and robustness"
+          https://arxiv.org/abs/1903.12261
+        - Original implementation:
+          https://github.com/hendrycks/robustness/blob/master/ImageNet-C/create_c/make_imagenet_c.py
+
+    """
+
+    class InitSchema(BaseTransformInitSchema):
+        sigma: float = Field(ge=0)
+        max_delta: int = Field(ge=1)
+        iterations: int = Field(ge=1)
+        mode: Literal["fast", "exact"]
+
+    def __init__(
+        self,
+        sigma: float = 0.7,
+        max_delta: int = 4,
+        iterations: int = 2,
+        mode: Literal["fast", "exact"] = "fast",
+        p: float = 0.5,
+    ):
+        super().__init__(p=p)
+        self.sigma = sigma
+        self.max_delta = max_delta
+        self.iterations = iterations
+        self.mode = mode
+
+    def apply(
+        self,
+        img: np.ndarray,
+        *args: Any,
+        dxy: np.ndarray,
+        **params: Any,
+    ) -> np.ndarray:
+        """Apply glass blur effect to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            *args (Any): Additional positional arguments.
+            dxy (np.ndarray): Displacement map.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Image with glass blur effect.
+
+        """
+        return fblur.glass_blur(
+            img,
+            self.sigma,
+            self.max_delta,
+            self.iterations,
+            dxy,
+            self.mode,
+        )
+
+    def get_params_dependent_on_data(
+        self,
+        params: dict[str, Any],
+        data: dict[str, Any],
+    ) -> dict[str, np.ndarray]:
+        """Get parameters that depend on input data.
+
+        Args:
+            params (dict[str, Any]): Parameters.
+            data (dict[str, Any]): Input data.
+
+        Returns:
+            dict[str, np.ndarray]: Dictionary with parameters.
+
+        """
+        height, width = params["shape"][:2]
+        # generate array containing all necessary values for transformations
+        width_pixels = height - self.max_delta * 2
+        height_pixels = width - self.max_delta * 2
+        total_pixels = int(width_pixels * height_pixels)
+        dxy = self.random_generator.integers(
+            -self.max_delta,
+            self.max_delta,
+            size=(total_pixels, self.iterations, 2),
+        )
+
+        return {"dxy": dxy}
+
+
+class AdvancedBlur(ImageOnlyTransform):
+    """Applies a Generalized Gaussian blur to the input image with randomized parameters for advanced data augmentation.
+
+    This transform creates a custom blur kernel based on the Generalized Gaussian distribution,
+    which allows for a wide range of blur effects beyond standard Gaussian blur. It then applies
+    this kernel to the input image through convolution. The transform also incorporates noise
+    into the kernel, resulting in a unique combination of blurring and noise injection.
+
+    Key features of this augmentation:
+
+    1. Generalized Gaussian Kernel: Uses a generalized normal distribution to create kernels
+       that can range from box-like blurs to very peaked blurs, controlled by the beta parameter.
+
+    2. Anisotropic Blurring: Allows for different blur strengths in horizontal and vertical
+       directions (controlled by sigma_x and sigma_y), and rotation of the kernel.
+
+    3. Kernel Noise: Adds multiplicative noise to the kernel before applying it to the image,
+       creating more diverse and realistic blur effects.
+
+    Implementation Details:
+        The kernel is generated using a 2D Generalized Gaussian function. The process involves:
+        1. Creating a 2D grid based on the kernel size
+        2. Applying rotation to this grid
+        3. Calculating the kernel values using the Generalized Gaussian formula
+        4. Adding multiplicative noise to the kernel
+        5. Normalizing the kernel
+
+        The resulting kernel is then applied to the image using convolution.
+
+    Args:
+        blur_limit (tuple[int, int] | int, optional): Controls the size of the blur kernel. If a single int
+            is provided, the kernel size will be randomly chosen between 3 and that value.
+            Must be odd and ≥ 3. Larger values create stronger blur effects.
+            Default: (3, 7)
+
+        sigma_x_limit (tuple[float, float] | float): Controls the spread of the blur in the x direction.
+            Higher values increase blur strength.
+            If a single float is provided, the range will be (0, limit).
+            Default: (0.2, 1.0)
+
+        sigma_y_limit (tuple[float, float] | float): Controls the spread of the blur in the y direction.
+            Higher values increase blur strength.
+            If a single float is provided, the range will be (0, limit).
+            Default: (0.2, 1.0)
+
+        rotate_limit (tuple[int, int] | int): Range of angles (in degrees) for rotating the kernel.
+            This rotation allows for diagonal blur directions. If limit is a single int, an angle is picked
+            from (-rotate_limit, rotate_limit).
+            Default: (-90, 90)
+
+        beta_limit (tuple[float, float] | float): Shape parameter of the Generalized Gaussian distribution.
+            - beta = 1 gives a standard Gaussian distribution
+            - beta < 1 creates heavier tails, resulting in more uniform, box-like blur
+            - beta > 1 creates lighter tails, resulting in more peaked, focused blur
+            Default: (0.5, 8.0)
+
+        noise_limit (tuple[float, float] | float): Controls the strength of multiplicative noise
+            applied to the kernel. Values around 1.0 keep the original kernel mostly intact,
+            while values further from 1.0 introduce more variation.
+            Default: (0.75, 1.25)
+
+        p (float): Probability of applying the transform. Default: 0.5
+
+    Notes:
+        - This transform is particularly useful for simulating complex, real-world blur effects
+          that go beyond simple Gaussian blur.
+        - The combination of blur and noise can help in creating more robust models by simulating
+          a wider range of image degradations.
+        - Extreme values, especially for beta and noise, may result in unrealistic effects and
+          should be used cautiously.
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize blur effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.putText(image, "Text Example", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        >>> cv2.line(image, (50, 250), (250, 250), (0, 0, 255), 3)  # Blue line
+        >>>
+        >>> # Example 1: Gaussian-like blur (beta = 1)
+        >>> gaussian_like = A.Compose([
+        ...     A.AdvancedBlur(
+        ...         blur_limit=5,
+        ...         sigma_x_limit=(0.5, 0.5),
+        ...         sigma_y_limit=(0.5, 0.5),
+        ...         rotate_limit=0,
+        ...         beta_limit=(1.0, 1.0),  # Standard Gaussian (beta = 1)
+        ...         noise_limit=(1.0, 1.0),  # No noise
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> gaussian_result = gaussian_like(image=image)
+        >>> gaussian_image = gaussian_result["image"]
+        >>> # The image will have a standard Gaussian blur applied
+        >>>
+        >>> # Example 2: Box-like blur (beta < 1)
+        >>> box_like = A.Compose([
+        ...     A.AdvancedBlur(
+        ...         blur_limit=(7, 9),
+        ...         sigma_x_limit=(0.6, 0.8),
+        ...         sigma_y_limit=(0.6, 0.8),
+        ...         rotate_limit=0,
+        ...         beta_limit=(0.5, 0.7),  # Box-like blur (beta < 1)
+        ...         noise_limit=(0.9, 1.1),  # Slight noise
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> box_result = box_like(image=image)
+        >>> box_image = box_result["image"]
+        >>> # The image will have a more box-like blur with heavier tails
+        >>>
+        >>> # Example 3: Peaked blur (beta > 1)
+        >>> peaked = A.Compose([
+        ...     A.AdvancedBlur(
+        ...         blur_limit=(7, 9),
+        ...         sigma_x_limit=(0.6, 0.8),
+        ...         sigma_y_limit=(0.6, 0.8),
+        ...         rotate_limit=0,
+        ...         beta_limit=(3.0, 6.0),  # Peaked blur (beta > 1)
+        ...         noise_limit=(0.9, 1.1),  # Slight noise
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> peaked_result = peaked(image=image)
+        >>> peaked_image = peaked_result["image"]
+        >>> # The image will have a more focused, peaked blur with lighter tails
+        >>>
+        >>> # Example 4: Anisotropic blur (directional)
+        >>> directional = A.Compose([
+        ...     A.AdvancedBlur(
+        ...         blur_limit=(9, 11),
+        ...         sigma_x_limit=(0.8, 1.0),    # Stronger x blur
+        ...         sigma_y_limit=(0.2, 0.3),    # Weaker y blur
+        ...         rotate_limit=(0, 0),         # No rotation
+        ...         beta_limit=(1.0, 2.0),
+        ...         noise_limit=(0.9, 1.1),
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> directional_result = directional(image=image)
+        >>> directional_image = directional_result["image"]
+        >>> # The image will have a horizontal directional blur
+        >>>
+        >>> # Example 5: Rotated directional blur
+        >>> rotated = A.Compose([
+        ...     A.AdvancedBlur(
+        ...         blur_limit=(9, 11),
+        ...         sigma_x_limit=(0.8, 1.0),    # Stronger x blur
+        ...         sigma_y_limit=(0.2, 0.3),    # Weaker y blur
+        ...         rotate_limit=(45, 45),       # 45 degree rotation
+        ...         beta_limit=(1.0, 2.0),
+        ...         noise_limit=(0.9, 1.1),
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> rotated_result = rotated(image=image)
+        >>> rotated_image = rotated_result["image"]
+        >>> # The image will have a diagonal directional blur
+        >>>
+        >>> # Example 6: Noisy blur
+        >>> noisy = A.Compose([
+        ...     A.AdvancedBlur(
+        ...         blur_limit=(5, 7),
+        ...         sigma_x_limit=(0.4, 0.6),
+        ...         sigma_y_limit=(0.4, 0.6),
+        ...         rotate_limit=(-30, 30),
+        ...         beta_limit=(0.8, 1.2),
+        ...         noise_limit=(0.7, 1.3),      # Strong noise variation
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> noisy_result = noisy(image=image)
+        >>> noisy_image = noisy_result["image"]
+        >>> # The image will have blur with significant noise in the kernel
+        >>>
+        >>> # Example 7: Random parameters (for general augmentation)
+        >>> random_blur = A.Compose([
+        ...     A.AdvancedBlur(p=0.5)  # Using default parameter ranges
+        ... ])
+        >>>
+        >>> random_result = random_blur(image=image)
+        >>> random_image = random_result["image"]
+        >>> # The image may have a random advanced blur applied with 50% probability
+
+    Reference:
+        This transform is inspired by techniques described in:
+        "Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data"
+        https://arxiv.org/abs/2107.10833
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    """
+
+    class InitSchema(BlurInitSchema):
+        sigma_x_limit: NonNegativeFloatRangeType
+        sigma_y_limit: NonNegativeFloatRangeType
+        beta_limit: NonNegativeFloatRangeType
+        noise_limit: NonNegativeFloatRangeType
+        rotate_limit: SymmetricRangeType
+
+        @field_validator("beta_limit")
+        @classmethod
+        def _check_beta_limit(cls, value: tuple[float, float] | float) -> tuple[float, float]:
+            result = to_tuple(value, low=0)
+            if not (result[0] < 1.0 < result[1]):
+                raise ValueError(
+                    f"Beta limit should include 1.0, got {result}",
+                )
+            return result
+
+        @model_validator(mode="after")
+        def _validate_limits(self) -> Self:
+            if (
+                isinstance(self.sigma_x_limit, (tuple, list))
+                and self.sigma_x_limit[0] == 0
+                and isinstance(self.sigma_y_limit, (tuple, list))
+                and self.sigma_y_limit[0] == 0
+            ):
+                msg = "sigma_x_limit and sigma_y_limit minimum value cannot be both equal to 0."
+                raise ValueError(msg)
+            return self
+
+    def __init__(
+        self,
+        blur_limit: tuple[int, int] | int = (3, 7),
+        sigma_x_limit: tuple[float, float] | float = (0.2, 1.0),
+        sigma_y_limit: tuple[float, float] | float = (0.2, 1.0),
+        rotate_limit: tuple[int, int] | int = (-90, 90),
+        beta_limit: tuple[float, float] | float = (0.5, 8.0),
+        noise_limit: tuple[float, float] | float = (0.9, 1.1),
+        p: float = 0.5,
+    ):
+        super().__init__(p=p)
+
+        self.blur_limit = cast("tuple[int, int]", blur_limit)
+        self.sigma_x_limit = cast("tuple[float, float]", sigma_x_limit)
+        self.sigma_y_limit = cast("tuple[float, float]", sigma_y_limit)
+        self.rotate_limit = cast("tuple[int, int]", rotate_limit)
+        self.beta_limit = cast("tuple[float, float]", beta_limit)
+        self.noise_limit = cast("tuple[float, float]", noise_limit)
+
+    def apply(self, img: np.ndarray, kernel: np.ndarray, **params: Any) -> np.ndarray:
+        """Apply advanced blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            kernel (np.ndarray): Kernel for blur.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Blurred image.
+
+        """
+        return fpixel.convolve(img, kernel=kernel)
+
+    def get_params(self) -> dict[str, np.ndarray]:
+        """Get parameters for the transform.
+
+        Returns:
+            dict[str, np.ndarray]: Dictionary with parameters.
+
+        """
+        ksize = fblur.sample_odd_from_range(
+            self.py_random,
+            self.blur_limit[0],
+            self.blur_limit[1],
+        )
+        sigma_x = self.py_random.uniform(*self.sigma_x_limit)
+        sigma_y = self.py_random.uniform(*self.sigma_y_limit)
+        angle = np.deg2rad(self.py_random.uniform(*self.rotate_limit))
+
+        # Split into 2 cases to avoid selection of narrow kernels (beta > 1) too often.
+        beta = (
+            self.py_random.uniform(self.beta_limit[0], 1)
+            if self.py_random.random() < HALF
+            else self.py_random.uniform(1, self.beta_limit[1])
+        )
+
+        noise_matrix = self.random_generator.uniform(
+            *self.noise_limit,
+            size=(ksize, ksize),
+        )
+
+        # Generate mesh grid centered at zero.
+        ax = np.arange(-ksize // 2 + 1.0, ksize // 2 + 1.0)
+        # > Shape (ksize, ksize, 2)
+        grid = np.stack(np.meshgrid(ax, ax), axis=-1)
+
+        # Calculate rotated sigma matrix
+        d_matrix = np.array([[sigma_x**2, 0], [0, sigma_y**2]])
+        u_matrix = np.array(
+            [[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]],
+        )
+        sigma_matrix = np.dot(u_matrix, np.dot(d_matrix, u_matrix.T))
+
+        inverse_sigma = np.linalg.inv(sigma_matrix)
+        # Described in "Parameter Estimation For Multivariate Generalized Gaussian Distributions"
+        kernel = np.exp(
+            -0.5 * np.power(np.sum(np.dot(grid, inverse_sigma) * grid, 2), beta),
+        )
+        # Add noise
+        kernel *= noise_matrix
+
+        # Normalize kernel
+        kernel = kernel.astype(np.float32) / np.sum(kernel)
+        return {"kernel": kernel}
+
+
+class Defocus(ImageOnlyTransform):
+    """Apply defocus blur to the input image.
+
+    This transform simulates the effect of an out-of-focus camera by applying a defocus blur
+    to the image. It uses a combination of disc kernels and Gaussian blur to create a realistic
+    defocus effect.
+
+    Args:
+        radius (tuple[int, int] | int): Range for the radius of the defocus blur.
+            If a single int is provided, the range will be [1, radius].
+            Larger values create a stronger blur effect.
+            Default: (3, 10)
+
+        alias_blur (tuple[float, float] | float): Range for the standard deviation of the Gaussian blur
+            applied after the main defocus blur. This helps to reduce aliasing artifacts.
+            If a single float is provided, the range will be (0, alias_blur).
+            Larger values create a smoother, more aliased effect.
+            Default: (0.1, 0.5)
+
+        p (float): Probability of applying the transform. Should be in the range [0, 1].
+            Default: 0.5
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    Note:
+        - The defocus effect is created using a disc kernel, which simulates the shape of a camera's aperture.
+        - The additional Gaussian blur (alias_blur) helps to soften the edges of the disc kernel, creating a
+          more natural-looking defocus effect.
+        - Larger radius values will create a stronger, more noticeable defocus effect.
+        - The alias_blur parameter can be used to fine-tune the appearance of the defocus, with larger values
+          creating a smoother, potentially more realistic effect.
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize defocus effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.putText(image, "Sharp Text", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
+        >>>
+        >>> # Example 1: Subtle defocus effect (small aperture)
+        >>> subtle_transform = A.Compose([
+        ...     A.Defocus(
+        ...         radius=(2, 3),           # Small defocus radius
+        ...         alias_blur=(0.1, 0.2),   # Minimal aliasing
+        ...         p=1.0                    # Always apply
+        ...     )
+        ... ])
+        >>>
+        >>> subtle_result = subtle_transform(image=image)
+        >>> subtle_defocus = subtle_result["image"]
+        >>> # The image will have a subtle defocus effect, with just slight blurring
+        >>>
+        >>> # Example 2: Moderate defocus effect (medium aperture)
+        >>> moderate_transform = A.Compose([
+        ...     A.Defocus(
+        ...         radius=(4, 6),           # Medium defocus radius
+        ...         alias_blur=(0.2, 0.3),   # Moderate aliasing
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> moderate_result = moderate_transform(image=image)
+        >>> moderate_defocus = moderate_result["image"]
+        >>> # The image will have a noticeable defocus effect, similar to a poorly focused camera
+        >>>
+        >>> # Example 3: Strong defocus effect (large aperture)
+        >>> strong_transform = A.Compose([
+        ...     A.Defocus(
+        ...         radius=(8, 12),          # Large defocus radius
+        ...         alias_blur=(0.4, 0.6),   # Strong aliasing
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> strong_result = strong_transform(image=image)
+        >>> strong_defocus = strong_result["image"]
+        >>> # The image will have a strong defocus effect, heavily blurring the details
+        >>>
+        >>> # Example 4: Using in a pipeline with other transforms
+        >>> pipeline = A.Compose([
+        ...     A.RandomBrightnessContrast(brightness_limit=0.1, contrast_limit=0.1, p=0.7),
+        ...     A.Defocus(radius=(3, 8), alias_blur=0.3, p=0.5),  # 50% chance of applying defocus
+        ...     A.GaussNoise(var_limit=(10, 30), p=0.3)           # Possible noise after defocus
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> transformed_image = pipeline_result["image"]
+        >>> # The image may have defocus blur applied with 50% probability
+
+    References:
+        Defocus aberration: https://en.wikipedia.org/wiki/Defocus_aberration
+
+    """
+
+    class InitSchema(BaseTransformInitSchema):
+        radius: OnePlusIntRangeType
+        alias_blur: NonNegativeFloatRangeType
+
+    def __init__(
+        self,
+        radius: tuple[int, int] | int = (3, 10),
+        alias_blur: tuple[float, float] | float = (0.1, 0.5),
+        p: float = 0.5,
+    ):
+        super().__init__(p=p)
+        self.radius = cast("tuple[int, int]", radius)
+        self.alias_blur = cast("tuple[float, float]", alias_blur)
+
+    def apply(
+        self,
+        img: np.ndarray,
+        radius: int,
+        alias_blur: float,
+        **params: Any,
+    ) -> np.ndarray:
+        """Apply defocus blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            radius (int): Radius of the defocus blur.
+            alias_blur (float): Standard deviation of the Gaussian blur.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Defocused image.
+
+        """
+        return fblur.defocus(img, radius, alias_blur)
+
+    def get_params(self) -> dict[str, Any]:
+        """Get parameters for the transform.
+
+        Returns:
+            dict[str, Any]: Dictionary with parameters.
+
+        """
+        return {
+            "radius": self.py_random.randint(*self.radius),
+            "alias_blur": self.py_random.uniform(*self.alias_blur),
+        }
+
+
+class ZoomBlur(ImageOnlyTransform):
+    """Apply zoom blur transform.
+
+    This transform simulates the effect of zooming during exposure, creating a dynamic radial blur.
+    It works by averaging multiple versions of the image at different zoom levels, creating
+    a smooth transition from the center outward.
+
+    Args:
+        max_factor ((float, float) or float): range for max factor for blurring.
+            If max_factor is a single float, the range will be (1, limit). Default: (1, 1.31).
+            All max_factor values should be larger than 1.
+        step_factor ((float, float) or float): If single float will be used as step parameter for np.arange.
+            If tuple of float step_factor will be in range `[step_factor[0], step_factor[1])`. Default: (0.01, 0.03).
+            All step_factor values should be positive.
+        p (float): probability of applying the transform. Default: 0.5.
+
+    Targets:
+        image
+
+    Image types:
+        uint8, float32
+
+    Examples:
+        >>> import numpy as np
+        >>> import albumentations as A
+        >>> import cv2
+        >>>
+        >>> # Create a sample image for demonstration
+        >>> image = np.zeros((300, 300, 3), dtype=np.uint8)
+        >>> # Add some shapes to visualize zoom blur effects
+        >>> cv2.rectangle(image, (100, 100), (200, 200), (255, 0, 0), -1)  # Red square
+        >>> cv2.circle(image, (150, 150), 30, (0, 255, 0), -1)  # Green circle
+        >>> cv2.line(image, (50, 150), (250, 150), (0, 0, 255), 5)  # Blue line
+        >>>
+        >>> # Example 1: Subtle zoom blur
+        >>> subtle_transform = A.Compose([
+        ...     A.ZoomBlur(
+        ...         max_factor=(1.05, 1.10),  # Small zoom range
+        ...         step_factor=0.01,         # Fine steps
+        ...         p=1.0                     # Always apply
+        ...     )
+        ... ])
+        >>>
+        >>> subtle_result = subtle_transform(image=image)
+        >>> subtle_blur = subtle_result["image"]
+        >>> # The image will have a subtle zoom blur effect, simulating a slight zoom during exposure
+        >>>
+        >>> # Example 2: Moderate zoom blur
+        >>> moderate_transform = A.Compose([
+        ...     A.ZoomBlur(
+        ...         max_factor=(1.15, 1.25),  # Medium zoom range
+        ...         step_factor=0.02,         # Medium steps
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> moderate_result = moderate_transform(image=image)
+        >>> moderate_blur = moderate_result["image"]
+        >>> # The image will have a more noticeable zoom blur effect
+        >>>
+        >>> # Example 3: Strong zoom blur
+        >>> strong_transform = A.Compose([
+        ...     A.ZoomBlur(
+        ...         max_factor=(1.3, 1.5),    # Large zoom range
+        ...         step_factor=(0.03, 0.05), # Larger steps (randomly chosen)
+        ...         p=1.0
+        ...     )
+        ... ])
+        >>>
+        >>> strong_result = strong_transform(image=image)
+        >>> strong_blur = strong_result["image"]
+        >>> # The image will have a strong zoom blur effect, simulating fast zooming
+        >>>
+        >>> # Example 4: In a pipeline with other transforms
+        >>> pipeline = A.Compose([
+        ...     A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.7),
+        ...     A.ZoomBlur(max_factor=(1.1, 1.3), step_factor=0.02, p=0.5),
+        ...     A.HorizontalFlip(p=0.5)
+        ... ])
+        >>>
+        >>> pipeline_result = pipeline(image=image)
+        >>> transformed_image = pipeline_result["image"]
+        >>> # The image may have zoom blur applied with 50% probability
+
+    Reference:
+        Zoom Blur: https://arxiv.org/abs/1903.12261
+
+    """
+
+    class InitSchema(BaseTransformInitSchema):
+        max_factor: OnePlusFloatRangeType
+        step_factor: NonNegativeFloatRangeType
+
+    def __init__(
+        self,
+        max_factor: tuple[float, float] | float = (1, 1.31),
+        step_factor: tuple[float, float] | float = (0.01, 0.03),
+        p: float = 0.5,
+    ):
+        super().__init__(p=p)
+        self.max_factor = cast("tuple[float, float]", max_factor)
+        self.step_factor = cast("tuple[float, float]", step_factor)
+
+    def apply(
+        self,
+        img: np.ndarray,
+        zoom_factors: np.ndarray,
+        **params: Any,
+    ) -> np.ndarray:
+        """Apply zoom blur to the input image.
+
+        Args:
+            img (np.ndarray): Image to blur.
+            zoom_factors (np.ndarray): Array of zoom factors.
+            **params (Any): Additional parameters.
+
+        Returns:
+            np.ndarray: Zoom blurred image.
+
+        """
+        return fblur.zoom_blur(img, zoom_factors)
+
+    def get_params(self) -> dict[str, Any]:
+        """Get parameters for the transform.
+
+        Returns:
+            dict[str, Any]: Dictionary with parameters.
+
+        """
+        step_factor = self.py_random.uniform(*self.step_factor)
+        max_factor = max(1 + step_factor, self.py_random.uniform(*self.max_factor))
+        return {"zoom_factors": np.arange(1.0, max_factor, step_factor)}