OpenCV 图像处理六（傅里叶变换、模板匹配与霍夫变换）

一、傅里叶变换

任何周期函数都可以表示为不同频率的正弦函数和的形式。
1

傅里叶变换（空间域变换到频率域）、 逆傅里叶变换（频率域信息变换到空间域）
（1）幅度图像（Magnitude Image）和相位图像（Phase Image）：幅度图像显示了每个频率分量的强度或能量信息，它的取值范围是非负的。相位图像显示了每个频率分量的相位信息，它的取值范围通常是[-π, π]。通过显示幅度图像和相位图像可以很直观地观察到图像中不同频率分量的贡献和相位信息。
（2）实数图像和虚数图像：实数图像和虚数图像是将复数的傅里叶变换结果分别表示为实部和虚部的图像。实数图像显示了图像中的低频信息，而虚数图像则显示了图像中的高频信息。这种可视化方法将复数形式的傅里叶变换结果拆分为两个部分，更加直观地展示了图像中不同频率分量的特点。

1.1 NumPy实现和逆实现

通过傅里叶变换可以将图像分解为不同频率分量，并且频率越高的分量对应于图像中变化越快的部分，即边缘和细节等。而频率越低的分量对应于图像中变化缓慢的部分，即平滑区域和低频信号等。这种分解可以帮助我们进行频域滤波、图像恢复和特征提取等图像处理任务。

1.1.1 NumPy实现傅里叶变换

函数:
（1）

#实现变化，返回的是一个复数数组
np.fft.fft2
1
2

（2）

# 将零频率分量移动到中心
np.fft.ffshift
1
2

不加shift

加shift

（3）

# 设置批频谱的范围
magnitude_spectrum = 20*np.log(np.abs(fshift))
1
2

Demo

import numpy as np
import cv2  as cv
import matplotlib.pyplot as plt

img=cv.imread('./img/test_img.jpg',0)
f=np.fft.fft2(img)
fshift = np.fft.fftshift(f)
magnitude_spectrum = 20*np.log(np.abs(fshift))
plt.subplot(121)
plt.imshow(img, cmap = 'gray')
plt.title('original')
plt.axis('off')
plt.subplot(122)
plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('result')
plt.axis('off')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

1.1.2 NumPy实现逆傅里叶变换

由频谱回到图像，在频域对图像进行处理,在频域的处理会反映在逆变换图像
（1）

# 实现逆傅里叶变换，返回应该复数数组
np.fft.ifft2
1
2

（2）

# 是fftshift逆函数
np.fft.ifftshift
1
2

（3）

# 设置值的范围
iimg=np.abs（逆傅里叶变换的结果）
1
2

Demo

import numpy as np
import  cv2 as cv
import matplotlib.pyplot as plt

img=cv.imread('./img/test_img.jpg',0)
#逆傅里叶变换
f=np.fft.fft2(img)
fshift = np.fft.fftshift(f)
ishift = np.fft.ifftshift(fshift)
iimg=np.fft.ifft2(ishift)
iimg=np.abs(iimg)
plt.subplot(131)
magnitude_spectrum = 20*np.log(np.abs(fshift))
plt.imshow(img, cmap = 'gray')
plt.title('original')
plt.axis('off')

plt.subplot(132)
plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('magnitude_spectrum')
plt.axis('off')

plt.subplot(133)
plt.imshow(iimg, cmap = 'gray')
plt.title('result')
plt.axis('off')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.2 OpenCV实现和逆实现

1.2.1 OpenCV实现傅里叶变换

（1）

#双通道，实数 、虚数
result=cv2.dft（原始图像，转换标识）
1
2

原始图像
首先被转换成np.float32格式，可以使用np.float32(img)来进行转换。

转换标识flags=cv2.DFT_COMPLEX_OUTPUT用于指定输出一个复数数组。

（2）

np.fft.ffshift
1

（3）用于计算复数的幅度的函数

result=cv2.magnitude（参数1，参数2）
1

参数1和参数2是两个具有相同形状和数据类型的数组，分别表示复数的实部和虚部。

