資料增強（噪聲，模糊，縮放，色域變換，均衡化，色彩抖動）

本篇為處女作，請大家多多指教，

在做深度學習時，資料的處理是重中之重，在做自己的資料集時，可能會面臨資料影像數目不均衡，資料量少的困擾，本篇文章就是介紹影像增強的方法，對影像進行增強，增加影像的數目，

一、增加噪聲

在影像中增加適量噪聲可以增強學習能力，噪聲有很多種，常見的有椒鹽噪聲，高斯噪聲等，

1.椒鹽噪聲：一種隨機出現的白點或者黑點，可能是亮的區域有黑色像素或是在暗的區域有白色像素（或是兩者皆有），

#添加椒鹽噪聲
def sp_noise(image):
      output = np.zeros(image.shape,np.uint8)
      prob=rand(0.0005,0.001)  #隨機噪聲比例
      thres = 1 - prob 
      for i in range(image.shape[0]):
          for j in range(image.shape[1]):
              rdn = random.random()
              if rdn < prob:
                output[i][j] = 0
              elif rdn > thres:
                output[i][j] = 255
              else:
                output[i][j] = image[i][j]
      return output

2.高斯噪聲：概率密度函式服從高斯分布，

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

二、濾波（模糊）處理

濾波處理主要是讓影像變得模糊，提取影像的重要資訊，常見的模糊處理有：高斯模糊，中值模糊，均值（椒鹽）模糊，

卷積核大小一般為奇數：（3，3）、（5，5）、（7，7）

#利用opencv模塊
img1 = cv2.blur(img,(5,5))  #中值濾波
img2 = cv2.medianBlur(img,5)  #椒鹽濾波
img3 = cv2.GaussianBlur(img,(5,5)，0)  #高斯濾波

三、旋轉

影像的大小不變，可以將影像進行上下旋轉，左右旋轉等增加資料量，一般根據自己的需求，有些資料旋轉之后就不符合原資料的要求了，

#利用pil模塊
img=Iamge.open('xxx')

#1.自定義旋轉的角度 
img2 = img.rotate(90) 

#2.參考固定的常量值  
img2 = im.transpose(Image.FLIP_LEFT_RIGHT)    #鏡像旋轉
img2 = im.transpose(Image.FLIP_TOP_BOTTOM)    #上下旋轉

此處其實沒必要進行翻轉，因為會不符合要求，所以要根據自己的需求進行選擇，

四、影像縮放

可以通過改變影像的大小對資料增強，但有可能會引起影像的失真，

def change_scale(image,input_shape,jitter=.5) 
    iw, ih = image.size
    h, w = input_shape 
    # 對影像進行縮放并且進行長和寬的扭曲 
    new_ar = w/h * rand(1-jitter,1+jitter)/rand(1-jitter,1+jitter) 
    scale = rand(.15,2.5) 
    if new_ar < 1: 
        nh = int(scale*h) 
        nw = int(nh*new_ar) 
    else: 
        nw = int(scale*w) 
        nh = int(nw/new_ar) 
        image = image.resize((nw,nh), Image.BICUBIC) 
    retuen image

五、色彩抖動

色彩抖動是通過隨機調整原始圖片的飽和度，亮度，對比度來對產生新的影像，增加資料集

def randomColor(image):
    #隨機生成0，1來隨機確定調整哪個引數，可能會調整飽和度，也可能會調整影像的飽和度和亮度
    saturation=random.randint(0,1)
    brightness=random.randint(0,1)
    contrast=random.randint(0,1)
    sharpness=random.randint(0,1)

    #當三個引數中一個引數為1，就可執行相應的操作
    if random.random() < saturation:
        random_factor = np.random.randint(0, 31) / 10.  # 隨機因子
        image = ImageEnhance.Color(image).enhance(random_factor)  # 調整影像的飽和度
    if random.random() < brightness:
        random_factor = np.random.randint(10, 21) / 10.  # 隨機因子
        image = ImageEnhance.Brightness(image).enhance(random_factor)  # 調整影像的亮度
    if random.random() < contrast:
        random_factor = np.random.randint(10, 21) / 10.  # 隨機因1子
        image = ImageEnhance.Contrast(image).enhance(random_factor)  # 調整影像對比度
    if random.random() < sharpness:
        random_factor = np.random.randint(0, 31) / 10.  # 隨機因子
        ImageEnhance.Sharpness(image).enhance(random_factor)  # 調整影像銳度
    return image

