花生_TL007

这个屌丝很懒，什么也没留下！

热门标签

《OpenCV》03 图像处理_ds.icec[0].plot()

作者：花生_TL007 | 2024-02-17 05:19:46

踩

ds.icec[0].plot()

3 OpenCV图像处理

主要内容

图像的几何变换
图像的形态学转换
图像的平滑方法
直方图的方法
边缘检测的方法
模板匹配和霍夫变换的应用

几何变换

学习目标

掌握图像的缩放，平移，旋转等
了解数字图像的仿射变换和透射变换

1 图像缩放

缩放是对图像的大小进行调整，即使图像放大或缩小。

API
```
cv2.resize(src,dsize,fx=0,fy=0,interpolation=cv2.INTER_LINEAR)
```
参数：
- src : 输入图像
- dsize: 绝对尺寸，直接指定调整后图像的大小
- fx,fy: 相对尺寸，将dsize设置为None，然后将fx和fy设置为比例因子即可
- interpolation：插值方法，
示例


import cv2 as cv
# 1. 读取图片
img1 = cv.imread("./image/dog.jpeg")
# 2.图像缩放
# 2.1 绝对尺寸
rows,cols = img1.shape[:2]
res = cv.resize(img1,(2*cols,2*rows),interpolation=cv.INTER_CUBIC)
 
# 2.2 相对尺寸
res1 = cv.resize(img1,None,fx=0.5,fy=0.5)
 
# 3 图像显示
# 3.1 使用opencv显示图像(不推荐)
cv.imshow("orignal",img1)
cv.imshow("enlarge",res)
cv.imshow("shrink）",res1)
cv.waitKey(0)
 
# 3.2 使用matplotlib显示图像
fig,axes=plt.subplots(nrows=1,ncols=3,figsize=(10,8),dpi=100)
axes[0].imshow(res[:,:,::-1])
axes[0].set_title("绝对尺度（放大）")
axes[1].imshow(img1[:,:,::-1])
axes[1].set_title("原图")
axes[2].imshow(res1[:,:,::-1])
axes[2].set_title("相对尺度（缩小）")
plt.show()

2 图像平移

图像平移将图像按照指定方向和距离，移动到相应的位置。

cv.warpAffine(img,M,dsize)

参数：

img: 输入图像
M： 2*∗3移动矩阵

对于(x,y)处的像素点，要把它移动到(x+t_x , y+t_yx+tx,y+ty)处时，M矩阵应如下设置：

M=
$[\begin{matrix} 1 & 0 & t_{x} \\ 0 & 1 & t_{y} \end{matrix}]$ $\begin{bmatrix} 1&0&t_x\\ 0&1&t_y\\ \end{bmatrix}$ M=⎣⎡1001txty⎦⎤

注意：将MM设置为np.float32类型的Numpy数组。
dsize: 输出图像的大小

注意：输出图像的大小，它应该是(宽度，高度)的形式。请记住,width=列数，height=行数。
示例

需求是将图像的像素点移动(50,100)的距离：


import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1. 读取图像
img1 = cv.imread("./image/image2.jpg")
 
# 2. 图像平移
rows,cols = img1.shape[:2]
M = M = np.float32([[1,0,100],[0,1,50]])# 平移矩阵
dst = cv.warpAffine(img1,M,(cols,rows))
 
# 3. 图像显示
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img1[:,:,::-1])
axes[0].set_title("原图")
axes[1].imshow(dst[:,:,::-1])
axes[1].set_title("平移后结果")
plt.show()

3 图像旋转

图像旋转是指图像按照某个位置转动一定角度的过程，旋转中图像仍保持这原始尺寸。图像旋转后图像的水平对称轴、垂直对称轴及中心坐标原点都可能会发生变换，因此需要对图像旋转中的坐标进行相应转换。

那图像是怎么进行旋转的呢？如下图所示：

假设图像逆时针旋转\thetaθ，则根据坐标转换可得旋转转换为:

其中：

带入上面的公式中，有：

也可以写成：

[\begin{matrix} x^{'} & y^{'} & 1 \end{matrix}]

$\begin{bmatrix}x'& y'&1\end{bmatrix}$ =

[\begin{matrix} x & y & 1 \end{matrix}]

$\begin{bmatrix}x& y&1\end{bmatrix}$

[\begin{matrix} \cos θ & - \sin θ & 0 \\ \sin θ & \cos θ & 0 \\ 0 & 0 & 1 \end{matrix}]

$\begin{bmatrix} \cos\theta&-\sin\theta&0\\ \sin\theta&\cos\theta&0\\0&0&1 \end{bmatrix}$ [x′y′1]=[xy1]⎣⎡cosθsinθ0−sinθcosθ0001⎦⎤同时我们要修正原点的位置，因为原图像中的坐标原点在图像的左上角，经过旋转后图像的大小会有所变化，原点也需要修正。

假设在旋转的时候是以旋转中心为坐标原点的，旋转结束后还需要将坐标原点移到图像左上角，也就是还要进行一次变换。

[\begin{matrix} x^{″} & y^{″} & 1 \end{matrix}]

$\begin{bmatrix}x''& y''&1\end{bmatrix}$ =

[\begin{matrix} x^{'} & y^{'} & 1 \end{matrix}]

$\begin{bmatrix}x'& y'&1\end{bmatrix}$

[\begin{matrix} 1 & 0 & 0 \\ 0 & - 1 & 0 \\ l e f t & t o p & 1 \end{matrix}]

$\begin{bmatrix} 1&0&0\\ 0&-1&0\\left&top&1 \end{bmatrix}$ [x′′y′′1]=[x′y′1]⎣⎡10left0−1top001⎦⎤

[\begin{matrix} x & y & 1 \end{matrix}]

$\begin{bmatrix}x& y&1\end{bmatrix}$

[\begin{matrix} \cos θ & - \sin θ & 0 \\ \sin θ & \cos θ & 0 \\ 0 & 0 & 1 \end{matrix}]

$\begin{bmatrix} \cos\theta&-\sin\theta&0\\ \sin\theta&\cos\theta&0\\0&0&1 \end{bmatrix}$

[\begin{matrix} 1 & 0 & 0 \\ 0 & - 1 & 0 \\ l e f t & t o p & 1 \end{matrix}]

$\begin{bmatrix} 1&0&0\\ 0&-1&0\\left&top&1 \end{bmatrix}$ =[xy1]⎣⎡cosθsinθ0−sinθcosθ0001⎦⎤⎣⎡10left0−1top001⎦⎤