a + bi（其中 a 是实部，b 是虚部）
sqrt(a^2 + b^2)

Demo

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
img = cv.imread('./img/test_img.jpg', 0)
# 进行傅里叶变换
dft = cv.dft(np.float32(img), flags=cv.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
# 计算幅度谱
magnitude_spectrum = 20 * np.log(cv.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1]))
plt.subplot(121)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(122)
plt.imshow(magnitude_spectrum, cmap='gray')
plt.title('Magnitude Spectrum')
plt.axis('off')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这段代码首先使用cv.imread()加载图像，然后使用cv.dft()进行傅里叶变换。接下来，使用np.fft.fftshift()将频率分量移动到图像中心。最后，通过cv.magnitude()计算复数的幅度，并使用20 * np.log()对结果进行缩放以便于显示。
注意：在这个例子中，傅里叶变换的结果是复数，cv.magnitude()用于计算复数的幅度并生成幅度谱。

1.2.2 OpenCV实现逆傅里叶变换

（1）

取决于元数据的类型和大小，双通道的
返回=cv.idft(原始数据)
1
2

（2）

 np.fft.ifftshift(magnitude_spectrum)
1

（3）

# 双通道的形式换成255的
cv.magnitude(img_back[:, :, 0], img_back[:, :, 1])
1
2

Demo

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
# 读取图像
img = cv.imread('./img/test_img.jpg', 0)
# 进行傅里叶变换
dft = cv.dft(np.float32(img), flags=cv.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
magnitude_spectrum = 20 * np.log(cv.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1]))
# 进行逆傅里叶变换
fshift_inverse = np.fft.ifftshift(dft_shift)
img_back = cv.idft(fshift_inverse)
img_back = cv.magnitude(img_back[:, :, 0], img_back[:, :, 1])
# 显示图像对比
plt.subplot(131)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(132)
plt.imshow(magnitude_spectrum, cmap='gray')
plt.title('Magnitude Spectrum')
plt.axis('off')
plt.subplot(133)
plt.imshow(img_back, cmap='gray')
plt.title('Inverse Fourier Transform')
plt.axis('off')
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

1.3 频域滤波

目的:图像增强、图像去噪、边缘检测、特征提取、压缩、加密等。
1

在图像中，低频分量表示颜色或灰度变化较为平缓的区域，通常对应图像中的平滑部分；

假设你正在拍摄一片平静的湖面。湖水的平静部分将对应低频分量，因为它们变化缓慢且颜色趋于一致。

高频分量表示变化较快、灰度过渡尖锐的区域，通常对应图像中的细节部分

观察一幅包含文字的图像时，文字的边缘对应高频分量。这是因为文字边缘通常具有锐利的灰度过渡，由于字体的笔画和字母之间的间隔。

1.3.1低频、高频

低通滤波器允许低频分量通过，同时衰减高频分量，从而模糊图像。这种滤波器可以用来平滑图像，去除噪声或减少图像中不必要的细节。

相反，高通滤波器允许高频分量通过，同时衰减低频分量，以增强图像中的尖锐细节。这会使图像更加清晰，但可能会导致对比度的降低。

1.3.2 高通滤波器

去除中心的fftshift

构造高通滤波器

# 构造高通滤波器
rows, cols = img.shape
crow, ccol = int(rows / 2), int(cols / 2)  # 中心位置
filter = np.ones_like(img)  # 创建与图像大小相同的滤波器
d = 30  # 高通滤波半径阈值
filter[crow - d: crow + d, ccol - d: ccol + d] = 0  #将中心d半径内的值设为0
1
2
3
4
5
6

Demo