色彩抖動之后的影像可以根據自己的需求進行刪減，對于一些陰間影像可以剔除掉，

六、影像均衡化

#限制對比度自適應直方圖均衡
def clahe(image):
    b, g, r = cv2.split(image)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    b = clahe.apply(b)
    g = clahe.apply(g)
    r = clahe.apply(r)
    image_clahe = cv2.merge([b, g, r])
    return image_clahe

#伽馬變換
def gamma(image):
        fgamma = rand(0,2)
        image_gamma = np.uint8(np.power((np.array(image) / 255.0), fgamma) * 255.0)
        cv2.normalize(image_gamma, image_gamma, 0, 255, cv2.NORM_MINMAX)
        cv2.convertScaleAbs(image_gamma, image_gamma)
        return image_gamma

#直方圖均衡
def hist(image):
        r, g, b = cv2.split(image)
        r1 = cv2.equalizeHist(r)
        g1 = cv2.equalizeHist(g)
        b1 = cv2.equalizeHist(b)
        image_equal_clo = cv2.merge([r1, g1, b1])
        return image_equal_clo

全部代碼

#已有：翻轉，色域變換，噪聲，大小改變，模糊，色彩抖動，均衡化
import cv2
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image,ImageEnhance
from matplotlib.colors import rgb_to_hsv, hsv_to_rgb
import os
import random

#限制對比度自適應直方圖均衡
def clahe(image):
    b, g, r = cv2.split(image)
    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
    b = clahe.apply(b)
    g = clahe.apply(g)
    r = clahe.apply(r)
    image_clahe = cv2.merge([b, g, r])
    return image_clahe
#伽馬變換
def gamma(image):
        fgamma = 2
        image_gamma = np.uint8(np.power((np.array(image) / 255.0), fgamma) * 255.0)
        cv2.normalize(image_gamma, image_gamma, 0, 255, cv2.NORM_MINMAX)
        cv2.convertScaleAbs(image_gamma, image_gamma)
        return image_gamma
#直方圖均衡
def hist(image):
        r, g, b = cv2.split(image)
        r1 = cv2.equalizeHist(r)
        g1 = cv2.equalizeHist(g)
        b1 = cv2.equalizeHist(b)
        image_equal_clo = cv2.merge([r1, g1, b1])
        return image_equal_clo
#椒鹽噪聲
def sp_noise(image):
      output = np.zeros(image.shape,np.uint8)
      prob=rand(0.0005,0.001)
      thres = 1 - prob 
      for i in range(image.shape[0]):
          for j in range(image.shape[1]):
              rdn = random.random()
              if rdn < prob:
                output[i][j] = 0
              elif rdn > thres:
                output[i][j] = 255
              else:
                output[i][j] = image[i][j]
      return output
#色彩抖動
def randomColor(image):
    saturation=random.randint(0,1)
    brightness=random.randint(0,1)
    contrast=random.randint(0,1)
    sharpness=random.randint(0,1)
    if random.random() < saturation:
        random_factor = np.random.randint(0, 31) / 10.  # 隨機因子
        image = ImageEnhance.Color(image).enhance(random_factor)  # 調整影像的飽和度
    if random.random() < brightness:
        random_factor = np.random.randint(10, 21) / 10.  # 隨機因子
        image = ImageEnhance.Brightness(image).enhance(random_factor)  # 調整影像的亮度
    if random.random() < contrast:
        random_factor = np.random.randint(10, 21) / 10.  # 隨機因1子
        image = ImageEnhance.Contrast(image).enhance(random_factor)  # 調整影像對比度
    if random.random() < sharpness:
        random_factor = np.random.randint(0, 31) / 10.  # 隨機因子
        ImageEnhance.Sharpness(image).enhance(random_factor)  # 調整影像銳度
    return image