在OpenCV中图像旋转首先根据旋转角度和旋转中心获取旋转矩阵，然后根据旋转矩阵进行变换，即可实现任意角度和任意中心的旋转效果。

API
```
cv2.getRotationMatrix2D(center, angle, scale)
```
参数：
- center：旋转中心
- angle：旋转角度
- scale：缩放比例
返回：
- M：旋转矩阵
  
  调用cv.warpAffine完成图像的旋转

示例


import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像
img = cv.imread("./image/image2.jpg")
 
# 2 图像旋转
rows,cols = img.shape[:2]
# 2.1 生成旋转矩阵
M = cv.getRotationMatrix2D((cols/2,rows/2),90,1)
# 2.2 进行旋转变换
dst = cv.warpAffine(img,M,(cols,rows))
 
# 3 图像展示
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img1[:,:,::-1])
axes[0].set_title("原图")
axes[1].imshow(dst[:,:,::-1])
axes[1].set_title("旋转后结果")
plt.show()

4 仿射变换

图像的仿射变换涉及到图像的形状位置角度的变化，是深度学习预处理中常到的功能,仿射变换主要是对图像的缩放，旋转，翻转和平移等操作的组合。

那什么是图像的仿射变换，如下图所示，图1中的点1, 2 和 3 与图二中三个点一一映射, 仍然形成三角形, 但形状已经大大改变，通过这样两组三点（感兴趣点）求出仿射变换，接下来我们就能把仿射变换应用到图像中所有的点中，就完成了图像的仿射变换。

在OpenCV中，仿射变换的矩阵是一个2×3的矩阵，M = \left[

\begin{matrix} A & B \end{matrix}

$\begin{matrix} A & B \end{matrix}$ \right]=\left[

\begin{matrix} a_{00} & a_{01} & b_{0} \\ a_{10} & a_{11} & b_{1} \end{matrix}

$\begin{matrix} a_{00}& a_{01}&b_0\\ a_{10}&a_{11}&b_1 \end{matrix}$ \right]M=[AB]=[a00a10a01a11b0b1]其中左边的2×2子矩阵$A$是线性变换矩阵，右边的2×1子矩阵$B$是平移项：A=\left[

\begin{matrix} a_{00} & a_{01} \\ a_{10} & a_{11} \end{matrix}

$\begin{matrix} a_{00} & a_{01}\\ a_{10} & a_{11} \end{matrix}$ \right], B=\left[

\begin{matrix} b_{0} \\ b_{1} \end{matrix}

$\begin{matrix} b_{0}\\ b_{1} \end{matrix}$ \right]A=[a00a10a01a11],B=[b0b1]对于图像上的任一位置(x,y)，仿射变换执行的是如下的操作：T_{affine}=A\left[

\begin{matrix} x \\ y \end{matrix}

$\begin{matrix} x\\ y \end{matrix}$ \right]+B=M\left[

\begin{matrix} x \\ y \\ 1 \end{matrix}

$\begin{matrix}x\\y\\1\end{matrix}$ \right]Taffine=A[xy]+B=M⎣⎡xy1⎦⎤

需要注意的是，对于图像而言，宽度方向是x，高度方向是y，坐标的顺序和图像像素对应下标一致。所以原点的位置不是左下角而是右上角，y的方向也不是向上，而是向下。

在仿射变换中，原图中所有的平行线在结果图像中同样平行。为了创建这个矩阵我们需要从原图像中找到三个点以及他们在输出图像中的位置。然后cv2.getAﬃneTransform 会创建一个 2x3 的矩阵，最后这个矩阵会被传给函数 cv2.warpAﬃne。

示例


import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 图像读取
img = cv.imread("./image/image2.jpg")
 
# 2 仿射变换
rows,cols = img.shape[:2]
# 2.1 创建变换矩阵
pts1 = np.float32([[50,50],[200,50],[50,200]])
pts2 = np.float32([[100,100],[200,50],[100,250]])
M = cv.getAffineTransform(pts1,pts2)
# 2.2 完成仿射变换
dst = cv.warpAffine(img,M,(cols,rows))
 
# 3 图像显示
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原图")
axes[1].imshow(dst[:,:,::-1])
axes[1].set_title("仿射后结果")
plt.show()

5 透射变换

透射变换是视角变化的结果，是指利用透视中心、像点、目标点三点共线的条件，按透视旋转定律使承影面（透视面）绕迹线（透视轴）旋转某一角度，破坏原有的投影光线束，仍能保持承影面上投影几何图形不变的变换。

它的本质将图像投影到一个新的视平面，其通用变换公式为：\left[

\begin{matrix} x^{'} & y^{'} & z^{'} \end{matrix}

$\begin{matrix} x' & y'& z' \end{matrix}$ \right]=\left[

\begin{matrix} u & v & w \end{matrix}

$\begin{matrix} u & v & w \end{matrix}$ \right]\left[

\begin{matrix} a_{00} & a_{01} & a_{02} \\ a_{10} & a_{11} & a_{12} \\ a_{20} & a_{21} & a_{22} \end{matrix}

$\begin{matrix} a_{00}& a_{01}&a_{02}\\ a_{10}&a_{11}&a_{12}\\ a_{20}&a_{21}&a_{22} \end{matrix}$ \right][x′y′z′]=[uvw]⎣⎡a00a10a20a01a11a21a02a12a22⎦⎤其中，(u,v)是原始的图像像素坐标，w取值为1，(x=x'/z',y=y'/z')是透射变换后的结果。后面的矩阵称为透视变换矩阵，一般情况下，我们将其分为三部分：T = \left[

\begin{matrix} a_{00} & a_{01} & a_{02} \\ a_{10} & a_{11} & a_{12} \\ a_{20} & a_{21} & a_{22} \end{matrix}

$\begin{matrix} a_{00}& a_{01}&a_{02}\\ a_{10}&a_{11}&a_{12}\\ a_{20}&a_{21}&a_{22} \end{matrix}$ \right] = \left[

\begin{matrix} T 1 & T 2 \\ T 3 & a_{22} \end{matrix}

$\begin{matrix} T1& T2\\ T3&a_{22} \end{matrix}$ \right]T=⎣⎡a00a10a20a01a11a21a02a12a22⎦⎤=[T1T3T2a22]其中：T1表示对图像进行线性变换，T2对图像进行平移，T3表示对图像进行投射变换，a_{22}a22一般设为1.

在opencv中，我们要找到四个点，其中任意三个不共线，然后获取变换矩阵T，再进行透射变换。通过函数cv.getPerspectiveTransform找到变换矩阵，将cv.warpPerspective应用于此3x3变换矩阵。

示例


import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像
img = cv.imread("./image/image2.jpg")
# 2 透射变换
rows,cols = img.shape[:2]
# 2.1 创建变换矩阵
pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]])
pts2 = np.float32([[100,145],[300,100],[80,290],[310,300]])
 
