离散傅里叶_离散傅立叶变换原理-优快云博客

本文链接：https://blog.youkuaiyun.com/linqianbi/article/details/78680519

本文详细介绍了一张图像经过傅立叶变换的过程，包括图像预处理、离散傅立叶变换、幅度图像计算及对数尺度缩放等关键步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原理：

对一张图像使用傅立叶变换就是将它分解成正弦和余弦两部分。也就是将图像从空间域(spatial domain)转换到频域(frequency domain)。这一转换的理论基础来自于以下事实：任一函数都可以表示成无数个正弦和余弦函数的和的形式。傅立叶变换就是一个用来将函数分解的工具。 2维图像的傅立叶变换可以用以下数学公式表达:

$F(k,l) = \displaystyle\sum\limits_{i=0}^{N-1}\sum\limits_{j=0}^{N-1} f(i,j)e^{-i2\pi(\frac{ki}{N}+\frac{lj}{N})}e^{ix} = \cos{x} + i\sin {x}$

式中 f 是空间域(spatial domain)值， F 则是频域(frequency domain)值。转换之后的频域值是复数，因此，显示傅立叶变换之后的结果需要使用实数图像(real image) 加虚数图像(complex image), 或者幅度图像(magitude image)加相位图像(phase image)。在实际的图像处理过程中，仅仅使用了幅度图像，因为幅度图像包含了原图像的几乎所有我们需要的几何信息。然而，如果你想通过修改幅度图像或者相位图像的方法来间接修改原空间图像，你需要使用逆傅立叶变换得到修改后的空间图像，这样你就必须同时保留幅度图像和相位图像了。

在此示例中，我将展示如何计算以及显示傅立叶变换后的幅度图像。由于数字图像的离散性，像素值的取值范围也是有限的。比如在一张灰度图像中，像素灰度值一般在0到255之间。因此，我们这里讨论的也仅仅是离散傅立叶变换(DFT)。如果你需要得到图像中的几何结构信息，那你就要用到它了。请参考以下步骤(假设输入图像为单通道的灰度图像 I):

将图像延扩到最佳尺寸. 离散傅立叶变换的运行速度与图片的尺寸息息相关。当图像的尺寸是2， 3，5的整数倍时，计算速度最快。因此，为了达到快速计算的目的，经常通过添凑新的边缘像素的方法获取最佳图像尺寸。函数 getOptimalDFTSize() 返回最佳尺寸，而函数 copyMakeBorder() 填充边缘像素:
```
Mat padded;                            //将输入图像延扩到最佳的尺寸
int m = getOptimalDFTSize( I.rows );
int n = getOptimalDFTSize( I.cols ); // 在边缘添加0
copyMakeBorder(I, padded, 0, m - I.rows, 0, n - I.cols, BORDER_CONSTANT, Scalar::all(0));
```
添加的像素初始化为0.
为傅立叶变换的结果(实部和虚部)分配存储空间. 傅立叶变换的结果是复数，这就是说对于每个原图像值，结果是两个图像值。此外，频域值范围远远超过空间值范围，因此至少要将频域储存在 float 格式中。结果我们将输入图像转换成浮点类型，并多加一个额外通道来储存复数部分：
```
Mat planes[] = {Mat_<float>(padded), Mat::zeros(padded.size(), CV_32F)};
Mat complexI;
merge(planes, 2, complexI);         // 为延扩后的图像增添一个初始化为0的通道
```

进行离散傅立叶变换. 支持图像原地计算 (输入输出为同一图像):

 
    dft(complexI, complexI);            // 变换结果很好的保存在原始矩阵中

将复数转换为幅度.复数包含实数部分(Re)和复数部分 (imaginary - Im)。离散傅立叶变换的结果是复数，对应的幅度可以表示为:

$M = \sqrt[2]{ {Re(DFT(I))}^2 + {Im(DFT(I))}^2}$

转化为OpenCV代码:

 
      split(complexI, planes);                   // planes[0] = Re(DFT(I), planes[1] = Im(DFT(I))
magnitude(planes[0], planes[1], planes[0]);// planes[0] = magnitude
Mat magI = planes[0];

对数尺度(logarithmic scale)缩放. 傅立叶变换的幅度值范围大到不适合在屏幕上显示。高值在屏幕上显示为白点，而低值为黑点，高低值的变化无法有效分辨。为了在屏幕上凸显出高低变化的连续性，我们可以用对数尺度来替换线性尺度:

$M_1 = \log{(1 + M)}$

转化为OpenCV代码:
```
magI += Scalar::all(1);                    // 转换到对数尺度
log(magI, magI);
```

