OpenCV（02）图像颜色处理，灰度化，二值化，仿射变换

图像颜色加法

• 颜色加法

  import cv2 as cv
  import numpy as np

  #读图
  cao = cv.imread('E:\hqyj\code\opencv\images\cao.png')
  pig = cv.imread('E:\hqyj\code\opencv\images\pig.png')
  #饱和操作 cv.add(img1,img2) np.uint8
  dst1 = cv.add(cao,pig)
  #numpy直接相加 取模运算 对256取模 250+10=4
  dst2 = cao+pig

  print(cao)

  print(pig)

  print(dst1)

  cv.imshow('dst1',dst1)
  cv.imshow('dst2',dst2)

  x = np.uint8([[250]])
  y = np.uint8([[10]])
  xy1 = cv.add(x,y)
  xy2 = x+y
  print(xy1)
  print(xy2)

  dst3 = cv.addWeighted(cao,0.2,pig,0.8,0)
  cv.imshow('dst3',dst3)

  cv.waitKey(0)
  cv.destroyAllWindows()

• 图像转换

  import cv2 as cv
  import numpy as np

  读取图片

  img = cv.imread('E:\hqyj\code\opencv\images\pig.png')

  颜色转换 cv.cvtColor(img, cv.COLOR_BGR2HSV)->图像，转换方式

  灰度图

  gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY)
  cv.imshow('gray',gray)

  转hsv

  hsv = cv.cvtColor(img,cv.COLOR_BGR2HSV)
  cv.imshow('hsv',hsv)

  bgr转rgb

  rgb = cv.cvtColor(img,cv.COLOR_BGR2RGB)
  cv.imshow('rgb',rgb)

  cv.waitKey(0)
  cv.destroyAllWindows()

灰度化

• 最大值法

  import cv2 as cv
  import numpy as np

  #读取图像
  pig = cv.imread('E:\hqyj\code\opencv\images\pig.png')
  shape = pig.shape #(h,w,c)
  img = np.zeros((shape[0],shape[1]),dtype = np.uint8)
  #for循环遍历像素点
  for i in range(shape[0]):
  for j in range(shape[1]):
  img[i,j] = max(pig[i,j,0],pig[i,j,1],pig[i,j,2])
  cv.imshow('grey',img)
  cv.waitKey(0)
  cv.destroyAllWindows()

• 平均值法

  import cv2 as cv
  import numpy as np

  #读取图像
  pig = cv.imread('E:\hqyj\code\opencv\images\pig.png')
  shape = pig.shape #(h,w,c)
  img = np.zeros((shape[0],shape[1]),dtype = np.uint8)
  #for循环遍历像素点
  for i in range(shape[0]):
  for j in range(shape[1]):
  #将int()：转换为更大的类型，防止溢出
  img[i,j] =np.uint8((int(pig[i,j,0])+int(pig[i,j,1])+int(pig[i,j,2]))/3)
  cv.imshow('grey',img)
  cv.waitKey(0)
  cv.destroyAllWindows()