def rand(a=0, b=1): 
    return np.random.rand()*(b-a) + a 

def get_data(image,input_shape=[200,200],random=True, jitter=.5,hue=.1, sat=1.5, val=1.5, proc_img=True):
    iw, ih = image.size
    h, w = input_shape 
    # 對影像進行縮放并且進行長和寬的扭曲 
    new_ar = w/h * rand(1-jitter,1+jitter)/rand(1-jitter,1+jitter) 
    scale = rand(.15,2.5) 
    if new_ar < 1: 
        nh = int(scale*h) 
        nw = int(nh*new_ar) 
    else: 
        nw = int(scale*w) 
        nh = int(nw/new_ar) 
        image = image.resize((nw,nh), Image.BICUBIC) 
     # 翻轉影像 
    flip = rand()<.5 
    if flip:
      image = image.transpose(Image.FLIP_LEFT_RIGHT)
    #噪聲或者虛化，二選一
    image = cv2.cvtColor(np.asarray(image), cv2.COLOR_RGB2BGR)
    a1=np.random.randint(0, 3)
    if a1==0:   
      image=sp_noise(image)
    elif a1==1:
      image=cv2.GaussianBlur(image, (5, 5), 0)
    else:
      image=image
    #均衡化
    index_noise = np.random.randint(0, 10)
    print(index_noise)
    if index_noise==0:
        image = hist(image)
        print('hist,done')
    elif index_noise==1:
         image = clahe(image)
         print('clahe,done')
    elif index_noise==2:
         image = gamma(image)
         print('gamma,done')
    else:
         image=image
    
    image = Image.fromarray(cv2.cvtColor(image,cv2.COLOR_BGR2RGB))
    #色彩抖動
    image=randomColor(image)
    print(image.size)
    # 色域扭曲 
    hue = rand(-hue, hue) 
    sat = rand(1, sat) if rand()<.5 else 1/rand(1, sat) 
    val = rand(1, val) if rand()<.5 else 1/rand(1, val) 
    x = rgb_to_hsv(np.array(image)/255.)
    x[..., 0] += hue 
    x[..., 0][x[..., 0]>1] -= 1 
    x[..., 0][x[..., 0]<0] += 1 
    x[..., 1] *= sat 
    x[..., 2] *= val 
    x[x>1] = 1 
    x[x<0] = 0 
    image_data = hsv_to_rgb(x)

    image_data=np.array(image)
    return image_data

if __name__ == "__main__":
   
    #影像批量處理
    dirs='./class_pic3/407_3/'   #原始影像所在的檔案夾
    dets='./class_pic3/dets/407_3/'   #影像增強后存放的檔案夾
    mylist=os.listdir(dirs)
    l=len(mylist)       #檔案夾圖片的數量
    for j in range(0,l):
        image = cv2.imread(dirs+mylist[j])
        img = Image.fromarray(np.uint8(image))
        for i in range(0,2):      #自定義增強的張數
            img_ret=get_data(img)   
            #imwrite(存入圖片路徑+圖片名稱+‘.jpg’,img)
            #注意：名稱應該是變化的，不然會覆寫原來的圖片        
            cv2.imwrite(dets+'1'+str(j)+'0'+str(i)+'.jpg',img_ret)   
            print('done')

    #單個影像處理
    '''          
    image=cv2.imread("./class_pic3/323/002.jpg")
    img = Image.fromarray(np.uint8(image))
    for i in range(0,4):
      img_ret=get_data(img)
      cv2.imwrite('./class_pic3/323'+'02'+str(i)+'.jpg',img_ret)
      print('done')
    '''

大家可以根據自己的需求對代碼有所調整，