github:https://github.com/albumentations-team/albumentations

how to install

pip 安装

pip install albumentations

源码库安装

pip install -U git+https://github.com/albumentations-team/albumentations

与pytorch结合使用torchvision方法

trans =  A.Compose([
        A.HorizontalFlip(p=0.5),
        A.VerticalFlip(p=0.5),
        A.OneOf([
            A.IAAAdditiveGaussianNoise(),   # 将高斯噪声添加到输入图像
            A.GaussNoise(),    # 将高斯噪声应用于输入图像。
        ], p=0.2),   # 应用选定变换的概率
        A.OneOf([
            A.MotionBlur(p=0.2),   # 使用随机大小的内核将运动模糊应用于输入图像。
            A.MedianBlur(blur_limit=3, p=0.1),    # 中值滤波
            A.Blur(blur_limit=3, p=0.1),   # 使用随机大小的内核模糊输入图像。
        ], p=0.2),
        A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
        # 随机应用仿射变换:平移,缩放和旋转输入
        A.RandomBrightnessContrast(p=0.2),   # 随机明亮对比度
    ])
trans_img = trans(image=img_arr)

plt.figure(figsize=(8,8))
plt.subplot(121)
plt.title('original image')
plt.imshow(img_arr, cmap='gray')
plt.subplot(122)
plt.title('albumentions image')
plt.imshow(trans_img['image'], cmap='gray')
from torchvision import transforms as t
as_tensor = t.ToTensor()

img_tensor = as_tensor(trans_img['image'])

例子

ac5bb3e992f4c566b31bad04ff4143e6

数据增强方法

像素级变化

像素级别改变仅仅改变输入图像,并且将所有其他目标(mask、关键点等)保持不变。功能如下:
image-1721161840011
098d44878fecb63461f8e4d6b4f58a6a
ccc42898233f098199e267c8ed97612a

import albumentations as A
trans = A.Compose([
        A.HorizontalFlip(p=0.5),
        A.VerticalFlip(p=0.5),
        A.OneOf([
            A.IAAAdditiveGaussianNoise(),   # 将高斯噪声添加到输入图像
            A.GaussNoise(),    # 将高斯噪声应用于输入图像。
        ], p=0.2),   # 应用选定变换的概率
        A.OneOf([
            A.MotionBlur(p=0.2),   # 使用随机大小的内核将运动模糊应用于输入图像。
            A.MedianBlur(blur_limit=3, p=0.1),    # 中值滤波
            A.Blur(blur_limit=3, p=0.1),   # 使用随机大小的内核模糊输入图像。
        ], p=0.2),
        A.ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=0.2),
        # 随机应用仿射变换:平移,缩放和旋转输入
        A.RandomBrightnessContrast(p=0.2),   # 随机明亮对比度
    ])

这里面特别要注意两个方法,很重要。Compose 和 OneOf。Compose大家都知道,torchvision里面有,就是把所有的变换放在一起,按顺序执行。而OneOf就厉害了,他可以选择性的执行包在它里面的变换。比如把都是模糊的变换(高斯模糊,模糊,运动模糊等等)放在OneOf里面,它就可以随机选择一种变换执行。

AdvancedBlur

# ----------------AdvancedBlur高级模糊-------------------------------
def advancedBlur(img):
    """
    blur_limit (tuple of int or int): 模糊核的尺寸范围。如果是一个整数(只能是odd),则模糊核的尺寸将从 1 到该整数之间随机选择。如果是一个元组,则在该元组的范围内随机选择。默认为 (3, 7)。
    sigmaX_limit (tuple of float or float): 高斯核在 X 方向的标准差范围。如果是一个浮点数,则标准差将从 0 到该浮点数之间随机选择。如果是一个元组,则在该元组的范围内随机选择。默认为 (0.2, 1.0)。
    sigmaY_limit (tuple of float or float, optional): 高斯核在 Y 方向的标准差范围。如果未提供,则取 sigmaX_limit 的值。
    always_apply (bool, optional): 是否总是应用该变换。默认为 False。
    p (float, optional): 应用该变换的概率。默认为 0.5。
    """
    advancedBlur = A.Compose([
        #p=0.5概率使用
        A.AdvancedBlur(blur_limit=(3, 7), sigmaX_limit=(0.2, 1.0), always_apply=True)
    ])
    img_advancedBlur=advancedBlur(image=img)['image']
    # 显示原图和模糊后的图像
    plt.figure(figsize=(12, 6))
    plt.subplot(1, 2, 1)
    plt.title("OI")
    plt.imshow(img)
    plt.axis("off")

    plt.subplot(1, 2, 2)
    plt.title("BI")
    plt.imshow(img_advancedBlur)
    plt.axis("off")

    plt.show()