import numpy as np
import cv2 as cv
import matplotlib.pyplot as plt
# 读取图像
img = cv.imread('./img/test_img.jpg', 0)
# 进行傅里叶变换
f = np.fft.fft2(img)
fshift = np.fft.fftshift(f)
# 构造高通滤波器
rows, cols = img.shape
crow, ccol = int(rows / 2), int(cols / 2)  # 中心位置
filter = np.ones_like(img)  # 创建与图像大小相同的滤波器
d = 30  # 高通滤波半径阈值
filter[crow - d: crow + d, ccol - d: ccol + d] = 0  #将中心d半径内的值设为0
# 进行滤波操作
fshift_filtered = fshift * filter
# 进行傅里叶逆变换
f_ishift = np.fft.ifftshift(fshift_filtered)
img_filtered = np.fft.ifft2(f_ishift)
img_filtered = np.abs(img_filtered)
# 显示结果
plt.subplot(131)
plt.imshow(img, cmap='gray')
plt.title('Original')
plt.axis('off')
plt.subplot(132)
plt.imshow(np.log(1 + np.abs(fshift)), cmap='gray')
plt.title('Magnitude Spectrum')
plt.axis('off')
plt.subplot(133)
plt.imshow(img_filtered, cmap='gray')
plt.title('Filtered Image')
plt.axis('off')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

1.3.3 低通滤波器

去除边缘的fftshift

设置低通滤波器