T = cv.getPerspectiveTransform(pts1,pts2)
# 2.2 进行变换
dst = cv.warpPerspective(img,T,(cols,rows))
 
# 3 图像显示
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img[:,:,::-1])
axes[0].set_title("原图")
axes[1].imshow(dst[:,:,::-1])
axes[1].set_title("透射后结果")
plt.show()

6 图像金字塔

图像金字塔是图像多尺度表达的一种，最主要用于图像的分割，是一种以多分辨率来解释图像的有效但概念简单的结构。

图像金字塔用于机器视觉和图像压缩，一幅图像的金字塔是一系列以金字塔形状排列的分辨率逐步降低，且来源于同一张原始图的图像集合。其通过梯次向下采样获得，直到达到某个终止条件才停止采样。

金字塔的底部是待处理图像的高分辨率表示，而顶部是低分辨率的近似，层级越高，图像越小，分辨率越低。

API


cv.pyrUp(img)       #对图像进行上采样
cv.pyrDown(img)        #对图像进行下采样

示例


import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 图像读取
img = cv.imread("./image/image2.jpg")
# 2 进行图像采样
up_img = cv.pyrUp(img)  # 上采样操作
img_1 = cv.pyrDown(img)  # 下采样操作
# 3 图像显示
cv.imshow('enlarge', up_img)
cv.imshow('original', img)
cv.imshow('shrink', img_1)
cv.waitKey(0)
cv.destroyAllWindows()

总结

图像缩放：对图像进行放大或缩小

cv.resize()
图像平移：

指定平移矩阵后，调用cv.warpAffine()平移图像
图像旋转：

调用cv.getRotationMatrix2D获取旋转矩阵，然后调用cv.warpAffine()进行旋转
仿射变换：

调用cv.getAffineTransform将创建变换矩阵，最后该矩阵将传递给cv.warpAffine()进行变换
透射变换：

通过函数cv.getPerspectiveTransform()找到变换矩阵，将cv.warpPerspective()进行投射变换
金字塔

图像金字塔是图像多尺度表达的一种，使用的API：

cv.pyrUp(): 向上采样

cv.pyrDown(): 向下采样

形态学操作

学习目标

理解图像的邻域，连通性
了解不同的形态学操作：腐蚀，膨胀，开闭运算，礼帽和黑帽等，及其不同操作之间的关系

1 连通性

在图像中，最小的单位是像素，每个像素周围有8个邻接像素，常见的邻接关系有3种：4邻接、8邻接和D邻接。分别如下图所示：

4邻接：像素p(x,y)的4邻域是：(x+1,y)；(x-1,y)；(x,y+1)；(x,y-1)，用N_4(p)N4(p)表示像素p的4邻接
D邻接：像素p(x,y)的D邻域是：对角上的点 (x+1,y+1)；(x+1,y-1)；(x-1,y+1)；(x-1,y-1)，用N_D(p)ND(p)表示像素p的D邻域
8邻接：像素p(x,y)的8邻域是： 4邻域的点＋ D邻域的点，用N_{8}(p)N8(p)表示像素p的8邻域

连通性是描述区域和边界的重要概念，两个像素连通的两个必要条件是：

两个像素的位置是否相邻
两个像素的灰度值是否满足特定的相似性准则（或者是否相等

根据连通性的定义，有4联通、8联通和m联通三种。

4联通：对于具有值VV的像素pp和qq，如果qq在集合N_4(p)N4(p)中，则称这两个像素是4连通。
8联通：对于具有值VV的像素pp和qq，如果qq在集合N_8(p)N8(p)中，则称这两个像素是8连通。
对于具有值VV的像素pp和qq，如果:
1. qq在集合N_4(p)N4(p)中，或
2. qq在集合N_D(p)ND(p)中，并且N_4(p)N4(p)与N_4(q)N4(q)的交集为空（没有值VV的像素）
则称这两个像素是mm连通的，即4连通和D连通的混合连通。

2 形态学操作

形态学转换是基于图像形状的一些简单操作。它通常在二进制图像上执行。腐蚀和膨胀是两个基本的形态学运算符。然后它的变体形式如开运算，闭运算，礼帽黑帽等。

2.1 腐蚀和膨胀

腐蚀和膨胀是最基本的形态学操作，腐蚀和膨胀都是针对白色部分（高亮部分）而言的。

膨胀就是使图像中高亮部分扩张，效果图拥有比原图更大的高亮区域；腐蚀是原图中的高亮区域被蚕食，效果图拥有比原图更小的高亮区域。膨胀是求局部最大值的操作，腐蚀是求局部最小值的操作。

腐蚀

具体操作是：用一个结构元素扫描图像中的每一个像素，用结构元素中的每一个像素与其覆盖的像素做“与”操作，如果都为1，则该像素为1，否则为0。如下图所示，结构A被结构B腐蚀后：

腐蚀的作用是消除物体边界点，使目标缩小，可以消除小于结构元素的噪声点。

API：

   cv.erode(img,kernel,iterations)

参数：

img: 要处理的图像
kernel: 核结构
iterations: 腐蚀的次数，默认是1

膨胀

具体操作是：用一个结构元素扫描图像中的每一个像素，用结构元素中的每一个像素与其覆盖的像素做“与”操作，如果都为0，则该像素为0，否则为1。如下图所示，结构A被结构B腐蚀后：

膨胀的作用是将与物体接触的所有背景点合并到物体中，使目标增大，可添补目标中的孔洞。

API：

   cv.dilate(img,kernel,iterations)

参数：

img: 要处理的图像
kernel: 核结构
iterations: 腐蚀的次数，默认是1

示例

我们使用一个5*5的卷积核实现腐蚀和膨胀的运算：


import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像
img = cv.imread("./image/image3.png")
# 2 创建核结构
kernel = np.ones((5, 5), np.uint8)
 
# 3 图像腐蚀和膨胀
erosion = cv.erode(img, kernel) # 腐蚀
dilate = cv.dilate(img,kernel) # 膨胀
 
# 4 图像展示
fig,axes=plt.subplots(nrows=1,ncols=3,figsize=(10,8),dpi=100)
axes[0].imshow(img)
axes[0].set_title("原图")
axes[1].imshow(erosion)
axes[1].set_title("腐蚀后结果")
axes[2].imshow(dilate)
axes[2].set_title("膨胀后结果")
plt.show()