Blur-使用均值滤波来模糊图像

# -----------------Blur
def blur(img):
    """
    blur_limit (int or tuple of int): 模糊核大小的上限。如果是一个整数,则模糊核大小将在 1 和该整数之间随机选择。如果是一个元组,则模糊核大小将在该范围内随机选择。模糊核的大小必须是奇数。默认值为 (3, 7)。
    always_apply (bool, optional): 是否总是应用该变换。默认值为 False。
    p (float, optional): 应用该变换的概率。默认值为 0.5。
    """
    transform = A.Compose([
        A.Blur(blur_limit=(3, 7), p=0.5)
    ])

CLAHE-用于应用对比度受限的自适应直方图均衡化

def CLAHE(img):
    """
    clip_limit (float or tuple of float): 对比度的剪裁限制。默认值为 4.0。如果提供一个元组,则在这个范围内随机选择一个值。
    tile_grid_size (tuple of int): 每个网格的大小。默认值为 (8, 8)。
    always_apply (bool, optional): 是否总是应用该变换。默认值为 False。
    p (float, optional): 应用该变换的概率。默认值为 0.5。
    """
    transform = A.Compose([
        A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), always_apply=False, p=0.5)
    ])

ChannelDropout-用于随机删除图像中的通道(颜色通道)

def channeldropout(image):
    """
    channel_drop_range (tuple of int): 要删除的通道数量范围。例如,如果 (1, 2),则随机删除 1 到 2 个通道。默认为 (1, 1)。
    fill_value (int or tuple of int): 填充删除通道的值。可以是单个整数(灰度值)或者元组(RGB)。默认为 0。
    always_apply (bool, optional): 是否总是应用该变换。默认为 False。
    p (float, optional): 应用该变换的概率。默认为 0.5。
    """
    # 定义增强变换
    transform = A.Compose([
        A.ChannelDropout(channel_drop_range=(1, 2), fill_value=0, p=0.5)
    ])

ChannelShuffle-用于随机改变图像的通道顺序

def ChannelShuffle(image):
    #p (float, optional): 应用该变换的概率。默认为 0.5。
    # 定义增强变换
    transform = A.Compose([
        A.ChannelShuffle(p=0.5)
    ])

    # 应用增强变换
    transformed = transform(image=image)
    shuffled_image = transformed["image"]

ChromaticAberration-用于模拟色差效果,即光学系统中不同波长的光在通过透镜或者凸透镜时,由于折射率不同而产生的颜色分离现象。

def ChromaticAberration (image):
    """
    shift_limit (float, optional): 颜色分离的最大位移量。默认为 0.2。
    border_mode (str, optional): 边界模式。默认为 'reflect'。
    value (list of int, optional): 填充颜色值。默认为 [0, 0, 0]。
    p (float, optional): 应用该变换的概率。默认为 0.5。
    """
    # 定义增强变换
    transform = A.Compose([
        A.ChromaticAberration(shift_limit=0.2, border_mode='reflect', value=[0, 0, 0], p=0.5)
    ])

ColorJitter-用于随机调整图像的亮度、对比度、饱和度和色调,以增加数据的多样性,改善模型的泛化能力。

