Opencv计算机视觉入门——图像的处理（一）

深藏阁楼爱情的钟 2021-11-26 13:54 437阅读 0赞

接上次的笔记，开始图像操作的第二段学习旅程~~~

图像的处理（一）

图像阈值

拿到一张图像，图像是由众多像素点组成的，我们要对每一个像素点的值进行判断，用像素点的值与阈值进行比较，对于大于或小于阈值分别做不同的处理。

  1. ret,dist = cv2.threshold(src,thresh,maxval,type)

src：输入图，只能输入单通道图像，通常来说为灰度图

dist：输出图

thresh：阈值

maxval：当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值

type：二值化操作的类型，包括以下5种类型：cv2.THRESH_BINARY;cv2.THRESH_BINARY_INV;cv2.THRESH_TRUNC;cv2.THRESH_TOZERO;cv2.THRESH_TOZERO_INV

cv2.THRESH_BINARY：超过阈值部分取maxval（最大值），否则取0

cv2.THRESH_BINARY_INV：THRESH_BINARY的反转，即超过阈值部分取0，否则取maxval（最大值）

cv2.THRESH_TRUNC：大于阈值部分设为阈值，否则不变

cv2.THRESH_TOZERO：大于阈值部分不改变，否则设为0

cv2.THRESH_TOZERO_INV：THRESH_TOZERO的反转

  1. #图像阈值
  2. import matplotlib.pyplot as plt
  3. ret, thresh1 = cv2.threshold(img_gray,127,255,cv2.THRESH_BINARY)
  4. ret, thresh2 = cv2.threshold(img_gray,127,255,cv2.THRESH_BINARY_INV)
  5. ret, thresh3 = cv2.threshold(img_gray,127,255,cv2.THRESH_TRUNC)
  6. ret, thresh4 = cv2.threshold(img_gray,127,255,cv2.THRESH_TOZERO)
  7. ret, thresh5 = cv2.threshold(img_gray,127,255,cv2.THRESH_TOZERO_INV)
  9. title = ['Original Image','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
  10. images = [img,thresh1,thresh2,thresh3,thresh4,thresh5]
  11. for i in range(6):
  12.     plt.subplot(2,3,i + 1),plt.imshow(images[i],'gray')
  13.     plt.title(title[i])
  14.     plt.xticks()
  15.     plt.yticks()
  16. plt.show()

图像平滑

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Fuc2hpZGFzaGVu_size_16_color_FFFFFF_t_70

当前输入数据，如上lena图像上有很多噪音点，现在我们想通过滤波、平滑处理等操作尽可能的去掉这些噪音点。

  1. #图像平滑
  2. img = cv2.imread('lenaNoise.png')
  3. cv2.imshow('image',img)
  4. cv2.waitKey(0)
  5. cv2.destroyAllWindows()
  7. #均值滤波
  8. #简单的平均卷积操作
  9. blur = cv2.blur(img,(3,3))
  10. cv2.imshow('blur',blur)
  11. cv2.waitKey(0)
  12. cv2.destroyAllWindows()
  14. #方框滤波
  15. #基本和滤波一样，可以选择归一化
  16. box = cv2.boxFilter(img,-1,(3,3),normalize=True)
  17. cv2.imshow('box',box)
  18. cv2.waitKey(0)
  19. cv2.destroyAllWindows()
  21. #方框滤波
  22. #基本和滤波一样，可以选择归一化,容易越界
  23. box = cv2.boxFilter(img,-1,(3,3),normalize=False)
  24. cv2.imshow('box',box)
  25. cv2.waitKey(0)
  26. cv2.destroyAllWindows()
  28. #高斯滤波
  29. #高斯模糊的卷积核里的数值是满足高斯分布的，相当于更重视中间的
  30. aussian = cv2.GaussianBlur(img,(5,5),1)
  31. cv2.imshow('aussian',aussian)
  32. cv2.waitKey(0)
  33. cv2.destroyAllWindows()
  35. #中值滤波
  36. #相当于用中值代替,利用中值滤波处理后，椒盐噪声几乎完全被去除掉
  37. median = cv2.medianBlur(img,5)
  38. cv2.imshow('median',median)
  39. cv2.waitKey(0)
  40. cv2.destroyAllWindows()
  42. #展示所有的
  43. res = np.hstack((blur,aussian,median))
  44. print(res)
  45. cv2.imshow('median vs average',res)
  46. cv2.waitKey(0)
  47. cv2.destroyAllWindows()

均值滤波相当于低通滤波，有将图像模糊化的趋势，对椒盐噪声计基本无能为力。中值滤波的优点是可以很好的过滤掉椒盐噪声，缺点是易造成图像的不连续性。

形态学-腐蚀操作

  1. #形态学—腐蚀操作
  2. img = cv2.imread('dige.png')
  3. cv2.imshow('image',img)
  4. cv2.waitKey(0)
  5. cv2.destroyAllWindows()
  7. kernel_1 = np.ones((3,3),np.uint8)
  8. erosion = cv2.erode(img,kernel_1,iterations=1)
  9. cv2.imshow('erosion',erosion)
  10. cv2.waitKey(0)
  11. cv2.destroyAllWindows()
  13. pie = cv2.imread('pie.png')
  14. cv2.imshow('pie',pie)
  15. cv2.waitKey(0)
  16. cv2.destroyAllWindows()
  18. kernel_2 = np.ones((30,30),np.uint8)
  19. erosion_1 = cv2.erode(pie,kernel_2,iterations=1)
  20. erosion_2 = cv2.erode(pie,kernel_2,iterations=2)
  21. erosion_3 = cv2.erode(pie,kernel_2,iterations=3)
  22. res = np.hstack((erosion_1,erosion_2,erosion_3))
  23. cv2.imshow('res',res)
  24. cv2.waitKey(0)
  25. cv2.destroyAllWindows()

形态学-膨胀操作

  1. #形态学—膨胀操作
  2. img = cv2.imread('dige.png')
  3. cv2.imshow('image',img)
  4. cv2.waitKey(0)
  5. cv2.destroyAllWindows()
  7. kernel = np.ones((3,3),np.uint8)
  8. dige_erosion = cv2.erode(img,kernel,iterations=1)
  9. cv2.imshow('erosion',dige_erosion)
  10. cv2.waitKey(0)
  11. cv2.destroyAllWindows()
  13. kernel = np.ones((3,3),np.uint8)
  14. dige_dilate = cv2.dilate(dige_erosion,kernel,iterations=1)
  15. cv2.imshow('dilate',dige_dilate)
  16. cv2.waitKey(0)
  17. cv2.destroyAllWindows()
  19. pie = cv2.imread('pie.png')
  20. kernel = np.ones((30,30),np.uint8)
  21. dilate_1 = cv2.dilate(pie,kernel,iterations=1)
  22. dilate_2 = cv2.dilate(pie,kernel,iterations=2)
  23. dilate_3 = cv2.dilate(pie,kernel,iterations=3)
  24. res = np.hstack((dilate_1,dilate_2,dilate_3))
  25. cv2.imshow('res',res)
  26. cv2.waitKey(0)
  27. cv2.destroyAllWindows()

开运算与闭运算

开运算：先腐蚀，再膨胀

闭运算：先膨胀，再腐蚀

  1. #开运算与闭运算
  2. #开：先腐蚀，再膨胀
  3. img = cv2.imread('dige.png')
  4. kernel = np.ones((3,3),np.uint8)
  5. opening = cv2.morphologyEx(img,cv2.MORPH_OPEN,kernel)
  6. cv2.imshow('opening',opening)
  7. cv2.waitKey(0)
  8. cv2.destroyAllWindows()
  10. #闭：先膨胀，再腐蚀
  11. img =cv2.imread('dige.png')
  12. kernel = np.ones((3,3),np.uint8)
  13. closing = cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel)
  14. cv2.imshow('closing',closing)
  15. cv2.waitKey(0)
  16. cv2.destroyAllWindows()
  18. #梯度运算
  19. #梯度=膨胀-腐蚀
  20. pie = cv2.imread('pie.png')
  21. kernel = np.ones((7,7),np.uint8)
  22. dilate = cv2.dilate(pie,kernel,iterations=5)
  23. erossion = cv2.erode(pie,kernel,iterations=5)
  25. res = np.hstack((dilate,erossion))
  26. cv2.imshow('res',res)
  27. cv2.waitKey(0)
  28. cv2.destroyAllWindows()
  30. gradient = cv2.morphologyEx(pie,cv2.MORPH_GRADIENT,kernel)
  31. cv2.imshow('gradient',gradient)
  32. cv2.waitKey(0)
  33. cv2.destroyAllWindows()
  36. #礼帽和黑帽
  37. #礼帽=原始输入-开运算结果
  38. #黑帽=闭运算-原始输入
  40. #礼帽
  41. img = cv2.imread('dige.png')
  42. kernel = np.ones((5,5),np.uint8)
  43. tophat = cv2.morphologyEx(img,cv2.MORPH_TOPHAT,kernel)
  44. cv2.imshow('topcat',tophat)
  45. cv2.waitKey(0)
  46. cv2.destroyAllWindows()
  47. #黑帽
  48. img = cv2.imread('dige.png')
  49. kernel = np.ones((5,5),np.uint8)
  50. blackhat = cv2.morphologyEx(img,cv2.MORPH_BLACKHAT,kernel)
  51. cv2.imshow('blackhat',blackhat)
  52. cv2.waitKey(0)
  53. cv2.destroyAllWindows()