2.2 开闭运算

开运算和闭运算是将腐蚀和膨胀按照一定的次序进行处理。但这两者并不是可逆的，即先开后闭并不能得到原来的图像。

开运算

开运算是先腐蚀后膨胀，其作用是：分离物体，消除小区域。特点：消除噪点，去除小的干扰块，而不影响原来的图像。
闭运算

闭运算与开运算相反，是先膨胀后腐蚀，作用是消除/“闭合”物体里面的孔洞，特点：可以填充闭合区域。
API
```
cv.morphologyEx(img, op, kernel)
```
参数：
- img: 要处理的图像
- op: 处理方式：若进行开运算，则设为cv.MORPH_OPEN，若进行闭运算，则设为cv.MORPH_CLOSE
- Kernel：核结构
示例

使用10*10的核结构对卷积进行开闭运算的实现。
```
import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像
img1 = cv.imread("./image/image5.png")
img2 = cv.imread("./image/image6.png")
# 2 创建核结构
kernel = np.ones((10, 10), np.uint8)
# 3 图像的开闭运算
cvOpen = cv.morphologyEx(img1,cv.MORPH_OPEN,kernel) # 开运算
cvClose = cv.morphologyEx(img2,cv.MORPH_CLOSE,kernel)# 闭运算
# 4 图像展示
fig,axes=plt.subplots(nrows=2,ncols=2,figsize=(10,8))
axes[0,0].imshow(img1)
axes[0,0].set_title("原图")
axes[0,1].imshow(cvOpen)
axes[0,1].set_title("开运算结果")
axes[1,0].imshow(img2)
axes[1,0].set_title("原图")
axes[1,1].imshow(cvClose)
axes[1,1].set_title("闭运算结果")
plt.show()
```
总结
1. 连通性邻接关系：4邻接，8邻接和D邻接
  
  连通性：4连通，8连通和m连通
2. 形态学操作
  - 腐蚀和膨胀：
    
    腐蚀：求局部最大值
    
    膨胀：求局部最小值
  - 开闭运算：
    
    开运算：先腐蚀后膨胀目的：分离物体，消除小区域特点：消除噪点，去除小的干扰块，而不影响原理啊的图像。
    
    闭运算：先膨胀后腐蚀目的：消除“闭合”物体里面的孔洞特点：可以填充闭合区域。
  - 礼帽和黑帽：
    
    礼帽：原图像与开运算之差
    
    从原图中减去开运算后的图，得到的效果图突出了比原图轮廓周围的区域更明亮的区域，且这一操作和选择的核的大小相关。
    
    　　礼帽运算用来分离比邻近点亮一些的斑块。当一幅图像具有大幅的背景的时候，而微小物品比较有规律的情况下，可以使用顶帽运算进行背景提取。
    
    黑帽：闭运算与原图像之差
黑帽运算后的效果图突出了比原图轮廓周围的区域更暗的区域，且这一操作和选择的核的大小相关。

黑帽运算用来分离比邻近点暗一些的斑块。

图像平滑

学习目标
- 了解图像中的噪声类型
- 了解平均滤波，高斯滤波，中值滤波等的内容
- 能够使用滤波器对图像进行处理
1 图像噪声

由于图像采集、处理、传输等过程不可避免的会受到噪声的污染，妨碍人们对图像理解及分析处理。常见的图像噪声有高斯噪声、椒盐噪声等。

1.1 椒盐噪声

椒盐噪声也称为脉冲噪声，是图像中经常见到的一种噪声，它是一种随机出现的白点或者黑点，可能是亮的区域有黑色像素或是在暗的区域有白色像素（或是两者皆有）。椒盐噪声的成因可能是影像讯号受到突如其来的强烈干扰而产生、类比数位转换器或位元传输错误等。例如失效的感应器导致像素值为最小值，饱和的感应器导致像素值为最大值。

1.2 高斯噪声

高斯噪声是指噪声密度函数服从高斯分布的一类噪声。由于高斯噪声在空间和频域中数学上的易处理性，这种噪声(也称为正态噪声)模型经常被用于实践中。高斯随机变量z的概率密度函数由下式给出：p(z)=\frac{1}{\sqrt{2 \pi} \sigma} e^{\frac{-(z-\mu)^{2}}{2 \sigma^{2}}}p(z)=√2πσ1e2σ2−(z−μ)2

其中z表示灰度值，μ表示z的平均值或期望值，σ表示z的标准差。标准差的平方\sigma^{2}σ2称为z的方差。高斯函数的曲线如图所示。

2 图像平滑简介

图像平滑从信号处理的角度看就是去除其中的高频信息，保留低频信息。因此我们可以对图像实施低通滤波。低通滤波可以去除图像中的噪声，对图像进行平滑。

根据滤波器的不同可分为均值滤波，高斯滤波，中值滤波，双边滤波。

2.1 均值滤波

采用均值滤波模板对图像噪声进行滤除。令表示中心在(x, y)点，尺寸为m×n 的矩形子图像窗口的坐标组。均值滤波器可表示为：\hat{f}(x, y)=\frac{1}{m n} \sum_{(s, t) \in S_{x y}} g(s, t)f^(x,y)=mn1(s,t)∈Sxy∑g(s,t)由一个归一化卷积框完成的。它只是用卷积框覆盖区域所有像素的平均值来代替中心元素。

例如，3x3标准化的平均过滤器如下所示：K=\frac{1}{9}
$[\begin{matrix} 1 1 1 \\ 1 1 1 \\ 1 1 1 \end{matrix}]$
K=91⎣⎡ 1 1 1 1 1 1 1 1 1⎦⎤均值滤波的优点是算法简单，计算速度较快，缺点是在去噪的同时去除了很多细节部分，将图像变得模糊。