def ColorJitter(image):
    """
    brightness (float or tuple of float): 亮度调整的范围。如果是一个单独的浮点数,则调整因子在 [1-brightness, 1+brightness] 范围内随机选择。如果是一个元组 (min_factor, max_factor),则从 [1-min_factor, 1+max_factor] 范围内随机选择。默认为 0.2。
    contrast (float or tuple of float): 对比度调整的范围。工作方式与亮度类似。默认为 0.2。
    saturation (float or tuple of float): 饱和度调整的范围。默认为 0.2。
    hue (float or tuple of float): 色调调整的范围。默认为 0.2。
    always_apply (bool, optional): 是否总是应用该变换。默认为 False。
    p (float, optional): 应用该变换的概率。默认为 0.5。
    """
    # 定义增强变换
    transform = A.Compose([
        A.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.2, p=0.5)
    ])

Defocus-用于模拟物体在焦外的表现,通常由于镜头聚焦不准确或者深度浅引起。

def Defocus(image):
    """
    blur_limit (int or tuple of int): 模糊核大小的上限。如果是一个整数,则模糊核大小将在 [1, blur_limit] 范围内随机选择。如果是一个元组 (min_limit, max_limit),则在指定范围内随机选择模糊核大小。模糊核的大小必须是奇数。默认为 (7, 7)。
    sigma_limit (float or tuple of float): 高斯模糊的标准差范围。如果是一个单独的浮点数,则标准差在 [0, sigma_limit] 范围内随机选择。如果是一个元组 (min_limit, max_limit),则在指定范围内随机选择标准差。默认为 (0.5, 2.0)。
    always_apply (bool, optional): 是否总是应用该变换。默认为 False。
    p (float, optional): 应用该变换的概率。默认为 0.5。
    """
    # 定义增强变换
    transform = A.Compose([
        A.Defocus(blur_limit=(7, 7), sigma_limit=(0.5, 2.0), p=0.5)
    ])

Downscale-将图像缩小尺寸的操作,通常用于减少图像的分辨率或者降低计算成本。

Albumentations 库并没有直接提供 Downscale 类作为内置变换。通常,要实现图像的缩小操作,可以使用 OpenCV 库中的函数来实现。

Emboss

# 缩小图像尺寸
scale_percent = 50  # 设定缩小的百分比
width = int(image.shape[1] * scale_percent / 100)
height = int(image.shape[0] * scale_percent / 100)
dim = (width, height)

# 使用 INTER_AREA 或者其他合适的插值方法进行缩小
resized_image = cv2.resize(image, dim, interpolation=cv2.INTER_AREA)

Equalize-直方图均衡化,用于增强图像的对比度,特别是在灰度图像中。

直方图均衡化通过重新分布图像像素的灰度级别,使得图像中的像素灰度分布更加均匀,从而增强图像的对比度和细节。

equalized_image = cv2.equalizeHist(image)

FDA-频域分析,将图像从空间域转换到频域的技术。这种转换通常使用傅里叶变换来实现,其目的是在频域中分析图像的频率信息,以便进行各种处理和增强。

傅里叶变换和频域分析:傅里叶变换是一种将信号从时域(空间域)转换到频域的方法。在图像处理中,可以将图像视为一个二维信号,应用二维傅里叶变换(2D Fourier Transform)来将图像从空间域转换为频域。在频域中,图像的信息被表示为不同频率的成分,这些成分可以用来进行滤波、增强、压缩等操作。

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取灰度图像
image = cv2.imread("image.jpg", cv2.IMREAD_GRAYSCALE)

# 进行二维傅里叶变换
f_transform = np.fft.fft2(image)
f_shift = np.fft.fftshift(f_transform)

# 计算频谱图
magnitude_spectrum = 20 * np.log(np.abs(f_shift))

# 显示原始图像和频谱图
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.title("Original Image")
plt.imshow(image, cmap='gray')
plt.axis("off")

plt.subplot(1, 2, 2)
plt.title("Magnitude Spectrum")
plt.imshow(magnitude_spectrum, cmap='gray')
plt.axis("off")

plt.show()

FancyPCA-用于生成具有随机变化的图像样本。它利用主成分分析(PCA)的变化来修改图像的外观,从而增加数据的多样性,有助于改善模型的泛化能力。