• 加权平均值法

  import cv2 as cv
  import numpy as np

  #读取图像
  pig = cv.imread('E:\hqyj\code\opencv\images\pig.png')
  shape = pig.shape #(h,w,c)
  img = np.zeros((shape[0],shape[1]),dtype = np.uint8)
  #定义权重
  wb,wg,wr = 0.114,0.587,0.299
  #for循环遍历像素点
  for i in range(shape[0]):
  for j in range(shape[1]):
  #将int()：转换为更大的类型，防止溢出
  img[i,j] = round((wb * pig[i,j,0] + wg * pig[i,j,1] + wr * pig[i,j,2])//3)

  cv.imshow('grey',img)
  cv.waitKey(0)
  cv.destroyAllWindows()

二值化

• 二值化（阈值法）格式：阈值法：
  _,binary = cv2.threshold(img,thresh,maxval,type)
  _和binary：cv2.threshold 函数返回两个值：一个是计算出的最佳阈值（retval），另一个是阈值处理后的图像（binary），_ 被用来忽略返回值中的第一个元素，即计算出的最佳阈值
  img：输入图像，要进行二值化处理的灰度图。
  thresh：设定的阈值。当像素值大于(或小于，取决于阈值类型)thresh时，该像素被赋予的值。
  type：阈值处理的类型。

• 自适应二值化格式：
  cv2.adaptiveThreshold(image_np_gray, maxval, adaptiveMethod, thresholdType, blockSize, c)
  其中各个参数的含义如下：
  maxval：最大阈值，一般为255
  adaptiveMethod：小区域阈值的计算方式：
  ADAPTIVE_THRESH_MEAN_C：小区域内取均值
  ADAPTIVE_THRESH_GAUSSIAN_C：小区域内加权求和，权重是个高斯核
  thresholdType：二值化方法，只能使用THRESH_BINARY、THRESH_BINARY_INV，也就是阈值法和反阈值法
  blockSize：选取的小区域的面积，如7就是7*7的小块。(只能取奇数)
  c：最终阈值等于小区域计算出的阈值再减去此值

  import cv2 as cv

  #读图
  flower = cv.imread('E:\hqyj\code\opencv\images\flower.png')
  #灰度化处理
  gray = cv.cvtColor(flower,cv.COLOR_BGR2GRAY)
  gray = cv.resize(gray,(360,360))
  cv.imshow('1.gray',gray)

  #二值化 1.阈值法 cv.THRESH_BINARY
  thresh,binary = cv.threshold(gray,127,255,cv.THRESH_BINARY)
  print(thresh)
  cv.imshow('2.binary',binary)

  #2.反阈值法 cv.THRESH_BINARY_INV
  _,binary_inv = cv.threshold(gray,127,255,cv.THRESH_BINARY_INV)
  cv.imshow('3.binary_inv',binary_inv)

  #3.截断阈值法 cv.THRESH_TRUNC
  _,binary_trunc = cv.threshold(gray,170,255,cv.THRESH_TRUNC)
  cv.imshow('4.binary_trunc',binary_trunc)

  #4.低阈值零处理法 cv.THRESH_TOZERO
  _,binary_tozero = cv.threshold(gray,127,255,cv.THRESH_TOZERO)
  cv.imshow('5.binary_tozero',binary_tozero)

  #5.超阈值零处理法 cv.THRESH_TOZERO_INV
  _,binary_tozero_inv = cv.threshold(gray,127,255,cv.THRESH_TOZERO_INV)
  cv.imshow('6.binary_tozero_inv',binary_tozero_inv)

  #6.OTSU阈值法
  shresh1,otsu=cv.threshold(gray,200,255,cv.THRESH_OTSU)
  #7.OTSU+反阈值法
  shresh2,otsu_inv = cv.threshold(gray,shresh1,255,cv.THRESH_BINARY_INV)
  print(shresh1)
  print(shresh2)
  cv.imshow('7.otsu',otsu)

  #自适应二值化 小区域计算 必须只能结合阈值法或反阈值法
  #1.取均值
  binary_adaptive = cv.adaptiveThreshold(gray,255,cv.ADAPTIVE_THRESH_MEAN_C,cv.THRESH_BINARY,7,10)
  #2.加权求和法 高斯核
  adaptive_binary = cv.adaptiveThreshold(gray,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,cv.THRESH_BINARY,11,10)
  cv.imshow('8.binary_adaptive',binary_adaptive)
  cv.imshow('9.adaptive_binary',adaptive_binary)

  cv.waitKey(0)
  cv.destroyAllWindows()

仿射变换

• 仿射变换流程
  1.读图cv.imread()，调尺寸cv.resize()
  2.获取仿射变换矩阵

  1.旋转：M = cv.getRotationMatrix2D(center,angle,scale)
  center：旋转中心点的坐标，格式为(x,y)。
  angle：旋转角度，单位为度，正值表示逆时针旋转负值表示顺时针旋转。
  scale：缩放比例，若设为1，则不缩放。
  2.平移：M = np.float32([[1,0,tx],[0,1,ty]])
  3.缩放：M = np.float32([[sx,0,0],[0,sy,0]])
  4.剪切：M = np.float32([[shx,1,0],[1,shy,0]])

• 旋转

  import cv2 as cv

  #读图
  cat = cv.imread('E:\hqyj\code\opencv\images\cat1.png')
  cat = cv.resize(cat,(520,520))
  #获取旋转矩阵 cvv2.getRotationMatrix2D(center,angle,scale) 2x3
  M = cv.getRotationMatrix2D((260,260),-45,1)
  #仿射变换函数 cv.warpAffine(img,M,(w,h))
  img = cv.warpAffine(cat,M,(520,520))
  cv.imshow('img',img)
  cv.waitKey(0)
  cv.destroyAllWindows()

• 平移

  import cv2 as cv
  import numpy as np

  #读图
  cat = cv.imread('E:\hqyj\code\opencv\images\cat1.png')
  cat = cv.resize(cat,(520,520))
  #定义平移量
  tx,ty = 80,120
  #定义平移矩阵
  M = np.float32([[1,0,tx],[0,1,ty]])
  #仿射变换函数 M = cv.warpAffine(img,M,(w,h))
  img = cv.warpAffine(cat,M,(520,520))
  cv.imshow('img',img)
  cv.waitKey(0)
  cv.destroyAllWindows()

• 缩放

  import cv2 as cv
  import numpy as np

  #读图
  cat = cv.imread('E:\hqyj\code\opencv\images\cat1.png')
  cat = cv.resize(cat,(520,520))
  #定义缩放量
  sx,sy = 0.5,0.5
  #定义缩放矩阵
  M = np.float32([[sx,0,0],[0,sy,0]])
  #仿射变换函数 cv.warpAffine(img,M,(w,h))
  img = cv.warpAffine(cat,M,(520,520))
  cv.imshow('img',img)
  cv.waitKey(0)
  cv.destroyAllWindows()

• 剪切

  import cv2 as cv
  import numpy as np

  #读图
  cat = cv.imread('E:\hqyj\code\opencv\images\cat1.png')
  cat = cv.resize(cat,(520,520))
  #定义缩放量
  shx,shy = 0.5,0.5
  #定义缩放矩阵
  M = np.float32([[shx,1,0],[1,shy,0]])
  #仿射变换函数 cv.warpAffine(img,M,(w,h))
  img = cv.warpAffine(cat,M,(520,520))
  cv.imshow('img',img)
  cv.waitKey(0)
  cv.destroyAllWindows()