API:
```
cv.blur(src, ksize, anchor, borderType)
```
参数:
- src：输入图像
- ksize：卷积核的大小
- anchor：默认值 (-1,-1) ，表示核中心
- borderType：边界类型
示例：
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像读取
img = cv.imread('./image/dogsp.jpeg')
# 2 均值滤波
blur = cv.blur(img,(5,5))
# 3 图像显示
plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img[:,:,::-1]),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(blur[:,:,::-1]),plt.title('均值滤波后结果')
plt.xticks([]), plt.yticks([])
plt.show()
```
2.2 高斯滤波

二维高斯是构建高斯滤波器的基础，其概率分布函数如下所示：

G(x,y)的分布是一个突起的帽子的形状。这里的σ可以看作两个值，一个是x方向的标准差\sigma_xσx，另一个是y方向的标准差\sigma_yσy。

当\sigma_xσx和\sigma_yσy取值越大，整个形状趋近于扁平；当\sigma_xσx和\sigma_yσy，整个形状越突起。

正态分布是一种钟形曲线，越接近中心，取值越大，越远离中心，取值越小。计算平滑结果时，只需要将"中心点"作为原点，其他点按照其在正态曲线上的位置，分配权重，就可以得到一个加权平均值。

高斯平滑在从图像中去除高斯噪声方面非常有效。

高斯平滑的流程：
- 首先确定权重矩阵
假定中心点的坐标是（0,0），那么距离它最近的8个点的坐标如下：

更远的点以此类推。

为了计算权重矩阵，需要设定σ的值。假定σ=1.5，则模糊半径为1的权重矩阵如下：

这9个点的权重总和等于0.4787147，如果只计算这9个点的加权平均，还必须让它们的权重之和等于1，因此上面9个值还要分别除以0.4787147，得到最终的权重矩阵。
- 计算高斯模糊
有了权重矩阵，就可以计算高斯模糊的值了。

假设现有9个像素点，灰度值（0-255）如下：

每个点乘以对应的权重值：

得到

将这9个值加起来，就是中心点的高斯模糊的值。

对所有点重复这个过程，就得到了高斯模糊后的图像。如果原图是彩色图片，可以对RGB三个通道分别做高斯平滑。

API：
```
cv2.GaussianBlur(src,ksize,sigmaX,sigmay,borderType)
```
参数：
- src: 输入图像
- ksize:高斯卷积核的大小，注意：卷积核的宽度和高度都应为奇数，且可以不同
- sigmaX: 水平方向的标准差
- sigmaY: 垂直方向的标准差，默认值为0，表示与sigmaX相同
- borderType:填充边界类型
示例：
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像读取
img = cv.imread('./image/dogGasuss.jpeg')
# 2 高斯滤波
blur = cv.GaussianBlur(img,(3,3),1)
# 3 图像显示
plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img[:,:,::-1]),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(blur[:,:,::-1]),plt.title('高斯滤波后结果')
plt.xticks([]), plt.yticks([])
plt.show()
```
2.3 中值滤波

中值滤波是一种典型的非线性滤波技术，基本思想是用像素点邻域灰度值的中值来代替该像素点的灰度值。

中值滤波对椒盐噪声（salt-and-pepper noise）来说尤其有用，因为它不依赖于邻域内那些与典型值差别很大的值。

