官网：https://imgaug.readthedocs.io/en/latest/

一、Sequential 顺序增强器

列表扩充器，可能包含按顺序或随机顺序应用的其他增强器。

按预定义顺序应用：

aug = iaa.Sequential([
    iaa.Affine(translate_px={"x":-40}),
    iaa.AdditiveGaussianNoise(scale=0.1*255)
])

以随机顺序应用（请注意，每批次采样一次，然后对批次中的所有图像进行相同处理）：

aug = iaa.Sequential([
      iaa.Affine(translate_px={"x":-40}),
      iaa.AdditiveGaussianNoise(scale=0.1*255)
], random_order=True)

二、SomeOf 子项增强器

仅将其部分子项应用于图像的增强器。

应用给定的增强器中的两个：

aug = iaa.SomeOf(2, [
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
])

应用给定的增强器中的零个到最大个：

aug = iaa.SomeOf((0, None), [
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
])

随机应用给定的四个增强器中的两个：

aug = iaa.SomeOf(2, [
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
], random_order=True)

三、OneOf 其一增强器

总是执行其中一个增强器。

将四个增强器中的一个应用于每个图像：

aug = iaa.OneOf([
    iaa.Affine(rotate=45),
    iaa.AdditiveGaussianNoise(scale=0.2*255),
    iaa.Add(50, per_channel=True),
    iaa.Sharpen(alpha=0.5)
])

四、Sometimes 部分增强器

使用一个或多个增强器仅增强p％的图像。

将高斯模糊应用于50％的图像：

aug = iaa.Sometimes(0.5, iaa.GaussianBlur(sigma=2.0))

将高斯模糊应用于50％的图像的， 将仿射旋转和锐化应用到另外50％。

aug = iaa.Sometimes(
      0.5,
      iaa.GaussianBlur(sigma=2.0),
      iaa.Sequential([iaa.Affine(rotate=45), iaa.Sharpen(alpha=1.0)])
  )

五、WithColorspace 附带颜色空间增强器

在特定颜色空间内应用子增强器。

将图像转换为HSV，然后将每个像素的H值增加10到50：

aug = iaa.WithColorspace(
    to_colorspace="HSV",
    from_colorspace="RGB",
    children=iaa.WithChannels(0, iaa.Add((10, 50)))
)

六、WithChannels 通道增强器

将子增强器应用于特定通道。

将每个像素的R值（红色）增加10到100：

aug = iaa.WithChannels(0, iaa.Add((10, 100)))

将每个图像的红色通道旋转0到45度：

aug = iaa.WithChannels(0, iaa.Affine(rotate=(0, 45)))

七、Noop 无操作增强器

绝不更改输入图像的增强器（无操作）。

aug = iaa.Noop()

八、Lambda Lambda增强器

为每批输入图像调用lambda函数的增强器。

用黑色像素替换每个图像的每四行：

def img_func(images, random_state, parents, hooks):
    for img in images:
        img[::4] = 0
    return images

def keypoint_func(keypoints_on_images, random_state, parents, hooks):
    return keypoints_on_images

aug = iaa.Lambda(img_func, keypoint_func)

九、AssertLambda 断言增强器

增强器使用lambda函数作为条件在每批输入图像上运行断言。

TODO的例子

十、AssertShape 断言形状增强器

增强器对输入图像和关键点的形状运行断言。

检查批处理中的每个图像是否具有32x32x3的形状，否则引发异常：

seq = iaa.Sequential([
    iaa.AssertShape((None, 32, 32, 3)),
    iaa.Fliplr(0.5) # only executed if shape matches
])

检查批次中的每个图像的高度是否在32<=x<64，宽度为64以及1或3个通道中：

seq = iaa.Sequential([
    iaa.AssertShape((None, (32, 64), 32, [1, 3])),
    iaa.Fliplr(0.5)
])

十一、Resize 大小增强器

增强器将图像大小调整为指定的高度和宽度。

将每个图像的大小调整为高度=32和宽度=64：

aug = iaa.Resize({"height": 32, "width": 64})

将每个图像的大小调整为高度=32并保持宽度的宽高比相同：

aug = iaa.Resize({"height": 32, "width": "keep-aspect-ratio"})

将每个图像的大小调整为其原始大小的50％到100％之间：

aug = iaa.Resize((0.5, 1.0))

将每个图像的高度调整为其原始大小和宽度的50-75％，调整为16px或32px或64px：

aug = iaa.Resize({"height": (0.5, 0.75), "width": [16, 32, 64]})

十二、CropAndPad 裁剪/填充增强器

增强器按照像素或百分比（相对于输入图像大小）来裁剪/填充图像。