FancyPCA 的基本思想是在像素级别对图像进行主成分分析(PCA)。PCA可以提取出数据中最重要的方差分量,通过对这些主成分进行随机调整,可以生成具有一定变化但保留基本结构的新图像。

def PCA(image,alpha_std=0.1):
    import numpy as np
    original_img = image.astype(float)
    # 将图像展开为一维数组
    img_vec = original_img.reshape((-1, 3))

    # 计算图像的均值和协方差矩阵
    img_mean = np.mean(img_vec, axis=0)
    img_cov = np.cov(img_vec, rowvar=False)

    # 计算特征值和特征向量
    eig_vals, eig_vecs = np.linalg.eigh(img_cov)

    # 对特征值进行随机调整
    rand_coeff = np.random.randn(3) * alpha_std
    delta = np.dot(eig_vecs, rand_coeff * eig_vals)

    # 添加随机扰动到图像像素值
    img_pca = original_img + delta.reshape((1, 1, 3))

    # 将图像像素值限制在 0 到 255 之间
    img_pca = np.clip(img_pca, 0, 255).astype(np.uint8)

FromFloat-用于将输入图像的像素值从浮点数类型转换为特定的数据类型,比如 uint8。

def FromFloat(image):
    """
    dtype (str or numpy.dtype): 指定转换后的数据类型。常见的选项包括 uint8、uint16 等。如果未指定,默认为 np.uint8。
    max_value (float, optional): 输入图像中的最大像素值。如果提供了 max_value,则会按照以下公式对输入图像进行缩放:image = image * (max_value / image.max())。默认值为 1.0。
    """
    image_float = image.astype(float) / 255.0  # 将图像转换为浮点数类型,并归一化到 [0, 1]

    # 定义 FromFloat 变换
    transform = A.Compose([
        A.FromFloat(dtype="uint8", max_value=255.0)
    ])

    # 应用增强变换
    transformed = transform(image=image_float)
    image_uint8 = transformed["image"]

GaussNoise-用于向图像中添加高斯噪声。

高斯噪声是一种常见的噪声类型,其像素值服从均值为 0、方差为给定值的正态分布。

def GaussNoise(image):
    """
    var_limit ((float, float) or float): 控制添加的高斯噪声的强度。如果是一个单独的浮点数,则使用范围 [0, var_limit] 内的随机值作为方差;如果是元组 (min_variance, max_variance),则在指定范围内选择随机方差值。方差越大,噪声越强。默认为 (10.0, 50.0)。
    """
    # 定义 GaussNoise 变换
    transform = A.Compose([
        A.GaussNoise(var_limit=(10.0, 50.0), p=0.5)
    ])

GaussianBlur-用于对图像进行高斯模糊处理。

高斯模糊是一种常见的图像处理操作,用于减少图像中的噪声和细节,使图像变得更加平滑。

def GaussianBlur(image):
    #blur_limit ((int, int) or int): 控制高斯核的大小。
    # 如果是一个单独的整数,则高斯核大小在 [1, blur_limit] 范围内随机选择;如果是元组 (min_blur, max_blur),则在指定范围内选择随机大小的高斯核。高斯核大小必须是奇数。默认为 (3, 7)。
    # 定义 GaussianBlur 变换
    transform = A.Compose([
        A.GaussianBlur(blur_limit=(3, 7), p=0.5)
    ])

GlassBlur-用于模拟玻璃模糊效果。这种效果会使图像看起来像是透过玻璃或者玻璃片的效果,常用于艺术风格的图像处理。

    """
    sigma (float or tuple of float): 控制玻璃模糊的强度。如果是一个单独的浮点数,则使用范围 [0, sigma] 内的随机值作为模糊强度;如果是元组 (min_sigma, max_sigma),则在指定范围内选择随机模糊强度。默认为 (0.7, 1.0)。

    max_delta (int, optional): 控制模糊过程中最大像素偏移量。增加此值可以增强玻璃模糊效果的随机性。默认为 4。

    iterations (int, optional): 控制玻璃模糊的迭代次数。每次迭代会增强模糊效果。默认为 2。

    mode (str, optional): 玻璃模糊的模式。可选值包括 "fast" 和 "accurate",分别代表快速模式和精确模式。默认为 "fast"。

    p (float): 应用该变换的概率。默认为 0.5,即有 50% 的概率应用该增强。
    """
    # 定义 GlassBlur 变换
    transform = A.Compose([
        A.GlassBlur(sigma=0.7, max_delta=4, iterations=2, mode="fast", p=0.5)
    ])

    # 应用增强变换
    transformed = transform(image=image)
    image_blurred = transformed["image"]

