（2）DFT和FFT原理与实现

目录

---

1、图像变换
2、离散傅里叶变换（Discrete Fourier Transform）
3、DFT性质
4、DFT与数字图像处理
5、FFT-快速傅里叶变换
6、DFT与FFT的算法实现

---

1. 图像变换

— —数学领域中有很多种变换，如傅里叶变换、拉普拉斯变换、Z变换等。但是这些数学变换的用途大致相同，即利用某种变换使得遇到的问题更方便的观测或解决。数字图像处理技术（Digital Image Processing）是一门应用学科，它是建立在一定的数学理论基础之上的科学，因此，在解决数字图像处理的具体问题时，作为解决方案或技巧，就必须要用到各种数学变换，称为图像变换。

– 在数字图像处理中，图像增强、图像复原、图像编码和压缩、图像分析与描述等每一种处理手段和方法都要用到图像变换，例如：在对图像进行去噪或锐化操作时，low-pass filter、high-pass filter 可以借助傅里叶变换把要在空间域中解决的卷积运算问题转换并映射到频率域中的乘积运算。

2. 离散傅里叶变换（DFT）

回顾：连续信号的傅里叶变换

2.1 一维离散傅里叶变换

为了在计算机上实现傅里叶变换计算，必须把连续函数离散化，离散函数的额傅里叶变换称为离散傅里叶变换。

连续信号离散化过程如下：

• 建立连续时间信号x(t)
• 设定采样间隔△t
• 对连续信号做时域等间隔采样，得到离散序列x(k△t), (k=0,1,2,N-1)
• 可得到有N个元素的离散函数序列x(n)

因此，一维离散傅里叶变换(DFT)和一维离散傅里叶反变换
（Inverse DFT）可表示为：

一维离散傅里叶变换具有周期性，证明如下：

欧拉方程（Euler theorem）：

2.2 二维离散傅里叶变换

对于一个具有MxN尺度的二维离散函数f(x,y), （x=0，1，2,M-1; y=0,1,2,N-1）,其离散傅里叶变换为：

在运用计算机进行二维离散傅里叶变换时，可先对每一行或者每一列进行一维的离散傅里叶变换，然后对上一步的计算结果再进行列或者行的一维离散傅里叶变换，即可得到二维的离散傅里叶变换结果。具体步骤如下图所示：

3. DFT Properties

二维离散傅里叶变换具有许多数字图像处理中非常实用的性质，主要包括：可分离性、平移性、线性特性、比例特性、周期性和共轭对称性、微分特性、旋转特性等。
3-1. 可分离性
由二维傅里叶变换不难看出可以把变换方程写成如下形式：

这个性质称为二维傅里叶变换的可分离性，利用这个性质，可以通过进行两次一维离散傅里叶变换（或反变换）来实现一个二维傅里叶变换（反变换）。以正变换为例，具体算法步骤如下：

3-2. 平移性

这一性质表明，当用exp[j2π(ux/M+vy/N)]乘以f(x,y),求乘积的傅里叶变换，可以使得空间频率域u-v平面坐标原点从（0，0）平移到（u，v）的位置。同样，当用exp[-j2π(ux/M+vy/N)]乘以F(x,y),并求此乘积的离散傅里叶反变换，可以使空间x-y平面坐标系的原点从(0，0)平移到（x，y）的位置。

3-3. 线性特性

如果二维离散函数f1（x，y）和f2（x，y）的傅里叶变换分别为F1（x，y）和F1（x，y），则存在以下线性特性。
f1（x，y）+ f2（x，y）<=>F1（x，y）+ F1（x，y）
这一性质可使得我们节约求傅里叶变换的时间，如果已经得到了F1（x，y）和F1（x，y），则f1（x，y）+ f2（x，y）的傅里叶变换结果只需将F1（x，y）和F1（x，y）相加求和即可。

需要注意的是，如果在显示器上显示|F1（x，y）+ F1（x，y）|的结果，则往往由于其最大值超过了数字图像处理设备所允许的最大灰度造成信息丢失现象。因此，在显示|F1（x，y）+ F1（x，y）|的结果时应先检查其最大值，若超过了设备所允许的最大灰度值，则应当先做线性对比度压缩处理。

3-4. 比例特性

3-5. 周期性和共轭对称性

从二维离散傅里叶变换对的表达式可以看出，离散傅里叶变换和它的反变换具有周期性，即：

3- 6. 旋转特性

二维傅里叶变换具有如下旋转特性：

f(r,a+b) <=> F(w,φ+φ0)
该性质表明，如果f（x，y）在空间域旋转一个角度a，则对应的傅里叶变换也在频率域旋转同样的角度。反之，亦然。

3-7. 微分特性


在模式识别技术中，经常用到Laplace算子。

3- 8. 平均值特性

4. DFT与数字图像处理

接下来用Lena.jpg标准图来做二维傅里叶变换：
Mac OS 下使用OpenCV和C++集成开发环境做傅里叶变换
代码如下：

