opencv图像数据增强笔记

# 导入相关包import cv2import numpy as npfrom matplotlib import pyplot as plt
%matplotlib inline

filename = 'lena.jpg'img = cv2.imread(filename)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)print(img.shape) # 输出通道数，大小是350*350 3通道plt.imshow(img)

class Resize:
    def __init__(self, size):
        self.size=size    def __call__(self, img):
        return cv2.resize(img, self.size)# Resize( (600, 600))通过修改函数中参数进行调节图片的大小resize=Resize( (600, 600))
img_resize=resize(img)
plt.imshow(img_resize)

#载入原图img_original=cv2.imread('lena.jpg',0)#迭代阈值分割print("请输入阈值0-255")
thresh = int(input())
retval,img_global=cv2.threshold(img_original,thresh,255,cv2.THRESH_BINARY)print(retval) 

#最优阈值ret2,th2 = cv2.threshold(img_original,0,255,cv2.THRESH_OTSU)print(ret2)#显示图片plt.subplot(1,3,1)
plt.imshow(img_original,'gray')
plt.title('Original Image')
plt.subplot(1,3,2)
plt.hist(img_original.ravel(),256)#.ravel方法将矩阵转化为一维plt.subplot(1,3,3)
plt.imshow(th2,'gray')
plt.title('Otsu thresholding')
plt.show()

class Flip:
    def __init__(self, mode):
        self.mode=mode    def __call__(self, img):
        return cv2.flip(img, self.mode)# 指定翻转类型（非随机）# mode=0垂直翻转、1水平翻转、-1水平加垂直翻转flip=Flip(mode=0)
img_flip=flip(img)
plt.imshow(img_flip)

import random# 随机翻转class RandomFlip((object)):  
    def __init__(self, mode=1):
        # 设置一个翻转参数，1、0或-1,默认1
        assert mode in [-1, 0, 1], "mode should be a value in [-1, 0, 1]"
        self.mode = mode    def __call__(self, img):
        # 随机生成0或1（即是否翻转）
        if random.randint(0, 1) == 1:            return cv2.flip(img, self.mode)        else:            return img

randomflip=RandomFlip(0)
img_randomflip=randomflip(img)
plt.imshow(img_randomflip)

def gasuss_noise(image, mean=0, var=0.001): # 模拟高斯噪声
    ''' 
        添加高斯噪声
        mean : 均值 
        var : 方差
    '''
    image = np.array(image/255, dtype=float)
    noise = np.random.normal(mean, var ** 0.5, image.shape)
    out = image + noise    if out.min() < 0:
        low_clip = -1.
    else:
        low_clip = 0.
    out = np.clip(out, low_clip, 1.0)
    out = np.uint8(out*255)    return out

img_noise = gasuss_noise(img) # 添加噪声dst = cv2.fastNlMeansDenoisingColored(img,None,10,10,7,21) # 去噪函数plt.subplot(121),plt.imshow(img_noise) # 含噪声（绿点）图plt.subplot(122),plt.imshow(dst) # 去噪后的图plt.show()

kernel = np.ones((3, 3), dtype=np.uint8) # 定义3x3卷积核dilate = cv2.dilate(img, kernel, 1) # 1:迭代次数，也就是执行几次膨胀操作erosion = cv2.erode(img, kernel, 1) 

plt.subplot(131),plt.imshow(img)
plt.subplot(132),plt.imshow(dilate) # 膨胀plt.subplot(133),plt.imshow(erosion) # 腐蚀plt.show()

