pytorch（10）transform模块(进阶)

图像变换

1. Pad
   
   对图片边缘进行填充
   
   transforms.Pad(padding,fill=0,padding_mode='constant')

• padding:设置填充大小，(a,b,c,d)左上右下填充abcd
• padding_mode:填充模式，4种模式，constant,edge,reflect,symmetric
• fill:constant时，设置填充的像素值，(r,g,b) or (gray)

# ==================01 pad==================
flag = True
# flag = False
if flag:
    x_img = Image.open("face.jpg")
    x_img_handled = transforms.Pad(padding=150, fill=200, padding_mode='constant')(x_img)
    x_img_handled.show()

1. ColorJitter
   
   调整亮度、对比度、饱和度和色相
   
   transforms.ColorJitter(brightness=0, contrast=0, saturation=0, hue=0)

• brightness:亮度调整因子
  
  为a时，从[max(0,1-a),1+a]中随机选择
  
  为(a,b)时，从[a,b]中选择
• contrast:对比度参数，同brightness
• saturation:饱和度参数，同brightness
• hue:色相参数
  
  当为a时，从[-a,a]中选择参数，注：0<=a<=0.5
  
  为(a,b)时，从[a,b]中选择参数，注：-0.5<= a <=b<=0.5

# ==================02 ColorJitter==========
flag = True
# flag = False
if flag:
    x_img = Image.open("face.jpg")
    x_img_handled = transforms.ColorJitter(brightness=(1.5, 1.5),
                                           contrast=(1.5,1.5),
                                           saturation=(1.5,1.5),
                                           hue=0.7)(x_img)
    x_img_handled.show()

1. Grayscale
   
   Grayscale(num_output_channels)

# ==================03 Grayscale==========
flag = True
# flag = False
if flag:
    x_img = Image.open("face.jpg")
    x_img_handled = transforms.Grayscale(3)(x_img)
    x_img_handled.show()

1. RandomGrayscale
   
   RandomGrayscale(num_output_channels,p=0.1)
   
   依概率将图片转换为灰度图

• num_output_channels:输出通道数，1 or 3
• p:概率值，图像被转换为灰度图的概率

# ==================04 RandomGrayscale==========
flag = True
# flag = False
if flag:
    x_img = Image.open("face.jpg")
    x_img_handled = transforms.RandomGrayscale(p=0.7)(x_img)
    x_img_handled.show()

1. RandomAffine
   
   RandomAffine(degrees, translate=None, scale=None, shear=None,resample=False,fillcoloor=0)
   
   对图像进行仿射变换，仿射变换是二维的线性变换，旋转、评议、缩放、错切、翻转

• shear:错切角度设置，有水平错切和垂直错切
  
  参数为a，仅在x轴错切，错切角度在(-a,a)之间
  
  参数为(a,b)，a设置x轴角度，b设置y轴角度
  
  为(a,b,c,d)，则a,b设置x轴角度，c,d设置y轴角度
• resample:重采样方式，NEAREST,BILINEAR,BICUBIC

# ==================05 RandomAffine=============
flag = True
# flag = False
if flag:
    x_img = Image.open("face.jpg")
    x_img_handled = transforms.RandomAffine(30,shear=(30,50))(x_img)
    plt.imshow(x_img_handled)
    plt.show()

1. RandomErasing
   
   RandomErasing(p=0.5, scale=(0.02,0.33),ratio=(0.3,0.3),value=0,inplace=False)
   
   功能：对图像进行随机遮挡

• p:概率值，执行该操作的概率
• scale:遮挡区域的面积
• ratio:遮挡区域的长宽比
• value:设置遮挡区域的像素值，(R,G,B) OR (GRAY)

# ==================06 RandomErasing=============
flag = True
# flag = False
if flag:
    x_img = Image.open("face.jpg")
    x_img = transforms.ToTensor()(x_img)
    x_img_handled = transforms.RandomErasing(p=1,scale=(0.04,0.04),ratio=(0.3,3.3),value="random",inplace=False)(x_img)
    x_img_handled = transform_invert(x_img_handled, transforms.ToTensor)
    x_img_handled.show()
    # plt.imshow(x_img_handled)
    # plt.show()

1. transforms.Lambda
   
   用户自定义lambda方法
   
   transforms.Lambda(lambd)
   
   lambd: lambda匿名函数
   
   transforms.TenCrop(200, vertical_flip=True),

transforms.Lambda(lambda crops: torch.stack([transforms.Totensor()(crop) for crop in crops]))

transforms

1. transforms.RandomChoice
   
   从一系列transforms方法中随机挑选一个
   
   transforms.RandomChoice([transforms1,transforms2,transforms3])
2. transforms.RandomApply
   
   依概率执行一组transforms操作
   
   transforms.RandomApply([transforms1,transforms2,transforms3], p=0.5)
3. transforms.RandomOrder
   
   对一组transforms操作打乱顺序
   
   transforms.RandomOrder([transforms1,transforms2,transforms3

自定义transforms

自定义transforms要素：

1. 仅接收一个参数，返回一个参数
2. 注意上下游的输出与输入（上一个的输出是下一个输入）

class Compose(object):
	def __call__(self, img):
		for t in self.transforms:
			img = t(img)
        return img

设置多个参数(通过类方法)：

class YourTransforms(object):
	def __init__(self,...):
		...
	def __call__(self,img):
		...
		return img

椒盐噪声

脉冲噪声，随机出现的白点或者黑点，白点成为盐噪声，黑色为椒噪声

信噪比(Signal-Noise Rate,SNR)是衡量噪声的比例，图像中为图像像素的占比

add salt pepper noise

基本结构

class AddPepperNoise(object):
	def __init__(self,snr,p):
		self.snr = snr
		self.p = p

	def __call__(self,img):
		...
		# 具体实现过程
		...
		return img

class Compose(object):
	def __call__(self,img):
		for t in self.transforms:
			img = t(img)
		return img

from PIL import Image
from torchvision import transforms
import cv2
from common_tools import transform_invert
import random
import numpy as np
snr = 0.9
img = Image.open("face.jpg")
imgdeld = np.array(img).copy()
h, w, c = imgdeld.shape
signal_pic = snr
noise_pic = 1-snr
mask = np.random.choice((0,1,2),size=(h,w,1),p=[signal_pic,noise_pic/2.,noise_pic/2])
mask = np.repeat(mask, c, axis=2)
imgdeld[mask == 1] =255
imgdeld[mask == 2] =0
masked = Image.fromarray(mask.astype('uint8')).convert('RGB')
imgdeld=Image.fromarray(imgdeld.astype('uint8')).convert('RGB')
imgdeld.show()
# print(mask.shape)