注意：此增强器在增强图像后会自动将图像重新调整为原始大小。 要停用此功能，请添加参数keep_size=False。

相对于其原始大小，每侧裁剪或填充最多10％（负则裁剪，正则填充）：

aug = iaa.CropAndPad(percent=(-0.25, 0.25))

每边填充0至20％。 这会为侧面增加新的像素。 这些像素将填充恒定值（mode=constant）或填充最近边缘（mode=edge）上的值。 如果使用常量值，则它将是0到128之间的随机值（从图像中采样）。

aug = iaa.CropAndPad(
    percent=(0, 0.2),
    pad_mode=["constant", "edge"],
    pad_cval=(0, 128)
)

将每个图像的顶部填充0到30个像素，右侧填充0-10px，底部填充0-30px，左侧填充0-10px。 available模式填充新像素，constant模式填充0到128之间的常量值。

aug = iaa.CropAndPad(
    px=((0, 30), (0, 10), (0, 30), (0, 10)),
    pad_mode=ia.ALL,
    pad_cval=(0, 128)
)

每边裁剪/填充最多10px。 该值将每个图像采样一次并用于所有边。

aug = iaa.CropAndPad(
    px=(-10, 10),
    sample_independently=False
)

十三、Pad 填充增强器

填充图像的增强器。

这是CropAndPad的代理。 它只接受正像素/百分比值。

十四、Crop 裁剪增强器

在图像两侧裁剪的增强器。

这是CropAndPad的代理。 它只接受正像素/百分比值并将它们作为负值传给CropAndPad。

十五、Fliplr 水平翻转增强器

水平翻转输入图像。

水平翻转50％的图像：

aug = iaa.Fliplr(0.5)

十六、Flipud 垂直翻转增强器

垂直翻转输入图像。

垂直翻转50％的图像：

aug = iaa.Flipud(0.5)

十七、Superpixels 超像素增强器

完全或部分地将图像变换为其超像素表示。

每个图像生成大约64个超像素。 用平均像素颜色替换每个概率为50％。

aug = iaa.Superpixels(p_replace=0.5, n_segments=64)

每个图像生成16到128个超像素。 用平均像素颜色替换每个超像素的概率在10到100％之间（每个图像采样一次）。

aug = iaa.Superpixels(p_replace=(0.1, 1.0), n_segments=(16, 128))

将n_segments设置为固定值64然后将p_replace从0.0增加到1.0的效果：

将p_replace设置为固定值1.0然后将n_segments从1 * 16增加到9*16=144的效果：

十八、ChangeColorspace 改变颜色空间增强器

改变图像的色彩空间的增强器。

以下示例显示如何将颜色空间从RGB更改为HSV，然后将50-100添加到第一个通道，然后转换回RGB。 这增加了每个图像的色调值。

aug = iaa.Sequential([
    iaa.ChangeColorspace(from_colorspace="RGB", to_colorspace="HSV"),
    iaa.WithChannels(0, iaa.Add((50, 100))),
    iaa.ChangeColorspace(from_colorspace="HSV", to_colorspace="RGB")
])

十九、Grayscale 灰度增强器

将图像转换为灰度图。

将图像更改为灰度，并通过改变强度将其与原始图像叠加，有效地删除0到100％的颜色：

aug = iaa.Grayscale(alpha=(0.0, 1.0))

可视化：alpha从0.0增加到1.0：

二十、GaussianBlur 高斯模糊增强器

使用高斯内核模糊图像的增强器

用高斯内核模糊每个图像，sigma为3.0：

aug = iaa.GaussianBlur(sigma=(0.0, 3.0))

二十一、AverageBlur 平均模糊增强器

通过在邻域上计算的简单手段来模糊图像。

使用随机大小在2x2和11x11之间的平均值来模糊每个图像：

aug = iaa.AverageBlur(k=(2, 11))

使用具有随机大小的平均值来模糊每个图像，高度可以在5到11之间变化，宽度为1到3之间：

aug = iaa.AverageBlur(k=((5, 11), (1, 3)))

二十二、MedianBlur 中值模糊增强器

通过计算邻域的中值来模糊图像。

使用中位数超过3x3和11x11之间随机大小的中位数模糊每个图像：

aug = iaa.MedianBlur(k=(3, 11))

二十三、Convolve 卷积增强器

应用卷积输入图像。

使用3x3内核卷积每个图像：

matrix = np.array([[0, -1, 0],
                   [-1, 4, -1],
                   [0, -1, 0]])
aug = iaa.Convolve(matrix=matrix)

使用3x3内核卷积每个图像，每个图像动态选择：

