imgaug的使用

1、安装

直接用pip install imgaug会报错，因为shapely没有找到，所以先要安装Shapely，直接pip也会报错，有可能会是：OSError: [WinError 126] 找不到指定的模块

解决办法是：

https://www.lfd.uci.edu/~gohlke/pythonlibs/

从连接中找到Shaply，下载对应自己python的版本

之后在文件的目录下，pip install 对应版本的.whl文件

之后

pip install git+https://github.com/aleju/imgaug #从github安装

或者
pip install imgaug

安装就绪之后就可使用

在使用过程中，可能会碰到numpy中找不到某些模块，我在使用时事bit_generate模块找不到，np.random.bit_generator，但是查看了numpy的代码，确实有这个模块，找不到问题所在，可能就是版本不对应，不太想在这里浪费太多时间，于是就

pip uninstall numpy

然后重新装了numpy就可以了。

2、使用

imgaug的说明文档：

https://imgaug.readthedocs.io/en/latest/source/examples_bounding_boxes.html

#标准用例
from imgaug import augmenters as iaa

seq = iaa.Sequential([
    iaa.Crop(px=(0, 16)), # 从图像的每条边随机裁剪0-16个像素
    iaa.Fliplr(0.5), # 将50%的图像进行水平翻转
    iaa.GaussianBlur(sigma=(0, 3.0)) # sigma0-3.0的高斯模糊
])

#一个batch读取1000张图片
for batch_idx in range(1000):
    # images格式是4D numpy array ： (N, height, width, channels)（图像个数、高、宽、通道数）
    # 或者是3D numpy arrays： (height, width, channels).
    # 灰度图是 (height, width, 1) .
    # 所有images 数据必须是uint8类型，大小在0到255之间
    images = load_batch(batch_idx) #加载图片
    images_aug = seq(images=images) #对图片进行增强
    #train_on_images(images_aug)  #其他的一些对增强后的图片操作

#裁剪、仿射、模糊、噪声等处理


import numpy as np
import imgaug as ia
import imgaug.augmenters as iaa
import imageio
import cv2


ia.seed(1)


# 示例是array (32, 64, 64, 3) uint8类型的.
#ia.quokka:以numpy数组的形式返回quokka（无尾熊）的图像。
images = np.array(
    [ia.quokka(size=(64, 64)) for _ in range(32)],
    dtype=np.uint8
)



seq = iaa.Sequential([
    iaa.Fliplr(0.5), # 水平翻转
    iaa.Crop(percent=(0, 0.1)), # 随机裁剪，裁剪的大小是0-10%

    # 对50%的图像进行高斯模糊，sigma值为0-0.5
    iaa.Sometimes(0.5,
        iaa.GaussianBlur(sigma=(0, 0.5))
    ),

    # 增强或减弱每张图的对比度
    iaa.ContrastNormalization((0.75, 1.5)),

    # 增加高斯噪声
    # 对50%的图像，我们对每个像素进行一次噪声采样
    # 对剩余的50%的图像进行每个像素和通道的noise，这样的操作会改变每个像素的颜色（不仅仅是亮度）
    iaa.AdditiveGaussianNoise(loc=0, scale=(0.0, 0.05*255), per_channel=0.5),

    # 将一些图像调亮，一些图像调暗
    # 对20%的图像，我们对每个通道multiply采样一次
    iaa.Multiply((0.8, 1.2), per_channel=0.2),

    # 将仿射变换应用于每个图像缩放、平移/移动、旋转和剪切。
    iaa.Affine(
        scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
        translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
        rotate=(-25, 25),
        shear=(-8, 8)
    )
], random_order=True) # 按随机顺序进行增强

images_aug = seq(images=images)

#更多的增强
import numpy as np
import imgaug as ia
import imgaug.augmenters as iaa


ia.seed(1)

# # 示例是array (32, 64, 64, 3) uint8类型的.
images = np.array(
    [ia.quokka(size=(64, 64)) for _ in range(32)],
    dtype=np.uint8
)

# Sometimes(0.5, ...) 对50%的图像进行增强操作
# 例：Sometimes(0.5, GaussianBlur(0.3)) 对一半的图进行高斯模糊
sometimes = lambda aug: iaa.Sometimes(0.5, aug)

