整体概要

变换类型	具体类
模糊/噪声	AdvancedBlur*，Blur*，Downscale*，Defocus*，GlassBlur*，GaussianBlur*，GaussNoise*，ImageCompression*，ISONoise*，MultiplicativeNoise*，MedianBlur*，MotionBlur*，ZoomBlur*
几何变换	Affine，Flip，GridDistortion，HorizontalFlip，OpticalDistortion，Perspective，PiecewiseAffine，RandomRotate90，Rotate，SafeRotate，ShiftScaleRotate，Transpose，VerticalFlip
裁剪/填充	BBoxSafeRandomCrop，Crop，CenterCrop，CropAndPad，CropNonEmptyMaskIfExists，PadIfNeeded，RandomCrop，RandomCropFromBorders，RandomCropNearBBox，RandomResizedCrop，RandomSizedBBoxSafeCrop，RandomSizedCrop
放缩	LongestMaxSize，RandomScale，Resize，SmallestMaxSize
图像直方图	CLAHE*，Equalize*，HistogramMatching*
图像基本属性	ColorJitter*，HueSaturationValue*，RandomToneCurve*，RandomBrightnessContrast*
数据类型变换	FromFloat*，ToGray*，ToFloat*，ToTensorV2，ToRGB*
Dropout	ChannelDropout*，CoarseDropout，Cutout*，GridDropout，MaskDropout，PixelDropout
特殊效果	RandomFog*，RandomRain*，RandomShadow*，RandomSnow*，RandomSunFlare*，Spatter*，RandomGravel*
其余图像增强	ChannelShuffle*，Emboss*，ElasticTransform，FDA*，FancyPCA*，InvertImg*，Lambda，Normalize*，PixelDistributionAdaptation*，Posterize*，RandomGamma*，RandomGridShuffle，RingingOvershoot*，RGBShift*，Sharpen*，Solarize*，Superpixels*，ToSepia*，TemplateTransform*，UnsharpMask*
工具类	Compose，OneOf，OneOrOther，ReplayCompose，Sequential，SomeOf

注：

• ImageOnlyTransform的子类（*标注）变换仅可应用于image。
• DualTransform的子类变换可应用于image，mask，masks，bboxes，keypoints。
• 斜体标注的图像增强，意味着可能会导致原图像宽高大小的不固定变化，使用时应注意。
• 以IAA开头的图像增强需要依靠另一个图像增强库imgaug，由于大部分这样的方法在albumentations中已有替代方案，原方法大多数已经弃用，故这里不再列出。
• JpegCompression已弃用，可用ImageCompression替代。
• RandomBrightness、RandomContrast已弃用，可用RandomBrightnessContrast替代。
• Github版本的Albumentations可能会比pip版本的多极少一部分图像增强方法。
• Albumentations的通常输入是numpy.ndarray，数据类型应为int或32位float。

---

详细说明

1、AdvancedBlur(ImageOnlyTransform): class

功能：使用随机参数的广义正态卷积核来模糊输入图像。这一转换会先向产生的随机参数卷积核添加乘法噪声，然后再应用卷积。（论文链接：https://arxiv.org/pdf/2107.10833.pdf）
初始化参数：
blur_limit: 用以模糊输入图像的最大高斯核大小。若为0则会根据sigma进行计算：round(sigma * (3 if img.dtype == np.uint8 else 4) * 2 + 1) + 1。若为单一值，则等同于(0, blur_limit)。（可以为二元整数tuple或者单一值，必须为[0, inf)间的0或奇数）（默认(3, 7)）
sigmaX_limit: x方向上高斯核的标准差。若为单一值则等同于(0, sigma_limit)。若为0则会如此计算：sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8。（可以为二元tuple或者单一值，必须在[0,inf)间）（默认0）
sigmaY_limit: y方向上高斯核的标准差，同上。
rotate_limit: 在给定范围内选择一个随机角度旋转高斯核。如果为单一值则等同于(-rotate_limit, rotate_limit)。（可以为二元整数tuple或单一值）（默认(-90, 90)）
beta_limit：分布形状参数，1为正态分布。低于1会使得分布尾部比正态分布更重，高于1会使得分布比正态分布更轻。（可以为二元tuple或单一值）（默认(0.5, 8.0)）
noise_limit: 控制卷积核噪声强度的乘法因子。如果设置为单一值则等同于(0, noise_limit)。（可以为二元tuple或单一值。必须为正值，最好是以1.0为中心的区间）（默认(0.75, 1.25)）
always_apply: 是否总应用。（bool）（默认False）
p：应用该转换的概率。（默认0.5）

t = A.AdvancedBlur(blur_limit=11, always_apply=True)
res_img = t(image=img)["image"]

2、Affine(DualTransform): class

功能：对图像应用仿射变换。（仿射变换涉及：图像平移，旋转，放缩，剪切）。
初始化参数：
scale: 放缩因子。1.0意味着没有变化，0.5意味着缩小到原来的50%。（可以为二元tuple、单值或者具有键“x”和“y”的字典（当keep_ratio=False时，对x、y轴使用不同的值才有意义））（默认None）
translate_percent: 以原图像的宽高比例为单位的平移。0意味着没有变化，0.5意味着移动该方向大小的一半。（可以为二元tuple、单值或者具有键“x”和“y”的字典）（默认None）
translate_px: 以像素为单位的平移。（可以为二元tuple、单值或者具有键“x”和“y”的字典）（默认None）
rotate: 旋转角度。旋转发生在图像的中心而不是左上角。（可以为固定值或者二元区间，若为区间则会在其中随机均匀采样）（默认None）
shear: 剪切角度。合理的值应位于[-45, 45]。（可以为固定值或者二元区间，若为区间则会在其中随机均匀采样，也可以为具有键“x”和“y”的字典）（默认None）
interpolation: 插值方法。（默认cv2.INTER_LINEAR）
mask_interpolation: 掩码插值方法（默认cv2.INTER_NEAREST）
cval: 填充新创建的像素时所使用的常数值。仅当mode=“constant”时有效。（默认0）
cval_mask: 类似cval但是仅对掩码有效。（默认0）
mode: opencv的边界填充策略。（默认cv2.BORDER_CONSTANT）
fit_output: 如果为True，则将调整图像平面的大小和位置，以在仿射变换后紧密地捕捉整个图像（忽略“translate_pcenter”和“translate-px”）。否则（“False”），变换后的图像的部分可能最终出现在图像平面之外。拟合输出形状对于避免应用旋转后图像的角在图像平面之外是有用的。（默认False）
keep_ratio: 若为True，在应用随机放缩后原始的宽高比会被保持。（默认False）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Affine(always_apply=True)
res_img = t(image=img)["image"]

t = A.Affine(shear={"x":30, "y":10}, fit_output=True, always_apply=True)
res_img = t(image=img)["image"]

3、Blur(ImageOnlyTransform): class

功能：使用随机大小的核模糊输入图像
初始化参数：
blur_limit: 用以模糊输入图像的最大核大小。（可以为int或二元int tuple）（默认(3, 7)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Blur((10, 11), always_apply=True)
res_img = t(image=img)["image"]

4、BboxParams(Params): class