def gen_matrix(image, nb_channels, random_state):
      matrix_A = np.array([[0, -1, 0],
                           [-1, 4, -1],
                           [0, -1, 0]])
     matrix_B = np.array([[0, 0, 0],
                          [0, -4, 1],
                          [0, 2, 1]])
      if random_state.rand() < 0.5:
          return [matrix_A] * nb_channels
      else:
          return [matrix_B] * nb_channels
aug = iaa.Convolve(matrix=gen_matrix)

二十四、Sharpen 锐化增强器

锐化图像增强器。

锐化图像，然后使用0.0到1.0之间的alpha将结果与原始图像重叠：

aug = iaa.Sharpen(alpha=(0.0, 1.0), lightness=(0.75, 2.0))

可视化：保持lightness为1.0，alpha从0.0增加到1.0：

可视化：保持alpha为1.0，lightness从0.75增加到1.5：

二十五、Emboss 浮雕增强器

浮雕图像增强器。

浮雕图像，然后使用0.0到1.0之间的alpha将结果与原始图像叠加：

aug = iaa.Emboss(alpha=(0.0, 1.0), strength=(0.5, 1.5))

可视化：保持strength为1.0，alpha从0.0增加到1.0：

可视化：保持alpha为1.0，strength从0.5增加到1.5：

二十六、EdgeDetect 边缘增强器

检测边缘增强器。

检测边缘，将其转换为黑白图像，然后使用介于0.0和1.0之间的随机alpha将这些图像与原始图像叠加在一起：

aug = iaa.EdgeDetect(alpha=(0.0, 1.0))

可视化：alpha从0.0增加到1.0：

二十七、DirectedEdgeDetect 方向边缘增强器

特定方向边缘检测增强器。

检测图像中具有随机方向（0到360度）的边缘，将图像转换为黑白图像，然后使用介于0.0和1.0之间的随机alpha将这些图像与原始图像叠加：

aug = iaa.DirectedEdgeDetect(alpha=(0.0, 1.0), direction=(0.0, 1.0))

可视化：保持direction为1.0，alpha从0.0增加到1.0：

可视化：保持alpha为1.0，direction从0增加到1（0到360度）：

二十八、Add 像素加法增强器

为图像中的所有像素添加值。

在图像中添加-40到40之间的随机值，每个图像对每个图像采样一次，然后对所有像素采样相同：

aug = iaa.Add((-40, 40))

在图像中添加-40到40之间的随机值。 在50％的图像中，每个通道的值不同（3个采样值）。 在剩下的50%图像中，所有通道的值都相同：

aug = iaa.Add((-40, 40), per_channel=0.5)

二十九、AddElementwise 相邻像素加法增强器

向具有相邻像素的图像像素添加不同值。

在图像中添加-40到40之间的随机值，每个像素采样一次：

aug = iaa.AddElementwise((-40, 40))

在图像中添加-40到40之间的随机值。 在50％的图像中，每个通道的值不同（每个像素3个采样值）。 在剩下的50%图像中，每个像素的所有通道的值都相同：

aug = iaa.AddElementwise((-40, 40), per_channel=0.5)

三十、AdditiveGaussianNoise 高斯噪声增强器

为图像添加高斯噪声（又称白噪声）。

将高斯噪声添加到图像中，每个像素从正态分布N(0，s)采样一次，其中s对每个图像采样并在0和0.05 * 255之间变化：

aug = iaa.AdditiveGaussianNoise(scale=(0, 0.05*255))

将高斯噪声添加到图像中，每个像素从正态分布N(0,0.05 * 255)采样一次：

aug = iaa.AdditiveGaussianNoise(scale=0.05*255)

将高斯噪声添加到图像中，对于50％的图像，每个像素从正常分布N(0,0.05 * 255)采样一次，并对来自相同正态分布的其他50％采样三次（通道）：

aug = iaa.AdditiveGaussianNoise(scale=0.05*255, per_channel=0.5)

三十一、Multiply 像素乘法增强器

将图像中的所有像素与特定值相乘，从而使图像更暗或更亮。

将每个图像乘以0.5到1.5之间的随机值：

aug = iaa.Multiply((0.5, 1.5))

将50％图像乘以0.5到1.5之间的随机值，并将剩余的50％通道乘以，即每个通道独立采样一个乘数：

aug = iaa.Multiply((0.5, 1.5), per_channel=0.5)

三十二、MultiplyElementwise 相邻像素乘法增强器

将相邻像素的像素值乘以不同的值，使每个像素更暗或更亮。

将每个像素乘以0.5到1.5之间的随机值：

aug = iaa.MultiplyElementwise((0.5, 1.5))

将50％的图像乘以0.5到1.5之间的随机值，并在剩余50％中乘以通道，即每个通道和像素独立地采样一个乘数：