API：
```
cv.medianBlur(src, ksize )
```
参数：
- src：输入图像
- ksize：卷积核的大小
示例：
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像读取
img = cv.imread('./image/dogsp.jpeg')
# 2 中值滤波
blur = cv.medianBlur(img,5)
# 3 图像展示
plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img[:,:,::-1]),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(blur[:,:,::-1]),plt.title('中值滤波后结果')
plt.xticks([]), plt.yticks([])
plt.show()
```
总结
1. 图像噪声
  - 椒盐噪声：图像中随机出现的白点或者黑点
  - 高斯噪声：噪声的概率密度分布是正态分布
2. 图像平滑
  - 均值滤波：算法简单，计算速度快，在去噪的同时去除了很多细节部分，将图像变得模糊
    
    cv.blur()
  - 高斯滤波: 去除高斯噪声
    
    cv.GaussianBlur()
  - 中值滤波: 去除椒盐噪声
    
    cv.medianBlur()
直方图

学习目标
- 掌握图像的直方图计算和显示
- 了解掩膜的应用
- 熟悉直方图均衡化，了解自适应均衡化
1 灰度直方图

1.1 原理

直方图是对数据进行统计的一种方法，并且将统计值组织到一系列实现定义好的 bin 当中。其中， bin 为直方图中经常用到的一个概念，可以译为 “直条” 或 “组距”，其数值是从数据中计算出的特征统计量，这些数据可以是诸如梯度、方向、色彩或任何其他特征。

图像直方图（Image Histogram）是用以表示数字图像中亮度分布的直方图，标绘了图像中每个亮度值的像素个数。这种直方图中，横坐标的左侧为较暗的区域，而右侧为较亮的区域。因此一张较暗图片的直方图中的数据多集中于左侧和中间部分，而整体明亮、只有少量阴影的图像则相反。

注意：直方图是根据灰度图进行绘制的，而不是彩色图像。假设有一张图像的信息（灰度值 0 - 255，已知数字的范围包含 256 个值，于是可以按一定规律将这个范围分割成子区域（也就是 bins）。如：\left[0,255\right] = \left[0,15\right]\bigcup\left[16,30\right]\cdots\bigcup\left[240,255\right][0,255]=[0,15]⋃[16,30]⋯⋃[240,255] 然后再统计每一个 bin(i) 的像素数目。可以得到下图（其中 x 轴表示 bin，y 轴表示各个 bin 中的像素个数）：

直方图的一些术语和细节：
- dims：需要统计的特征数目。在上例中，dims = 1 ，因为仅仅统计了灰度值。
- bins：每个特征空间子区段的数目，可译为 “直条” 或 “组距”，在上例中， bins = 16。
- range：要统计特征的取值范围。在上例中，range = [0, 255]。
直方图的意义：
- 直方图是图像中像素强度分布的图形表达方式。
- 它统计了每一个强度值所具有的像素个数。
- 不同的图像的直方图可能是相同的
1.2 直方图的计算和绘制

我们使用OpenCV中的方法统计直方图，并使用matplotlib将其绘制出来。

API：
```
cv2.calcHist(images,channels,mask,histSize,ranges[,hist[,accumulate]])
```
参数：
- images: 原图像。当传入函数时应该用中括号 [] 括起来，例如：[img]。
- channels: 如果输入图像是灰度图，它的值就是 [0]；如果是彩色图像的话，传入的参数可以是 [0]，[1]，[2] 它们分别对应着通道 B，G，R。　　
- mask: 掩模图像。要统计整幅图像的直方图就把它设为 None。但是如果你想统计图像某一部分的直方图的话，你就需要制作一个掩模图像，并使用它。（后边有例子）　　
- histSize:BIN 的数目。也应该用中括号括起来，例如：[256]。　　
- ranges: 像素值范围，通常为 [0，256]
示例：

如下图，绘制相应的直方图
```
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
# 1 直接以灰度图的方式读入
img = cv.imread('./image/cat.jpeg',0)
# 2 统计灰度图
histr = cv.calcHist([img],[0],None,[256],[0,256])
# 3 绘制灰度图
plt.figure(figsize=(10,6),dpi=100)
plt.plot(histr)
plt.grid()
plt.show()
```
1.3 掩膜的应用

掩膜是用选定的图像、图形或物体，对要处理的图像进行遮挡，来控制图像处理的区域。

在数字图像处理中，我们通常使用二维矩阵数组进行掩膜。掩膜是由0和1组成一个二进制图像，利用该掩膜图像要处理的图像进行掩膜，其中1值的区域被处理，0 值区域被屏蔽，不会处理。

掩膜的主要用途是：
- 提取感兴趣区域：用预先制作的感兴趣区掩模与待处理图像进行”与“操作，得到感兴趣区图像，感兴趣区内图像值保持不变，而区外图像值都为0。
- 屏蔽作用：用掩模对图像上某些区域作屏蔽，使其不参加处理或不参加处理参数的计算，或仅对屏蔽区作处理或统计。
- 结构特征提取：用相似性变量或图像匹配方法检测和提取图像中与掩模相似的结构特征。
- 特殊形状图像制作
掩膜在遥感影像处理中使用较多，当提取道路或者河流，或者房屋时，通过一个掩膜矩阵来对图像进行像素过滤，然后将我们需要的地物或者标志突出显示出来。

我们使用cv.calcHist（）来查找完整图像的直方图。如果要查找图像某些区域的直方图，该怎么办？只需在要查找直方图的区域上创建一个白色的掩膜图像，否则创建黑色，然后将其作为掩码mask传递即可。

示例：
```
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
# 1. 直接以灰度图的方式读入
img = cv.imread('./image/cat.jpeg',0)
# 2. 创建蒙版
mask = np.zeros(img.shape[:2], np.uint8)
mask[400:650, 200:500] = 255
# 3.掩模
masked_img = cv.bitwise_and(img,img,mask = mask)
# 4. 统计掩膜后图像的灰度图
mask_histr = cv.calcHist([img],[0],mask,[256],[1,256])
# 5. 图像展示
fig,axes=plt.subplots(nrows=2,ncols=2,figsize=(10,8))
axes[0,0].imshow(img,cmap=plt.cm.gray)
axes[0,0].set_title("原图")
axes[0,1].imshow(mask,cmap=plt.cm.gray)
axes[0,1].set_title("蒙版数据")
axes[1,0].imshow(masked_img,cmap=plt.cm.gray)
axes[1,0].set_title("掩膜后数据")
axes[1,1].plot(mask_histr)
axes[1,1].grid()
axes[1,1].set_title("灰度直方图")
plt.show()
```
2 直方图均衡化

2.1 原理与应用

想象一下，如果一副图像中的大多数像素点的像素值都集中在某一个小的灰度值值范围之内会怎样呢？如果一幅图像整体很亮，那所有的像素值的取值个数应该都会很高。所以应该把它的直方图做一个横向拉伸（如下图），就可以扩大图像像素值的分布范围，提高图像的对比度，这就是直方图均衡化要做的事情。

“直方图均衡化”是把原始图像的灰度直方图从比较集中的某个灰度区间变成在更广泛灰度范围内的分布。直方图均衡化就是对图像进行非线性拉伸，重新分配图像像素值，使一定灰度范围内的像素数量大致相同。

这种方法提高图像整体的对比度，特别是有用数据的像素值分布比较接近时，在X光图像中使用广泛，可以提高骨架结构的显示，另外在曝光过度或不足的图像中可以更好的突出细节。

使用opencv进行直方图统计时，使用的是：

API：
```
dst = cv.equalizeHist(img)
```
参数：
- img: 灰度图像
返回：
- dst : 均衡化后的结果
示例：
```
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
# 1. 直接以灰度图的方式读入
img = cv.imread('./image/cat.jpeg',0)
# 2. 均衡化处理
dst = cv.equalizeHist(img)
# 3. 结果展示
fig,axes=plt.subplots(nrows=2,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img,cmap=plt.cm.gray)
axes[0].set_title("原图")
axes[1].imshow(dst,cmap=plt.cm.gray)
axes[1].set_title("均衡化后结果")
plt.show()
```
2.2 自适应的直方图均衡化

上述的直方图均衡，我们考虑的是图像的全局对比度。的确在进行完直方图均衡化之后，图片背景的对比度被改变了，在猫腿这里太暗，我们丢失了很多信息，所以在许多情况下，这样做的效果并不好。如下图所示，对比下两幅图像中雕像的画面，由于太亮我们丢失了很多信息。

为了解决这个问题，需要使用自适应的直方图均衡化。此时，整幅图像会被分成很多小块，这些小块被称为“tiles”（在 OpenCV 中 tiles 的大小默认是 8x8），然后再对每一个小块分别进行直方图均衡化。所以在每一个的区域中，直方图会集中在某一个小的区域中）。如果有噪声的话，噪声会被放大。为了避免这种情况的出现要使用对比度限制。对于每个小块来说，如果直方图中的 bin 超过对比度的上限的话，就把其中的像素点均匀分散到其他 bins 中，然后在进行直方图均衡化。

最后，为了去除每一个小块之间的边界，再使用双线性差值，对每一小块进行拼接。

API：
```
cv.createCLAHE(clipLimit, tileGridSize)
```
参数：
- clipLimit: 对比度限制，默认是40
- tileGridSize: 分块的大小，默认为8*88∗8
示例：
```
import numpy as np
import cv2 as cv
# 1. 以灰度图形式读取图像
img = cv.imread('./image/cat.jpeg',0)
# 2. 创建一个自适应均衡化的对象，并应用于图像
clahe = cv.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
cl1 = clahe.apply(img)
# 3. 图像展示
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(10,8),dpi=100)
axes[0].imshow(img,cmap=plt.cm.gray)
axes[0].set_title("原图")
axes[1].imshow(cl1,cmap=plt.cm.gray)
axes[1].set_title("自适应均衡化后的结果")
plt.show()
```
总结
1. 灰度直方图：
  - 直方图是图像中像素强度分布的图形表达方式。
  - 它统计了每一个强度值所具有的像素个数。
  - 不同的图像的直方图可能是相同的
  cv.calcHist（images，channels，mask，histSize，ranges [，hist [，accumulate]]）
2. 掩膜
  
  创建蒙版，透过mask进行传递，可获取感兴趣区域的直方图
3. 直方图均衡化：增强图像对比度的一种方法
  
  cv.equalizeHist(): 输入是灰度图像，输出是直方图均衡图像
4. 自适应的直方图均衡
  
  将整幅图像分成很多小块，然后再对每一个小块分别进行直方图均衡化，最后进行拼接
  
  clahe = cv.createCLAHE(clipLimit, tileGridSize)
边缘检测

学习目标
- 了解Sobel算子，Scharr算子和拉普拉斯算子
- 掌握canny边缘检测的原理及应用
1 原理

边缘检测是图像处理和计算机视觉中的基本问题，边缘检测的目的是标识数字图像中亮度变化明显的点。图像属性中的显著变化通常反映了属性的重要事件和变化。边缘的表现形式如下图所示：

图像边缘检测大幅度地减少了数据量，并且剔除了可以认为不相关的信息，保留了图像重要的结构属性。有许多方法用于边缘检测，它们的绝大部分可以划分为两类：基于搜索和基于零穿越。
- 基于搜索：通过寻找图像一阶导数中的最大值来检测边界，然后利用计算结果估计边缘的局部方向，通常采用梯度的方向，并利用此方向找到局部梯度模的最大值，代表算法是Sobel算子和Scharr算子。
- 基于零穿越：通过寻找图像二阶导数零穿越来寻找边界，代表算法是Laplacian算子。
2 Sobel检测算子

Sobel边缘检测算法比较简单，实际应用中效率比canny边缘检测效率要高，但是边缘不如Canny检测的准确，但是很多实际应用的场合，sobel边缘却是首选，Sobel算子是高斯平滑与微分操作的结合体，所以其抗噪声能力很强，用途较多。尤其是效率要求较高，而对细纹理不太关心的时候。

2.1 方法

对于不连续的函数，一阶导数可以写作：f'(x)= f(x)-f(x-1)f′(x)=f(x)−f(x−1)或f'(x)= f(x+1)-f(x)f′(x)=f(x+1)−f(x)所以有：f'(x) = \frac{f(x+1)-f(x-1)}{2}f′(x)=2f(x+1)−f(x−1)假设要处理的图像为II，在两个方向求导:
- 水平变化: 将图像II 与奇数大小的模版进行卷积，结果为G_xGx。比如，当模板大小为3时, G_xGx为:G_x=\left[ $\begin{matrix} - 1 & 0 & + 1 \\ - 2 & 0 & + 2 \\ - 1 & 0 & + 1 \end{matrix}$ $\begin{matrix}-1&0&+1\\-2&0&+2\\-1&0&+1\end{matrix}$ \right]* IGx=⎣⎡−1−2−1000+1+2+1⎦⎤∗I
- 垂直变化: 将图像II与奇数大小的模板进行卷积，结果为G_yGy。比如，当模板大小为3时, G_yGy为:G_y = \left[ $\begin{matrix} - 1 & - 2 & - 1 \\ 0 & 0 & 0 \\ + 1 & + 2 & + 1 \end{matrix}$ $\begin{matrix}-1&-2&-1\\0&0&0\\+1&+2&+1\end{matrix}$ \right]*IGy=⎣⎡−10+1−20+2−10+1⎦⎤∗I
在图像的每一点，结合以上两个结果求出：G = \sqrt{G_{x}^2+G_{y}^2}G=√Gx2+Gy2统计极大值所在的位置，就是图像的边缘。

注意：当内核大小为3时, 以上Sobel内核可能产生比较明显的误差，为解决这一问题，我们使用Scharr函数，但该函数仅作用于大小为3的内核。该函数的运算与Sobel函数一样快，但结果却更加精确，其计算方法为:G_x=\left[
$\begin{matrix} - 3 & 0 & + 3 \\ - 10 & 0 & + 10 \\ - 3 & 0 & + 3 \end{matrix}$
\right]* IGx=⎣⎡−3−10−3000+3+10+3⎦⎤∗I

G_y = \left[
$\begin{matrix} - 3 & - 10 & - 3 \\ 0 & 0 & 0 \\ + 3 & + 10 & + 3 \end{matrix}$
\right]*IGy=⎣⎡−30+3−100+10−30+3⎦⎤∗I

2.2 应用

利用OpenCV进行sobel边缘检测的API是：
```
Sobel_x_or_y = cv2.Sobel(src, ddepth, dx, dy, dst, ksize, scale, delta, borderType)
```
参数：
- src：传入的图像
- ddepth: 图像的深度
- dx和dy: 指求导的阶数，0表示这个方向上没有求导，取值为0、1。
- ksize: 是Sobel算子的大小，即卷积核的大小，必须为奇数1、3、5、7，默认为3。
  
  注意：如果ksize=-1，就演变成为3x3的Scharr算子。
- scale：缩放导数的比例常数，默认情况为没有伸缩系数。
- borderType：图像边界的模式，默认值为cv2.BORDER_DEFAULT。
Sobel函数求完导数后会有负值，还有会大于255的值。而原图像是uint8，即8位无符号数，所以Sobel建立的图像位数不够，会有截断。因此要使用16位有符号的数据类型，即cv2.CV_16S。处理完图像后，再使用cv2.convertScaleAbs()函数将其转回原来的uint8格式，否则图像无法显示。

Sobel算子是在两个方向计算的，最后还需要用cv2.addWeighted( )函数将其组合起来
```
Scale_abs = cv2.convertScaleAbs(x)  # 格式转换函数
result = cv2.addWeighted(src1, alpha, src2, beta) # 图像混合
```
示例：
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 读取图像
img = cv.imread('./image/horse.jpg',0)
# 2 计算Sobel卷积结果
x = cv.Sobel(img, cv.CV_16S, 1, 0)
y = cv.Sobel(img, cv.CV_16S, 0, 1)
# 3 将数据进行转换
Scale_absX = cv.convertScaleAbs(x)  # convert 转换  scale 缩放
Scale_absY = cv.convertScaleAbs(y)
# 4 结果合成
result = cv.addWeighted(Scale_absX, 0.5, Scale_absY, 0.5, 0)
# 5 图像显示
plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img,cmap=plt.cm.gray),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(result,cmap = plt.cm.gray),plt.title('Sobel滤波后结果')
plt.xticks([]), plt.yticks([])
plt.show()
```
将上述代码中计算sobel算子的部分中将ksize设为-1，就是利用Scharr进行边缘检测。
```
x = cv.Sobel(img, cv.CV_16S, 1, 0, ksize = -1)
y = cv.Sobel(img, cv.CV_16S, 0, 1, ksize = -1)
```
3 Laplacian算子