HistogramMatching-用于将一幅图像的颜色分布匹配到另一幅图像的颜色分布。这种技术可以使得两幅图像在颜色上更加一致,常用于图像增强和风格迁移等应用中。


HueSaturationValue

# reference_image (numpy.ndarray): 作为参考的图像,将要匹配其颜色分布的图像。
transform = A.Compose([
    A.HistogramMatching(reference_image=reference_image, p=1.0)
])

ISONoise

如果想要模拟相机 ISO 噪声效果,可以考虑添加高斯噪声。高斯噪声是一种常见的图像噪声类型,可以通过在每个像素上添加具有特定均值和方差的随机数来实现。

def add_gaussian_noise(image, mean=0, std=25):
    """
    添加高斯噪声到图像
    """
    row, col, ch = image.shape
    gauss = np.random.normal(mean, std, (row, col, ch))
    noisy = image + gauss
    return np.clip(noisy, 0, 255).astype(np.uint8)

MedianBlur-用于去除图像中的噪声。

MedianBlur 变换可以用来应用中值模糊到图像上,从而平滑图像并去除噪声。

"""
blur_limit (int or tuple of int): 中值模糊核大小的上限。如果是一个整数,则模糊核大小将在 1 和该整数之间随机选择。如果是一个元组,则模糊核大小将在该范围内随机选择。模糊核的大小必须是奇数。默认为 (3, 7)。
always_apply (bool, optional): 是否总是应用该变换。默认为 False。
p (float, optional): 应用该变换的概率。默认为 0.5。
"""
# 定义 MedianBlur 变换
transform = A.Compose([
    A.MedianBlur(blur_limit=(3, 7), p=0.5)
])

MotionBlur-用于模拟运动模糊效果

运动模糊可以使图像中移动的物体或相机移动时产生的模糊效果,这种效果在一些应用中可以用来增加动态感或者仿真特定环境下的图像。

"""
blur_limit (int or tuple of int): 运动模糊核大小的上限。如果是一个整数,则模糊核大小将在 1 和该整数之间随机选择。如果是一个元组,则模糊核大小将在该范围内随机选择。模糊核的大小必须是奇数。默认为 (3, 7)。
direction (float or tuple of float): 模糊方向的角度范围。如果是一个浮点数,则方向将在 0 到该角度之间随机选择。如果是一个元组,则方向将在给定范围内随机选择。默认为 (0, 360)。
always_apply (bool, optional): 是否总是应用该变换。默认为 False。
p (float, optional): 应用该变换的概率。默认为 0.5。
"""
# 定义 MotionBlur 变换
transform = A.Compose([
    A.MotionBlur(blur_limit=(3, 7), direction=(0, 360), p=0.5)
])

Normalize-用于将图像的像素值标准化到一个特定的范围内,通常是 [0, 1] 或者 [-1, 1]。

def normalize_image(image):
    # 将图像像素值标准化到 [0, 1]
    normalized_image = image / 255.0
    return normalized_image

PlanckianJitter

在图像色温上引入随机扰动,模拟光源的色温变化或者环境光的变化。这种效果可以用于增加图像的真实感或者在特定情境下进行图像增强。

def planckian_jitter(image, delta_kelvin=1000):
    # 随机生成色温扰动
    delta = np.random.uniform(-delta_kelvin, delta_kelvin)
    kelvin = 6500 + delta  # 6500K 是白炽灯的标准色温

    # 转换为 RGB 色彩空间
    img_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    # 色温转换
    img_kelvin = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2LAB).astype(np.float32)
    img_kelvin[:, :, 0] = kelvin
    img_jitter = cv2.cvtColor(img_kelvin.astype(np.uint8), cv2.COLOR_LAB2RGB)

    return img_jitter
