Your ad could be here - Reach CV/ML engineers

Interested in advertising?

Stay updated

News & Insights

functional transforms

API Documentation | Albumentations

albumentations.augmentations.blur.transforms

View Source on GitHub

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.

Members

classAdvancedBlur
classBlur
classBlurInitSchema
classDefocus
classGaussianBlur
classGlassBlur
classMedianBlur
classMotionBlur
classZoomBlur

AdvancedBlurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
blur_limit	One of: tuple[int, int] int	(3, 7)	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	One of: tuple[float, float] float	(0.2, 1.0)	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	One of: tuple[float, float] float	(0.2, 1.0)	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	One of: tuple[int, int] int	(-90, 90)	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	One of: tuple[float, float] float	(0.5, 8.0)	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	One of: tuple[float, float] float	(0.9, 1.1)	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	0.5	Probability of applying the transform. Default: 0.5

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

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.

Blurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
blur_limit	One of: tuple[int, int] int	(3, 7)	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	0.5	Probability of applying the transform. Default: 0.5

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

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.

BlurInitSchemaclass

Parameters

Name	Type	Default	Description
p	Annotated	-	-
strict	bool	-	-
blur_limit	One of: tuple[int, int] int	-	-

Defocusclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
radius	One of: tuple[int, int] int	(3, 10)	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	One of: tuple[float, float] float	(0.1, 0.5)	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	0.5	Probability of applying the transform. Should be in the range [0, 1]. Default: 0.5

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

Notes

- 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.

References

Defocus aberration: https://en.wikipedia.org/wiki/Defocus_aberration

GaussianBlurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
blur_limit	One of: tuple[int, int] int	0	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
sigma_limit	One of: tuple[float, float] float	(0.5, 3.0)	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)
p	float	0.5	Probability of applying the transform. Default: 0.5

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

Notes

- When blur_limit=0 (default), this implementation exactly matches PIL's

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

GlassBlurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
sigma	float	0.7	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	4	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	2	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	One of: 'fast' 'exact'	fast	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	0.5	Probability of applying the transform. Should be in the range [0, 1]. Default: 0.5

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

Notes

- 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.

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

MedianBlurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
blur_limit	One of: tuple[int, int] int	(3, 7)	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	0.5	Probability of applying the transform. Default: 0.5

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)

Notes

- 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.

References

Median filter: https://en.wikipedia.org/wiki/Median_filter
OpenCV medianBlur: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga564869aa33e58769b4469101aac458f9

MotionBlurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
blur_limit	One of: tuple[int, int] int	(3, 7)	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)
allow_shifted	bool	True	Allow random kernel position shifts. - If True: Kernel can be randomly offset from center - If False: Kernel will always be centered Default: True
angle_range	tuple[float, float]	(0, 360)	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]	(-1.0, 1.0)	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)
p	float	0.5	Probability of applying the transform. Default: 0.5

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

Notes

- 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

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

ZoomBlurclass

Try it on Explore

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.

Parameters

Name	Type	Default	Description
max_factor	One of: tuple[float, float] float	(1, 1.31)	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	One of: tuple[float, float] float	(0.01, 0.03)	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	0.5	probability of applying the transform. Default: 0.5.

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

albumentations.augmentations.blur.transforms

Members

AdvancedBlurclass

Parameters

Examples

Notes

Blurclass

Parameters

Examples

Notes

BlurInitSchemaclass

Parameters

Defocusclass

Parameters

Examples

Notes

References

GaussianBlurclass

Parameters

Examples

Notes

References

GlassBlurclass

Parameters

Examples

Notes

References

MedianBlurclass

Parameters

Examples

Notes

References

MotionBlurclass

Parameters

Examples

Notes

References

ZoomBlurclass

Parameters

Examples

On this page