Laplacian是利用二阶导数来检测边缘。因为图像是 “2维”, 我们需要在两个方向求导，如下式所示：\Delta src= \frac{\partial ^{2}src}{\partial x^{2}}+ \frac{\partial ^{2}src}{\partial y^{2}}Δsrc=∂x2∂2src+∂y2∂2src那不连续函数的二阶导数是：f''(x)=f'(x+1)-f'(x)=f(x+1)+f(x-1)-2f(x)f′′(x)=f′(x+1)−f′(x)=f(x+1)+f(x−1)−2f(x)那使用的卷积核是：kernel=
$[\begin{matrix} 0 1 0 \\ 1 - 4 1 \\ 0 1 0 \end{matrix}]$
kernel=⎣⎡ 0 1 0 1 −4 1 0 1 0⎦⎤API：
```
laplacian = cv2.Laplacian(src, ddepth[, dst[, ksize[, scale[, delta[, borderType]]]]])
```
参数：
- Src: 需要处理的图像，
- Ddepth: 图像的深度，-1表示采用的是原图像相同的深度，目标图像的深度必须大于等于原图像的深度；
- ksize：算子的大小，即卷积核的大小，必须为1,3,5,7。
示例：
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 读取图像
img = cv.imread('./image/horse.jpg',0)
# 2 laplacian转换
result = cv.Laplacian(img,cv.CV_16S)
Scale_abs = cv.convertScaleAbs(result)
# 3 图像展示
plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img,cmap=plt.cm.gray),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(Scale_abs,cmap = plt.cm.gray),plt.title('Laplacian检测后结果')
plt.xticks([]), plt.yticks([])
plt.show()
```
4 Canny边缘检测

Canny 边缘检测算法是一种非常流行的边缘检测算法，是 John F. Canny 于 1986年提出的，被认为是最优的边缘检测算法。

4.1 原理

Canny边缘检测算法是由4步构成，分别介绍如下：
- 第一步：噪声去除
  
  由于边缘检测很容易受到噪声的影响，所以首先使用$5*5$高斯滤波器去除噪声，在图像平滑那一章节中已经介绍过。
- 第二步：计算图像梯度
对平滑后的图像使用 Sobel 算子计算水平方向和竖直方向的一阶导数（Gx 和 Gy）。根据得到的这两幅梯度图（Gx 和 Gy）找到边界的梯度和方向，公式如下:

Edge\_Gradient\left ( G \right )= \sqrt{G_{x}^{2}+G_{y}^{2}}Edge_Gradient(G)=√Gx2+Gy2

Angle\left ( \theta \right )= tan^{-1}\left ( \frac{G_{y}}{G_{x}} \right )Angle(θ)=tan−1(GxGy)

如果某个像素点是边缘，则其梯度方向总是垂直与边缘垂直。梯度方向被归为四类：垂直，水平，和两个对角线方向。
- 第三步：非极大值抑制
在获得梯度的方向和大小之后，对整幅图像进行扫描，去除那些非边界上的点。对每一个像素进行检查，看这个点的梯度是不是周围具有相同梯度方向的点中最大的。如下图所示：

A点位于图像的边缘，在其梯度变化方向，选择像素点B和C，用来检验A点的梯度是否为极大值，若为极大值，则进行保留，否则A点被抑制，最终的结果是具有“细边”的二进制图像。
- 第四步：滞后阈值
现在要确定真正的边界。我们设置两个阈值： minVal 和 maxVal。当图像的灰度梯度高于 maxVal 时被认为是真的边界，低于 minVal 的边界会被抛弃。如果介于两者之间的话，就要看这个点是否与某个被确定为真正的边界点相连，如果是就认为它也是边界点，如果不是就抛弃。如下图：

如上图所示，A 高于阈值 maxVal 所以是真正的边界点，C 虽然低于 maxVal 但高于 minVal 并且与 A 相连，所以也被认为是真正的边界点。而 B 就会被抛弃，因为低于 maxVal 而且不与真正的边界点相连。所以选择合适的 maxVal 和 minVal 对于能否得到好的结果非常重要。

4.2 应用

在OpenCV中要实现Canny检测使用的API:
```
canny = cv2.Canny(image, threshold1, threshold2)
```
参数：
- image:灰度图，
- threshold1: minval，较小的阈值将间断的边缘连接起来
- threshold2: maxval，较大的阈值检测图像中明显的边缘
示例：
```
import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像读取
img = cv.imread('./image/horse.jpg',0)
# 2 Canny边缘检测
lowThreshold = 0
max_lowThreshold = 100
canny = cv.Canny(img, lowThreshold, max_lowThreshold) 
# 3 图像展示
plt.figure(figsize=(10,8),dpi=100)
plt.subplot(121),plt.imshow(img,cmap=plt.cm.gray),plt.title('原图')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(canny,cmap = plt.cm.gray),plt.title('Canny检测后结果')
plt.xticks([]), plt.yticks([])
plt.show()
```
总结
1. 边缘检测的原理
  - 基于搜索：利用一阶导数的最大值获取边界
  - 基于零穿越：利用二阶导数为0获取边界
2. Sobel算子
  
  基于搜索的方法获取边界
  
  cv.sobel()
  
  cv.convertScaleAbs()
  
  cv.addweights()
3. Laplacian算子
  
  基于零穿越获取边界
  
  cv.Laplacian()
4. Canny算法
  
  流程：
  - 噪声去除：高斯滤波
  - 计算图像梯度：sobel算子，计算梯度大小和方向
  - 非极大值抑制：利用梯度方向像素来判断当前像素是否为边界点
  - 滞后阈值：设置两个阈值，确定最终的边界
5 算子比较

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/100406

《OpenCV》03 图像处理_ds.icec[0].plot()

3 OpenCV图像处理

主要内容

几何变换

1 图像缩放

2 图像平移

3 图像旋转

4 仿射变换

5 透射变换

6 图像金字塔

形态学操作

1 连通性

2 形态学操作

2.1 腐蚀和膨胀

2.2 开闭运算

图像平滑

1 图像噪声

1.1 椒盐噪声

1.2 高斯噪声

2 图像平滑简介

2.1 均值滤波

2.2 高斯滤波

2.3 中值滤波

直方图

1 灰度直方图

1.1 原理

1.2 直方图的计算和绘制

1.3 掩膜的应用

2 直方图均衡化

2.1 原理与应用

2.2 自适应的直方图均衡化

边缘检测

1 原理

2 Sobel检测算子

2.1 方法

2.2 应用

3 Laplacian算子

4 Canny边缘检测

4.1 原理

4.2 应用