# 定义 Albumentations 的自定义增强变换
transform = A.Compose([
    A.Lambda(image=lambda img: planckian_jitter(img, delta_kelvin=1000))
])
# 应用增强变换
transformed = transform(image=image)
image_jittered = transformed["image"]

Posterize(海报效果)-将图像色彩级别减少到较少级别的技术,使得图像看起来像是由平坦的色块组成,类似于印刷品质感。

RGBShift-随机偏移图像的 R(红色)、G(绿色)、B(蓝色)通道的值,从而产生一种颜色偏移效果。

# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RGBShift(r_shift_limit=25, g_shift_limit=25, b_shift_limit=25, p=0.5)
])

RandomBrightnessContrast-用于随机调整图像亮度和对比度的变换之一。通过这个变换,可以使图像在亮度和对比度上产生随机变化,从而增强图像数据的多样性和鲁棒性。

# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomBrightnessContrast(brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), p=0.5)
])

RandomFog-用于随机添加雾霾效果到图像中,模拟雾天或者雾化的环境。这种变换可以增加图像的多样性和鲁棒性,特别适用于一些视觉任务中,如天气识别、自动驾驶等领域。

"""
fog_coef_lower 和 fog_coef_upper 控制雾霾的密度范围,以模拟不同浓度的雾霾效果。在示例中,它们分别设置为 0.1 和 0.5,表示雾霾效果的浓度在 0.1 到 0.5 之间随机变化。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomFog(fog_coef_lower=0.1, fog_coef_upper=0.5, p=0.5)
])

RandomGamma-用于随机调整图像的 gamma 值,从而影响图像的亮度和对比度。通过调整 gamma 值,可以使图像的整体亮度更明亮或更暗,增强图像的视觉效果和鲁棒性。

"""
gamma_limit 控制随机 gamma 值调整的范围,以元组形式表示 (min_gamma, max_gamma),在示例中设置为 (0.8, 1.2) 表示 gamma 值可以在 0.8 到 1.2 之间随机变化。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomGamma(gamma_limit=(0.8, 1.2), p=0.5)
])

RandomGravel-用于模拟在图像上添加随机砾石(小石子)效果。这种变换可以增加图像的复杂性和真实性,特别适用于地表或场景分类任务中。

"""
gravel_lower 和 gravel_upper 控制砾石效果的密度范围,以模拟不同浓度的砾石分布。在示例中,它们分别设置为 10 和 50,表示砾石效果的密度在 10 到 50 之间随机变化。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomGravel(gravel_lower=10, gravel_upper=50, p=0.5)
])

RandomRain-用于模拟在图像上添加随机雨滴效果。这种变换可以增加图像的真实感和视觉复杂性,特别适用于天气识别、场景生成等任务中。

"""
参数如 slant_lower、slant_upper 控制雨滴的倾斜角度范围;drop_length 和 drop_width 控制雨滴的长度和宽度;drop_color 控制雨滴的颜色;blur_value 控制雨滴模糊的程度;brightness_coefficient 控制雨滴的亮度系数;rain_type 指定雨的类型("heavy"、"drizzle" 等)。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomRain(slant_lower=-10, slant_upper=10, drop_length=20, drop_width=1, drop_color=(200, 200, 200), blur_value=7, brightness_coefficient=0.7, rain_type="heavy", p=0.5)
])

RandomShadow-用于模拟在图像上添加随机阴影效果。这种变换可以增加图像的真实感和视觉复杂性,特别适用于场景生成、虚拟现实等任务中。

