albumentations.augmentations.pixel.weather

Add depth-dependent fog via the atmospheric scattering equation and a synthetic depth map. Use for outdoor and driving robustness to haze. Unlike RandomFog (which overlays circular fog patches), this transform uses a physically-based scattering model: farther pixels (by synthetic depth) get more fog, producing realistic distance-dependent haze. Depth is derived from image position (linear, diagonal, or radial), not from a real depth map. Formula: `result = image * exp(-density * depth) + fog_color * (1 - exp(-density * depth))`

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
>>> transform = A.AtmosphericFog(density_range=(1.0, 2.5), depth_mode="linear", p=1.0)
>>> result = transform(image=image)["image"]
>>> # Radial fog (center clear, edges foggy)
>>> transform_radial = A.AtmosphericFog(density_range=(1.5, 3.0), depth_mode="radial", p=1.0)
>>> result_radial = transform_radial(image=image)["image"]

Notes

- Depth is synthetic (from pixel position), not from scene geometry. - For typical outdoor frames, "linear" matches sky far / ground near.

Simulate fog by overlaying semi-transparent circles and blending with a fog color. Good for driving or outdoor robustness to weather. Fog is built from random circles with controllable intensity; an image-size-dependent Gaussian blur is applied to the result. Patch-based (no depth); for distance-dependent fog use AtmosphericFog.

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8)

# Default usage
>>> transform = A.RandomFog(p=1.0)
>>> foggy_image = transform(image=image)["image"]

# Custom fog intensity range
>>> transform = A.RandomFog(fog_coef_range=(0.3, 0.8), p=1.0)
>>> foggy_image = transform(image=image)["image"]

# Adjust fog transparency
>>> transform = A.RandomFog(fog_coef_range=(0.2, 0.5), alpha_coef=0.1, p=1.0)
>>> foggy_image = transform(image=image)["image"]

Notes

- Fog is created by overlaying semi-transparent circles at random positions and with random radius; alpha is controlled by alpha_coef. - Higher fog_coef values give denser fog; effect is typically stronger toward center and gradually decreases toward the edges. - A Gaussian blur (dependent on the shorter image dimension) is applied after blending to reduce sharpness.

References

• [{'description': 'Fog', 'source': 'https://en.wikipedia.org/wiki/Fog'}, {'description': 'Atmospheric perspective', 'source': 'https://en.wikipedia.org/wiki/Aerial_perspective'}]

Add gravel-like particle artifacts on the image. Number and size of particles and ROI are configurable. Simulates dirt or debris on a lens or surface. This transform simulates the appearance of gravel or small stones scattered across specific regions of an image. It's particularly useful for augmenting datasets of road or terrain images, adding realistic texture variations.

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8)

# Default usage
>>> transform = A.RandomGravel(p=1.0)
>>> augmented_image = transform(image=image)["image"]

# Custom ROI and number of patches
>>> transform = A.RandomGravel(
...     gravel_roi=(0.2, 0.2, 0.8, 0.8),
...     number_of_patches=5,
...     p=1.0
... )
>>> augmented_image = transform(image=image)["image"]

# Combining with other transforms
>>> transform = A.Compose([
...     A.RandomGravel(p=0.7),
...     A.RandomBrightnessContrast(p=0.5),
... ])
>>> augmented_image = transform(image=image)["image"]

Notes

- The gravel effect is created by modifying the saturation channel in the HLS color space. - Gravel particles are distributed within randomly generated patches inside the specified ROI. - This transform is particularly useful for: * Augmenting datasets for road condition analysis * Simulating variations in terrain for computer vision tasks * Adding realistic texture to synthetic images of outdoor scenes

References

• [{'description': 'Road surface textures', 'source': 'https://en.wikipedia.org/wiki/Road_surface'}, {'description': 'HLS color space', 'source': 'https://en.wikipedia.org/wiki/HSL_and_HSV'}]