aug = iaa.MultiplyElementwise((0.5, 1.5), per_channel=0.5)

三十三、Dropout 丢弃增强器

将图像中的某个像素设为零。

每个图像的采样值范围为0<=p<=0.2，然后将图像中p％像素转换为黑色像素：

aug = iaa.Dropout(p=(0, 0.2))

每个图像的样本值为0<=p<=0.2，然后将图像中p％像素转换为黑色像素，但在50％的图像中每个通道独立执行此操作：

aug = iaa.Dropout(p=(0, 0.2), per_channel=0.5)

三十四、CoarseDropout 矩形丢弃增强器

将图像中的矩形区域设置为零。

通过将所有像素转换为黑色像素来丢弃2％，但是在具有原始大小的50％的图像的较低分辨率版本上执行此操作，丢弃2x2的正方形：

aug = iaa.CoarseDropout(0.02, size_percent=0.5)

通过将它们转换为黑色像素，将0到5％的像素丢弃，但是在原始大小的5％到50％的图像的较低分辨率版本上执行此操作会导致丢弃大的矩形区域：

aug = iaa.CoarseDropout((0.0, 0.05), size_percent=(0.02, 0.25))

丢弃2％的图像，但是在具有原始大小的50％的图像的较低分辨率版本上执行此操作，丢弃2x2个正方形。 此外，在50％的图像通道中执行此操作，以便仅将某些通道的信息设置为0，而其他通道保持不变：

aug = iaa.CoarseDropout(0.02, size_percent=0.15, per_channel=0.5)

三十五、Invert 反转增强器

反转图像中的所有值，即将像素从值v设置为255-v。

在50％的图像中反转所有像素：

aug = iaa.Invert(0.5)

对于50％的图像，以25％的概率（每个图像）反转这些图像中的所有像素。 在剩余的50％的图像中，反转所有通道的25％：

aug = iaa.Invert(0.25, per_channel=0.5)

三十六、ContrastNormalization 对比度增强器

图像对比度增强器。

将对比度标准化0.5到1.5倍，每个图像随机采样：

aug = iaa.ContrastNormalization((0.5, 1.5))

将对比度标准化0.5到1.5倍，每个图像随机采样，每个通道独立采集50％的图像：

aug = iaa.ContrastNormalization((0.5, 1.5), per_channel=0.5)

三十七、Affine 仿射变换增强器

仿射变换增强器。

将图像缩放到原始大小的50到150％的值：

aug = iaa.Affine(scale=(0.5, 1.5))

将图像缩放到其原始大小的50到150％的值，但是每个轴独立地执行此操作（即，每个图像采样两个值）：

aug = iaa.Affine(scale={"x": (0.5, 1.5), "y": (0.5, 1.5)})

在x轴和y轴上独立地将图像平移-20到+20％：

aug = iaa.Affine(translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)})

在x轴和y轴上独立地将图像转换-20到20像素：

aug = iaa.Affine(translate_px={"x": (-20, 20), "y": (-20, 20)})

将图像旋转-45到45度：

aug = iaa.Affine(rotate=(-45, 45))

剪切图像-16到16度：

aug = iaa.Affine(shear=(-16, 16))

当应用仿射变换时，经常生成新的像素，例如， 在向左平移时，在右侧生成像素。 存在各种模式来设置应该如何填充这些像素。 下面的代码显示了一个使用所有模式的示例，每个图像随机采样。 如果模式是constant（用一个常量值填充全部），则使用0到255之间的随机亮度：

aug = iaa.Affine(translate_percent={"x": -0.20}, mode=ia.ALL, cval=(0, 255))

三十八、PiecewiseAffine 扭曲增强器

在图像上放置一个规则的点网格，并通过仿射变换随机移动这些点的邻域。 这会导致局部扭曲。

通过移动点来局部地扭曲图像，每个点具有距离v（相对于图像大小的百分比），其中z对于每个点从N(0，z)采样v对于每个图像从0.01到0.05的范围采样：

aug = iaa.PiecewiseAffine(scale=(0.01, 0.05))

可视化：scale从0.01增加到0.3：

PiecewiseAffine的工作原理是在图像上放置一个规则的点网格并移动它们。 默认情况下，此网格由4x4点组成。
可视化：从2x2增加到16x16：

三十九、ElasticTransformation 像素位移增强器

通过使用位移字段在本地移动像素来转换图像。

通过在强度为0.25的失真场后移动单个像素来局部扭曲图像。 每个像素的移动强度范围为0到5.0：

aug = iaa.ElasticTransformation(alpha=(0, 5.0), sigma=0.25)

可视化：保持sigma为0.25，alpha从0.0增加到5.0：

可视化：保持alpha为2.5，sigma从0.01增加到2.0：