图像梯度-Sobel算子

20190728163740629.png

梯度简单来说就是求导。OpenCV提供了三种不同的梯度滤波器，或者说高通滤波器：Sobel，Scharr和Lapacian。Sobel，Scharr其实就是求一阶或二阶导。Scharr是对Sobel的部分优化。Laplacian是求二阶导。

  1. #图像梯度-Sobel算子
  2. img = cv2.imread('pie.png',cv2.IMREAD_GRAYSCALE)
  3. cv2.imshow('img',img)
  4. cv2.waitKey(0)
  5. cv2.destroyAllWindows()
  7. dist = cv2.Sobel(src,ddepth,dx,dy,ksize)
  9. ddepth:图像深度
  11. dx和dy分别表示水平和竖直方向
  13. ksize是Sobel算子的大小
  15. #图像梯度-Sobel算子
  16. img = cv2.imread('pie.png',cv2.IMREAD_GRAYSCALE)
  17. cv2.imshow('img',img)
  18. cv2.waitKey(0)
  19. cv2.destroyAllWindows()
  21. def cv_show(img,name):
  22.     cv2.imshow(name,img)
  23.     cv2.waitKey(0)
  24.     cv2.destroyAllWindows()
  26. #cv2.CV_64F,64F代表每一个像素点元素占64位浮点数
  27. sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
  28. sobelx = cv2.convertScaleAbs(sobelx)
  29. cv_show(sobelx,'sobelx')
  31. #白到黑是正数，黑到白是负数，所有的负数都会被截断为0，所以要取绝对值
  32. sobely = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
  33. sobely = cv2.convertScaleAbs(sobely)
  34. cv_show(sobely,'sobely')
  36. sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
  37. sobely = cv2.convertScaleAbs(sobely)
  38. cv_show(sobely,'sobely')
  40. #分别计算x和y，再求和
  41. sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
  42. cv_show(sobelxy,'sobelxy')
  44. img = cv2.imread('lena.jpg',cv2.IMREAD_GRAYSCALE)
  45. sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
  46. sobelx = cv2.convertScaleAbs(sobelx)
  47. sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
  48. sobely = cv2.convertScaleAbs(sobely)
  49. sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
  50. cv_show(sobelxy,'sobelxy')
  52. #整体计算存在重影,不建议
  53. img = cv2.imread('lena.jpg',cv2.IMREAD_GRAYSCALE)
  54. sobelxy = cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
  55. sobelxy = cv2.convertScaleAbs(sobelxy)
  56. cv_show(sobelxy,'sobelxy')

