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：插值方法，

插值	含义
cv2.INTER_LINEAR	双线性插值法
cv2.INTER_NEAREST	最*邻插值
cv2.INTER_AREA	像素区域重采样 (默认)
cv2.INTER_CUBIC	双三次插值

示例

import cv2 as cv
import matplotlib.pyplot as plt
# 1. 读取图片
img1 = cv.imread(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\kids.jpg")
# 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： 23移动矩阵

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

$ $

注意：将设置为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(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\kids.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 图像旋转

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

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

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

根据两角差余弦公式展开得：

其中：

带入上面的公式中，有：

也可以写成：

同时我们要修正原点的位置，因为原图像中的坐标原点在图像的左上角，经过旋转后图像的大小会有所变化，原点也需要修正。

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

理解

符号含义

$([x y 1])$ ：原图像点的齐次坐标（用三维向量表示二维点，方便矩阵变换）。

旋转变换矩阵（对应图像逆时针旋转 $θ$ ）。

*移 + 镜像修正矩阵（0 -1 是为了适配图像坐标系 $y$ 轴向下的特点，left/top 是把旋转中心移回图像左上角的*移量）。

变换逻辑

图像旋转分两步：

① 先旋转：用旋转矩阵把点 $[x y]$ 转到以 “旋转中心” 为原点的坐标系，得到中间点 $[x' y']$ ，对应公式里的 $[x y 1] * 旋转矩阵= [x' y' 1]$ 。

② 再修正原点：旋转后坐标系原点在 “旋转中心”，但图像显示需要原点回到左上角，所以用*移矩阵调整，把 $[x' y']$ 转到最终的 $[x'' y'']$ ，对应 $[x y 1]$ $**移矩阵 = [x'' y'' 1]$ 。

矩阵相乘的意义

“旋转矩阵 × *移矩阵” 合并成一个复合变换矩阵，这样可以用一次矩阵乘法完成 “旋转 + 修正原点” 两步操作，数学上等价于先旋转、再*移，最终得到原坐标 $[x y]$ 到目标坐标 $[x'' y'']$ 的映射。

简单说就是：用矩阵相乘把 “旋转” 和 “修正原点” 两个操作合并，一步算出旋转后图像的最终坐标 ，本质是计算机图形学里 “组合变换” 的常用技巧～

在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((r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\kids.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的矩阵：

其中左边的2×2子矩阵A是线性变换矩阵，右边的2×1子矩阵B是*移项：

对于图像上的任一位置(x,y)，仿射变换执行的是如下的操作：

$$ 需要注意的是，对于图像而言，宽度方向是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 透射变换

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

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

其中，(u,v)是原始的图像像素坐标，w取值为1，(x=x'/z',y=y'/z')是透射变换后的结果。后面的矩阵称为透视变换矩阵，一般情况下，我们将其分为三部分：

其中：T1表示对图像进行线性变换，T2对图像进行*移，T3表示对图像进行投射变换， $^{ }$ 一般设为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(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\kids.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)，用表示像素p的4邻接
D邻接：像素p(x,y)的D邻域是：对角上的点 (x+1,y+1)；(x+1,y-1)；(x-1,y+1)；(x-1,y-1)，用表示像素p的D邻域
8邻接：像素p(x,y)的8邻域是： 4邻域的点＋ D邻域的点，用表示像素p的8邻域

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

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

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

4联通：对于具有值的像素和，如果在集合中，则称这两个像素是4连通。
8联通：对于具有值的像素和，如果在集合中，则称这两个像素是8连通。
连通：对于具有值的像素和，如果:
1. 在集合 $)$ 中，或
2. 在集合中，并且与的交集为空（没有值的像素）
则称这两个像素是连通的，即4连通和D连通的混合连通。

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

2.腐蚀和膨胀

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

膨胀就是使图像中高亮部分扩张，效果图拥有比原图更大的高亮区域；

腐蚀是原图中的高亮区域被蚕食，效果图拥有比原图更小的高亮区域。

膨胀是求局部最大值的操作，腐蚀是求局部最小值的操作。

腐蚀

具体操作是：用一个结构元素扫描图像中的每一个像素，用结构元素中的每一个像素与其覆盖的像素做“与”操作，如果都为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(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\letter.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()

3.开闭运算

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

开运算

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

闭运算与开运算相反，是先膨胀后腐蚀，作用是消除/“闭合”物体里面的孔洞，特点：可以填充闭合区域。
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(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\letteropen.png")
img2 = cv.imread(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\letterclose.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()

4.礼帽和黑帽

礼帽运算

原图像与“开运算“的结果图之差，如下式计算：

　　因为开运算带来的结果是放大了裂缝或者局部低亮度的区域，因此，从原图中减去开运算后的图，得到的效果图突出了比原图轮廓周围的区域更明亮的区域，且这一操作和选择的核的大小相关。

　　礼帽运算用来分离比邻*点亮一些的斑块。当一幅图像具有大幅的背景的时候，而微小物品比较有规律的情况下，可以使用顶帽运算进行背景提取。
黑帽运算

为”闭运算“的结果图与原图像之差。数学表达式为：

　　

黑帽运算后的效果图突出了比原图轮廓周围的区域更暗的区域，且这一操作和选择的核的大小相关。

黑帽运算用来分离比邻*点暗一些的斑块。
API
```
cv.morphologyEx(img, op, kernel)
```
参数：
- img: 要处理的图像
- op: 处理方式：

参数	功能
cv.MORPH_CLOSE	闭运算
cv.MORPH_OPEN	开运算
cv.MORPH_TOPHAT	礼帽运算
cv.MORPH_BLACKHAT	黑帽运算

- Kernel：核结构
示例

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 1 读取图像
img1 = cv.imread(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\letteropen.png")
img2 = cv.imread(r"D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\letterclose.png")
# 2 创建核结构
kernel = np.ones((10, 10), np.uint8)
# 3 图像的礼帽和黑帽运算
cvOpen = cv.morphologyEx(img1,cv.MORPH_TOPHAT,kernel) # 礼帽运算
cvClose = cv.morphologyEx(img2,cv.MORPH_BLACKHAT,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()

总结

连通性邻接关系：4邻接，8邻接和D邻接

连通性：4连通，8连通和m连通
形态学操作
- 腐蚀和膨胀：
  
  腐蚀：求局部最大值
  
  膨胀：求局部最小值
- 开闭运算：
  
  开：先腐蚀后膨胀
  
  闭：先膨胀后腐蚀
- 礼帽和黑帽：
  
  礼帽：原图像与开运算之差
  
  黑帽：闭运算与原图像之差

图像*滑

学习目标

了解图像中的噪声类型
了解*均滤波，高斯滤波，中值滤波等的内容
能够使用滤波器对图像进行处理

1 图像噪声

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

1.1 椒盐噪声

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

1.2 高斯噪声

高斯噪声是指噪声密度函数服从高斯分布的一类噪声。由于高斯噪声在空间和频域中数学上的易处理性，这种噪声(也称为正态噪声)模型经常被用于实践中。高斯随机变量z的概率密度函数由下式给出：

$^{}$

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

2 图像*滑简介

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

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

2.1 均值滤波

采用均值滤波模板对图像噪声进行滤除。令 $S_{x y}$ 表示中心在(x, y)点，尺寸为m×n 的矩形子图像窗口的坐标组。均值滤波器可表示为：

均值滤波原理是 “用邻域像素*均值替换中心像素”

作用逻辑

噪声（比如随机的亮点、暗点）的像素值通常和周围差异大。取*均后，噪声的 “极端值” 会被周围正常像素 “拉低 / 拉高”，从而实现*滑图像、滤除噪声的效果。

由一个归一化卷积框完成的。它只是用卷积框覆盖区域所有像素的*均值来代替中心元素。

例如，3x3标准化的*均过滤器如下所示：

比如 $3* 3$ 窗口，就是把中心像素周围 8 个邻居 + 自己，共 9 个像素取*均，结果作为新的中心像素值。 $3* 3$ 模板是最常用的具体实现（9 个像素等权*均）。

均值滤波的优点是算法简单，计算速度较快，缺点是在去噪的同时去除了很多细节部分，将图像变得模糊。

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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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方向的标准差 $^{ }$ ，另一个是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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\dogGauss.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 中值滤波

中值滤波是一种典型的非线性滤波技术，基本思想是对图像中每个像素，取其邻域（比如 3×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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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()

总结

图像噪声
- 椒盐噪声：图像中随机出现的白点或者黑点
- 高斯噪声：噪声的概率密度分布是正态分布
图像*滑
- 均值滤波：算法简单，计算速度快，在去噪的同时去除了很多细节部分，将图像变得模糊
  
  cv.blur()
- 高斯滤波: 去除高斯噪声
  
  cv.GaussianBlur()
- 中值滤波: 去除椒盐噪声
  
  cv.medianBlur()

直方图

学习目标

掌握图像的直方图计算和显示
了解掩膜的应用
熟悉直方图均衡化，了解自适应均衡化

1 灰度直方图

1.1 原理

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

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

注意：直方图是根据灰度图进行绘制的，而不是彩色图像。假设有一张图像的信息（灰度值 0 - 255，已知数字的范围包含 256 个值，于是可以按一定规律将这个范围分割成子区域（也就是 bins）。如：

然后再统计每一个 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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\cat.jpeg',0)
# 2. 创建蒙版
mask = np.zeros(img.shape[:2], np.uint8)
mask[400:650, 200:500] = 1
# 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光图像中使用广泛，可以提高骨架结构的显示，另外在曝光过度或不足的图像中可以更好的突出细节。

理解：

直方图均衡化不是直接 “加减像素值” ，而是通过一个 “亮度映射表” ，把原始亮度值映射到新的亮度值，实现 “让像素在全亮度范围更均匀分布”。

步骤拆解（以过暗图像为例）：

统计原始直方图：比如图像很暗，大部分像素集中在亮度 0~50（假设最大亮度是 255）。

计算 “累积分布函数（CDF）”：把直方图从左到右累加，得到一个 “累积曲线”。

目的：找到 “原始亮度” 和 “新亮度” 的对应关系。

构建映射表：用 CDF 把原始亮度拉伸到 0~255 全范围。

比如原始亮度 20，通过映射表可能变成 100；原始亮度 50，可能变成 180……

替换像素亮度：遍历图像，把每个像素的原始亮度，用映射表替换成新亮度。

使用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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\cat.jpeg',0)
# 2. 均衡化处理
dst = cv.equalizeHist(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(dst,cmap=plt.cm.gray)
axes[1].set_title("均衡化后结果")
plt.show()

2.2 自适应的直方图均衡化

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

为了解决这个问题，需要使用自适应的直方图均衡化。此时，整幅图像会被分成很多小块，这些小块被称为“tiles”（在 OpenCV 中 tiles 的大小默认是 8x8），然后再对每一个小块分别进行直方图均衡化。所以在每一个的区域中，直方图会集中在某一个小的区域中）。

假设我们有一张照片，左边很暗、右边很亮：

1. 拆分图像为小区域（tiles）

把整幅图切成很多 8×8 的小方块（OpenCV 默认是 8×8 ，也可以自己设置）。每个小方块就是一个独立的 “局部区域”。

2. 对每个小区域做直方图均衡化

对每个 8×8 的小方块，单独统计它的像素亮度分布（直方图），然后做均衡化。这样：

左边暗的小方块，会把自己的暗部拉明，找回细节；

右边亮的小方块，会把自己的亮部细节拉开，不会过曝。

解决 “噪声放大” 问题（重要细节！）

但有个新问题：如果小区域里有噪声（比如随机的亮点 / 暗点），单独均衡化会让噪声被 “放大”，变得更明显。

统计直方图时，如果某个亮度区间（bin）的像素特别多（超过限制），就把多余的像素 “分散” 到其他区间，避免噪声被过度增强。

如果有噪声的话，噪声会被放大。为了避免这种情况的出现，要使用对比度限制。对于每个小块来说，如果直方图中的 bin 超过对比度的上限的话，就把其中的像素点均匀分散到其他 bins 中，然后再进行直方图均衡化。

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

API：

cv.createCLAHE(clipLimit, tileGridSize)

参数：

clipLimit: 对比度限制，默认是40
tileGridSize: 分块的大小，默认为

示例：

import numpy as np
import cv2 as cv
# 1. 以灰度图形式读取图像
img = cv.imread(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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()

总结

灰度直方图：
- 直方图是图像中像素强度分布的图形表达方式。
- 它统计了每一个强度值所具有的像素个数。
- 不同的图像的直方图可能是相同的
cv.calcHist（images，channels，mask，histSize，ranges [，hist [，accumulate]]）
掩膜

创建蒙版，透过mask进行传递，可获取感兴趣区域的直方图
直方图均衡化：增强图像对比度的一种方法

cv.equalizeHist(): 输入是灰度图像，输出是直方图均衡图像
自适应的直方图均衡

将整幅图像分成很多小块，然后再对每一个小块分别进行直方图均衡化，最后进行拼接

clahe = cv.createCLAHE(clipLimit, tileGridSize)

边缘检测

学习目标

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

1 原理

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

图像边缘检测大幅度地减少了数据量，并且剔除了可以认为不相关的信息，保留了图像重要的结构属性。有许多方法用于边缘检测，它们的绝大部分可以划分为两类：基于搜索和基于零穿越。

基于搜索：通过寻找图像一阶导数中的最大值来检测边界，然后利用计算结果估计边缘的局部方向，通常采用梯度的方向，并利用此方向找到局部梯度模的最大值，代表算法是Sobel算子和Scharr算子。
基于零穿越：通过寻找图像二阶导数零穿越来寻找边界，代表算法是Laplacian算子。

2 Sobel检测算子

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

2.1 原理

对于不连续的函数(离散函数)，一阶导数可以写作

或

所以有：

理解离散函数的导数*似。因为图像是 “离散” 的像素点，无法像连续函数那样求导，所以要用相邻像素的差值来*似导数。

假设要处理的图像为，在两个方向求导:

水*变化: 将图像与奇数大小的模版进行卷积，结果为 $^{ }$ 。比如，当模板大小为3时, $^{ }$ 为:

垂直变化: 将图像与奇数大小的模板进行卷积，结果为 $^{ }$ 。比如，当模板大小为3时, $^{ }$ 为:

在图像的每一点，结合以上两个结果求出：

统计极大值所在的位置，就是图像的边缘。

注意：当内核大小为3时, 以上Sobel内核可能产生比较明显的误差，为解决这一问题，我们使用Scharr函数，但该函数仅作用于大小为3的内核。该函数的运算与Sobel函数一样快，但结果却更加精确，其计算方法为:

理解 “卷积核（矩阵）如何实现离散求导”

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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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维”, 我们需要在两个方向求导，如下式所示：

那不连续函数的二阶导数是：

那使用的卷积核是：

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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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）找到边界的梯度和方向，公式如下:

如果某个像素点是边缘，则其梯度方向总是与边缘垂直。梯度方向被归为四类：垂直，水*，和两个对角线方向。

第三步：非极大值抑制

在获得梯度的方向和大小之后，对整幅图像进行扫描，去除那些非边界上的点。对每一个像素进行检查，看这个点的梯度是不是周围具有相同梯度方向的点中最大的。如下图所示：

假设我们有一个像素

A

，它的梯度方向是水*向右（如上图）：

确定梯度方向的 “邻域像素”：梯度方向垂直于边缘，所以沿着梯度方向，找 $A$ 前后的两个像素（比如 $C$ 和 $B$ ）。
- 如果梯度方向是水* → 邻域像素是左侧 $C$ 和右侧 $B$ ；
- 如果梯度方向是垂直 → 邻域像素是上方和下方；
- 如果是对角线 → 邻域像素是对角线上的两个点。
比较梯度幅值：比较 $A$ 、 $C$ 、 $B$ 的梯度幅值：
- 如果 $A$ 的幅值是最大的 → 保留 $A$ （认为是真正的边缘点）；
- 如果 $A$ 的幅值不是最大的 → 抑制 $A$ （置为 0，认为是边缘的 “伪响应”）。

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(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\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()

总结

边缘检测的原理
- 基于搜索：利用一阶导数的最大值获取边界
- 基于零穿越：利用二阶导数为0获取边界
Sobel算子

基于搜索的方法获取边界

cv.sobel()

cv.convertScaleAbs()

cv.addweights()
Laplacian算子

基于零穿越获取边界

cv.Laplacian()
Canny算法

流程：
- 噪声去除：高斯滤波
- 计算图像梯度：sobel算子，计算梯度大小和方向
- 非极大值抑制：利用梯度方向像素来判断当前像素是否为边界点
- 滞后阈值：设置两个阈值，确定最终的边界

5 算子比较

算子	核心原理与传统优缺点	*年技术发展与延伸应用
Roberts	- 原理：基于对角差分*似梯度，简单快速 - 优点：对陡峭低噪声图像边缘响应直接 - 缺点：边缘粗、定位精度有限	- 常作为轻量型边缘检测预步骤，与深度学习模型结合时，可辅助生成初始边缘候选框，降低模型计算量
Sobel	- 原理：高斯滑 + 差分，结合水 / 垂直方向梯度 - 优点：抗噪强，对渐变灰度和噪声图像效果好，定位较准 - 缺点：复杂纹理场景边缘连续性不足	- 优化方向：结合自适应高斯核（根据局部纹理调整 σ），提升复杂场景边缘保留能力；与边缘连接算法（如基于图割）结合，修复断裂边缘
Kirsch	- 原理：8 个方向模板卷积，强化多方向边缘响应 - 优点：对渐变灰度和噪声图像鲁棒 - 缺点：计算量相对高，边缘易有冗余响应	- 发展：用于工业缺陷检测场景，结合形态学后处理（如开运算），抑制重复边缘；在遥感图像边缘提取中，辅助区分不同地物边界
Prewitt	- 原理：类似 Sobel，简化权重的梯度算子 - 优点：计算简单，对渐变灰度和噪声有基础抗噪性 - 缺点：边缘精度、抗噪弱于 Sobel	- 应用：低算力设备（如嵌入式）的边缘预检测，为后续轻量化模型提供初始特征；与超像素分割结合，优化边缘与语义区域的对齐
Laplacian	- 原理：二阶导数（拉普拉斯算子）检测边缘，对阶跃边缘敏感 - 优点：定位精准 - 缺点：噪声敏感，易丢失方向信息、边缘不连续	- 改进：结合各向异性扩散（如 Perona-Malik 滤波）先去噪，再用 LoG（拉普拉斯高斯）变体，缓解噪声问题；在医学图像（如视网膜血管分割）中，辅助提取细微管状边缘
LoG（Marr-Hildreth）	- 原理：高斯*滑 + 拉普拉斯，强调边缘的 “双响应” - 优点：理论完善，可区分明 / 暗区边缘 - 缺点：双边缘效应明显，噪声敏感	- 替代方案：用深度学习模型（如 U-Net 改进结构）模拟 LoG 特性，避免双边缘问题；在图像复原领域，辅助判断模糊核边缘，优化去模糊算法
Canny	- 原理：高斯去噪→Sobel 算梯度→非极大值抑制→双阈值滞后 - 优点：抗噪强、边缘精准连续，经典且通用 - 缺点：双阈值需人工调优，复杂场景弱边缘易漏检	- 升级方向： 1. 自适应阈值（结合图像局部统计特征、熵计算），适配不同场景； 2. 与 Transformer 结合（如 Edge Transformer），利用全局上下文修复弱边缘、抑制噪声； 3. 在自动驾驶场景，融合激光雷达点云边缘与 Canny 视觉边缘，提升环境感知鲁棒性
深度学习边缘检测（如 HED、RCF、EdgeNeXt）	- 原理：基于卷积神经网络端到端学习边缘特征，自动提取多尺度、语义边缘 - 优点：适应复杂场景，可学习高级语义边缘（如物体轮廓 vs 背景纹理） - 缺点：依赖大规模标注数据，推理速度相对传统算子慢	- 发展趋势： 1. 轻量化模型（如 MobileEdgeNet）适配终端设备，在手机影像处理中实时优化边缘； 2. 结合自监督学习，降低标注成本，提升小数据集泛化性； 3. 多模态融合（视觉 + 深度 + 红外），解决极端环境（如夜视、雾天）边缘检测难题

模板匹配

1.1 原理

所谓的模板匹配，就是在给定的图片中查找和模板最相似的区域，该算法的输入包括模板和图片，整个任务的思路就是按照滑窗的思路不断的移动模板图片，计算其与图像中对应区域的匹配度，最终将匹配度最高的区域选择为最终的结果。

实现流程：

准备两幅图像：

1.原图像(I)：在这幅图中，找到与模板相匹配的区域

2.模板(T)：与原图像进行比对的图像块
滑动模板图像和原图像进行比对：

将模板块每次移动一个像素 (从左往右，从上往下)，在每一个位置，都计算与模板图像的相似程度。

对于每一个位置将计算的相似结果保存在结果矩阵（R）中。如果输入图像的大小（WxH）且模板图像的大小(wxh)，则输出矩阵R的大小为（W-w + 1,H-h + 1）将R显示为图像，如下图所示：

获得上述图像后，查找最大值所在的位置，那么该位置对应的区域就被认为是最匹配的。对应的区域就是以该点为顶点，长宽和模板图像一样大小的矩阵。

可视化匹配效果：R 里存的是模板在原图不同位置的相似度数值，把它转成图像（比如亮度代表相似度高低），能直观看到模板在哪块区域匹配度高、哪块低，方便人眼快速发现最匹配位置（像找亮度最高的 “热点” ），不用对着一堆数字分析。

1.2 实现

我们使用OpenCV中的方法实现模板匹配。

API：

res = cv.matchTemplate(img,template,method)

参数：

img: 要进行模板匹配的图像
Template ：模板
method：实现模板匹配的算法，主要有：
1. *方差匹配(CV_TM_SQDIFF)：利用模板与图像之间的*方差进行匹配，最好的匹配是0，匹配越差，匹配的值越大。
2. 相关匹配(CV_TM_CCORR)：利用模板与图像间的乘法进行匹配，数值越大表示匹配程度较高，越小表示匹配效果差。
3. 利用相关系数匹配(CV_TM_CCOEFF)：利用模板与图像间的相关系数匹配，1表示完美的匹配，-1表示最差的匹配。

完成匹配后，使用cv.minMaxLoc()方法查找最大值所在的位置即可。如果使用*方差作为比较方法，则最小值位置是最佳匹配位置。

示例：

在该案例中，载入要搜索的图像和模板，图像如下所示：

模板如下所示：

通过matchTemplate实现模板匹配，使用minMaxLoc定位最匹配的区域，并用矩形标注最匹配的区域。

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 1 图像和模板读取
img = cv.imread('./image/wulin2.jpeg')
template = cv.imread('./image/wulin.jpeg')
h,w,l = template.shape
# 2 模板匹配
# 2.1 模板匹配
res = cv.matchTemplate(img, template, cv.TM_CCORR)
# 2.2 返回图像中最匹配的位置，确定左上角的坐标，并将匹配位置绘制在图像上
min_val, max_val, min_loc, max_loc = cv.minMaxLoc(res)
# 使用*方差时最小值为最佳匹配位置
# top_left = min_loc
top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv.rectangle(img, top_left, bottom_right, (0,255,0), 2)
# 3 图像显示
plt.imshow(img[:,:,::-1])
plt.title('匹配结果'), plt.xticks([]), plt.yticks([])
plt.show()

拓展：模板匹配不适用于尺度变换，视角变换后的图像，这时我们就要使用关键点匹配算法，比较经典的关键点检测算法包括SIFT和SURF等，主要的思路是首先通过关键点检测算法获取模板和测试图片中的关键点；然后使用关键点匹配算法处理即可，这些关键点可以很好的处理尺度变化、视角变换、旋转变化、光照变化等，具有很好的不变性。

霍夫变换

霍夫变换常用来提取图像中的直线和圆等几何形状，如下图所示：

2.1 原理

原理

在笛卡尔坐标系中，一条直线由两个点和确定，如下图所示:

将直线y=kx+q可写成关于的函数表达式：

$^{ } $ 对应的变换通过图形直观的表示下：

变换后的空间我们叫做霍夫空间。即：笛卡尔坐标系中的一条直线，对应于霍夫空间中的一个点。反过来，同样成立，霍夫空间中的一条线，对应于笛卡尔坐标系中一个点，如下所示：

我们再来看下A、B两个点，对应于霍夫空间的情形：

在看下三点共线的情况：

可以看出如果在笛卡尔坐标系的点共线，那么这些点在霍夫空间中对应的直线交于一点。

如果不止存在一条直线时，如下所示：

我们选择尽可能多的直线汇成的点，上图中三条直线汇成的A、B两点，将其对应回笛卡尔坐标系中的直线：

到这里我们似乎已经完成了霍夫变换的求解。但如果像下图这种情况时：

上图中的直线是，那怎么确定呢？

为了解决这个问题，我们考虑将笛卡尔坐标系转换为极坐标。

在极坐标下是一样的，极坐标中的点对应于霍夫空间的线，这时的霍夫空间不在是参数的空间，而是的空间，是原点到直线的垂直距离，表示直线的垂线与横轴顺时针方向的夹角，直线是垂直线时角度为0度，直线是水*线时角度是180度。

我们只要求得霍夫空间中的交点的位置，即可得到原坐标系下的直线。

实现流程

假设有一个大小为100100的图片，使用霍夫变换检测图片中的直线，则步骤如下所示：

直线都可以使用表示，首先创建一个2D数组，我们叫做累加器，初始化所有值为0，行表示 $ρ$ ，列表示。

该数组的大小决定了结果的准确性，若希望角度的精度为1度，那就需要180列。对于，最大值为图片对角线的距离，如果希望精度达到像素级别，行数应该与图像的对角线的距离相等。
取直线上的第一个点，将其带入直线在极坐标中的公式中，然后遍历 $θ$ 的取值：0，1，2，...，180，分别求出对应的 $ρ$ 值，如果这个数值在上述累加器中存在相应的位置，则在该位置上加1。
取直线上的第二个点，重复上述步骤，更新累加器中的值。对图像中的直线上的每个点都直线以上步骤，每次更新累加器中的值。
搜索累加器中的最大值，并找到其对应的，就可将图像中的直线表示出来。

关于霍夫空间的深入理解

2.2 霍夫线检测

在OpenCV中做霍夫线检测是使用的API是：

cv.HoughLines(img, rho, theta, threshold)

参数：

img: 检测的图像，要求是二值化的图像，所以在调用霍夫变换之前首先要进行二值化，或者进行Canny边缘检测
rho、theta: $ρ$ 和的精确度
threshold: 阈值，只有累加器中的值高于该阈值时才被认为是直线。

示例：

检测下述图像中的直线：

import numpy as np
import random
import cv2 as cv
import matplotlib.pyplot as plt
# 1.加载图片，转为二值图
img = cv.imread(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\rili.jpg')
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
edges = cv.Canny(gray, 50, 150)

# 2.霍夫直线变换
lines = cv.HoughLines(edges, 0.8, np.pi / 180, 150)
# 3.将检测的线绘制在图像上（注意是极坐标噢）
for line in lines:
    rho, theta = line[0]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = a * rho
    y0 = b * rho
    x1 = int(x0 + 1000 * (-b))
    y1 = int(y0 + 1000 * (a))
    x2 = int(x0 - 1000 * (-b))
    y2 = int(y0 - 1000 * (a))
    cv.line(img, (x1, y1), (x2, y2), (0, 255, 0))
# 4. 图像显示
plt.figure(figsize=(10,8),dpi=100)
plt.imshow(img[:,:,::-1]),plt.title('霍夫变换线检测')
plt.xticks([]), plt.yticks([])
plt.show()

2.3 霍夫圆检测[了解]

原理

圆的表示式是：

其中和表示圆心坐标，表示圆半径，因此标准的霍夫圆检测就是在这三个参数组成的三维空间累加器上进行圆形检测，此时效率就会很低，所以OpenCV中使用霍夫梯度法进行圆形的检测。

霍夫梯度法将霍夫圆检测范围两个阶段，第一阶段检测圆心，第二阶段利用圆心推导出圆半径。

圆心检测的原理：圆心是圆周法线的交汇处，设置一个阈值，在某点的相交的直线的条数大于这个阈值就认为该交汇点为圆心。
圆半径确定原理：圆心到圆周上的距离（半径）是相同的，确定一个阈值，只要相同距离的数量大于该阈值，就认为该距离是该圆心的半径。

原则上霍夫变换可以检测任何形状，但复杂的形状需要的参数就多，霍夫空间的维数就多，因此在程序实现上所需的内存空间以及运行效率上都不利于把标准霍夫变换应用于实际复杂图形的检测中。霍夫梯度法是霍夫变换的改进，它的目的是减小霍夫空间的维度，提高效率。

API

在OpenCV中检测图像中的圆环使用的是API是：
```
circles = cv.HoughCircles(image, method, dp, minDist, param1=100, param2=100, minRadius=0,maxRadius=0 )
```
参数：
- image：输入图像，应输入灰度图像
- method：使用霍夫变换圆检测的算法，它的参数是CV_HOUGH_GRADIENT
- dp：霍夫空间的分辨率，dp=1时表示霍夫空间与输入图像空间的大小一致，dp=2时霍夫空间是输入图像空间的一半，以此类推
- minDist为圆心之间的最小距离，如果检测到的两个圆心之间距离小于该值，则认为它们是同一个圆心
- param1：边缘检测时使用Canny算子的高阈值，低阈值是高阈值的一半。
- param2：检测圆心和确定半径时所共有的阈值
- minRadius和maxRadius为所检测到的圆半径的最小值和最大值
返回：
- circles：输出圆向量，包括三个浮点型的元素——圆心横坐标，圆心纵坐标和圆半径

实现

由于霍夫圆检测对噪声比较敏感，所以首先对图像进行中值滤波。

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
# 1 读取图像，并转换为灰度图
planets = cv.imread(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\star.jpeg')
gay_img = cv.cvtColor(planets, cv.COLOR_BGRA2GRAY)
# 2 进行中值模糊，去噪点
img = cv.medianBlur(gay_img, 7)  
# 3 霍夫圆检测
circles = cv.HoughCircles(img, cv.HOUGH_GRADIENT, 1, 200, param1=100, param2=30, minRadius=0, maxRadius=100)
# 4 将检测结果绘制在图像上
if circles is not None:  # 先检查是否检测到圆
    circles = np.round(circles[0, :]).astype("int")  # 将坐标和半径转为整数
    for (x, y, r) in circles:  # 直接解包为整数变量
        # 绘制圆形
        cv.circle(planets, (x, y), r, (0, 255, 0), 2)
        # 绘制圆心
        cv.circle(planets, (x, y), 2, (0, 0, 255), 3)
else:
    print("未检测到圆，请调整霍夫圆检测参数。")
# 5 图像显示
plt.figure(figsize=(10,8),dpi=100)
plt.imshow(planets[:,:,::-1]),plt.title('霍夫变换圆检测')
plt.xticks([]), plt.yticks([])
plt.show()

总结：

模板匹配

原理：在给定的图片中查找和模板最相似的区域

API：利用cv.matchTemplate()进行模板匹配，然后

使用cv.minMaxLoc()搜索最匹配的位置。
霍夫线检测

原理：将要检测的内容转换到霍夫空间中，利用累加器统计最优解，将检测结果表示处理

API：cv2.HoughLines()

注意：该方法输入是的二值化图像，在进行检测前要将图像进行二值化处理
霍夫圆检测

方法：霍夫梯度法

API：cv.HoughCircles()

图像变换-傅里叶变换

学习目标

理解傅里叶变换
知道傅里叶变换的相关概念
知道傅里叶变换的分类
知道怎么在图像中进行傅里叶变换
了解傅里叶变换在图像应用中的意义
知道在OPenCV中怎么实现傅里叶变换
了解频域滤波的分类

1 傅里叶变换的理解

傅里叶变换是由法国的一位数学家Joseph Fourier在18世纪提出来的，他认为：任何连续周期的信号都可以由一组适当的正弦曲线组合而成。

傅里叶变换是描述信号的需要，它能够反映信号的特征，并可以使用特征值进行量化，比如正弦波可以使用幅值和频率进行描述。下面这幅图是变压器空载电流的输入波形：

它看起来和正弦波很相*，但很难定量的描述其特征，采用傅里叶变换后，得到下述的频谱图（幅值）：

从该频谱图中可以清楚的看到，主要包括3，5，7，9次谐波，我们就可以对原信号进行描述。

傅里叶变换是一种信号分析方法，它使我们能够对信号的构成和特点进行深入和定量的研究，把信号通过频谱的方式进行准确的、定量的描述。

那我们为什么要把信号分解为正弦波的组合，而不是其他波形呢？

傅里叶变换是信号的分析方法，目的就是要简化问题，而不是将其变复杂，傅里叶选择了正弦波，而没有选择其他波形，是因为正弦波有任何其他波形不具有的特点：正弦波输入至任何线性系统中，不会产生新的频率成分，输出的仍是正弦波，改变的仅仅是幅值和相位。用单位幅值的不同频率的正弦波输入至某线性系统，记录其输出正弦波的幅值和频率的关系，就得到该系统的幅频特性，记录输出正弦波的相位和频率的关系，就得到该系统的相频特性。线性系统是自动控制研究的主要对象，我们只要研究系统对正弦波的输入输出关系，就可以知道该系统对任意输入信号的响应。这是傅里叶变换的最主要的意义。

2 傅里叶变换中相关概念

2.1 时域和频域

傅里叶变换是将难以处理的时域信号转换成易于分析的频域信号，那频域和时域到底是什么呢？

时域：时域是真实的世界，是唯一存在的域。从我们出生开始，所接触的这个世界就是随着时间在变化的，如花开花落，四季变换，生老病死等。以时间作为参照来分析动态世界的方法我们称其为时域分析。

比如说一段音乐，就是一个随时间变化的震动，这就是时域的表示，如下图：

频域：频域它不是真实的，而是一个数学构造。频域是一个遵循特定规则的数学范畴，也被一些学者称为上帝视角。结合上面对时域的理解，如果时域是运动永不停止的，那么频域就是静止的。

正弦波是频域中唯一存在的波形，这是频域中最重要的规则，**即正弦波是对频域的描述，因为频域中的任何波形都可用正弦波合成**。

在看上面那段音乐，我们可以将其表示成频域形式，就是一个永恒的音符。

而对于信号来说，信号强度随时间的变化规律就是时域特性，信号是由哪些单一频率的信号合成的就是频域特性,傅里叶变换实质就是是频域函数和时域函数的转换。

那频域与时域之间的关系是什么样的呢？利用正弦函数的叠加成一个矩形，不仅仅是矩形，你能想到的任何波形都是可以如此方法用正余弦波叠加起来的。如下图所示，时域是永远随着时间的变化而变化的，而频域就是装着正余弦波的空间。

从时域来看，我们会看到一个*似为矩形的波，而我们知道这个矩形的波可以拆分为一些正弦波的叠加。而从频域方向来看，我们就看到了每一个正余弦波的幅值，每两个正弦波之间都还有一条直线，那并不是分割线，而是振幅为 0 的正弦波！也就是说，为了组成特殊的曲线，有些正弦波成分是不需要的。随着叠加的递增，所有正弦波中上升的部分逐渐让原本缓慢增加的曲线不断变陡，而所有正弦波中下降的部分又抵消了上升到最高处时继续上升的部分使其变为水*线。一个矩形就这么叠加而成了。

我们看下面的动图理解，如下所示：

2.2 频谱和相位谱

在傅里叶变换中怎么描述变换后的结果呢？有两个概念：频谱和相位谱。

频谱：将信号分解为若干不同频率的正弦波，那么每一个正弦波的幅度，就叫做频谱，也叫做幅度谱。

相位谱：频谱只代表了一个正弦函数的幅值，而要准确描述一个正弦函数，我们不仅需要幅值，还需要相位，不同相位决定了波的位置，所以对于频域分析，仅仅有频谱（振幅谱）是不够的，我们还需要一个相位谱

如上图所示：投影点我们用粉色点来表示，红色的点表示离正弦函数频率轴最*的一个峰值，而相位差就是粉色点和红色点水*距离。将相位差画到一个坐标轴上就形成了相位谱

3 傅里叶变换

根据原信号的属性，我们可以将傅里叶变换分为以下几种：

序号	信号类型	傅里叶变换方法	英文名称
1	非周期性连续信号	傅立叶变换	Fourier Transform
2	周期性连续信号	傅立叶级数	Fourier Series
3	非周期性离散信号	离散时域傅立叶变换	Discrete Time Fourier Transform
4	周期性离散信号	离散傅立叶变换	Discrete Fourier Transform

在实际应用较多的是傅里叶变换、傅里叶级数离散傅里叶变换，我们对其进行分别介绍。

任意波形都可以通过正弦波的叠加来表示，正弦波可以通过欧拉公式写成指数的形式，欧拉公式如下：

$$e^{it}=\cos(t)+i\sin(t)$$

所以以下内容都是以指数形式进行展示。

3.1 傅里叶级数

任意的周期连续信号都可以使用正弦波叠加而成，这叫做傅里叶级数，写成指数形式如下所示：

$$f(t) = \sum_{-\infty}^{\infty}c_ne^{i\frac{2\pi nt}t }dt$$

其中c_n表示傅里叶级数：

$$c_n=\frac{1}{T}\int_{-\frac{T}{2}}^{\frac{T}{2}}f(t)e^{-i\frac{2\pi nt}t }dt$$

公式中的T表示时域信号的周期。从上式中可以看出周期信号的频谱是离散的非周期信号。

3.2 傅里叶变换

对于非周期的连续信号，也可以使用正弦信号来逼*，这时我们将非周期信号看做周期无限大的周期信号，则有：

$$F(\omega) = \int_{-\infty}^{\infty}f(t)e^{-i\omega t}dt$$

其中ω表示频率，t表示时间。我们叫做傅里叶变换。从中可以看出非周期信号的频谱是连续的非周期信号。

逆变换为：

$$f(t) = \frac{1}{2\pi}\int_{-\infty}^{\infty}F(\omega)e^{i\omega t}dw$$

利用上述公式就可将频域信号转换为时域信号。

3.3 离散傅里叶变换（DFT）

由于数字信号处理是希望在计算机上实现各种运算和变换，其所涉及的变量和运算都是离散的，因此对于数字信号处理，应该找到在时域和频域都是离散的傅里叶变换，即离散傅里叶变换。

对于非周期的离散信号进行傅里叶变换就是离散傅里叶变换，其计算方法如下所示：

$$F(k)= \sum_{n=0}^{N-1}f(n)e^{-i\frac{2\pi kn}{N}}$$

其中N表示傅里叶变换的点数，k表示傅里叶变换的频谱。

逆变换为：

$$f(n) = \frac{1}{N}\sum_{k=0}^{N-1}F(k)e^{ikn\frac{2\pi}{N}}$$

4 傅里叶变换在图像中的应用

4.1 图像中的傅里叶变换

图像是二维的离散信号，所以我们在对图像进行二维傅里叶变换。对于M*N的一幅图像的离散二维傅里叶变换，公式如下：

$$F(u,v) = \sum_{x=0}^{M-1}\sum_{y=0}^{N-1}f(x,y)e^{-i2\pi(\frac{ux}M+\frac{vy}N)}$$

其中u和v确定频率，f(x,y)是灰度值，该式的意义是两个求和号对图像进行遍历，f(x,y)取出原像素的数值，当固定x时，横轴不动，对y进行遍历时，表示变换前像素的位置比例与变换后的位置相乘，映射到新的位置，且能够反映像素沿y方向距离的差异，越靠后的像素(y越大)值越大，即能够反映出不同位置(纵轴)像素之间的差异；前一项含义为保留像素相对位置(横轴)的信息(遍历y时为常数)，2π为修正参数。

逆变换由下式给出：

$$f(x,y) = \sum_{x=0}^{M-1}\sum_{y=0}^{N-1}F(u,v)e^{i2\pi(\frac{ux}M+\frac{vy}N)}$$

4.2 图像傅里叶变换的物理意义

图像的频率是表征图像中灰度变化剧烈程度的指标，是灰度在*面空间上的梯度。如：大面积的沙漠在图像中是一片灰度变化缓慢的区域，对应的频率值很低；而对于地表属性变换剧烈的边缘区域在图像中是一片灰度变化剧烈的区域，对应的频率值较高。傅里叶变换在实际中有非常明显的物理意义，从物理效果看，傅里叶变换是将图像从空间域转换到频率域，其逆变换是将图像从频率域转换到空间域。换句话说，傅里叶变换的物理意义是将图像的灰度分布函数变换为图像的频率分布函数。

傅里叶逆变换是将图像的频率分布函数变换为灰度分布函数。

我们在做DFT时是将图像的空域和频域沿x和y方向进行无限周期拓展的，如下图所示：

如果只取其中一个周期，会得到：

为了便于频域的滤波和频谱的分析，常在变换后进行频谱的中心化，即对掉频谱的四个象限，如下图所示：

经中心化后的频谱为：

在经过频谱居中后的频谱中，中间最亮的点是最低频率，属于直流分量，越往外，频率越高，如下所示：

4.3 在opencv中实现图像的傅里叶变换

在OPenCV中实现图像的傅里叶变换，使用的是：

正变换：

dft = cv2.dft(src, dst=None)

参数：

src: 输入图像，要转换成np.float32格式
dst:参数是可选的, 决定输出数组的大小。默认输出数组的大小和输入图像大小一样。如果输出结果比输入图像大，输入图像就需要在进行变换前补 0。如果输出结果比输入图像小的话，输入图像就会被切割。

dft: 傅里叶变换后的结果，有两个通道，第一个通道是结果的实数部分，第二个通道是结果的虚数部分。我们需要在此基础上计算傅里叶变换的频谱和相位。

逆变换：

img = cv.idft(dft)

参数：

dft: 图像的频域表示

img: 图像的空域表示

实现：

import numpy as np 
import cv2 as cv
from matplotlib import pyplot as plt
# 1 读取图像
img = cv.imread(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\deer.jpeg',0)
# 2 傅里叶变换
# 2.1 正变换
dft = cv.dft(np.float32(img),flags = cv.DFT_COMPLEX_OUTPUT) 
# 2.2 频谱中心化
dft_shift = np.fft.fftshift(dft)
# 2.3 计算频谱和相位谱
mag, angle = cv.cartToPolar(dft_shift[:,:,0], dft_shift[:,:,1], angleInDegrees=True)
mag=20*np.log(mag)
# 3 傅里叶逆变换
# 3.1 反变换
img_back = cv.idft(dft)
# 3.2 计算灰度值
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])
# 4 图像显示
plt.figure(figsize=(10,8))
plt.subplot(221),plt.imshow(img, cmap = 'gray') 
plt.title('输入图像'), plt.xticks([]), plt.yticks([]) 
plt.subplot(222),plt.imshow(mag, cmap = 'gray')
plt.title('频谱'), plt.xticks([]), plt.yticks([]) 
plt.subplot(223),plt.imshow(angle, cmap = 'gray')
plt.title('相位谱'), plt.xticks([]), plt.yticks([])
plt.subplot(224),plt.imshow(img_back, cmap = 'gray')
plt.title('逆变换结果'), plt.xticks([]), plt.yticks([])
plt.show()

结果展示：

4.4 频域滤波

图像变换到频域后，就可以进行频域滤波，主要包括：高通滤波，低通滤波，带通滤波和带阻滤波。

1 高通和低通滤波器

我们知道，图像在经过傅里叶变换后，经频谱中心化后，从中间到外面，频率上依次是从低频到高频的。那么我们假设把中间规定一小部分去掉，是不是相对于把低频信号去掉了呢？这也就是相当于进行了高通滤波。

这个滤波模板如下图所示：

其中黑色部分为0，白色部分为1，我们将这个模板与图像的傅里叶变换相与就实现了高通滤波。如下所示：

import numpy as np 
import cv2 as cv
from matplotlib import pyplot as plt
# 1 读取图像
img = cv.imread(r'D:\learn\000人工智能数据大全\黑马数据\OpenCV\image\deer.jpeg',0)
# 2 设计高通滤波器(傅里叶变换结果中有两个通道，所以高通滤波中也有两个通道)
rows,cols = img.shape
mask = np.ones((rows,cols,2),np.uint8)
mask[int(rows/2)-30:int(rows/2)+30,int(cols/2)-30:int(cols/2)+30,:] = 0
# 3 傅里叶变换
# 3.1 正变换
dft = cv.dft(np.float32(img),flags = cv.DFT_COMPLEX_OUTPUT) 
# 3.2 频谱中心化
dft_shift = np.fft.fftshift(dft)
# 3.3 滤波
dft_shift = dft_shift * mask
# 3.4 频谱去中心化
dft_shift = np.fft.fftshift(dft_shift)
# 3 傅里叶逆变换
# 3.1 反变换
img_back = cv.idft(dft_shift)
# 3.2 计算灰度值
img_back = cv.magnitude(img_back[:,:,0],img_back[:,:,1])
plt.subplot(121),plt.imshow(img, cmap = 'gray') 
plt.title('输入图像'), plt.xticks([]), plt.yticks([]) 
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('高通滤波结果'), plt.xticks([]), plt.yticks([])
plt.show()

从结果中可以看出，高通滤波器有利于提取图像的轮廓，图像的轮廓或者边缘或者一些噪声处，灰度变化剧烈，那么在把它们经过傅里叶变换后。就会变成高频信号（高频是捕捉细节的），所以在把图像低频信号滤掉以后剩下的自然就是轮廓了。

现在我们看下低通滤波的效果，构造一个低通滤波器很简单，只要把上述模板中的1改为0，0改为1即可。把设计高通滤波器部分的代码改成如下所示：

rows,cols = img.shape
mask = np.zeros((rows,cols,2),np.uint8)
mask[int(rows/2)-30:int(rows/2)+30,int(cols/2)-30:int(cols/2)+30,:] = 1

低通滤波的效果如下图所示：

从结果中可看到低通滤波后图像轮廓变模糊了，图像的大部分信息基本上都保持了。图像的主要信息都集中在低频上，所以低通滤波器的效果是这样也是能够理解的。上述的高通、低通滤波器的构造有0,1构成的理想滤波器，也是最简单的滤波器，另一些其它的滤波器。比方说高斯滤波器，butterworth滤波器等等，如下图所示：

2 带通和带阻滤波器

我们把高通和低通的一部分结合在模板中就形成了带通滤波器，它容许一定频率范围信号通过, 但减弱(或减少)频率低于於下限截止频率和高于上限截止频率的信号的通过，如下图所示：

还是以理想的带通滤波器演示如下，将构建的滤波的代码修改如下：

rows,cols = img.shape
mask1 = np.ones((rows,cols,2),np.uint8)
mask1[int(rows/2)-8:int(rows/2)+8,int(cols/2)-8:int(cols/2)+8] = 0
mask2 = np.zeros((rows,cols,2),np.uint8)
mask2[int(rows/2)-80:int(rows/2)+80,int(cols/2)-80:int(cols/2)+80] = 1
mask = mask1*mask2

结果如下所示：

这就是带通的效果，它既能保留一部分低频，也能保留一部分高频。至于保留多少，根据需求选择就可以了。

带阻滤波器减弱(或减少)一定频率范围信号, 但容许频率低于於下限截止频率和高于上限截止频率的信号的通过，如下示：

在代码中将设计滤波器部分改为如下所示：

mask = np.ones((rows,cols,2),np.uint8)
mask[int(rows/2)+80:int(rows/2)+150,int(cols/2)-150:int(cols/2)+150] = 0
mask[int(rows/2)-150:int(rows/2)-80,int(cols/2)-150:int(cols/2)+150] = 0
mask[int(rows/2)-150:int(rows/2)+150,int(cols/2)+80:int(cols/2)+150] = 0
mask[int(rows/2)-150:int(rows/2)+150,int(cols/2)-150:int(cols/2)-80] = 0
plt.imshow(mask[:,:,1],cmap=plt.cm.gray)

结果如下所示:

从结果中可看到带阻滤波器保持了原图像的大部分信息，图像的主要信息都集中在低频上，而边缘轮廓信息都在高频位置。带阻滤波器滤除了中频信息，保留了低频和高频信息，所以对图像的信息破坏是比较小的。：

总结：

傅里叶变换的理解

任何连续周期的信号都可以由一组适当的正弦曲线组合而成
相关概念：

时域：以时间作为参照来分析动态世界的方法

频域：频域它不是真实的，而是一个数学构造

幅度谱：将信号分解为若干不同频率的正弦波，那么每一个正弦波的幅度，就叫做频谱，也叫做幅度谱

相位谱：每一个正弦波的相位，就叫做相位谱
傅里叶变换分类

傅里叶级数：任意的周期连续信号的傅里叶变换

傅里叶变换：非周期连续信号

离散傅里叶变换：非周期离散信号
图像中的应用
- 二维傅里叶变换
- 意义：将图像的灰度分布函数变换为图像的频率分布函数。
- API：
  
  cv.dft()
  
  cv.idft()
- 滤波：高通，低通，带通，带阻

补充内容

**离散函数的导数*似**

一、先理解 “离散” vs “连续”

连续函数（比如数学里的：可以用微积分求导（如），因为 $x$ 是连续变化的。
离散函数（比如图像的像素）：像素是一个个 “点”，亮度值只在整数坐标有定义（比如 $x=0,1,2...$ ），没有中间值。

所以，图像的 “导数”（像素亮度的变化率）不能直接用微积分公式，只能用相邻像素的差值*似！

二、用 “相邻像素差” *似导数

对于离散的像素，假设我们有一个一维信号（比如一行像素的亮度）：

$f(x)$ 表示坐标 $x$ 处的像素亮度。

导数的物理意义是 “变化率” ，反映亮度变化的快慢。在连续函数里，导数是 “无穷小的变化量”，但离散情况下，我们只能用 “有限的差值” *似。

1. 向前差分（第一种*似）

用 “当前点” 和 “下一个点” 的差，*似导数：

理解：比如 $x$ 处亮度是 100， $x+1$ 处是 150，差值是 50 → *似认为 $x$ 处的变化率是 50。

2. 向后差分（第二种*似）

用 “前一个点” 和 “当前点” 的差，*似导数：

理解：比如 $x -1$ 处亮度是 80， $x$ 处是 100，差值是 20 → *似认为 $x$ 处的变化率是 20。

3. 中心差分（更准确的*似）

把 “向前差分” 和 “向后差分” 结合，取*均，得到 中心差分：

理解：用 $x -1$ 和 $x+1$ 的差值，除以 2（因为两点间隔 2 个单位），这样*似更接*真实导数（连续情况下的导数定义）。

三、为什么用这些*似？

因为图像是离散的，没有 “无穷小” 的变化，只能用相邻像素的 “有限差值” 模拟导数。这三种*似里：

向前 / 向后差分简单，但误差大；
中心差分更接*连续函数的导数，误差更小，所以常用。

四、回到 Sobel 算子

Sobel 算子本质是二维的 “差分*似”（同时考虑

x

和

y

方向），但基础就是这种一维的 “离散导数*似”。它先用类似的方法计算

x

和

y

方向的 “变化率”，再综合得到边缘。

五、总结（一句话懂离散导数）

因为图像是离散的像素点，无法用连续函数的导数公式，所以用 “相邻像素的亮度差” *似导数。向前差分、向后差分是简单*似，中心差分更准确，这些就是离散函数求导的基本思路～

理解了这个，再看 Sobel 算子的二维扩展（同时算

x

、

y

方向的差分）就更顺啦！

理解 “卷积核（矩阵）如何实现离散求导”

假设要处理的图像为，在两个方向求导:

水*变化: 将图像与奇数大小的模版进行卷积，结果为 $^{ }$ 。比如，当模板大小为3时, $^{ }$ 为:

垂直变化: 将图像与奇数大小的模板进行卷积，结果为 $^{ }$ 。比如，当模板大小为3时, $^{ }$ 为:

在图像的每一点，结合以上两个结果求出：

理解：

Gx（和 Gy）就是用卷积核对图像做离散求导的*似。

但要注意：

这里的 “求导” 是离散情况下的*似，不是连续函数的严格求导。
卷积核的作用，就是用 “加权求和” 的方式，模拟 “相邻像素的差值”（也就是离散导数的核心逻辑）。

示例：Gx矩阵计算原理：

像素点(i,j)的Gx值 = 
  -1 * I(i-1,j-1) + 0 * I(i-1,j) + 1 * I(i-1,j+1)
  -2 * I(i, j-1)  + 0 * I(i,j)  + 2 * I(i, j+1)
  -1 * I(i+1,j-1) + 0 * I(i+1,j) + 1 * I(i+1,j+1)

简化后等价于：Gx(i,j) ≈ [I(i-1,j+1) + 2I(i,j+1) + I(i+1,j+1)] - [I(i-1,j-1) + 2I(i,j-1) + I(i+1,j-1)])

矩阵运算的物理意义：

每个矩阵实际上是方向差分算子
Sobel水*算子实质：

Gx ≈ [右侧像素加权和] - [左侧像素加权和]
     正权重区域       负权重区域

中心列为0，避免中心像素影响梯度计算

Sobel和Scharr的矩阵数值是固定的吗？

是的，但存在变体：

算子类型	核心特性	标准矩阵(3×3)	存在变体	备注	效果对比
Sobel	基础边缘检测		5×5/7×7扩展归一化版本		边缘较粗边缘更细存在方向偏差
Scharr	优化的精度		仅3×3 无更大尺寸	是对 Sobel 核的优化，数值更大（比如 -3、-10 等），让加权更 “激进”，对边缘的响应更明显，减少 3×3 Sobel 核的误差。	方向更准确弱边缘遗漏弱边缘保留

算子类型

核心特性

标准矩阵(3×3)

存在变体

备注

效果对比

Sobel

基础边缘检测

5×5/7×7扩展
归一化版本

边缘较粗

边缘更细

存在方向偏差

Scharr

优化的精度

仅3×3
无更大尺寸

是对 Sobel 核的优化，数值更大（比如 -3、-10 等），让加权更 “激进”，对边缘的响应更明显，减少 3×3 Sobel 核的误差。

方向更准确

弱边缘遗漏

弱边缘保留

为什么 “乘以矩阵（卷积）” 能模拟求导？

核心逻辑：

离散求导的本质是 **“相邻像素的差值”** 。
卷积核通过 **“加权差值”** （不是简单相减，而是周围像素的加权和相减），更鲁棒地模拟这种变化率。
核的数值设计（比如 Sobel 核的 -1、0、+1 分布），刚好让加权和的结果等价于 “水* / 垂直方向的亮度变化率”。

总结（一句话打通逻辑）

Sobel（和 Scharr）的卷积核是固定的经典设计，通过 “局部加权求和” 的方式，模拟图像在水* / 垂直方向的离散亮度变化率（*似导数） 。乘以这些矩阵（卷积），本质是用加权差值的方法，找到图像中亮度变化最剧烈的位置（边缘）。

补充提示：

实际应用中，常使用cv.Sobel(src, cv.CV_16S, 1, 0)避免溢出
Scharr在OpenCV中调用：cv.Scharr(src, ddepth, dx, dy)
最终梯度计算：cv.magnitude(Gx, Gy)更高效
现代替代方案：深度学习边缘检测（如HED网络）

霍夫空间的深入理解

霍夫变换检测直线，本质是把图像空间的直线检测，转化为参数空间（霍夫空间）的交点统计，核心逻辑分 4 步，用 “找图像里的直线” 举个通俗例子，帮你理解：

一、核心思想：空间转换

图像里的直线，能对应到极坐标参数空间（ρ，θ） 里的一个点；反过来，参数空间里的一个交点，对应图像空间里的一条直线。你可以简单理解为：“图像里的直线” 和 “参数空间的点” 是一对多的映射关系，检测直线就变成找参数空间里的 “热门交点”（被很多点投票选中的 ρ，θ）。

二、步骤拆解（以 100×100 图像为例）

1. 准备 “累加器”（统计投票的工具）

直线用极坐标 $(ρ，θ)$ 表示(ρ 是原点到直线的垂直距离， $θ$ 是垂线与 $x$ 轴夹角）。
建一个 2D 数组（累加器），行代表 ρ ，列代表 θ，初始值全为 0 。
- $θ$ 范围：0°~180°（直线旋转一周覆盖的角度），若精度 1°，就需要 180 列（对应 $θ$ $=0,1,2,...,179$ ）。
- $ρ$ 范围：最大是图像对角线长度（100×100 图像对角线约 141 像素），若精度 1 像素，就需要 141 行（对应 $ρ=0,1,2,...,140$ ）。

2. 遍历图像点，投出 “直线票”

图像里的每个边缘点（假设是直线上的点），都会参与投票：

拿一个点 $(x,y)$ ，代入极坐标公式。
遍历 θ 所有可能值（0°~180°），算出对应的 ρ ，然后在累加器里找到 (ρ，θ) 对应的格子，票数 +1 。
- 比如点 $(x 1,y 1)$ ，当 $(θ=30°)$ 时算出 $ρ=50)$ ，就在累加器第 50 行、30 列的位置 +1 ；换 $θ=45°$ 再算 $ρ$ ，继续对应位置 +1 …… 直到遍历完所有 $θ$ 。
图像里每条直线上的点，都会重复这个操作：每个点遍历 $θ$ 算 $ρ$ ，给对应 $(ρ，θ)$ 投票。

3. 找 “热门交点”（累加器最大值）

所有点投票结束后，累加器里某些

(ρ，θ)

的格子，会被同一直线上的很多点反复投票，这些格子的数值会特别大（因为同一直线上的点，对应参数空间是同一个

(ρ，θ)

）。

4. 转回图像直线

找到累加器里数值最大的格子，对应的

(ρ，θ)

，代入极坐标公式，就能算出图像空间里的直线 。

本质是用投票的方式，把 “找直线” 变成 “找参数空间里的热门交点” ，把几何问题转化成了统计问题，这样即使图像有噪声、点不全，只要多数点能对齐同一个 $(ρ，θ)$ ，就能检测出直线～

霍夫线检测的整个流程如下图所示，这是在stackflow上一个关于霍夫线变换的解释：

posted @ 2025-07-05 21:05 指尖下的世界阅读(25) 评论(0) 收藏举报

刷新页面返回顶部

指尖下的世界

今日事今日毕,今日无事早休息.

3.OpenCV图像处理

几何变换

1 图像缩放

2 图像*移​

3 图像旋转

4 仿射变换

5 透射变换

6 图像金字塔

形态学操作

1.连通性

2.腐蚀和膨胀

3.开闭运算

4.礼帽和黑帽

图像*滑

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 应用

模板匹配

1.1 原理

1.2 实现

霍夫变换

2.1 原理

2.2 霍夫线检测

2.3 霍夫圆检测[了解]

图像变换-傅里叶变换

1 傅里叶变换的理解

2 傅里叶变换中相关概念

2.1 时域和频域

2.2 频谱和相位谱

3 傅里叶变换

3.1 傅里叶级数

3.2 傅里叶变换

3.3 离散傅里叶变换（DFT）

4 傅里叶变换在图像中的应用

4.1 图像中的傅里叶变换

4.2 图像傅里叶变换的物理意义

4.3 在opencv中实现图像的傅里叶变换

4.4 频域滤波

1 高通和低通滤波器

2 带通和带阻滤波器

补充内容

离散函数的导数*似

理解 “卷积核（矩阵）如何实现离散求导”

霍夫空间的深入理解

2 图像*移

**离散函数的导数*似**