功能：指定bounding box的类型参数。一般用在Compose实例的初始化参数中。
初始化参数：
format: bounding boxes的类型。（应为“coco”， “pascal_voc”，“albumentations”或者“yolo”。
“coco”格式：[x_min, y_min, width, height"]。
“pascal_voc”格式：[x_min, y_min, x_max, y_max]。
“albumentations”格式：如“pascal_voc”，但是归一化好了，即范围在[0,1]。
“yolo”格式：[x, y, width, height]，x，y指归一化的bbox中心；width，height指归一化的bbox宽高。
）
label_fields: 与boxes相关联的变量列表，应与boxes类型一致。（列表）（默认None）
min_area: 一个bounding box的最小面积。所有可见面积（像素单位）小于这个值的bounding box将被移除。（默认0.0）
min_visibility: 保持该box在列表中的最小面积比。（默认0.0）
check_each_transform: 如果为True，在每个dual transform后都会检查bboxes是否满足限制。（bool）（默认True）

5、BBoxSafeRandomCrop(DualTransform): class

功能：在不损失bboxes的条件下裁剪输入的一个随机部分。
初始化参数：
erosion_rate: 在裁剪前应用到图像的腐蚀高度比例（默认0，有可能损失bbox）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

bboxes = [[50, 50, 400, 350]]   # [x1, y1, width, height]
category_ids=[0]
t = A.Compose([
    A.BBoxSafeRandomCrop(erosion_rate=0.5, always_apply=True)],
    bbox_params=A.BboxParams(format='coco', label_fields=['category_ids']))
res = t(image=img, bboxes=bboxes, category_ids=category_ids)

6、Compose(BaseCompose): class

功能：组合transforms并且处理有关bounding boxes的变换
初始化参数：
transforms: 一系列组合的transformations（列表）
bbox_params: 用于bounding boxes变换的参数（BboxParams）（默认None）
keypoint_params: 用于关键点变换的参数（KeypointParams）（默认None）
additional_target: 具有“键(新target名称), 值(旧target名称)”的字典（dict）（默认None）
p: 应用所有变换的概率（默认1.0）

t = A.Compose([
    A.ColorJitter(),
    A.Flip(),
    A.GaussianBlur(blur_limit=(17, 19))
], p=1)
res_img = t(image=img)["image"]

7、Crop(DualTransform): class

功能：从图像中裁剪一个区域
初始化参数：
x_min, y_min, x_max, y_max: 裁剪区域在原图像左上方点x,y坐标和右下方x,y坐标（int）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.Crop(20, 20, 300, 300, always_apply=True)
res_img = t(image=img)["image"]

8、ColorJitter(ImageOnlyTransform): class

功能：随机变换图像的亮度，对比度和饱和度。注意与torchvision的ColorJitter相比可能会有些小区别。
初始化参数：
brightness: 改变亮度的程度。从区间[max(0, 1-brightness), 1+brightness]或给定[min, max]中均匀取值。（必须为非负数，可以为单一值或者二元序列）（默认0.2）
contrast: 改变对比度的程度。从区间[max(0, 1-contrast), 1+contrast]或给定[min, max]中均匀取值。（必须为非负数，可以为单一值或者二元序列）（默认0.2）
saturation: 改变饱和度的程度。从区间[max(0, 1-saturation), 1+saturation]或给定[min, max]中均匀取值。（必须为非负数，可以为单一值或者二元序列）（默认0.2）
hue: 改变色度的程度。从区间[-hue, hue]或给定[min, max]中均匀取值。（必须满足0<=hue<=0.5或者-0.5<=min<=max<=0.5，可以为单一值或者二元序列）（默认0.2）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ColorJitter(always_apply=True)
res_img = t(image=img)["image"]

9、CLAHE(ImageOnlyTransform): class

功能：限制对比度的自适应直方图均衡（CLAHE详解推荐这篇博文：https://blog.csdn.net/u9Oo9xkM169LeLDR84/article/details/107438106）
初始化参数：
clip_limit: 对比度阈值限制的界限（默认4.0）。若为单一值，则等同于(1, clip_limit)。（可以为单一值或二元序列）（默认(1, 4)）
tile_grid_size: 直方图均衡化使用的tile网格大小（二元序列）（默认(8,8)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.CLAHE(always_apply=True)
res_img = t(image=img)["image"]

10、Cutout(ImageOnlyTransform): class

功能：图像中方形区域的删除（论文链接：https://arxiv.org/abs/1708.04552）
初始化参数：
num_holes: 需要抹除的区域数量（int）（默认8）
max_h_size: 空洞的最大高度（int）（默认8）
max_w_size: 空洞的最大宽度（int）（默认8）
fill_value: 空洞的填充值（可以单一值或者列表）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Cutout(max_h_size=40, max_w_size=40, fill_value=0, always_apply=True)
res_img = t(image=img)["image"]

11、CenterCrop(DualTransform): class

功能：裁剪图像的中心区域
初始化参数：
height: 裁剪后的宽度（int）
width: 裁剪后的高度（int）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1）

t = A.CenterCrop(300, 300, always_apply=True)
res_img = t(image=img)["image"]

12、ChannelDropout(ImageOnlyTransform): class

功能：随机删除输入图像的一个色彩通道
初始化参数：
channel_drop_range: 选择删除通道的范围（二元Tuple，通道索引从1开始，并且不能删除全部通道）（默认(1, 1)）
fill_value: 删除后的通道用什么像素值填充（默认0）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ChannelDropout(channel_drop_range=(1, 2), always_apply=True)
res_img = t(image=img)["image"]

13、ChannelShuffle(ImageOnlyTransform): class

功能：随机排列输入RGB图像的色彩通道
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ChannelShuffle(always_apply=True)
res_img = t(image=img)["image"]

14、CoarseDropout(DualTransform): class

功能：随机删除图像的方形区域（论文链接：https://arxiv.org/abs/1708.04552）
初始化参数：
max_holes: 需要抹除的区域的最大数量（int）（默认8）
max_height: 单个区域的最大高度（若为浮点数，则视为图像高度的比例）（默认8）
max_weight: 单个区域的最大宽度（若为浮点数，则视为图像宽度的比例）（默认8）
min_holes: 需要抹除的区域的最小数量（int）（默认None）
min_height: 单个区域的最小高度（若为浮点数，则视为图像高度的比例）（int）（默认None）
min_weight: 单个区域的最小宽度（若为浮点数，则视为图像高度的比例）（int）（默认None）
fill_value: 对于删除后区域像素的填充值（int）（默认0）
mask_fill_value: 对于掩码中删除后区域的填充值（int）（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.CoarseDropout(always_apply=True)
res_img = t(image=img)["image"]

15、CropAndPad(DualTransform): class

功能：使用指定像素数量或者图像尺寸的比例裁剪和填充图像。裁剪将移除图像边缘的像素，填充将向图像边缘添加像素。此变换将永不裁剪高度或宽度小于1的图像。（注意：此变换自动将图像resize回他们原来的大小，若不希望这么做，请设置keep_size=False。）
初始化参数：
px: 需要在图像每侧裁剪（为负值）或者填充（正值）的像素量。（不能与percent同时设置。
  若为None，将禁用此项；
  若为int，将对每一侧应用给定值；
  若为二元tuple，则将从该tuple指定的区间中均匀采样：同时若same_independently为False，会采样一个值应用到图像的每一侧，否则采样不同值应用到图像的不同侧；
  若为四元tuple，那么就分别表示上右下左四个方向，每个方向可以指定一个单一值或者一个采样区间（二元tuple）或者一个采样列表（多元list）。）（默认None）
percent: 指定比例裁剪（负值）或填充（正值）在图像每一侧的像素数量。（必须位于(-1.0, inf)间，不能与px参数同时设置。
  若为None，将禁用此项；
  若为float，将对每一侧应用给定值；
  若为二元tuple，则将从该tuple指定的区间中均匀采样：同时若same_independently为False，会采样一个值应用到图像的每一侧，否则采样不同值应用到图像的不同侧；
  若为四元tuple，那么就分别表示上右下左四个方向，每个方向可以指定一个单一值或者一个采样区间（二元tuple）或者一个采样列表（多元list）。）（默认None）
pad_mode: OpenCV边界模式。（默认None）
pad_cval: 若pad_mode为“BORDER_CONSTANT”，此项指定要填充的常数值。（
若为单值，将使用该值；
若为二元tuple，若其中至少一个是float，则将从该连续区间中均匀采样并用作填充值；若均为int，则该采样区间视为离散区间；
若为多元list，则会从该列表中随机选择一个元素作为填充值。）（默认None）
pad_cval_mask: 与cval相同但仅对mask有效（默认None）
keep_size: 在裁剪和填充之后，是否要resize回图像原来大小。（bool）（默认True）
same_independently: 若为False，则px/percent从区间采样或从列表采样的值可以分别作用到图像的不同侧。（bool）（默认True）
interpolation: 插值模式。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.CropAndPad(px=[(30,40), (40,50), (50,60), (60,70)], keep_size=True, always_apply=True)
res_img = t(image=img)["image"]

16、CropNonEmptyMaskIfExists(DualTransform): class

功能：如果mask非空，则用mask裁剪图像（感觉上是尽量裁剪到mask附近的区域）；否则随机裁剪。
初始化参数：
height: 像素单位的裁剪后竖直方向大小。（int）
width：像素单位的裁剪后水平方向大小。（int）
ignore_values: 需要忽略的mask上的值，“0”值是永远忽略的。（int列表）（默认None）
ignore_channels: 需要忽略的mask上的通道。（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

mask = np.zeros(img[:,:,0].shape)
mask[100:300, 200:400] = 1
t = A.CropNonEmptyMaskIfExists(200, 200, always_apply=True)
res= t(image=img, mask=mask)
res_img = res["image"]
res_mask = res["mask"]

17、Downscale(ImageOnlyTransform): class

功能：通过先下采样再上采样来降低图像质量
初始化参数：
scale_min: 图像放缩的下界。（应小于1）（默认0.25）
scale_max: 图像放缩的上界。（应小于1）（默认0.25）
interpolation: cv2插值方法。（单一值，该方法将同时应用于下采样和上采样；字典{downscale=flag1, upscale=flag2)；Downscale.Interpolation(downscale=flag1, upscale=flag2)）（默认None，即Interpolation(downscale=cv2.INTER_NEAREST, upscale=cv2.INTER_NEAREST)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Downscale(scale_min=0.1, scale_max=0.3, interpolation={"downscale":cv2.INTER_NEAREST, "upscale":cv2.INTER_LINEAR},
                always_apply=True)

18、Defocus(ImageOnlyTransform): class

功能：应用defocus图像增强。（论文链接：https://arxiv.org/abs/1903.12261）
初始化参数：
radius: 失焦的半径的范围。（int或二元int元组，若为单一值，等效于[1,limit]）（默认(3, 10)）
alias_blur: 失焦的alias_blur的范围（高斯模糊的sigma）。（float或二元float数组，若为单一值，等效于(0, limit)）（默认(0.1, 0.5)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Defocus(always_apply=True)
res_img = t(image=img)["image"]

19、Emboss(ImageOnlyTransform): class

功能：对输入图像进行浮雕，并将结果与原始图像叠加。
初始化参数：
alpha: 设置浮雕后图像的可见性的范围。（二元tuple。若为0，则只有原始图像可见；若为1，则只有浮雕版本可见。）（默认(0.2, 0.5)）
strength: 浮雕化的强度范围。（二元tuple）（默认(0.2, 0.7)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Emboss(alpha=(0.7, 0.8), always_apply=True)
res_img = t(image=img)["image"]

20、Equalize(ImageOnlyTransform): class

功能：均衡化图像直方图。
初始化参数：
mode: 使用OpenCV还是Pillow均衡化方法。（{‘cv’, ‘pil’}）（默认"cv"）
by_channels: 若为True，则均衡化将分别应用到各个色彩通道，否则将把图像转化到YCbCr表示并对“Y”通道进行均衡化。（bool）（默认True）
mask: 如果指定，只有被mask选中的像素需要包含在分析中。（可以为1通道或3通道numpy.ndarray或可调用对象（“image”参数必须在函数签名中包含））（默认None）
mask_params: mask函数的参数（str列表）（默认()）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Equalize(always_apply=True)
res_img = t(image=img)["image"]

mask = np.zeros(img[:, :, 0].shape)
mask[0:100, 0:100] = 1    # 选择图像左上角的一个方形区域
t = A.Equalize(mask=mask, always_apply=True)
res_img = t(image=img)["image"]

def getLarger(image, thr):	# 只选择值大于界限thr的像素
    image = image.copy()
    image[image<thr] = 0
    return image
t = A.Equalize(mask=getLarger, mask_params=["thr"], always_apply=True)
res_img = t(image=img, thr=100)["image"]	# 调用变换时需指定thr参数

21、ElasticTransform(DualTransform): class

功能：对图像应用弹性变换。（参考链接：https://gist.github.com/ernestum/601cdf56d2b424757de5）总而言之，就是先从范围为[-1, 1]的均匀分布中采样生成替换流，然后利用标准差为σ（也称弹性因子）的高斯卷积处理替换流，再将替换流乘上一个放缩因子α，最后再利用处理后的替换流对原图像进行处理即可得到变形后的图像。（这里的σ应当取适当值，值较大会接近仿射变换）。当然实际实现中可能会略有不同。
初始化参数：
alpha: 放缩因子。（默认1）
sigma: 弹性因子，高斯滤波器参数。（默认50）
alpha_affine: 均匀采样的值范围。（float，表示区间(-alpha_affine, alpha_affine)）（默认50）
interpolation: 指定插值方法。（默认cv2.INTER_LINEAR）
border_mode: 指定边缘填充方法。（默认cv2.BORDER_REFLECT_101）
value: 如果边缘填充为常数填充，则此项用于指定填充的常数值。（默认None）
mask_value: 如果边缘填充为常数填充，则此项用于指定mask填充的常数值。（默认None）
always_apply: 是否总应用。（bool）（默认False）
approximate: 是否以固定的卷积核大小对替换图进行平滑，启用此项将可以获得在大图像上2倍的速度提升。（bool）（默认False）
same_dxdy: 是否对x方向和y方向使用相同的随机变换，启用此项将可以获得在打突袭上2倍的速度提升。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ElasticTransform(always_apply=True)
res_img = t(image=img)["image"]

22、FDA(ImageOnlyTransform): class

功能：傅里叶域变换。（参考链接：https://github.com/YanchaoYang/FDA）将target_img与img进行傅里叶变换到频域空间后，将target_img对应频域图像中的幅度图的中心区域（即低频区域，指图像灰度变化平坦的部分，与之相反的高频区域即指图像灰度变化剧烈的部分如边缘、轮廓等）（量由beta参数控制）替换到img对应频域图像中的幅度图的相应位置中去，再将结果图像进行傅里叶变换的逆变换重新变换回空间域。
初始化参数：
reference_images: 参考图像路径的列表（默认）或参考图像的列表。（str列表或者numpy.ndarray列表）
beta_limit: 论文中的beta系数，建议在0.3以下。（默认0.1）
read_fn: 使用该函数读取图像。该函数应该返回关于图像像素的numpy array。（默认read_rgb_image）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.FDA(reference_images=[img2_path], beta_limit=0.01, always_apply=True)
res_img = t(image=img)["image"]

23、Flip(DualTransform): class

功能：对输入进行水平、垂直或水平垂直翻转。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Flip(always_apply=True)
res_img = t(image=img)["image"]

24、FancyPCA(ImageOnlyTransform): class

功能：对图像应用fancy PCA（论文：http://papers.nips.cc/paper/4824-imagenet-classification-with-deep-convolutional-neural-networks.pdf）。简单来说就是让图像矩阵，加上根据由图像本身色彩通道处理得到的某个特殊矩阵，以此来实现图像增强。（个人理解是一种基本不影响原图像所有语义信息的图像增强）
初始化参数：
alpha: 扰动/放缩特征向量和特征值的幅度。scale将从高斯分布(mu=0,sigma=alpha)中采样。（默认0.1）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.FancyPCA(alpha=0.5)
res_img = t(image=img)["image"]

25、FromFloat(ImageOnlyTransform): class

功能：输入一个所有值都处于[0, 1.0]范围内的数组，将它乘上“max_value”然后转化结果值到“dtype”指定的数据类型。如果“max_value”为None，这个变换将尝试通过“dtype”数据类型推断最大值。
初始化参数：
max_value: 最大可能的输入值。（默认None）
dtype: 输出的数据类型。（默认’uint16’）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.FromFloat(max_value=150, always_apply=True)
res_img = t(image=img/255.)["image"]

26、GlassBlur(Blur): class

功能：为输入图像添加玻璃模糊。（参考链接：https://arxiv.org/abs/1903.12261）通过高斯模糊以及迭代地交换一定距离的图像像素实现。
初始化参数：
sigma: 高斯核的标准差。（默认0.7）
max_delta: 交换像素的最大距离。（int）（默认4）
iterations: 迭代的次数。（int，必须位于[1, inf)之间）（默认2）
always_apply: 是否总应用。（bool）（默认False）
mode: 计算模式。（{‘fast’, ‘exact’}）（默认“fast”）
p: 应用该变换的概率。（默认0.5）

t = A.GlassBlur(always_apply=True)
res_img = t(image=img)["image"]

27、GaussianBlur(ImageOnlyTransform): class

功能：使用随机大小的高斯卷积核对输入图像进行模糊。
初始化参数：
blur_limit: 用来模糊输入图像的最大高斯核大小。若为0则会根据sigma进行计算：round(sigma * (3 if img.dtype == np.uint8 else 4) * 2 + 1) + 1。若为单一值，则等同于(0, blur_limit)。（可以为二元整数tuple或者单一值，必须为[0, inf)间的0或奇数）（默认(3, 7)）
sigma_limit: 高斯核标准差。若为单一值则等同于(0, sigma_limit)。若为0则会如此计算：sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8。（可以为二元tuple或者单一值，必须在[0,inf)间）（默认0）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.GaussianBlur(blur_limit=(9, 11), always_apply=True)
res_img = t(image=img)["image"]

28、GaussNoise(ImageOnlyTransform): class

功能：向输入图像中添加高斯噪声。
初始化参数：
var_limit: 噪声的方差范围。（可以为单一值或者二元tuple。若为单一值，则等同于(0, var_limit)）（默认(10.0, 50.0)）
mean: 噪声的均值。（默认0）
per_channel: 如果设置为True，噪声会分别对各个色彩通道采样；否则，噪声将仅采样一次并应用到所有通道上。（bool）（默认True）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.GaussNoise(var_limit=(80, 100), always_apply=True)
res_img = t(image=img)["image"]

29、GridDistortion(DualTransform): class

功能：网格变形。（参考链接：https://github.com/albumentations-team/albumentations/pull/722）
初始化参数：
num_steps: 每一侧的网格数量。（int）（默认5）
distort_limit: 变形界限。（单一值或者二元tuple。若为单一值，等同于(-distort_limit, distort_limit)）（默认0.3）
interpolation: 指定插值算法。（int）（默认cv2.INTER_LINEAR）
border_mode: 指定边界填充算法。（int）（默认cv2.BORDER_REFLECT_101）
value: 若边界填充为常数填充模式，则此项指定填充值。（默认None）
mask_value: 若边界填充为常数填充模式，则此项指定mask填充值。（默认None）
normalized: 若为True，则变形会被归一化，以防止超出图像。（bool）（False）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.GridDistortion(always_apply=True)
res_img = t(image=img)["image"]

t = A.GridDistortion(num_steps=50, normalized=True, always_apply=True)
res_img = t(image=img)["image"]

30、GridDropout(DualTransform): class

功能：以网格形式删除图像和对应mask的方形区域。（参考链接：https://arxiv.org/abs/2001.04086）
初始化参数：
ratio: 相对于unit_size的掩码空洞比例（水平和垂直方向相同）（必须位于0和1之间）（默认0.5）
unit_size_min: 网格单元的最小大小。（int，必须位于2和图像短边大小之间。若为None，holes_number_x和holes_number_y将用于建立grid。）（默认None）
unit_size_max: 网格单元的最大大小。（int，必须位于2和图像短边大小之间。若为None，holes_number_x和holes_number_y将用于建立grid。）（默认None）
holes_number_x: x方向上网格单元的数量。（int，必须位于1和image width//2之间。若为None，网格单元宽度将设为image_width//10。）（默认None）
holes_number_y: y方向上网格单元的数量。（int，必须位于1和image height//2之间。若为None，网格单元高度将等同于网格单元宽度和图像高度中的较小值）（默认None）
shift_x: x方向上从(0,0)坐标的网格偏移。裁剪至0和网格unit_width-hole_width之间。（int）（默认None）
shift_y: y方向上从(0,0)坐标的网格偏移。裁剪至0和网格unit_height-hole_height之间。（int）（默认None）
random_offset: 是否随机用0到网格unit size-hole size间的值设置偏移。若为True，则shift_x和shift_y将被忽略，偏移将被随机设置。（bool）（默认False）
fill_value: 删除后像素的填充值。（int）（默认None）
mask_fill_value: mask删除后像素的填充值。（int）（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.GridDropout(always_apply=True)
res_img = t(image=img)["image"]

31、HistogramMatching(ImageOnlyTransform): class

功能：应用直方图匹配。它操纵输入图像的像素，使其直方图与参考图像的直方图相匹配。如果图像具有多个通道，则只要输入图像和参考中的通道数量相等，就对每个通道独立地进行匹配。直方图匹配可以用作图像处理的轻量级归一化，例如特征匹配，特别是在图像是从不同来源或在不同条件下（即照明）拍摄的情况下。（参考链接：https://scikit-image.org/docs/dev/auto_examples/color_exposure/plot_histogram_matching.html）
初始化参数：
reference_images: 参考图像的文件路径的列表（默认）或者参考图像的列表。
blend_ratio: 混合比例的上下限。匹配图像将以随机因子与原图像混合，以增加产生图像的多样性。（二元tuple）（默认(0.5, 1.0)）
read_fn: 使用自定义的方法去读取图像。该方法应当能获取图像路径并返回图像的numpy.ndarray。（默认read_rgb_image）。
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.HistogramMatching(reference_images=[img2_path], blend_ratio=(0.9, 1.0), always_apply=True)
res_img = t(image=img)["image"]

32、HorizontalFlip(DualTransform): class

功能：沿y轴对输入进行水平翻转
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.HorizontalFlip(always_apply=True)
res_img = t(image=img)["image"]

33、HueSaturationValue(ImageOnlyTransform): class

功能：随机改变输入图像的色度，饱和度和值。
初始化参数：
hue_shift_limit: 改变色度的范围。（可为int或二元int元组。若为单一值，则等同于(-hue_shift_limit, hue_shift_limit)）（默认(-20, 20)）
sat_shift_limit: 改变饱和度的范围。（可为int或二元int元组。若为单一值，则等同于(-sat_shift_limit, sat_shift_limit)）（默认(-30, 30)）
val_shift_limit: 改变值的范围。（可为int或二元int元组。若为单一值，则等同于(-val_shift_limit, val_shift_limit)）（默认(-20, 20)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.HueSaturationValue(always_apply=True)
res_img = t(image=img)["image"]

34、ImageCompression(ImageOnlyTransform): class

功能：降低Jpeg，WebP格式图像的压缩。
初始化参数：
quality_lower: 图像质量的下界。（对于Jpeg，必须在范围[0,100]内；对于webp，必须在范围[1,100]内。）（默认99）
quality_upper: 图像质量的上界。（对于Jpeg，必须在范围[0,100]内；对于webp，必须在范围[1,100]内。）（默认100）
compression_type: 压缩类型。（必须为ImageCompressionType.JPEG或ImageCompressionType.WEBP）（默认ImageCompressionType.JPEG）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ImageCompression(always_apply=True, quality_lower=10, quality_upper=30)
res_img = t(image=img)["image"]

35、InvertImg(ImageOnlyTransform): class

功能：通过使用255减去图像像素值来翻转输入图像。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.InvertImg(always_apply=True)
res_img = t(image=img)["image"]

36、ISONoise(ImageOnlyTransform): class

功能：添加摄像机传感器噪声。
初始化参数：
color_shift: 颜色色度变化的方差范围。以在HLS色彩空间的360度色度角度比例测量。（二元tuple）（默认(0.01, 0.05)）
intensity: 控制色彩强度和光照噪声的乘法因子。（二元tuple）（默认(0.1, 0.5)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ISONoise(color_shift=(0.1, 0.5), intensity=(0.4, 0.5), always_apply=True)
res_img = t(image=img)["image"]

37、KeypointParams(Params): class

功能: 关键点的参数。
初始化参数：
format: 关键点的格式。（{‘xy’, ‘yx’, ‘xya’, ‘xys’, ‘xyas’, ‘xysa’}，其中x指x坐标，y指y坐标，s指关键点尺度，a指以角度或弧度为单位（取决于KeypointParams.angle_in_degrees）的关键点方向）（str）
label_fields: 与关键点相关联的变量列表，例如labels。（应与关键点同样类型）（默认None）
remove_invisible: 是否删除掉变换后不可见的点。（bool）（默认True）
angle_in_degrees: 在’xya’，‘xyas’，'xysa’模式下的关键点的角以角度还是弧度为单位。（bool）（默认True）
check_each_transform: 如果为True，则在每次dual transform后都检查关键点。（bool）（默认True）

38、Lambda(NoOp): class

功能：一个灵活的转换类，用于每个目标使用用户定义的转换函数。函数签名必须包括**kwargs才能接受插值方法、图像大小等可选参数。
初始化参数：
image: 图像转换函数。（callable）（默认None）
mask: 掩码转换函数。（callable）（默认None）
keypoint：关键点转换函数。（callable）（默认None）
bbox：BBox转换函数。（callable）（默认None）
always_apply: 表示这个变换是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.Lambda(image=lambda x, **kwargs: x // 2, always_apply=True)    # 包括**kwargs是必要的
res_img = t(image=img)["image"]

39、LongestMaxSize(DualTransform): class

功能：重新调整图像的尺度，以使得最大边与max_size相等，同时保持原始图像的长宽比。
初始化参数：
max_size: 变换后图像的最大大小。（int或int列表，如果是一个列表，最大值将会从该列表中随机选择。）（默认1024）
interpolation: 插值方法。（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.LongestMaxSize(always_apply=True)
res_img = t(image=img)["image"]

40、MultiplicativeNoise(ImageOnlyTransform): class

功能：将图像乘上一个随机数或一个随机数组。
初始化参数：
multiplier: 若为单一值图像会乘上这个值，若为元组，则会从[multiplier[0], multiplier[1])中取随机值用作乘数。（可为单一值或者多元元组）（默认(0.9, 1.1)）
per_channel: 若为False，相同的值会被使用在所有通道上；若为True，将对各个通道分别采样。（bool）（默认False）
elementwise: 如果False，则将图像中的所有像素与采样一次的随机值相乘。如果True，则将图像像素与按像素随机采样的值相乘。（bool）（默认False）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.MultiplicativeNoise(multiplier=(0.2, 0.8), per_channel=True, elementwise=True, always_apply=True)
res_img = t(image=img)["image"]

41、MedianBlur(Blur): class

功能：使用随机核大小的均值滤波器模糊输入图像。
初始化参数：
blur_limit: 模糊输入图像的最大核大小。（int或二元int元组，必须是位于[3, inf)的奇数。若为单一值等同于(3, blur_limit)）（默认7）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.MedianBlur(always_apply=True)
res_img = t(image=img)["image"]

42、MotionBlur(Blur): class

功能：使用随机核大小对输入图像应用运动模糊。
初始化参数：
blur_limit: 模糊输入图像的最大核大小。（int或二元int元组，必须是位于[3, inf)的奇数。若为单一值等同于(3, blur_limit)）（默认7）
allow_shifted: 如果设置为True，将仅仅创建无偏移的核；否则创建随机偏移的核。（bool）（默认True）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.MedianBlur(blur_limit=(17, 19), always_apply=True)
res_img = t(image=img)["image"]

43、MaskDropout(DualTransform): class

功能：图像和遮罩增强，将遮罩和对应于从遮罩中随机选择的对象实例的图像区域清零。掩码必须是单通道图像，零值被视为背景。图像可以是任意数量的通道。（参考链接：https://www.kaggle.com/c/severstal-steel-defect-detection/discussion/114254）
初始化参数：
max_objects: 能被清零的最大标签数量。（可为int或二元int元组，若为元组则等同于[min, max]中随机选择值作为最大数量。）（默认1）
image_fill_value: 填充图像时使用的填充值。（数值，也可为’inpaint’以应用修补（必须为3通道图像），实现只清零mask效果）（默认0）
mask_fill_value: 填充遮罩时使用的填充值。（默认0）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

mask = np.zeros(img[:, :, 0].shape)
mask[20:100, 20:100] = 1
mask[110:160, 120:200] = 1
mask[220: 300, 210:280] = 1
mask[310: 380, 300:380] = 1
t = A.MaskDropout(max_objects=4, always_apply=True)
res = t(image=img, mask=mask)
res_img = res["image"]
res_mask = res["mask"]

mask = np.zeros(img[:, :, 0].shape)
mask[20:100, 20:100] = 1
mask[110:160, 120:200] = 1
mask[220: 300, 210:280] = 1
mask[310: 380, 300:380] = 1
t = A.MaskDropout(max_objects=4, image_fill_value="inpaint", always_apply=True)
res = t(image=img, mask=mask)
res_img = res["image"]
res_mask = res["mask"]

44、NoOp(DualTransform): class

功能：无操作。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

45、Normalize(ImageOnlyTransform): class

功能：用以下公式进行标准化：img = (img - mean * max_pixel_value) / (std * max_pixel_value)。
初始化参数：
mean: 均值。（float或float序列）（默认(0.485, 0.456, 0.406)）
std: 方差。（float或float序列）（默认(0.229, 0.224, 0.225)）
max_pixel_value: 最大可能的像素值。（默认255.0）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.Normalize(always_apply=True)
res_img = t(image=img)["image"]

t = A.Normalize(mean=0, std=1, always_apply=True)
res_img = t(image=img)["image"]

46、OneOf(BaseCompose): class

功能：选择其中一个变换应用。被选中的变换将被以“force_apply=True”调用。单一变换的概率将作为权重考虑，每个变换选中的概率将是其归一化后的加权概率。
初始化参数：
transforms: 一系列候选的变换。
p: 执行OneOf整体逻辑的概率。（默认0.5）

t = A.OneOf([
    A.ColorJitter(),
    A.Flip(),
    A.GaussianBlur(blur_limit=(17, 19))
], p=1)
res_img = t(image=img)["image"]

47、OneOrOther(BaseCompose): class

功能：选择一个或者另一个变换应用。被选中的变换将被以“force_apply=True”调用。
初始化参数：
first: 若transforms没有设置，则此项设置第一个变换。（默认None）
second: 若transforms没有设置，则此项设置第二个变换。（默认None）
transforms: 变换列表。（列表，长度必须为2。）（默认None）
p: 应用第一个变换的概率。（默认0.5）

t = A.OneOrOther(transforms=[
    A.ColorJitter(p=1),
    A.Flip(p=1)
], p=1)
res_img = t(image=img)["image"]

48、OpticalDistortion(DualTransform): class

功能：桶形/枕形变形。非常规增强。（参考链接：https://stackoverflow.com/questions/6199636/formulas-for-barrel-pincushion-distortion）。当透镜的放大倍数伴随着轴向距离减小的时候，每个图像上的点径向地向图像中心移动，导致了桶形畸变的发生。这就形成了典型的“桶”形状。桶变形模型为：ru = rd*(1+k*rd^2)；其中ru和rd分别为到无变形图像和变形图像失真位置中心的距离，k是与透镜有关的变形参数。

初始化参数：
distort_limit: 变形参数k。（单一值或二元元组，若为单一值，等同于(-distort_limit, distort_limit)）（默认0.05）
shift_limit: 形变中心的偏移量。（单一值或二元元组，若为单一值，等同于(-shift_limit, shift_limit)）（默认0.05）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
border_mode: 边界填充方法。（int）（默认cv2.BORDER_REFLECT_101）
value: 若边界填充方法为常数填充，则此项指定填充值。（默认None）
mask_value: 若边界填充方法为常数填充，则此项指定mask填充值。（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.OpticalDistortion(distort_limit=2, always_apply=True)
res_img = t(image=img)["image"]

49、PadIfNeeded(DualTransform): class

功能：如果图像边缘比期望数字小，那么将其填充。
初始化参数：
min_height: 最小结果图像高度。（int）（默认1024）
min_width: 最小结果图像宽度。（int）（默认1024）
pad_height_divisor: 如果非None，保证图像高度是可以被此值整除。（int）（默认None）
pad_width_divisor: 如果非None，保证图像宽度是可以被此值整除。（int）（默认None）
position: 图像位置。（应为PositionType.CENTER或PositionType.TOP_LEFT或PositionType.TOP_RIGHT或PositionType.BOTTOM_LEFT或PositionType.BOTTOM_RIGHT或PositionType.RANDOM）（默认PositionType.CENTER）
border_mode: OpenCV边缘填充模式。（默认int）（默认cv2.BORDER_REFLECT_101）
value: 如果边缘填充模式为常数填充，则此项指定填充值。（默认None）
mask_value: 如果边缘填充模式为常数填充，则此项指定mask填充值。（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.PadIfNeeded(border_mode=cv2.BORDER_CONSTANT, always_apply=True)
res_img = t(image=img)["image"]

50、Perspective(DualTransform): class

功能：应用随机四点视角变换到输入上。
初始化参数：
scale: 正态分布的标准差。用于采样子图像的角与完整图像的角的随机距离。（可以为单一值或者二元tuple。如果是个单一值，等同于(0, scale)）（默认0.05, 0.1）
keep_size: 应用视角变换后是否将图像resize回初始大小。如果为False，输出图像可能最终会具有不同的形状，并总是一个列表而不是array。（bool）（默认True）
pad_mode: OpenCV边界填充模式。（int）（默认cv2.BORDER_CONSTANT）
pad_val: 如果填充模式为常数填充，则此项指定填充值。（默认0）
mask_pad_val: 如果填充模式为常数填充，则此项指定mask填充值。（默认0）
fit_output: 如果为True，则将调整图像平面的大小和位置，以便在透视变换后仍然捕获整个图像。（如果keep_size设置为True，则在resize图像前进行。）否则，变换图像的部分可能在图像平面之外。当使用大比例值时，此设置不应设置为True，因为它可能会导致非常大的图像。（bool）（默认False）
interpolation: 插值方法。（int）（cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Perspective(always_apply=True)
res_img = t(image=img)["image"]

51、PiecewiseAffine(DualTransform): class

功能：应用局部邻域之间不同的仿射变换。这种增强将点的规则网格放置在图像上，并通过仿射变换随机移动这些点的邻域。这会导致局部失真。（注意：这个图像增强器非常慢。尝试使用ElasticTransformation作为替代，其具有10倍的速度提升效果。）（注意：对于基于坐标的输入如关键点、bounding box、多边形等，这个增强器仍会使用一个基于图像的增强，这会导致比其他变换更慢并且不是完全正确的结果。）
初始化参数：
scale: 规则网格上的每个点都通过正态分布进行移动。这个scale因子相当于正态分布的sigma。请注意，如果“absolute_scale=False”（默认值），抖动（每个点在哪个方向上移动了多远）将乘以图像的高度/宽度，因此对于不同大小的图像，该比例可以是相同的。（建议值取在0.01和0.05之间（从弱到强的增强））（可以为单一值或二元tuple，若为单一值，则该值总会被用作scale；若为二元tuple，会从该闭区间中均匀采样一个随机值给每个图像。）（默认(0.03, 0.05)）
nb_rows: 规则网格应该具有的点的行数。（int或int元组。至少为2，对于大图像，建议取大于4的值，你因此需要调整scale到较小值。若为单一int，则该值总会被用作行数；若为二元tuple，则会从该闭离散区间中均匀采样一个值给每个图像。）（默认4）
nb_cols: 列数，与“nb_rows”相似。（默认4）
interpolation: 插值方法序号。（int，应在0-5之间。 - 0: Nearest-neighbor; - 1: Bi-linear (default); - 2: Bi-quadratic; - 3: Bi-cubic; - 4: Bi-quartic; - 5: Bi-quintic）（默认1）
mask_interpolation: 与interpolation一致但是是用于mask。（int）（默认0）
cval: 当填充一个新创建的像素时使用的常数值。（int）（默认0）
cval_mask: 与cval一致但是是用于mask。（int）（默认0）
mode: 位于输入边界外的点将用此模式填充（str）（默认"constant"）
absolute_scale: 是否将scale视为一个绝对值。（bool）（默认False）
always_apply: 是否总应用。（bool）（默认False）
keypoints_threshold: 用于由距离图向关键点转换时的界限。通过搜索每个通道中的argmin（非反转）或argmax（反转）来搜索关键点。此参数包含要接受的最大（非反转）或最小（反转）值，以便将命中视为关键点。使用None来禁用min/max。（默认0.01）
p: 应用该变换的概率。（默认0.5）

t = A.PiecewiseAffine(nb_rows=8, nb_cols=8, always_apply=True)
res_img = t(image=img)["image"]

52、PixelDropout(DualTransform): class

功能：随机将一些像素点设为0。
初始化参数：
dropout_prob: 像素删除概率。（默认0.01）
per_channel: 若为True，drop掩码会分别对每个通道进行采样；否则对所有通道应用相同的掩码。（bool）（默认False）
drop_value: 删除后的位置将被填充的值。（如果设为None将填充随机值）（默认0）
mask_drop_value: 在mask中删除后位置将被填充的值。（如果设为None将不改变原值。）（默认0）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.PixelDropout(always_apply=True)
res_img = t(image=img)["image"]

53、PixelDistributionAdaptation(ImageOnlyTransform): class

功能：另一个简单而快速的像素级域自适应。它在原始图像和参考图像上拟合一个简单的变换（如PCA、StandardScaler或MinMaxScaler），使用在该图像上训练的变换来变换原始图像，然后使用在参考图像上匹配的变换来执行逆变换。（参考链接：https://github.com/arsenyinfo/qudida）
初始化参数：
references_images: 参考图像的文件路径列表（默认）或者参考图像列表。（str列表或numpy.ndarray列表）
blend_ratio: 混合比例的上限和下限。匹配的图像会与原图像以一个随机比例混合，以增强生成图像的多样性。（二元tuple）（默认0.25, 1.0）
read_fn: 读取图像的自定义函数。该函数应当获取图像路径并返回关于图像的numpy.ndarray。（默认read_rgb_image）
transform_type: 转换类型。（{‘pca’, ‘standard’, ‘minmax‘}）（默认’pca’）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.PixelDistributionAdaptation([img2_path], always_apply=True)
res_img = t(image=img)["image"]

54、Posterize(ImageOnlyTransform): class

功能：减少每个色彩通道的bit数（保留高位若干位，低位置0）。
初始化参数：
num_bits: 保留的高位bit数量。（必须位于范围[0, 8]内。可以为(int,int）或者int，或者int列表[r,g,b]或者[[r1,r2],[g1,g2],[b1,b2]]。如果为单一值，则等同于[num_bits, num_bits]）（默认4）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Posterize(num_bits=(1, 4), always_apply=True)
res_img = t(image=img)["image"]

55、RandomBrightnessContrast(ImageOnlyTransform): class

功能：随机改变输入图像的亮度和对比度。
初始化参数：
brightness_limit: 改变亮度的范围。（单一值或二元tuple，若为单一值，等效于(-limit, limit)）（默认(-0.2, 0.2)）
contrast_limit: 改变对比度的范围。（单一值或二元tuple，若为单一值，等效于(-limit, limit)）（默认(-0.2, 0.2)）
brightness_by_max: 若为True则通过图像数据类型最大值调整对比度，不然通过均值调整对比度。（bool）（默认True）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomBrightnessContrast(always_apply=True)
res_img = t(image=img)["image"]

56、RandomCrop(DualTransform): class

功能：裁剪输入的一个随机部分。
初始化参数：
height: 输出高度。（int）
width：输出宽度。（int）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.RandomCrop(300, 300, always_apply=True)
res_img = t(image=img)["image"]

57、RandomCropFromBorders(DualTransform): class

功能：从距离边缘的随机位置裁剪输入图像，并最终不进行resize。
初始化参数：
crop_left: 图像将被从距离左边缘[0, crop_left*width]中的随机位置剪切。（必须为(0.0, 1.0)中的单一值）（默认0.1）
crop_right: 图像将被从距离右边缘[0, (1-crop_right)*width]中的随机位置剪切。（必须为(0.0, 1.0)中的单一值）（默认0.1）
crop_top: 图像将被从距离上边缘[0, crop_top*height]中的随机位置剪切。（必须为(0.0, 1.0)中的单一值）（默认0.1）
crop_bottom: 图像将被从距离下边缘[0, (1-crop_bottom)*height]中的随机位置剪切。（必须为(0.0, 1.0)中的单一值）（默认0.1）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.RandomCropFromBorders(always_apply=True)
res_img = t(image=img)["image"]

58、RandomCropNearBBox(DualTransform): class

功能：以随机坐标偏移(x,y)从图像中裁剪bbox。
初始化参数：
max_part_shift: x和y方向上相对于“cropping_bbox”（以cropping_box_key设置的名称）的宽高维度的最大偏移。（可为单一值或二元元组，若为单一值，则等同于(max_part_shift, max_part_shift)）（默认(0.3, 0.3)）
cropping_box_key: cropping box的额外目标键，该键指定的参数应传入一维列表[x1, y1, x2, y2]。（str）（默认"cropping_bbox"）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.RandomCropNearBBox(max_part_shift=(0.2, 0.3), always_apply=True)
res_img = t(image=img, cropping_bbox=[120, 120, 400, 400])["image"]

59、RandomFog(ImageOnlyTransform): class

功能：模拟图像的雾。（参考链接：https://github.com/UjjwalSaxena/Automold–Road-Augmentation-Library）
初始化参数：
fog_coef_lower: 雾强度系数的下限。（应在[0, 1]间）（默认0.3）
fog_coef_upper: 雾强度系数的上限。（应在[0, 1]间）（默认1）
alpha_coef: 雾圈的透明度。（应在[0, 1]间）（默认0.08）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomFog(always_apply=True)
res_img = t(image=img)["image"]

60、RandomGamma(ImageOnlyTransform): class

功能：随机gamma变换。Gamma变换是对输入图像灰度值进行的非线性操作，使输出图像灰度值与输入图像灰度值呈指数关系。其提升了暗部细节，通过非线性变换，让图像从曝光强度的线性响应变得更接近人眼感受的响应，即将漂白（相机曝光）或过暗（曝光不足）的图片，进行矫正。（个人参考：https://blog.csdn.net/pengchengliu/article/details/110097184）
初始化参数：
gamma_limit: gamma界限。（单一值或二元tuple。若为单一值，等同于(-gamma_limit, gamma_limit)）（默认(80, 120)）
eps: 已弃用。
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomGamma(gamma_limit=(80, 150), always_apply=True)
res_img = t(image=img)["image"]

61、RandomGridShuffle(DualTransform): class

功能：随机打乱图像网格中的单元。
初始化参数：
grid: 分割图像的网格行列数量。（二元int元组）（默认(3, 3)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomGridShuffle(always_apply=True)
res_img = t(image=img)["image"]

62、RandomRain(ImageOnlyTransform): class

功能：添加雨效果。（参考链接：https://github.com/UjjwalSaxena/Automold–Road-Augmentation-Library）
初始化参数：
slant_lower: 斜角的下限。（应为[-20, 20]中的值）（默认-10）
slant_upper: 斜角的上限。（应为[-20, 20]中的值）（默认10）
drop_length: 雨滴的长度。（应为[0, 100]中的值）（默认20）
drop_width: 雨滴的宽度。（应为[1, 5]中的值）（默认1）
drop_color: 雨滴的颜色。（(r, g, b)列表）（默认(200, 200, 200)）
blur_value: 下雨天看起来很朦胧。（int）（默认7）
brightness_coefficient: 下雨天通常很阴暗。（应为[0, 1]中的值）（默认0.7）
rain_type: 雨类型。（{None, ‘drizzle’, ‘heavy’, ‘torrential’}）（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomRain(always_apply=True)
res_img = t(image=img)["image"]

63、RandomResizedCrop(_BaseRandomSizedCrop): class

功能：torchvision变体。裁剪输入的一个随机部分，然后将它rescale到某个尺度。
初始化参数：
height: 裁剪和resize后的高度。（int）
width: 裁剪和resize后的宽度。（int）
scale: 裁剪原始大小的尺度范围。（二元元组）（默认(0.08, 1.0)）
ratio: 相对于原始长宽比的裁剪长宽比的范围。（二元元组）（默认(0.75, 1.3333333333333333）
interpolation: 指定插值算法的标识符。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.RandomResizedCrop(500, 500, always_apply=True)
res_img = t(image=img)["image"]

64、RandomRotate90(DualTransform): class

功能：随机翻转输入90度零次或更多次。
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomRotate90(always_apply=True)
res_img = t(image=img)["image"]

65、RandomScale(DualTransform): class

功能：随机resize输入。输出图像的大小与输入图像的大小不一致。
初始化参数：
scale_limit: 尺度因子范围。（单一值或二元tuple。若为单一值，则等同于(-scale_limit, scale_limit)。注意scale_limit会加上偏置1。如果scale_limit为tuple，如(low, high)，则从(1+low, 1+high)中采样。）（默认0.1）
interpolation: 指定插值算法。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomScale(always_apply=True)
res_img = t(image=img)["image"]

66、RandomShadow(ImageOnlyTransform): class

功能：模拟图像阴影。（参考链接：https://github.com/UjjwalSaxena/Automold–Road-Augmentation-Library）
初始化参数：
shadow_roi: 图像中展示阴影的区域。（四元组(x_min, y_min, x_max, y_max)，所有值必须位于[0, 1]中）（默认(0, 0.5, 1, 1)）
num_shadows_lower: 可能阴影的数量下限。（int，必须处于[0, ‘num_shadows_upper’]间）
num_shadows_upper: 可能阴影的数量上限。（int， 必须处于[‘num_shadows_lower’, inf)间）
shadow_dimension: 阴影多边形中边的数量。（int）（默认5）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomShadow(always_apply=True)
res_img = t(image=img)["image"]

67、RandomSizedBBoxSafeCrop(BBoxSafeRandomCrop): class

功能：裁剪输入的随机部分，并rescale，同时保证没有bboxes的损失。
初始化参数：
height: 裁剪和resize后的高度。（int）
width: 裁剪和resize后的宽度。（int）
erosion_rate: 裁剪前应用到输入图像高度上的腐蚀比例。（默认0.0）
interpolation: 插值方法。（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

bboxes = [[50, 50, 400, 350]]   # [x1, y1, width, height]
category_ids=[0]
t = A.Compose([
    A.RandomSizedBBoxSafeCrop(500, 500, always_apply=True)],
    bbox_params=A.BboxParams(format='coco', label_fields=['category_ids']))
res = t(image=img, bboxes=bboxes, category_ids=category_ids)
res_img = res["image"]
res_bboxes = res["bboxes"]

68、RandomSizedCrop(_BaseRandomSizedCrop): class

功能：裁剪图像的随机部分，并放缩到某个大小。
初始化参数：
min_max_height: 裁剪大小限制。（二元int元组）
height: 裁剪和放缩后的高度。（int）
width: 裁剪和放缩后的宽度。（int）
w2h_ratio: 裁剪的宽高比。（默认1.0）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.RandomSizedCrop((200, 400), 500, 500)
res_img = t(image=img)["image"]

69、RandomSnow(ImageOnlyTransform): class

功能：漂白一些模拟雪的像素值。（参考链接：https://github.com/UjjwalSaxena/Automold–Road-Augmentation-Library）
初始化参数：
snow_point_lower: 雪数量的下限。（应在[0, 1]范围内）（默认0.1）
snow_point_upper: 雪数量的上限。（应在[0, 1]范围内）（默认0.3）
brightness_coef: 越大的值会导致越多的雪数量。（应>0）（默认2.5）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomSnow(brightness_coeff=0.1, always_apply=True)
res_img = t(image=img)["image"]

70、RandomSunFlare(ImageOnlyTransform): class

功能：模拟光斑。（参考链接：https://github.com/UjjwalSaxena/Automold–Road-Augmentation-Library）
初始化参数：
flare_roi: 图像的何处要展示光斑。（四元tuple(x_min, y_min, x_max, y_max)，所有值必须处于[0, 1]范围内。）（默认0, 0, 1, 0.5)）
angle_lower: 角度下限。（必须位于[0, ‘angle_upper’]内）（默认0）
angle_upper: 角度上限。（必须位于[‘angle_lower’, 1]内）（默认1）
num_flare_circles_lower: 光斑数量的下限。（必须位于[0, ‘num_flare_circles_upper’]内）（默认6）
num_flare_circles_upper: 光斑数量的上限。（必须位于[‘num_flare_circles_lower’, inf]内）（默认10）
src_radius：光源半径。（int）（默认400）
src_color: 光斑色彩。（三元int元组(r, g, b)）（默认(255, 255, 255)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomSunFlare(always_apply=True)
res_img = t(image=img)["image"]

71、RandomToneCurve(ImageOnlyTransform): class

功能：通过操纵图像的色调曲线，随机改变图像亮区和暗区之间的关系。
初始化参数：
scale: 正态分布的标准差。用来采样修正图像曲线的两个控制点的随机移动距离。（应位于[0, 1]间）（默认0.1）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomToneCurve(scale=0.4, always_apply=True)
res_img = t(image=img)["image"]

72、ReplayCompose(Compose): class

功能：应用变换后将保存本次变换的信息到返回结果的save_key对应的目标键中（默认"replay"），若要再现该变换，则可通过将该项传入类函数replay实现。
初始化参数：
transforms: transform列表。（列表）
bbox_params: bbox参数。（默认None）
keypoint_params: 关键点参数。（默认None）
additional_targets: 额外的目标。（默认None）
p: 应用所有变换的概率。（默认0.5）
save_key: 保存关键字。（str）（“replay”）

t = A.ReplayCompose([
    A.ColorJitter(always_apply=True)
])
res = t(image=img)
res_img1 = res["image"]
res_replay = res["replay"]  # 获得变换信息
res_img2 = t.replay(res_replay, image=img)["image"] # 再现变换

73、Resize(DualTransform): class

功能：放缩输入到给定高度和宽度。
初始化参数：
height: 输出高度。（int）
width: 输出宽度。（int）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.Resize(300, 300, always_apply=True)
res_img = t(image=img)["image"]

74、RingingOvershoot(ImageOnlyTransform): class

功能：通过使用2D sinc滤波器对图像进行卷积来创建振铃或过冲伪影。（文献链接：https://arxiv.org/pdf/2107.10833.pdf）振铃伪影（ringing artifact）通常表现为图像中尖锐过渡附近的伪边缘，它们在视觉上看起来像边缘附近的条纹或“鬼影”。过冲伪影（overshoot artifact）通常与振铃伪影相结合，表现为边缘过渡处的跳跃增加。这些伪影的主要原因是信号在没有高频的情况下是带宽受限的。这些伪影非常常见，并且通常由图像锐化算法（例如JPEG等）引起。使用sinc滤波器（一个能切断高频的理想滤波器）来模拟振铃和过冲伪影。滤波器的参数定义如下图，其中(i, j)是核坐标，ωc是切断频率，J1是第一类一阶贝塞尔函数。

初始化参数：
blur_limit: sinc滤波器的最大核大小。（int或二元int元组。必须在[3, inf)间）（默认(7, 15)）
cutoff: 选择cutoff频率（弧度）的范围。（必须在(0, np.pi)间）（默认(np.pi/4, np.pi/2)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RingingOvershoot(always_apply=True)
res_img = t(image=img)["image"]

75、RGBShift(ImageOnlyTransform): class

功能：随机偏移输入GRB
初始化参数：
r_shift_limit: 为红色通道改变值的范围。（int或二元int元组。如果为单一值，则等同于(-r_shift_limit, r_shift_limit)）（默认(-20, 20)）
g_shift_limit: 为绿色通道改变值的范围。（int或二元int元组。如果为单一值，则等同于(-r_shift_limit, r_shift_limit)）（默认(-20, 20)）
b_shift_limit: 为蓝色通道改变值的范围。（int或二元int元组。如果为单一值，则等同于(-r_shift_limit, r_shift_limit)）（默认(-20, 20)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RGBShift(always_apply=True)
res_img = t(image=img)["image"]

76、Rotate(DualTransform): class

功能：使用通过均匀分布随机选择的角度旋转输入。
初始化参数：
limit: 随机角度选择范围。（int或二元int元组，若为单一值则等同于(-limit, limit)）（默认(-90, 90)）
interpolation: 插值方法。(int）（默认cv2.INTER_LINEAR）
border_mode: 边缘填充方法。（int）（默认cv2.BORDER_REFELCT_101）
value: 如果使用常数边缘填充，则此项指定填充值。（默认None）
mask_value: 如果使用常数边缘填充，则此项指定填充值。（默认None）
rotate_method: 对于bounding boxes使用的旋转方法。{‘largest_box’, ‘ellipse’}（默认’largest_box’）
crop_border: 若为True，则会在旋转后图像内部创建一个最大的可能的裁剪。（默认False）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Rotate(always_apply=True)
res_img = t(image=img)["image"]

t = A.Rotate(crop_border=True, always_apply=True)
res_img = t(image=img)["image"]

77、SafeRotate(DualTransform): class

功能：通过随机从均匀分布中选取的角度旋转在输入帧之内的输入，输出后的图像保持原本大小和长宽比。输出图像可能会具有伪影，因为在旋转之后，图像可能会具有一个不同的宽高比，而在resize之后，它会变回原来的形状和原来的宽高比，因此可能会导致部分伪影。
初始化参数：
limit: 随机选择角度的范围。（int或二元int元组，若为单一值，则等同于(-limit, limit)）（默认(-90, 90)）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
border_mode: 边界填充方法。（int）（默认cv2.BORDER_REFLECT_101）
value: 若边界填充为常数填充，则此项指定填充值。（默认None）
mask_value: 若边界填充为常数填充，则此项指定mask填充值。（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.SafeRotate(always_apply=True)
res_img = t(image=img)["image"]

78、Sequential(BaseCompose): class

功能：按序应用所有变换。此转换不用于替换“Compose”。相反，它应该在“Compose”中使用，就像使用“OneOf”或“OneOrOther”一样。例如，可以将“OneOf”与“Sequential”组合以创建一个包含多个图像增强序列的图像增强管道，并将一个随机选择的序列应用于输入数据。
初始化参数：
transforms: 变换列表。（列表）
p: 应用所有变换的概率。（默认0.5）

t = A.Sequential([
    A.ColorJitter(always_apply=True),
    A.Flip(always_apply=True)
], p=1)
res_img = t(image=img)["image"]

79、Sharpen(ImageOnlyTransform): class

功能：锐化图像并将结果与原图像重叠。
初始化参数：
alpha: 选择锐化后图像可见度的范围。若为0，则只有原图像可见；若为1，则只有锐化后图像可见。（二元tuple）（默认(0.2, 0.5)）
lightness: 选择锐化后图像的亮度的范围。（二元tuple）（默认(0.5, 1.0)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Sharpen(alpha=(0.8, 1.0), always_apply=True)
res_img = t(image=img)["image"]

80、ShiftScaleRotate(DualTransform): class

功能：随机应用仿射变换：对输入进行平移、缩放和旋转。
初始化参数：
shift_limit: 对高度和宽度的偏移因子的范围。（单一值或二元tuple。若为单一值，则等同于(-shift_limit, shift_limit)。下限和上限的绝对值应在[0, 1]中）（默认(-0.0625, 0.0625)）
scale_limit: 放缩因子范围。（单一值或二元tuple。若为单一值，则等同于(-scale_limit, scale_limit)。注意scale_limit将会以1为偏置。如果scale_limit是一个tuple如(low, high)，则会从(1+low, 1+high)中采样。）（默认(-0.1, 0.1)）
rotate_limit: 旋转范围。（int或二元int元组。若为单一值，则等同于(-rotate_limit, rotate_limit)）（默认(-45, 45)）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
border_mode: 边界填充方法。（int）（默认cv2.BORDER_REFLECT_101）
value: 如果边界填充为常数填充，则此项指定填充值。（默认None）
mask_value: 如果边界填充为常数填充，则此项指定mask填充值。（默认None）
shift_limit_x: 宽度的偏移因子的范围。如果其被设置，会使用此值而非shift_limit所指定的值。（单一值或二元tuple。若为单一值，则等同于(-shift_limit_x, shift_limit_x)。下限和上限的绝对值应在[0, 1]中）
shift_limit_y: 高度的偏移因子的范围。如果其被设置，会使用此值而非shift_limit所指定的值。（单一值或二元tuple。若为单一值，则等同于(-shift_limit_y, shift_limit_y)。下限和上限的绝对值应在[0, 1]中）
rotate_method: 对bounding boxes使用的旋转方法。（应为’largest_box’或’ellipse’）（默认’largest_box’）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ShiftScaleRotate(always_apply=True)
res_img = t(image=img)["image"]

81、SmallestMaxSize(DualTransform): class

功能：放缩图像以使得最小边长等同于max_size，同时保持原始图像的宽高比。
初始化参数：
max_size: 变换后图像短边的最大长度。（int或int列表，若为列表，则最大长度将从该列表中随机选择。（默认1024）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.SmallestMaxSize(always_apply=True)
res_img = t(image=img)["image"]

82、Solarize(ImageOnlyTransform): class

功能：沿某一界限反转所有像素值。
初始化参数：
threshold: solarize方法的界限范围。（单一值或二元tuple。若为单一值，则等同于[threshold, threshold]。）（默认128）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Solarize(always_apply=True)
res_img = t(image=img)["image"]

83、SomeOf(BaseCompose): class

功能：选择n个变换进行应用。所有选择的变换会以“force_apply=True”调用。每个变换本身的概率p会作为其在整个变换列表中的概率权重，所有变换的概率之和会被归一化为1。
初始化参数：
transforms: 变换列表。（列表）
n：应用的变换的数量。（int）
replace: 是否允许变换被重复选择。（默认True）
p: 应用整体逻辑的概率。（默认1）

t = A.SomeOf([
    A.ColorJitter(),
    A.Flip(),
    A.RandomCrop(300, 300),
    A.Rotate()
], n=2, p=1)
res_img = t(image=img)["image"]

84、Spatter(ImageOnlyTransform): class

功能：应用飞溅变换。它模拟了可以以雨或泥的形式遮挡镜头的腐蚀。（论文链接：https://arxiv.org/pdf/1903.12261.pdf）
初始化参数：
mean: 产生液体层的正态分布的均值。（单一值或float元组。若为单一值会将其作为均值，若为tuple，会从[mean[0], mean[1])中采样作为均值。）（默认0.65）
std: 产生液体层的正态分布的标准差。（单一值或float元组。若为单一值会将其作为标准差，若为tuple，会从[std[0], std[1])中采样作为标准差。）（默认0.3）
gauss_sigma: 液体层的高斯滤波的Sigma值。（单一值或float元组。若为单一值会将其作为gauss_sigma，若为tuple，会从[sigma[0], sigma[1])中采样作为gauss_sigma。）（默认2）
cutout_threshold: 液体层滤波的界限（决定水滴的数量）。（单一值或float元组。若为单一值会将其作为cutout_threshold，若为tuple，会从[cutout_threshold[0], cutout_threshold[1])中采样作为cutout_threshold。）（默认0.68）
intensity: 腐蚀的强度。单一值或float元组。若为单一值会将其作为强度，若为tuple，会从[intensity[0],intensity[1])中采样作为强度。）（默认0.6）
mode: 腐蚀的模式。（{‘rain’, ‘mud’}，可为str或者str列表。若为str列表则腐蚀会从该列表中采样。）（默认’rain’）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Spatter(always_apply=True)
res_img = t(image=img)["image"]

85、Superpixels(ImageOnlyTransform): class

功能：将图像部分/完全转换为其超像素表示。这个实现使用了slimage版本的SLIC算法。（算法详解推荐：https://blog.csdn.net/cocapop/article/details/127466253）
初始化参数：
p_replace: 为所有线段定义该线段内的像素被其平均颜色替换的概率（否则，像素不会更改）。（可为单一值或二元元组，若为单一值，则该值会总被使用；若为二元元组(a, b)，则会为每个图片从[a, b]中随机采样一个值作为概率。）
n_segments: 要生成多少超级像素的粗略目标数（算法可能会偏离此数）。较低的值将导致更粗糙的超级像素。较高的值在计算上更密集，因此会导致速度减慢。（int或二元int元组。若为单一值，则该值会总用作段的数量；若为二元元组(a,b)，则会为每个图片从离散区间[a…b]中采样一个值。）
max_size: 执行增强时的最大图像大小。如果图像的宽度或高度超过此值，则在增强之前将缩小图像的大小，以便最长的边与“max_size”匹配。这样做是为了加快进程。最终的输出图像具有与输入图像相同的大小。请注意，如果“p_replace”低于“1.0”，则向下/向上缩放也会影响未被替换的像素。使用“无”可不应用缩小/放大。（int或None）（默认128）
interpolation: 插值方法。（int）（默认cv2.INTER_LINEAR）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Superpixels(always_apply=True)
res_img = t(image=img)["image"]

86、TemplateTransform(ImageOnlyTransform): class

功能：应用输入图像与指定模板的混合。
初始化参数：
templates: 用于变换的作为模板的图像。（numpy array或者numpy array列表）
img_weight：用作输入图像所占的权重。（单一值或多元元组。若为单一值则总应用该值，若为多元tuple，则图像权重从[img_weight[0], img_weight[1])中取值。）（默认0.5）
template_weight: 用作输入图像所占的权重。（单一值或多元元组。若为单一值则总应用该值，若为多元tuple，则模板权重t从[template_weight[0], template_weight[1])中取值。）（默认0.5）
template_transform: 可以应用于模板的转换对象必须生成与输入图像大小相同的模板。（默认None）
name: 变换的名字，仅在反序列化时使用。（str）（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.TemplateTransform(templates=img2, always_apply=True)
res_img = t(image=img)["image"]

87、ToGray(ImageOnlyTransform): class

功能：将输入的RGB图像转换为灰度图。如果结果图像的均像素值大于127，则将结果灰度图像反转。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ToGray(always_apply=True)
res_img = t(image=img)["image"]

88、ToFloat(ImageOnlyTransform): class

功能：将像素值除以“max_value”，得到float32输出数组，其中所有值都在[0, 1.0]范围内。如果“max_vvalue”为None，则变换将尝试通过检查输入图像的数据类型来推断最大值。
初始化参数：
max_value: 最大可能的输入值。（默认None）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.ToFloat(always_apply=True)
res_img = t(image=img)["image"]

89、ToSepia(ImageOnlyTransform): class

功能：为输入RGB图像应用棕褐色滤波器。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ToSepia(always_apply=True)
res_img = t(image=img)["image"]

90、Transpose(DualTransform): class

功能：通过交换行列转置输入。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.Transpose(always_apply=True)
res_img = t(image=img)["image"]

91、UnsharpMask(ImageOnlyTransform): class

功能：使用Unsharp Masking处理锐化输入图像，并将结果与原始图像叠加。（论文链接：
arxiv.org/pdf/2107.10833.pdf）
初始化参数：
blur_limit: 用来模糊输入图像的最大高斯核大小。若为0则会根据sigma进行计算：round(sigma * (3 if img.dtype == np.uint8 else 4) * 2 + 1) + 1。若为单一值，则等同于(0, blur_limit)。（可以为二元整数tuple或者单一值，必须为[0, inf)间的0或奇数）（默认(3, 7)）
sigma_limit: 高斯核标准差。若为单一值则等同于(0, sigma_limit)。若为0则会如此计算：sigma = 0.3*((ksize-1)*0.5 - 1) + 0.8。（可以为二元tuple或者单一值，必须在[0,inf)间）（默认0）
alpha: 选择锐化后图像的可视性的范围。若为0，则只有初始图像可见；若为1，则只有锐化后的图像可见。（默认(0.2, 0.5)）
threshold: 仅对原始图像和平滑版本之间像素差异较大的区域限制锐化的值。较高的阈值意味着平坦区域的锐化程度较低。（必须位于[0, 255]间）（默认10）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.UnsharpMask(blur_limit=(31, 51), alpha=(0.8, 1.0), threshold=0, always_apply=True)
res_img = t(image=img)["image"]

92、VerticalFlip(DualTransform): class

功能：沿x轴翻转图像。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.VerticalFlip(always_apply=True)
res_img = t(image=img)["image"]

93、ZoomBlur(ImageOnlyTransform): class

功能：应用缩放模糊变换。（论文链接：https://arxiv.org/abs/1903.12261）
初始化参数：
max_factor: 用于模糊的最大因子的范围。（单一值或二元tuple。若为单一值，等同于(1, limit)。所有的max_factor都必须大于1。）（默认1.31）
step_factor: 用作numpy.arrange的步长参数（单一值或二元tuple。若为单一值则使用之；若为tuple则step_factor会从范围[step_factor[0], step_factor[1]]中采样。所有step_factor因子都必须为正值。）（默认(0.01, 0.03)）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.ZoomBlur(always_apply=True)
res_img = t(image=img)["image"]

94、ToTensorV2(BasicTransform): class

功能：将图像和掩码转换为“torch.Tensor”。将Numpy的“HWC”图像转换为pytorch的“CHW”张量。如果图像是“HW”格式（灰度图像），它将被转换为pytorch“HW’张量。这是旧的“ToTensor”转换的简化和改进版本（“ToTensor”已被弃用，现在它不存在于库中。应该使用“ToTensorV2”）。（此类位于albumentations.pytorch中，要调用该类，可以通过from albumentations.pytorch import ToTensorV2）
初始化参数：
transpose_mask: 如果为True，并且输入掩码有三个维度，则此转换将转换维度，使形状“[height，width，num_channels]”变为“[num_channels, height, width]”。后一种格式是PyTorch张量的标准格式。（bool）（默认False）

95、RandomGravel(ImageOnlyTransform): class

功能：添加砂砾。（参考链接：https://github.com/UjjwalSaxena/Automold–Road-Augmentation-Library）
初始化参数：
gravel_roi: 砂砾出现的区域。（四元元组(top-left x, top-left y, bottom-right x, botom-right y)，应位于[0, 1]间）（默认(0.1, 0.4, 0.9, 0.9)）
number_of_patches: 砂砾片的数量。（int）（默认2）
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认0.5）

t = A.RandomGravel(always_apply=True)
res_img = t(image=img)["image"]

96、ToRGB(ImageOnlyTransform): class

功能：将输入的灰度图转换为RGB图。
初始化参数：
always_apply: 是否总应用。（bool）（默认False）
p: 应用该变换的概率。（默认1.0）

t = A.ToRGB(always_apply=True)
res_img = t(image=img[:, :, 0])["image"]