opencv - Fourier Transform 傅里叶变换

努力减肥的小胖子5

于 2024-09-30 15:16:56 发布

阅读量290

点赞数 19

分类专栏： opencv 文章标签： opencv

本文链接：https://blog.csdn.net/yuxing55555/article/details/139413434

版权

opencv 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

目标

在本节中，我们将学习

使用 OpenCV 查找图像的傅里叶变换
利用 Numpy 中可用的 FFT 函数
傅里叶变换的一些应用
我们将看到以下函数：cv.dft()、cv.idft() 等

理论

傅里叶变换用于分析各种滤波器的频率特性。对于图像，2D 离散傅里叶变换 (DFT) 用于查找频域。一种称为快速傅里叶变换 (FFT) 的快速算法用于计算 DFT。有关这些的详细信息可以在任何图像处理或信号处理教科书中找到。请参阅其他资源部分。

对于正弦信号 $\sin(2 \pi ft)$ ，我们可以说 f 是信号的频率，如果取其频域，我们可以在 f 处看到一个尖峰。如果对信号进行采样以形成离散信号，我们会得到相同的频域，但在 $\pi, \pi]$ 或 $[0,2\pi]$ （或 N 点 DFT 的 $[0, N]$ ）范围内具有周期性。您可以将图像视为在两个方向上采样的信号。因此，在 X 和 Y 方向上进行傅里叶变换可以得到图像的频率表示。

更直观地，对于正弦信号，如果幅度在短时间内变化如此之快，您可以说它是一个高频信号。如果它变化缓慢，它就是一个低频信号。您可以将同样的想法扩展到图像。图像中幅度在哪里急剧变化？在边缘点或噪声处。所以我们可以说，边缘和噪声是图像中的高频内容。如果幅度没有太大变化，它就是低频分量。

现在我们将看到如何找到傅里叶变换。

Numpy 中的傅里叶变换

首先，我们将了解如何使用 Numpy 查找傅里叶变换。Numpy 有一个 FFT 包可以执行此操作。np.fft.fft2() 为我们提供了频率变换，它将是一个复杂数组。它的第一个参数是输入图像，它是灰度的。第二个参数是可选的，它决定输出数组的大小。如果它大于输入图像的大小，则在计算 FFT 之前用零填充输入图像。如果它小于输入图像，则输入图像将被裁剪。如果没有传递参数，则输出数组大小将与输入相同。

现在，一旦您得到结果，零频率分量（DC 分量）将位于左上角。如果您想将其置于中心，则需要在两个方向上将结果移动 $\frac{N}{2}$ 。这只需通过函数 np.fft.fftshift() 即可完成。（它更容易分析）。一旦找到频率变换，就可以找到幅度谱。

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