//
//  dft_t.cpp
//  OpenCV_demo1
//
//  Created by Hao Wang on 2018/11/2.
//  Copyright © 2018年 Hao Wang. All rights reserved.
//

#include 
#include 
#include 
#include 

using namespace std;
using namespace cv;


int main()
{
    Mat Im_read = imread("/Users/haowang/Desktop/Workspace_C++/Opencv_demo/OpenCV_demo1/Standard Pictures/Lena.jpg", IMREAD_GRAYSCALE);       //读入图像灰度图

    //判断图像是否加载成功
    if (Im_read.empty())
    {
        cout << "图像加载失败!" << endl;
        return -1;    // read error,return -1
    }
    else
        cout << "图像加载成功!"  << endl;

    Mat padded;                 //以0填充输入图像矩阵
    int m = getOptimalDFTSize(Im_read.rows);
    int n = getOptimalDFTSize(Im_read.cols);

    //填充输入图像I，输入矩阵为padded，上方和左方不做填充处理
    copyMakeBorder(Im_read, padded, 0, m - Im_read.rows, 0, n - Im_read.cols, BORDER_CONSTANT, Scalar::all(0));

    Mat planes[] = { Mat_(padded), Mat::zeros(padded.size(),CV_32F) };
    Mat complexI;
    merge(planes, 2, complexI);     //将planes融合合并成一个多通道数组complexI

    dft(complexI, complexI);        //进行傅里叶变换

    //计算幅值，转换到对数尺度(logarithmic scale)
    //=> log(1 + sqrt(Re(DFT(I))^2 + Im(DFT(I))^2))
    split(complexI, planes);        //planes[0] = Re(DFT(I),planes[1] = Im(DFT(I))
    //即planes[0]为实部,planes[1]为虚部
    magnitude(planes[0], planes[1], planes[0]);     //planes[0] = magnitude
    Mat magI = planes[0];

    magI += Scalar::all(1);
    log(magI, magI);                //转换到对数尺度(logarithmic scale)

    //如果有奇数行或列，则对频谱进行裁剪
    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));       //左上角图像划定ROI区域
    Mat q1(magI, Rect(cx, 0, cx, cy));      //右上角图像
    Mat q2(magI, Rect(0, cy, cx, cy));      //左下角图像
    Mat q3(magI, Rect(cx, cy, cx, cy));     //右下角图像

    //变换左上角和右下角象限
    Mat tmp;
    q0.copyTo(tmp);
    q3.copyTo(q0);
    tmp.copyTo(q3);

    //变换右上角和左下角象限
    q1.copyTo(tmp);
    q2.copyTo(q1);
    tmp.copyTo(q2);

    //归一化处理，用0-1之间的浮点数将矩阵变换为可视的图像格式
    normalize(magI, magI, 0, 1, CV_MINMAX);

    imshow("输入图像", Im_read);
    imshow("频谱图", magI);
    waitKey(0);
    return 0;

}

计算后得到Lena图的傅里叶变换结果如下：

5. FFT算法实现

5.1 一维离散傅里叶变换MATLAB实现

%FFT Discrete Fourier transform.
%   FFT(X) is the discrete Fourier transform (DFT) of vector X.  For
%   matrices, the FFT operation is applied to each column. For N-D
%   arrays, the FFT operation operates on the first non-singleton
%   dimension.
%
%   FFT(X,N) is the N-point FFT, padded with zeros if X has less
%   than N points and truncated if it has more.
%
%   FFT(X,[],DIM) or FFT(X,N,DIM) applies the FFT operation across the
%   dimension DIM.
%   
%   For length N input vector x, the DFT is a length N vector X,
%   with elements
%                    N
%      X(k) =       sum  x(n)*exp(-j*2*pi*(k-1)*(n-1)/N), 1 <= k <= N.
%                   n=1
%   The inverse DFT (computed by IFFT) is given by
%                    N
%      x(n) = (1/N) sum  X(k)*exp( j*2*pi*(k-1)*(n-1)/N), 1 <= n <= N.
%                   k=1
%
%   See also FFT2, FFTN, FFTSHIFT, FFTW, IFFT, IFFT2, IFFTN.

%   Copyright 1984-2005 The MathWorks, Inc.

%   Built-in function.

5.2 二维离散傅里叶变换MATLAB实现

function f = fft2(x, mrows, ncols)
%FFT2 Two-dimensional discrete Fourier Transform.
%   FFT2(X) returns the two-dimensional Fourier transform of matrix X.
%   If X is a vector, the result will have the same orientation.
%
%   FFT2(X,MROWS,NCOLS) pads matrix X with zeros to size MROWS-by-NCOLS
%   before transforming.
%
%   Class support for input X: 
%      float: double, single
%
%   See also FFT, FFTN, FFTSHIFT, FFTW, IFFT, IFFT2, IFFTN.

%   Copyright 1984-2010 The MathWorks, Inc. 

if ismatrix(x)
    if nargin==1
        f = fftn(x);
    else
        f = fftn(x,[mrows ncols]);
    end
