OpenCV傅立叶变换

对图像进行傅立叶变换

首先按列(或者按行)进行傅立叶变换，得到一个变换的矩阵，然后再对变换的矩阵按行(或者按列)进行傅立叶变换，从而每个像素点可以得到一个复数相对应。
具体的代码流程:
第一步将读入的图片转成傅立叶变换速度最快的大小。

Mat padded;
int m = getOptimalDFTSize(src.rows);
int n = getOptimalDFTSize(src.cols);
copyMakeBorder(src,padded,0,m - src.rows,0,n- src.cols,BORDER_CONSTANT,Scalar::all(0));

copyMakeBorder():主要用来对图片加边框。

copyMakeBorder(
				输入图片，
				输出图片，
				上部加多少个像素，
				下部。。。。，
				左部。。。。，
				右部。。。。，
				BORDER_CONSTANT，
				Scalar::all(0)
);

第二步定义一个两通道的Mat对象，存储dft变换的结果。

Mat planes[] = {Mat_<float>(padded),Mat::zeros(padded.size(),CV_32F)};
Mat complexI;
merge(planes,2,complexI);

merge():将一个二维的Mat数组合并为一个两通道的Mat对象。

merge(
	输入的数组，
	数组的大小，
	输出的多通道Mat
);

第三步进行傅立叶变换

dft(complexI,complexI);

傅立叶变换将变换的结果存储在complexI中，0通道存储实部，1通道存储虚部。
第四步取出变换的结果进行相应的处理

split(complexI,planes);
magnitude(planes[0],planes[1],planes[0]);
Mat magI = planes[0];

split():用来将多通道的Mat对象分为数组
magnitude():计算一个复数的模长

split(
	多通道的Mat对象，
	与通道数相同的数组
);
magnitude(
	输入的向量1-就是实部，
	输入的向量2-就是虚部，
	输出的向量-就是模长
);

最后将图片分为四部分重新拼组:

 	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 - Create a ROI per quadrant 
    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;                          
    q0.copyTo(tmp);
    q3.copyTo(q0);
    tmp.copyTo(q3);

    q1.copyTo(tmp);                    
    q2.copyTo(q1);
    tmp.copyTo(q2);

    normalize(magI, magI, 0, 1, CV_MINMAX);  

magI.rows&-2得到不大于magI.rows的最大偶数

完整的代码:

#include <ros/ros.h>
#include "opencv2/opencv.hpp"

using namespace  std;
using namespace cv;

int main(int argc,char** argv)
{
    Mat srv = imread("/home/dynamicw/Project/C++_Project/opencvtest/src/lesson01/source/icon.png",0);
    Mat src = Mat::ones(srv.size(),srv.type());
    for(int row = src.rows/2;row < src.rows-1;row++)
    {
        for(int col = 0;col < src.cols-1;col++)
        {
            // if(row < col)
                src.at<uchar>(row,col) = 255;
        }
    }
    int m  = getOptimalDFTSize(src.rows);//得到最佳的傅立叶变换的值
    int n = getOptimalDFTSize(src.cols);//同上
    cout << "m=" << m << endl;
    cout << "n=" << n << endl;
    Mat padded;
    copyMakeBorder(src,padded,0,m-src.rows,0,n-src.cols,BORDER_CONSTANT,Scalar::all(255));//为图片添加边框

    imshow("padded",padded);
    cout << "src size:" << src.size() << endl;
    cout << "padded size:" << padded.size() << endl;

    Mat planes[] = {Mat_<float>(padded),Mat::zeros(padded.size(),CV_32F)};//定义一个mat的数组
    Mat complexI;
    merge(planes,2,complexI);//将数组合并为一个两通道的mat对象
    dft(complexI,complexI);//对图像进行傅立叶变换，将变换的结果实部存储在第一个通道中，虚部存储在第二个通道中
    split(complexI,planes);//将两通道的Mat对象进行分离为一个二维数组
    magnitude(planes[0],planes[1],planes[0]);//求模长，将plane{0}的实部和plane{1}的虚部平方和再开方，并将结果存放在planes{0}中
    Mat magI = planes[0];//单独对模长构成的图像进行处理
    magI += Scalar::all(1);
    log(magI,magI);//M1 = log（M + 1）

    magI = magI(Rect(0,0,magI.cols&-2,magI.rows&-2));//mag.cols&-2得到小于mag.cols的最大偶数
    int cx = magI.cols/2;
    int cy = magI.rows/2;

    //将频率图分为四份
    Mat q0(magI,Rect(0,0,cx,cy));
    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);


    //标准化，将图片中的值序列化在相应的范围之内
    normalize(magI,magI,0,1,CV_MINMAX);
    imshow("src",src);
    imshow("sdf",magI);

    waitKey(0);
    return 0;
}