img = cv.imread('messi5.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('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

结果如下所示：
在这里插入图片描述

看，您可以看到中心有更多白色区域，表明低频内容更多。

所以您找到了频率变换现在您可以在频域中执行一些操作，例如高通滤波和重建图像，即找到逆 DFT。为此，您只需使用大小为 60x60 的矩形窗口进行掩蔽即可去除低频。然后使用 np.fft.ifftshift() 应用逆移位，以便 DC 分量再次出现在左上角。然后使用 np.ifft2() 函数找到逆 FFT。结果再次是一个复数。您可以取其绝对值。

rows, cols = img.shape
crow,ccol = rows//2 , cols//2
fshift[crow-30:crow+31, ccol-30:ccol+31] = 0
f_ishift = np.fft.ifftshift(fshift)
img_back = np.fft.ifft2(f_ishift)
img_back = np.real(img_back)

plt.subplot(131),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(132),plt.imshow(img_back, cmap = 'gray')
plt.title('Image after HPF'), plt.xticks([]), plt.yticks([])
plt.subplot(133),plt.imshow(img_back)
plt.title('Result in JET'), plt.xticks([]), plt.yticks([])

plt.show()

结果如下所示：
在这里插入图片描述

结果表明高通滤波是一种边缘检测操作。这就是我们在“图像梯度”一章中看到的。这也表明大多数图像数据存在于频谱的低频区域。无论如何，我们已经了解了如何在 Numpy 中查找 DFT、IDFT 等。现在让我们看看如何在 OpenCV 中做到这一点。

如果您仔细观察结果，尤其是最后一张 JET 颜色的图像，您会看到一些伪影（我用红色箭头标记了一个实例）。它显示了一些类似波纹的结构，这被称为振铃效应。这是由我们用于掩蔽的矩形窗口引起的。此掩码转换为 sinc 形状，从而导致此问题。因此，矩形窗口不用于过滤。更好的选择是高斯窗口。

OpenCV 中的傅里叶变换

OpenCV 为此提供了 cv.dft() 和 cv.idft() 函数。它返回的结果与上一个相同，但有两个通道。第一个通道将具有结果的实部，第二个通道将具有结果的虚部。首先应将输入图像转换为 np.float32。我们将了解如何执行此操作。

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

img = cv.imread('messi5.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('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

注意: 您还可以使用 cv.cartToPolar()，它可以一次性返回幅度和相位

因此，现在我们必须进行逆 DFT。在上一节中，我们创建了一个 HPF，这次我们将了解如何去除图像中的高频内容，即我们将 LPF 应用于图像。它实际上会使图像模糊。为此，我们首先创建一个掩码，在低频处具有高值 (1)，即我们传递 LF 内容，在 HF 区域为 0。

rows, cols = img.shape
crow,ccol = rows/2 , cols/2
# 首先创建一个掩码，中心方块为 1，其余全部为零
mask = np.zeros((rows,cols,2),np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1
# 应用掩码并进行逆 DFT
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('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()

查看结果：

在这里插入图片描述

注意: 与往常一样，OpenCV 函数 cv.dft() 和 cv.idft() 比 Numpy 函数更快。但 Numpy 函数更易于使用。有关性能问题的更多详细信息，请参阅以下部分。

DFT 的性能优化

DFT 计算的性能在某些数组大小下会更好。当数组大小为 2 的幂时，速度最快。大小为 2、3 和 5 的乘积的数组也能得到相当高效的处理。因此，如果您担心代码的性能，可以在找到 DFT 之前将数组的大小修改为任何最佳大小（通过填充零）。对于 OpenCV，您必须手动填充零。但对于 Numpy，您可以指定 FFT 计算的新大小，它会自动为您填充零。

那么我们如何找到这个最佳大小？OpenCV 为此提供了一个函数 cv.getOptimalDFTSize()。它适用于 cv.dft() 和 np.fft.fft2()。让我们使用 IPython 魔法命令 %timeit 检查它们的性能。

In [16]: img = cv.imread('messi5.jpg',0)
In [17]: rows,cols = img.shape
In [18]: print("{} {}".format(rows,cols))
342 548

In [19]: nrows = cv.getOptimalDFTSize(rows)
In [20]: ncols = cv.getOptimalDFTSize(cols)
In [21]: print("{} {}".format(nrows,ncols))
360 576

看到，大小 (342,548) 被修改为 (360, 576)。现在让我们用零填充它（对于 OpenCV）并找到它们的 DFT 计算性能。您可以通过创建一个新的大零数组并将数据复制到其中来完成此操作，或者使用 cv.copyMakeBorder()。

nimg = np.zeros((nrows,ncols))
nimg[:rows,:cols] = img

# or

right = ncols - cols
bottom = nrows - rows
bordertype = cv.BORDER_CONSTANT #just to avoid line breakup in PDF file
nimg = cv.copyMakeBorder(img,0,bottom,0,right,bordertype, value = 0)

现在我们计算 Numpy 函数的 DFT 性能比较：

In [22]: %timeit fft1 = np.fft.fft2(img)
10 loops, best of 3: 40.9 ms per loop
In [23]: %timeit fft2 = np.fft.fft2(img,[nrows,ncols])
100 loops, best of 3: 10.4 ms per loop

它显示速度提高了 4 倍。现在我们将对 OpenCV 函数进行相同的尝试。

In [24]: %timeit dft1= cv.dft(np.float32(img),flags=cv.DFT_COMPLEX_OUTPUT)
100 loops, best of 3: 13.5 ms per loop
In [27]: %timeit dft2= cv.dft(np.float32(nimg),flags=cv.DFT_COMPLEX_OUTPUT)
100 loops, best of 3: 3.11 ms per loop

它还显示速度提高了 4 倍。您还可以看到 OpenCV 函数比 Numpy 函数快大约 3 倍。

为什么拉普拉斯算子是高通滤波器？

论坛中提出了类似的问题。问题是，为什么拉普拉斯算子是高通滤波器？为什么Sobel是 HPF？等等。对此给出的第一个答案是从傅里叶变换的角度。只需对拉普拉斯算子的傅里叶变换进行更高尺寸的 FFT 即可。分析它：

import cv2 as cv
import numpy as np
from matplotlib import pyplot as plt
# 没有缩放参数的简单平均滤波器
mean_filter = np.ones((3,3))
# 创建高斯滤波器
x = cv.getGaussianKernel(5,10)
gaussian = x*x.T
# 不同的边缘检测滤波器
# x 方向上的 scharr
scharr = np.array([[-3, 0, 3],
                   [-10,0,10],
                   [-3, 0, 3]])

# x 方向上的 sobel
sobel_x= np.array([[-1, 0, 1],
                   [-2, 0, 2],
                   [-1, 0, 1]])

# y 方向上的 sobel
sobel_y= np.array([[-1,-2,-1],
                   [0, 0, 0],
                   [1, 2, 1]])

# 拉普拉斯算子
laplacian=np.array([[0, 1, 0],
                    [1,-4, 1],
                    [0, 1, 0]])

filters = [mean_filter, gaussian, laplacian, sobel_x, sobel_y, scharr]
filter_name = ['mean_filter', 'gaussian','laplacian', 'sobel_x', \
                'sobel_y', 'scharr_x']
fft_filters = [np.fft.fft2(x) for x in filters]
fft_shift = [np.fft.fftshift(y) for y in fft_filters]
mag_spectrum = [np.log(np.abs(z)+1) for z in fft_shift]

for i in range(6):
    plt.subplot(2,3,i+1),plt.imshow(mag_spectrum[i],cmap = 'gray')
    plt.title(filter_name[i]), plt.xticks([]), plt.yticks([])

plt.show()