else
    if nargin==1
        f = fft(fft(x,[],2),[],1);
    else
        f = fft(fft(x,ncols,2),mrows,1);
    end
end   

5.3 OpenCV（C++）实现

#include 
#include 
#include 
 
// Rearrange the quadrants of Fourier image so that the origin is at
// the image center
// src & dst arrays of equal size & type
void cvShiftDFT(CvArr * src_arr, CvArr * dst_arr )
{
    CvMat * tmp;
    CvMat q1stub, q2stub;
    CvMat q3stub, q4stub;
    CvMat d1stub, d2stub;
    CvMat d3stub, d4stub;
    CvMat * q1, * q2, * q3, * q4;
    CvMat * d1, * d2, * d3, * d4;
 
    CvSize size = cvGetSize(src_arr);
    CvSize dst_size = cvGetSize(dst_arr);
    int cx, cy;
 
    if(dst_size.width != size.width || 
       dst_size.height != size.height){
        cvError( CV_StsUnmatchedSizes, "cvShiftDFT", "Source and Destination arrays must have equal sizes", __FILE__, __LINE__ );   
    }
 
    if(src_arr==dst_arr){
        tmp = cvCreateMat(size.height/2, size.width/2, cvGetElemType(src_arr));
    }
 
    cx = size.width/2;
    cy = size.height/2; // image center
 
    q1 = cvGetSubRect( src_arr, &q1stub, cvRect(0,0,cx, cy) );
    q2 = cvGetSubRect( src_arr, &q2stub, cvRect(cx,0,cx,cy) );
    q3 = cvGetSubRect( src_arr, &q3stub, cvRect(cx,cy,cx,cy) );
    q4 = cvGetSubRect( src_arr, &q4stub, cvRect(0,cy,cx,cy) );
    d1 = cvGetSubRect( dst_arr, &d1stub, cvRect(0,0,cx,cy) );
    d2 = cvGetSubRect( dst_arr, &d2stub, cvRect(cx,0,cx,cy) );
    d3 = cvGetSubRect( dst_arr, &d3stub, cvRect(cx,cy,cx,cy) );
    d4 = cvGetSubRect( dst_arr, &d4stub, cvRect(0,cy,cx,cy) );
 
    if(src_arr!=dst_arr){
        if( !CV_ARE_TYPES_EQ( q1, d1 )){
            cvError( CV_StsUnmatchedFormats, "cvShiftDFT", "Source and Destination arrays must have the same format", __FILE__, __LINE__ ); 
        }
        cvCopy(q3, d1, 0);
        cvCopy(q4, d2, 0);
        cvCopy(q1, d3, 0);
        cvCopy(q2, d4, 0);
    }
    else{
        cvCopy(q3, tmp, 0);
        cvCopy(q1, q3, 0);
        cvCopy(tmp, q1, 0);
        cvCopy(q4, tmp, 0);
        cvCopy(q2, q4, 0);
        cvCopy(tmp, q2, 0);
    }
}
 
int main(int argc, char ** argv)
{
    const char* filename = argc >=2 ? argv[1] : "lena.jpg";
    IplImage * im;
 
    IplImage * realInput;
    IplImage * imaginaryInput;
    IplImage * complexInput;
    int dft_M, dft_N;
    CvMat* dft_A, tmp;
    IplImage * image_Re;
    IplImage * image_Im;
    double m, M;
 
    im = cvLoadImage( filename, CV_LOAD_IMAGE_GRAYSCALE );
    if( !im )
        return -1;
 
    realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
    imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
    complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);
 
    cvScale(im, realInput, 1.0, 0.0);
    cvZero(imaginaryInput);
    cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
 
    dft_M = cvGetOptimalDFTSize( im->height - 1 );
    dft_N = cvGetOptimalDFTSize( im->width - 1 );
 
    dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 );
    image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
    image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
 
    // copy A to dft_A and pad dft_A with zeros
    cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
    cvCopy( complexInput, &tmp, NULL );
    if( dft_A->cols > im->width )
    {
        cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
        cvZero( &tmp );
    }
 
    // no need to pad bottom part of dft_A with zeros because of
    // use nonzero_rows parameter in cvDFT() call below
 
    cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );
 
    cvNamedWindow("win", 0);
    cvNamedWindow("magnitude", 0);
    cvShowImage("win", im);
 
    // Split Fourier in real and imaginary parts
    cvSplit( dft_A, image_Re, image_Im, 0, 0 );
 
    // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
    cvPow( image_Re, image_Re, 2.0);
    cvPow( image_Im, image_Im, 2.0);
    cvAdd( image_Re, image_Im, image_Re, NULL);
    cvPow( image_Re, image_Re, 0.5 );
 
    // Compute log(1 + Mag)
    cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
    cvLog( image_Re, image_Re ); // log(1 + Mag)
 
 
    // Rearrange the quadrants of Fourier image so that the origin is at
    // the image center
    cvShiftDFT( image_Re, image_Re );
 
    cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
    cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));
    cvShowImage("magnitude", image_Re);
 
    cvWaitKey(-1);
    return 0;
}