class Rotate:
    def __init__(self, degree,size):
        self.degree=degree
        self.size=size    def __call__(self, img):
        h, w = img.shape[:2]
        center = (w // 2, h // 2) # 采取中心点为轴进行旋转
        M = cv2.getRotationMatrix2D(center,self.degree, self.size)        return cv2.warpAffine(img, M, (w, h))# 参数1是旋转角度，参数2是图像比例rotate=Rotate(45, 0.7)
img_rotating=rotate(img)
plt.imshow(img_rotating)

class Brightness:
    def __init__(self,brightness_factor):
        self.brightness_factor=brightness_factor    def __call__(self, img):
        img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # 通过cv2.cvtColor把图像从BGR转换到HSV
        darker_hsv = img_hsv.copy()
        darker_hsv[:, :, 2] =  self.brightness_factor * darker_hsv[:, :, 2]        return cv2.cvtColor(darker_hsv, cv2.COLOR_HSV2BGR)   
         
brightness=Brightness(0.6)
img2=brightness(img)
plt.imshow(img2)

import randomimport mathclass RandCropImage(object):
    """ random crop image """
    """ 随机裁剪图片 """

    def __init__(self, size, scale=None, ratio=None, interpolation=-1):

        self.interpolation = interpolation if interpolation >= 0 else None
        if type(size) is int:
            self.size = (size, size)  # (h, w)
        else:
            self.size = size

        self.scale = [0.08, 1.0] if scale is None else scale
        self.ratio = [3. / 4., 4. / 3.] if ratio is None else ratio    def __call__(self, img):
        size = self.size
        scale = self.scale
        ratio = self.ratio

        aspect_ratio = math.sqrt(random.uniform(*ratio))
        w = 1. * aspect_ratio
        h = 1. / aspect_ratio

        img_h, img_w = img.shape[:2]

        bound = min((float(img_w) / img_h) / (w**2),
                    (float(img_h) / img_w) / (h**2))
        scale_max = min(scale[1], bound)
        scale_min = min(scale[0], bound)

        target_area = img_w * img_h * random.uniform(scale_min, scale_max)
        target_size = math.sqrt(target_area)
        w = int(target_size * w)
        h = int(target_size * h)

        i = random.randint(0, img_w - w)
        j = random.randint(0, img_h - h)

        img = img[j:j + h, i:i + w, :]        if self.interpolation is None:            return cv2.resize(img, size)        else:            return cv2.resize(img, size, interpolation=self.interpolation)

crop = RandCropImage(350)
plt.imshow(crop(img))

# 随机裁剪图片class RandomErasing(object):
    def __init__(self, EPSILON=0.5, sl=0.02, sh=0.4, r1=0.3,
                 mean=[0., 0., 0.]):
        self.EPSILON = EPSILON
        self.mean = mean
        self.sl = sl
        self.sh = sh
        self.r1 = r1    def __call__(self, img):
        if random.uniform(0, 1) > self.EPSILON:            return img        for attempt in range(100):
            area = img.shape[0] * img.shape[1]

            target_area = random.uniform(self.sl, self.sh) * area
            aspect_ratio = random.uniform(self.r1, 1 / self.r1)

            h = int(round(math.sqrt(target_area * aspect_ratio)))
            w = int(round(math.sqrt(target_area / aspect_ratio)))            #print(w)

            
            # 此处插入代码
            if w < img.shape[0] and h < img.shape[1]:
                x1 = random.randint(0, img.shape[1] - h)
                y1 = random.randint(0, img.shape[0] - w)                if img.shape[2] == 3:
                    img[ x1:x1 + h, y1:y1 + w, 0] = self.mean[0]
                    img[ x1:x1 + h, y1:y1 + w, 1] = self.mean[1]
                    img[ x1:x1 + h, y1:y1 + w, 2] = self.mean[2]                else:
                    img[x1:x1 + h, y1:y1 + w,0] = self.mean[0]                return img 
        return img

erase = RandomErasing()
img2=erase(img)
plt.imshow(img2)

# 图片边缘填充class Pooling:
    def __init__(self,pooling1,pooling2,pooling3,pooling4):
        self.pooling1=pooling1
        self.pooling2=pooling2
        self.pooling3=pooling3
        self.pooling4=pooling4    def __call__(self, img):

        # 全0填充,若填充其它颜色，需修改下面value中数值即可
        img_pool = cv2.copyMakeBorder(img, self.pooling1, self.pooling2, self.pooling3, self.pooling4, 
                                       cv2.BORDER_CONSTANT, 
                                       value=(0, 0, 0))        return img_pool        
# Pooling()中的4个参数分别是，上下左右填充的像素大小pooling=Pooling(10,20,30,40)
img2=pooling(img)
plt.imshow(img2)

# 修改图片饱和度class Saturation:
    def __init__(self,saturation_factor):
        self.saturation_factor=saturation_factor    def __call__(self, img):

        img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) # 通过cv2.cvtColor把图像从BGR转换到HSV
        colorless_hsv = img_hsv.copy()
        colorless_hsv[:, :, 1] = self.saturation_factor * colorless_hsv[:, :, 1]        return cv2.cvtColor(colorless_hsv, cv2.COLOR_HSV2BGR)

        
saturation=Saturation(0.6)
img2=saturation(img)
plt.imshow(img2)

# 放大+平移class AmplificationTranslation:
    def __init__(self,mode1,mode2,mode3):
        self.mode1=mode1
        self.mode2=mode2
        self.mode3=mode3    def __call__(self, img):

        M_crop = np.array([
        [self.mode1, 0, self.mode2],
        [0, self.mode1, self.mode3]
        ], dtype=np.float32)

        img = cv2.warpAffine(img, M_crop, (img.shape[0], img.shape[1]))        return img# 将彩色图的BGR通道顺序转成RGBimg = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)      
# AmplificationTranslation()中，参数分别是：放大倍数、平移坐标(-150,-240)ATion=AmplificationTranslation(1.6,-150,-240)
img2=ATion(img)
plt.imshow(img2)

class ShearAngle:
    def __init__(self,mode):
        self.mode=mode    def __call__(self, img):

        # x轴的剪切变换，角度15°
        theta = self.mode * np.pi / 180
        M_shear = np.array([
        [1, np.tan(theta), 0],
        [0, 1, 0]
        ], dtype=np.float32)

        img_sheared = cv2.warpAffine(img, M_shear, (img.shape[0], img.shape[1]))        return img_sheared# 将彩色图的BGR通道顺序转成RGBimg = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)   
     
# ShearAngle()中，参数是：角度SAion=ShearAngle(15)
img2=SAion(img)
plt.imshow(img2)