# 定义将应用于每个图像的增强序列
seq = iaa.Sequential(
    [
        #
        # 对大多数图像应用以下增强程序。
        #
        iaa.Fliplr(0.5), # 对50%的图像进行水平翻转
        iaa.Flipud(0.2), # 20%的图像进行垂直翻转

        # 对一些图像进行裁剪， 0-10% of their height/width
        sometimes(iaa.Crop(percent=(0, 0.1))),

        # 对一些图像进行仿射变换
        # - 尺度变换 80-120% of image height/width (each axis independently)
        # - 转换：相对于高度/宽度（每个轴）范围是-20~+20
        # - 旋转 by -45 to +45 角
        # - 剪切 by -16 to +16 degrees
        # - order: 使用最近邻或双线性插值（快速）
        # - mode: 使用任何可用模式填充新创建的像素，API或sickit0image可看哪些模式是可用的
        # - cval: 如果模式是恒定的，则对新创建的像素使用随机亮度（例如，有时为黑色，有时为白色）
        sometimes(iaa.Affine(
            scale={"x": (0.8, 1.2), "y": (0.8, 1.2)},
            translate_percent={"x": (-0.2, 0.2), "y": (-0.2, 0.2)},
            rotate=(-45, 45),
            shear=(-16, 16),
            order=[0, 1],
            cval=(0, 255),
            mode=ia.ALL
        )),

        #
        # 为每个图像执行以下（不太重要）增强程序中的0到5个。不要把他们都执行，要不然增强的效果太强了，有点认不出来原图
        #
        iaa.SomeOf((0, 5),
            [
                # 将一些图像转换为它们的超级像素表示，
                # #每幅图像的样本量在20到200个超级混合体之间，但是
                # #不能用它们的平均值替换所有的超混合
                # #其中一些（p_replace）。
                sometimes(
                    iaa.Superpixels(
                        p_replace=(0, 1.0),
                        n_segments=(20, 200)
                    )
                ),

                # 使用不同的强度模糊每个图像
                # #高斯模糊（西格玛在0和3.0之间），
                # #平均/均匀模糊（内核大小介于2x2和7x7之间）
                # #中值模糊（内核大小介于3x3和11x11之间）。
                iaa.OneOf([
                    iaa.GaussianBlur((0, 3.0)),
                    iaa.AverageBlur(k=(2, 7)),
                    iaa.MedianBlur(k=(3, 11)),
                ]),

                # 对图像进行锐化， 将结果与原始结果重叠
                # #使用介于0（无锐化）和1之间的alpha的图像
                # #（完全锐化效果）。
                iaa.Sharpen(alpha=(0, 1.0), lightness=(0.75, 1.5)),

                # 进行浮雕效果的锐化
                iaa.Emboss(alpha=(0, 1.0), strength=(0, 2.0)),

                # 在某些图像中搜索所有边或
                # #定向边。然后用黑色标记这些边缘
                # #和白色图像，并与原始图像叠加
                # #使用0到0.7的alpha。
                sometimes(iaa.OneOf([
                    iaa.EdgeDetect(alpha=(0, 0.7)),
                    iaa.DirectedEdgeDetect(
                        alpha=(0, 0.7), direction=(0.0, 1.0)
                    ),
                ])),

                # 在一些图像中添加高斯噪声。
                # 在这些情况中，有50%的噪声是根据
                # 通道和像素。
                # 在其他50%的情况下，每个像素（即亮度变化）。
                iaa.AdditiveGaussianNoise(
                    loc=0, scale=(0.0, 0.05*255), per_channel=0.5
                ),


                #任意降低所有像素的1%到10%（即设置使它们变黑）或者在原尺寸上降低2-5%使大尺寸变小
                iaa.OneOf([
                    iaa.Dropout((0.01, 0.1), per_channel=0.5),
                    iaa.CoarseDropout(
                        (0.03, 0.15), size_percent=(0.02, 0.05),
                        per_channel=0.2
                    ),
                ]),

                # 以5%的概率反转每个图像的通道。
                # #这会将每个像素值v设置为255-v。
                iaa.Invert(0.05, per_channel=True), # 翻转颜色通道

                # 给每个像素值加-10~+10
                iaa.Add((-10, 10), per_channel=0.5),

                # 改变图片的亮度(原值的50-150% ).
                iaa.Multiply((0.5, 1.5), per_channel=0.5),

                # 改善或者降低图像的对比度
                iaa.ContrastNormalization((0.5, 2.0), per_channel=0.5),


                #将每个图像转换为灰度，然后结果与原始图像以随机alpha叠加。eg.移除不同强度的颜色。
                iaa.Grayscale(alpha=(0.0, 1.0)),

                # 在某些图像中，像素会局部移动（具有随机强度）。
                sometimes(
                    iaa.ElasticTransformation(alpha=(0.5, 3.5), sigma=0.25)
                ),

                # 在一些图像用强增强
                sometimes(iaa.PiecewiseAffine(scale=(0.01, 0.05)))
            ],
            # 随机进行上述的增强
            random_order=True
        )
    ],
    # 随机进行上述的增强
    random_order=True
)

images_aug = seq(images=images)