Add rain streaks (semi-transparent lines), optional blur and brightness reduction. Good for outdoor or driving robustness to rainy conditions. Streaks are drawn with configurable slant, length, and width; blur and darkening simulate wet, low-contrast views. Density and style are configurable (e.g. drizzle, heavy, torrential).

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, (100, 100, 3), dtype=np.uint8)
>>>
>>> # Default usage
>>> transform = A.RandomRain(p=1.0)
>>> rainy_image = transform(image=image)["image"]
>>>
>>> # Custom rain parameters
>>> transform = A.RandomRain(
...     slant_range=(-15, 15),
...     drop_length=30,
...     drop_width=2,
...     drop_color=(180, 180, 180),
...     blur_value=5,
...     brightness_coefficient=0.8,
...     p=1.0
... )
>>> rainy_image = transform(image=image)["image"]
>>>
>>> # Heavy rain
>>> transform = A.RandomRain(rain_type="heavy", p=1.0)
>>> heavy_rain_image = transform(image=image)["image"]

Notes

- Rain is drawn as semi-transparent lines; slant simulates wind. - rain_type (drizzle, heavy, torrential, default) controls drop count and style. - Blur and brightness reduction mimic wet, darker scenes.

References

• [{'description': 'Rain visualization techniques', 'source': 'https://developer.nvidia.com/gpugems/gpugems3/part-iv-image-effects/chapter-27-real-time-rain-rendering'}, {'description': 'Weather effects in computer vision', 'source': 'https://www.sciencedirect.com/science/article/pii/S1077314220300692'}]

Simulate cast shadows by darkening random regions. shadow_roi, num_shadows, shadow_dimension control placement and softness. Improves lighting robustness. This transform adds realistic shadow effects to images, which can be useful for augmenting datasets for outdoor scene analysis, autonomous driving, or any computer vision task where shadows may be present.

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8)

# Default usage
>>> transform = A.RandomShadow(p=1.0)
>>> shadowed_image = transform(image=image)["image"]

# Custom shadow parameters
>>> transform = A.RandomShadow(
...     shadow_roi=(0.2, 0.2, 0.8, 0.8),
...     num_shadows_limit=(2, 4),
...     shadow_dimension=8,
...     shadow_intensity_range=(0.3, 0.7),
...     p=1.0
... )
>>> shadowed_image = transform(image=image)["image"]

# Combining with other transforms
>>> transform = A.Compose([
...     A.RandomShadow(p=0.5),
...     A.RandomBrightnessContrast(p=0.5),
... ])
>>> augmented_image = transform(image=image)["image"]

Notes

- Shadows are created by generating random polygons within the specified ROI and reducing the brightness of the image in these areas. - The number of shadows, their shapes, and intensities can be randomized for variety. - This transform is particularly useful for: * Augmenting datasets for outdoor scene understanding * Improving robustness of object detection models to shadowed conditions * Simulating different lighting conditions in synthetic datasets

References

• [{'description': 'Shadow detection and removal', 'source': 'https://www.sciencedirect.com/science/article/pii/S1047320315002035'}, {'description': 'Shadows in computer vision', 'source': 'https://en.wikipedia.org/wiki/Shadow_detection'}]

Add snow overlay via bleach (brightness threshold) or texture (noise-based overlay). Good for winter or snowy-scene robustness in outdoor imagery. Two methods: "bleach" brightens pixels above a threshold (faster, simpler); "texture" adds a depth-weighted snow layer with sparkle (more realistic, heavier).

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, [100, 100, 3], dtype=np.uint8)

# Default usage (bleach method)
>>> transform = A.RandomSnow(p=1.0)
>>> snowy_image = transform(image=image)["image"]

# Using texture method with custom parameters
>>> transform = A.RandomSnow(
...     snow_point_range=(0.2, 0.4),
...     brightness_coeff=2.0,
...     method="texture",
...     p=1.0
... )
>>> snowy_image = transform(image=image)["image"]

Notes

- "bleach": brightness threshold in HLS; pixels above snow_point are scaled by brightness_coeff. Fast, less realistic. - "texture": HSV brightness boost, Gaussian noise texture, depth gradient (stronger at top), alpha blend, blue tint, sparkle. More realistic, heavier.

References

• [{'description': 'Bleach method', 'source': 'https://github.com/UjjwalSaxena/Automold--Road-Augmentation-Library'}, {'description': 'Texture method', 'source': 'Inspired by computer graphics techniques for snow rendering and atmospheric scattering simulations.'}]

Simulate lens flare: circles of light and rays. src_radius, num_flare_circles, angle control the effect. Good for outdoor robustness. This transform creates a sun flare effect by overlaying multiple semi-transparent circles of varying sizes and intensities along a line originating from a "sun" point. It offers two methods: a simple overlay technique and a more complex physics-based approach.

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> image = np.random.randint(0, 256, [1000, 1000, 3], dtype=np.uint8)