剪切和重分布幅度图象限. 还记得我们在第一步时延扩了图像吗? 那现在是时候将新添加的像素剔除了。为了方便显示，我们也可以重新分布幅度图象限位置(注：将第五步得到的幅度图从中间划开得到四张1/4子图像，将每张子图像看成幅度图的一个象限，重新分布即将四个角点重叠到图片中心)。这样的话原点(0,0)就位移到图像中心。

 
    magI = magI(Rect(0, 0, magI.cols & -2, magI.rows & -2));
int cx = magI.cols/2;
int cy = magI.rows/2;

Mat q0(magI, Rect(0, 0, cx, cy));   // Top-Left - 为每一个象限创建ROI
Mat q1(magI, Rect(cx, 0, cx, cy));  // Top-Right
Mat q2(magI, Rect(0, cy, cx, cy));  // Bottom-Left
Mat q3(magI, Rect(cx, cy, cx, cy)); // Bottom-Right

Mat tmp;                           // 交换象限 (Top-Left with Bottom-Right)
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);

q1.copyTo(tmp);                    // 交换象限 (Top-Right with Bottom-Left)
q2.copyTo(q1);
tmp.copyTo(q2);
 
   

归一化. 这一步的目的仍然是为了显示。现在我们有了重分布后的幅度图，但是幅度值仍然超过可显示范围[0,1] 。我们使用 normalize() 函数将幅度归一化到可显示范围。

 
    normalize(magI, magI, 0, 1, CV_MINMAX); // 将float类型的矩阵转换到可显示图像范围
                                        // (float [0， 1]).

完整的代码如下：

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <iostream>
using namespace cv;
Mat DFT(Mat srcImage)
{
	//1.转换位灰度图
	Mat srcGray;
	cvtColor(srcImage, srcGray, CV_BGR2GRAY);
	
	//2.将输入图像延扩到最佳的尺寸，边界用0填充
	int nRows = getOptimalDFTSize(srcGray.rows);
	int nCols = getOptimalDFTSize(srcGray.cols);
	
	Mat padded;
	//BORDER_CONSTANT是填充是常数的意思，填充的数是后面的0
	copyMakeBorder(srcGray, padded, 0, nRows - srcGray.rows, 0, nCols - srcGray.cols, BORDER_CONSTANT, Scalar::all(0));

	//3.为傅里叶变换的结果（实部与虚部）分别存储空间
	Mat planes[] = { Mat_<float>(padded),Mat::zeros(padded.size(),CV_32F) };
	Mat complexI;
	//将planes数组组合合并成一个多通道的数组complexI
	merge(planes, 2, complexI);//将两个数组合并成一个多通道的数组

	//4.进行离散傅里叶变换
	dft(complexI, complexI);
	//5.将复数转化为幅值
	// planes[0] = Re(DFT(I), planes[1] = Im(DFT(I)
	split(complexI, planes);//将多通道数组complexI分解为几个单通道的数组
	//magnitude(x,y,dst);dst=sqrt(x(I)^2+y(I)^2);
	magnitude(planes[0], planes[1], planes[0]);
	Mat magnitudeImage = planes[0];//傅里叶变换的幅值矩阵
	//6.进行对数尺度缩放
	magnitudeImage += Scalar::all(1);//对幅值都加1
	log(magnitudeImage, magnitudeImage);
	//7.剪切与重分布幅度图象限
	//若有奇数行或者奇数列，进行频谱裁剪
	magnitudeImage = magnitudeImage(Rect(0, 0, magnitudeImage.cols & -2, magnitudeImage.rows & -2));
	//重新排列傅里叶图像中的象限，使得原点位于图像中心
	int cx = magnitudeImage.cols / 2;
	int cy = magnitudeImage.rows / 2;
	Mat q0(magnitudeImage, Rect(0, 0, cx, cy));//ROI区域的左上
	Mat q1(magnitudeImage, Rect(cx, 0, cx, cy));//ROI区域的右上
	Mat q2(magnitudeImage, Rect(0, cy, cx, cy));//ROI区域的左下
	Mat q3(magnitudeImage, Rect(cx, cy, cx, cy));//ROI区域的右上

	//交换象限（左上与右下进行交换）
	Mat temp;
	q0.copyTo(temp);
	q3.copyTo(q0);
	temp.copyTo(q3);
	//交换象限（右上与左下进行交换）
	q1.copyTo(temp);
	q2.copyTo(q1);
	temp.copyTo(q2);
	//8.归一化，用0到1之间的浮点值将矩阵变换为可视的图像格式
	normalize(magnitudeImage, magnitudeImage, 0, 1, CV_MINMAX);
	return magnitudeImage;

}
int main()
{
	Mat srcImage = imread("text.jpg");
	if (!srcImage.data)
	{
		printf("could not load image...\n");
		return -1;
	}
	imshow("srcImage", srcImage);
	Mat resultImage = DFT(srcImage);
	imshow("res", resultImage);
	waitKey(0);
	return 0;

}

原图的灰度图：