图像梯度-Scharr算子

20190728174806876.png

图像梯度-laplacian算子

20190728174904542.png

拉普拉斯算子可以使用二阶导数的形式定义，可假设其离散实现类似于二阶Sobel导数。

  1. #不同算子的差异
  2. img = cv2.imread('lena.jpg',cv2.IMREAD_GRAYSCALE)
  3. sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
  4. sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
  5. sobelx = cv2.convertScaleAbs(sobelx)
  6. sobely = cv2.convertScaleAbs(sobely)
  7. sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
  9. scharrx = cv2.Scharr(img,cv2.CV_64F,1,0)
  10. scharry = cv2.Scharr(img,cv2.CV_64F,0,1)
  11. scharrx = cv2.convertScaleAbs(scharrx)
  12. scharry = cv2.convertScaleAbs(scharry)
  13. scharrxy = cv2.addWeighted(scharrx,0.5,scharry,0.5,0)
  15. laplacian = cv2.Laplacian(img,cv2.CV_64F)
  16. laplacian = cv2.convertScaleAbs(laplacian)
  18. res = np.hstack((img,sobelxy,scharrxy,laplacian))
  19. cv_show(res,'res')

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Fuc2hpZGFzaGVu_size_16_color_FFFFFF_t_70 1

发表评论

表情：
评论列表 （有 0 条评论，437人围观）

还没有评论，来说两句吧...

相关阅读