"""
参数如 shadow_roi 指定阴影的区域;num_shadows_lower 和 num_shadows_upper 控制添加阴影的数量范围;shadow_dimension 控制阴影的维度。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomShadow(shadow_roi=(0, 0.5, 1, 1), num_shadows_lower=1, num_shadows_upper=2, shadow_dimension=5, always_apply=True)
])

RandomSnow-用于模拟在图像上添加随机雪花效果。这种变换可以增加图像的真实感和视觉复杂性,特别适用于冬季场景生成、虚拟现实等任务中。

"""
参数如 snow_point_lower 和 snow_point_upper 控制添加雪花的密度范围;brightness_coefficient 控制雪花的亮度系数。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomSnow(snow_point_lower=0.1, snow_point_upper=0.3, brightness_coefficient=2.5, always_apply=True)
])

RandomSunFlare-用于模拟在图像上添加随机阳光耀斑效果。这种变换可以增加图像的真实感和视觉复杂性,特别适用于户外场景生成、虚拟现实等任务中。

"""
参数如 src_radius 控制耀斑的源半径;num_flare_circles_lower 和 num_flare_circles_upper 控制耀斑圈的数量范围;src_color 控制耀斑的颜色。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomSunFlare(src_radius=200, num_flare_circles_lower=6, num_flare_circles_upper=10, src_color=(255, 255, 255), p=1)
])

RandomToneCurve-用于在图像上应用随机色调曲线效果。这种变换可以调整图像的色调和对比度,增强图像的视觉效果。

"""
A.RandomToneCurve 是 Albumentations 提供的一个变换函数,用于在图像上应用随机色调曲线效果。
"""
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.RandomToneCurve(always_apply=True)
])

Sharpen-用于增强图像的边缘和细节,使图像看起来更清晰和更加鲜明。锐化技术通过突出图像中的高频部分(例如边缘和细节),来增强图像的视觉效果。

#alpha 控制锐化的强度,lightness 控制锐化后图像的亮度。
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.Sharpen(alpha=0.5, lightness=0.5, always_apply=True)
])

Solarize-用于反转图像中的像素值,使得一部分图像的像素值超过某个阈值后被反转。这种效果可以产生一种视觉上有趣或者艺术化的效果。

#threshold 参数控制反转的阈值,即超过该阈值的像素值将被反转。
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.Solarize(threshold=128, always_apply=True)
])

Spatter-用于增加图像的噪声或艺术化效果。模拟飞溅或斑点的特效效果。

#A.Spatter 是 Albumentations 提供的一个变换函数,用于对图像应用飞溅效果。
# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.Spatter(p=1)
])

Superpixels-将图像分割成紧密连接的、相似颜色和纹理的小区域的过程。超像素技术可以帮助减少图像处理任务的复杂性,并提供更好的图像特征。

ToFloat-将图像的像素值转换为浮点数类型的一个常见操作。

# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.ToFloat(max_value=255.0)  # 将像素值缩放到 0 到 1 之间
])

ToGray-将彩色图像转换为灰度图像。

# 定义 Albumentations 的增强变换
transform = A.Compose([
    A.ToGray(p=1.0)  # 将图像转换为灰度图像,p=1.0 表示始终应用该变换
])

ToRGB-将图像从其当前的色彩空间(如灰度或其他色彩空间)转换回 RGB 色彩空间。RGB 色彩空间是最常用的彩色图像表示方法,其中每个像素由红色(R)、绿色(G)和蓝色(B)三个通道组成。

# 加载灰度图像
gray_image = cv2.imread("path_to_your_gray_image.jpg", cv2.IMREAD_GRAYSCALE)

# 将灰度图像转换为 RGB 彩色图像
rgb_image = cv2.cvtColor(gray_image, cv2.COLOR_GRAY2RGB)

ToSepia-将彩色图像转换为深褐色(Sepia)色调的效果。Sepia 色调通常给人一种怀旧和复古的感觉,常见于老照片和艺术风格中。

def apply_sepia(image):
    # Sepia 转换矩阵
    sepia_matrix = np.array([[0.393, 0.769, 0.189],
                             [0.349, 0.686, 0.168],
                             [0.272, 0.534, 0.131]])

    # 转换为浮点数
    sepia_image = cv2.transform(image, sepia_matrix)

    # 将像素值限制在 0 到 255 之间并转换为 uint8 类型
    sepia_image = np.clip(sepia_image, 0, 255).astype(np.uint8)

    return sepia_image

UnsharpMask(锐化掩蔽)是一种图像增强技术,用于增强图像的边缘和细节,常用于提升图像的清晰度和视觉效果。

def unsharp_mask(image, kernel_size=(5, 5), sigma=1.0, amount=1.0, threshold=0):
    # 高斯模糊
    blurred = cv2.GaussianBlur(image, kernel_size, sigma)
    
    # 锐化图像
    sharpened = np.clip(image * (1 + amount) - blurred * amount, 0, 255).astype(np.uint8)
    
    # 应用阈值
    if threshold > 0:
        low_contrast_mask = np.abs(image - blurred) < threshold
        np.copyto(sharpened, image, where=low_contrast_mask)
    
    return sharpened

ZoomBlur(缩放模糊)是一种图像模糊效果,通过模糊处理可以使图像中心保持清晰,而边缘模糊,从而产生一种缩放的视觉效果。

def zoom_blur(image, strength=2.0, center=(0.5, 0.5)):
    height, width = image.shape[:2]
    zoom_image = np.zeros_like(image)
    
    # 计算中心点
    center_x = int(width * center[0])
    center_y = int(height * center[1])
    
    # 创建缩放图像
    for i in range(height):
        for j in range(width):
            offset_x = int((j - center_x) * strength)
            offset_y = int((i - center_y) * strength)
            new_x = min(max(j + offset_x, 0), width - 1)
            new_y = min(max(i + offset_y, 0), height - 1)
            zoom_image[i, j] = image[new_y, new_x]
    
    # 应用高斯模糊
    zoom_blur_image = cv2.GaussianBlur(zoom_image, (15, 15), 10)
    
    return zoom_blur_image

f59e66cce4e33cf0d39892c381f69da8

Mixing-level transforms

几张图拼接成一张。
45a85e15f761551ba229906278108558

序列化为Python dict (主要使用)

使用 to_dict 和 from_dict 来序列化转换流水线为Python dict 格式。如果我们需要在序列化流水线上有更多的控制,如需要将序列的版本保存到数据库或者将其他送到另一个服务器上,那么这两给函数就非常的有用了。

to_dict 会返回一个描述流水线的python 字典,此字典只包含最原始的数据类型,如dict、list、str、int、float等。为了从字典中恢复抓换流水线只需要调用 from_dict。如下使用方式:

transform_dict = A.to_dict(transform)
loaded_transform = A.from_dict(transform_dict)
print(loaded_transform)
flipped_image = loaded_transform(image=image)['image']

系列化与反序列化为 lambda 转换

Lambda 转换使用用户自定义的转换函数,对于 Lambda 转换只有管线的名字和位置会被保存。在使用 lambda_transforms 参数反序列化时,需要手动的提供所有 Lambda 转换实例。如下首先定义一个自定义的转换:

# 定义一个用于图片转换的函数
def hflip_image(image, **kwargs):
    return cv2.flip(image, 1)

之后定义一个 Lambda 表达式,为了之后的序列化需要为 Lambda 表达式指定

# 定义 Lambda 表达式,为了进行序列化需要指定名字
hflip_transform = A.Lambda(name='hflip_image', image=hflip_image, p=0.5)
print(hflip_transform)

将其应用到图片:

random.seed(1)
flipped_image_1 = hflip_transform(image=image)['image']

之后将其保存到 dict 中

transform_dict = A.to_dict(hflip_transform)
print(transform_dict)

加载完成就可以进行接下来的转换:

random.seed(1)
flipped_image_2 = loaded_transform(image=image)['image']
assert np.array_equal(flipped_image_1, flipped_image_2)

除了使用上面的 to_dict和 from_dict 方法,我们还可以使用 save 和 load 方法组合,该方法一样需要提供 lambda_transforms 参数的值:

# 先保存
A.save(hflip_transform, 'transform.json')
# 后加载
loaded_transform = A.load('transform.json', lambda_transforms={'hflip_image': hflip_transform})
print(loaded_transform)

Q.E.D.


曲中思念今犹在,不见当年梦中人。