# Default sun flare (overlay method)
>>> transform = A.RandomSunFlare(p=1.0)
>>> flared_image = transform(image=image)["image"]

# Physics-based sun flare with custom parameters

# Default sun flare
>>> transform = A.RandomSunFlare(p=1.0)
>>> flared_image = transform(image=image)["image"]

# Custom sun flare parameters

>>> transform = A.RandomSunFlare(
...     flare_roi=(0.1, 0, 0.9, 0.3),
...     angle_range=(0.25, 0.75),
...     num_flare_circles_range=(5, 15),
...     src_radius=200,
...     src_color=(255, 200, 100),
...     method="physics_based",
...     p=1.0
... )
>>> flared_image = transform(image=image)["image"]

References

• [{'description': 'Lens flare', 'source': 'https://en.wikipedia.org/wiki/Lens_flare'}, {'description': 'Alpha compositing', 'source': 'https://en.wikipedia.org/wiki/Alpha_compositing'}, {'description': 'Diffraction', 'source': 'https://en.wikipedia.org/wiki/Diffraction'}, {'description': 'Chromatic aberration', 'source': 'https://en.wikipedia.org/wiki/Chromatic_aberration'}, {'description': 'Screen blending', 'source': 'https://en.wikipedia.org/wiki/Blend_modes#Screen'}]

Simulate lens occlusion from rain or mud: splatter patterns and optional blur. fill and spread control appearance. Good for dirty or wet lens robustness.

Parameters

Examples

>>> import numpy as np
>>> import albumentations as A
>>> import cv2
>>>
>>> # Create a sample image
>>> image = np.ones((300, 300, 3), dtype=np.uint8) * 200  # Light gray background
>>> # Add some gradient to make effects more visible
>>> for i in range(300):
...     image[i, :, :] = np.clip(image[i, :, :] - i // 3, 0, 255)
>>>
>>> # Example 1: Rain effect with default parameters
>>> rain_transform = A.Spatter(
...     mode="rain",
...     p=1.0
... )
>>> rain_result = rain_transform(image=image)
>>> rain_image = rain_result['image']  # Image with rain drops
>>>
>>> # Example 2: Heavy rain with custom parameters
>>> heavy_rain = A.Spatter(
...     mode="rain",
...     mean=(0.7, 0.7),             # Higher mean = more coverage
...     std=(0.2, 0.2),              # Lower std = more uniform effect
...     cutout_threshold=(0.65, 0.65),  # Lower threshold = more drops
...     intensity=(0.8, 0.8),        # Higher intensity = more visible effect
...     color=(200, 200, 255),       # Blueish rain drops
...     p=1.0
... )
>>> heavy_rain_result = heavy_rain(image=image)
>>> heavy_rain_image = heavy_rain_result['image']
>>>
>>> # Example 3: Mud effect
>>> mud_transform = A.Spatter(
...     mode="mud",
...     mean=(0.6, 0.6),
...     std=(0.3, 0.3),
...     cutout_threshold=(0.62, 0.62),
...     intensity=(0.7, 0.7),
...     p=1.0
... )
>>> mud_result = mud_transform(image=image)
>>> mud_image = mud_result['image']  # Image with mud splatters
>>>
>>> # Example 4: Custom colored mud
>>> red_mud = A.Spatter(
...     mode="mud",
...     mean=(0.55, 0.55),
...     std=(0.25, 0.25),
...     cutout_threshold=(0.7, 0.7),
...     intensity=(0.6, 0.6),
...     color=(120, 40, 40),  # Reddish-brown mud
...     p=1.0
... )
>>> red_mud_result = red_mud(image=image)
>>> red_mud_image = red_mud_result['image']
>>>
>>> # Example 5: Random effect (50% chance of applying)
>>> random_spatter = A.Compose([
...     A.Spatter(
...         mode="rain" if np.random.random() < 0.5 else "mud",
...         p=0.5
...     )
... ])
>>> random_result = random_spatter(image=image)
>>> result_image = random_result['image']  # May or may not have spatter effect

References

• [{'description': 'Benchmarking Neural Network Robustness to Common Corruptions and Perturbations', 'source': 'https://arxiv.org/abs/1903.12261'}]