# 设置低通滤波器
rows, cols = img.shape
crow, ccol = rows//2, cols//2
mask = np.zeros((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1  # 选择中心区域作为低频成分
1
2
3
4
5

Demo

import cv2 as cv
import numpy as np
import matplotlib.pyplot as plt
# 读取图像
img = cv.imread('./img/test_img.jpg', 0)
# 进行傅里叶变换
dft = cv.dft(np.float32(img), flags=cv.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)
# 设置滤波器
rows, cols = img.shape
crow, ccol = rows//2, cols//2
mask = np.zeros((rows, cols, 2), np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1  # 选择中心区域作为低频成分
# 进行频域滤波
fshift = dft_shift * mask
f_ishift = np.fft.ifftshift(fshift)
img_back = cv.idft(f_ishift)
img_back = cv.magnitude(img_back[:, :, 0], img_back[:, :, 1])
# 显示原图和滤波后的图像
plt.subplot(121)
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.subplot(122)
plt.imshow(img_back, cmap='gray')
plt.title('Low Pass Filtered Image')
plt.axis('off')
plt.tight_layout()
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

模糊了，平滑图像，去除噪声

二、模板匹配

在模板匹配中，通常将图像A称为输入图像或源图像，将图像B称为模板图像或搜索图像。模板匹配的目标是在输入图像中寻找与模板图像最相似的部分。

2.1 模板匹配是使用函数 cv2.matchTemplate()实现的。

result = cv2.matchTemplate(image, templ, method, result=None, mask=None)
1

参数
image – 运行搜索的图像。它必须是 8 位或 32 位浮点。
templ – 搜索的模板。它不能大于源图像，并且具有相同的数据类型。
result是一个单通道 32 位浮点型。如果输入图像（原始图像）尺寸是 WH，模板的尺寸是 wh， 则返回值的大小为(W-w+1)*(H-h+1)。

method

说明

（1）对于cv2.TM_SQDIFF和cv2.TM_SQDIFF_NORMED方法，匹配结果的值越小，表示匹配程度越高。即匹配结果最小的位置是最佳的匹配位置。
（2）对于cv2.TM_CCORR，cv2.TM_CCORR_NORMED，cv2.TM_CCOEFF和cv2.TM_CCOEFF_NORMED方法，匹配结果的值越大，表示匹配程度越高。即匹配结果最大的位置是最佳的匹配位置。
（3）通过比较匹配结果的值，可以确定模板与输入图像的匹配程度。较小的值或较大的值表示较好的匹配。具体的阈值和判断标准可以根据具体的应用场景和需求来确定。通常，我们会选择一个阈值，当匹配结果超过或低于该阈值时，判定为有效的匹配或无效的匹配。这个阈值的选择可以根据实验和经验来进行调整。

2.2 依据method获取想要的最值及其位置需要以使cv2.minMaxLoc()函数实现

minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc( src [, mask] )
1

src：单通道的输入数组。

minVal：返回的最小值，如果没有最小值，则可以是空值。

maxVal：返回的最大值，如果没有最大值，则可以是空值。

minLoc：最小值的位置，如果没有最小值，则可以是空值。

maxLoc：最大值的位置，如果没有最大值，则可以是空值。

mask 为用来选取掩模的子集

2.2.1 选择

（1）当 method 的值为 cv2.TM_SQDIFF 和 cv2.TM_SQDIFF_NORMED 时，0 表示最佳匹配，值越大表示匹配效果越差。因此，在使用这两种方法时，要寻找最小值所在的位置作为最佳匹配

minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(matchTemplate 函数的返回值
topLeft = minLoc

# 以 topLeft 点为模板匹配位置的左上角坐标，
#根据模板图像的宽度和高度确定匹配位置的右下角坐标
bottomRight = (topLeft[0] + w, topLeft[1] + h) #w 和 h 是模板图像的宽度和高度
1
2
3
4
5
6

（2）当 method 的值为cv2.TM_CCORR、cv2.TM_CCORR_NORMED、cv2.TM_CCOEFF 和 cv2.TM_CCOEFF_NORMED 时，cv2.matchTemplate() 函数的返回值越小表示匹配度越差，而返回值越大表示匹配度越好。

minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(matchTemplate 函数的返回值
topLeft = maxLoc

# 以 topLeft 点为模板匹配位置的左上角坐标，
#根据模板图像的宽度和高度确定匹配位置的右下角坐标
bottomRight = (topLeft[0] + w, topLeft[1] + h)  # w 和 h 是模板图像的宽度和高度
1
2
3
4
5
6

2.2.2 显现标记匹配位置

rectangle(img, pt1, pt2, color, thickness=None, lineType=None, shift=None)
1

2.2.3 Demo

TM_SQDIFF
topLeft = minLoc

import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('img/x.jpg')
template = cv2.imread('img/x1.jpg')
th, tw,tl = template.shape
rv = cv2.matchTemplate(img,template,cv2.TM_SQDIFF)
minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(rv)
topLeft = minLoc
bottomRight = (topLeft[0] + tw, topLeft[1] + th)
cv2.rectangle(img,topLeft, bottomRight, (0,255,0), 30)
plt.subplot(121),plt.imshow(rv,cmap = 'gray')
plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img[:,:,::-1])
plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

cv2.TM_CCOEFF
topLeft = maxLoc

import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('img/x.jpg')
template = cv2.imread('img/x1.jpg')
th, tw ,tl= template.shape
rv = cv2.matchTemplate(img, template, cv2.TM_CCOEFF)
minVal, maxVal, minLoc, maxLoc = cv2.minMaxLoc(rv)
# 将变量名更新为对应的最大值
topLeft = maxLoc
bottomRight = (topLeft[0] + tw, topLeft[1] + th)
# 绘制矩形框
cv2.rectangle(img, topLeft, bottomRight, (0, 255, 0), 30)
# 显示结果
plt.subplot(121), plt.imshow(rv, cmap='gray')
plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
plt.subplot(122), plt.imshow(img[:,:,::-1])
plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

三、霍夫变换

霍夫变换（Hough Transform）是一种用于在数字图像中检测几何形状的技术。用于检测直线形状，还有其他如圆、椭圆等。

3.1 霍夫直线变换 – HoughLines函数

lines = cv2.HoughLines(image, rho, theta, threshold)
1

image：输入图像，通常为二值化图像（单通道，黑白）

rho：以像素为单位的距离精度，一般为1

theta：以弧度为单位的角度精度，一般为 np.pi/180

threshold：阈值，检测到的直线必须满足的投票数阈值

函数返回一个包含检测到的直线参数（rho和theta值）的数组，每一行表示一条检测到的直线。
使用霍夫直线变换函数，我们可以在图像中检测直线并对其进行分析、处理或绘制。

3.1.1 cv2.line()可以在图像上绘制直线，即使直线的端点坐标超出了图像的范围，也可以正确地绘制。

cv2.line(image, start_point, end_point, color, thickness)
1

image：要在其上绘制线段的图像

start_point：线段的起始点坐标，格式为 (x, y)

end_point：线段的结束点坐标，格式为 (x, y)

color：线段的颜色，可以是一个整数值（灰度图像）或一个包含三个整数值的元组/列表（彩色图像），表示蓝色、绿色、红色的值（BGR顺序）

thickness：线段的粗细，默认值为1

3.1.2 Demo

import cv2
import numpy as np
# 读取图像
image = cv2.imread('img/S1.jpg')
# 转换为灰度图像
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 进行边缘检测
edges = cv2.Canny(gray, 50, 150)
# 进行霍夫直线变换
lines = cv2.HoughLines(edges, 1, np.pi/180, 150)
# 绘制直线
if lines is not None:
    for line in lines:
        rho, theta = line[0]
        a = np.cos(theta)
        b = np.sin(theta)
        x0 = a * rho
        y0 = b * rho
        pt1 = (int(x0 + 1000*(-b)), int(y0 + 1000*(a)))
        pt2 = (int(x0 - 1000*(-b)), int(y0 - 1000*(a)))
        cv2.line(image, pt1, pt2, (0, 0, 255), 2)
# 显示结果
cv2.imshow('Lines', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

3.2 概率霍夫变换 cv2.HoughLinesP

lines =cv2.HoughLinesP(image, rho, theta, threshold, minLineLength,
maxLineGap)
1
2

cv2.HoughLinesP()函数是Hough变换的改进版本，主要在直线检测算法上进行了改进和优化。
传统的Hough变换是基于参数空间的方法，需要遍历所有像素点和所有可能的直线参数来进行计算，计算量较大，效率较低。而cv2.HoughLinesP()函数采用了概率霍夫变换（Probabilistic Hough Transform）的方法，通过随机采样的方式来快速寻找直线。
概率霍夫变换通过随机选择一部分边缘点来计算直线方程，并根据这些点的相对位置进行线段的连接，而不是遍历整张图像的所有像素点。这种随机采样的方式能够大大减少计算量，提高直线检测的速度。
另外，cv2.HoughLinesP()函数还引入了两个新的参数：minLineLength和maxLineGap。minLineLength参数用于指定线段的最小长度，比这个长度短的线段将被舍弃。maxLineGap参数用于定义在同一行中被认为是一条线段的最大间隙。这两个参数的引入使得直线检测更加准确和灵活。

import cv2
import numpy as np
# 读取图像
image = cv2.imread("img8/testSobelimg.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# 进行边缘检测
edges = cv2.Canny(gray, 50, 150)
# 进行直线检测
lines = cv2.HoughLinesP(edges, 1, np.pi/180, 100, minLineLength=100, maxLineGap=10)
# 绘制检测到的直线
if lines is not None:
    for line in lines:
        x1, y1, x2, y2 = line[0]
        cv2.line(image, (x1, y1), (x2, y2), (0, 0, 255), 2)
# 显示图像
cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.3 霍夫圆环变换

cv2.HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius]]]]]) 
1

import cv2
import numpy as np

# 读取图像
image = cv2.imread('Pic/show.png', cv2.IMREAD_GRAYSCALE)

# 霍夫圆环变换参数设置
dp = 1  # 累加器分辨率与图像分辨率之比的倒数
minDist = 50  # 检测到的圆心之间的最小距离
param1 = 100  # Canny边缘检测阈值上限
param2 = 30  # 圆心累加器阈值
minRadius = 10  # 最小圆半径
maxRadius = 100  # 最大圆半径

# 进行霍夫圆环变换
circles = cv2.HoughCircles(image, cv2.HOUGH_GRADIENT, dp, minDist,
                           param1=param1, param2=param2,
                           minRadius=minRadius, maxRadius=maxRadius)

if circles is not None:
    circles_rounded = np.uint16(np.around(circles))

    for circle in circles_rounded[0, :]:
        center = (circle[0], circle[1])
        radius = circle[2]

        # 绘制圆和中心点
        cv2.circle(image, center, radius, (0, 255, 0), 3)
        cv2.circle(image, center, 3, (0, 0, 255), -1)

    # 显示结果图像
    cv2.imshow('Hough Circles', image)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

（1）当

（2）当

（3）