4.2 傅里叶变换

4.2.1 图像掩码操作

filter2D函数：计算图像卷积

////////https://blog.csdn.net/qq_34784753/article/details/60144935
#include "stdafx.h"

#include <iostream>
#include <opencv2corecore.hpp>
#include <opencv2highguihighgui.hpp>
#include <opencv2imgprocimgproc.hpp>

using namespace std;
using namespace cv;

Mat Myfilter2D(Mat srcImage);
Mat filter2D_(Mat srcImage);

int main()
{
    Mat srcImage = imread("D:\大海.jpg");
    if (!srcImage.data)
    {
        cout << "读入图片失败" << endl;
        return -1;
    }
    Mat srcGray;
    cvtColor(srcImage, srcGray, CV_BGR2GRAY);
    imshow("srcGray", srcGray);
    Mat resultImage = Myfilter2D(srcGray);
    imshow("resultImage1", resultImage);
    resultImage = filter2D_(srcGray);
    imshow("resultImage2", resultImage);
    waitKey();
    return 0;
}

//基于像素邻域的掩码操作
Mat Myfilter2D(Mat srcImage)
{
    const int nChannels = srcImage.channels();
    Mat resultImage(srcImage.size(), srcImage.type());
    for (int j = 1; j < srcImage.rows - 1; j++)
    {
        //获取邻域指针
        const uchar* previous = srcImage.ptr<uchar>(j - 1);
        const uchar* current = srcImage.ptr<uchar>(j);
        const uchar* next = srcImage.ptr<uchar>(j + 1);
        uchar * output = resultImage.ptr<uchar>(j);
        for (int i = nChannels; i < nChannels*(srcImage.cols - 1); ++i)
        {
            //进行4-邻域掩码操作
            *output++ = saturate_cast<uchar>(current[i - nChannels] + current[i + nChannels]
                + previous[i] + next[i]) / 4;
        }
    }

    //进行边界处理
    resultImage.row(0).setTo(Scalar(0));
    resultImage.row(resultImage.rows - 1).setTo(Scalar(0));
    resultImage.col(0).setTo(Scalar(0));
    resultImage.col(resultImage.cols - 1).setTo(Scalar(0));
    return resultImage;
}

//使用自带掩码库进行操作
Mat filter2D_(Mat srcImage)
{
    Mat resultImage(srcImage.size(), srcImage.type());
    //构造核函数因子
    Mat kern = (Mat_<float>(3, 3) << 0, 1, 0,
        1, 0, 1,
        0, 1, 0) / (float)(4);
    filter2D(srcImage, resultImage, srcImage.depth(), kern);
    return resultImage;
}

4.2.2 离散傅里叶

///////https://blog.csdn.net/keith_bb/article/details/53389819
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

using namespace std;
using namespace cv;

int main()
{
    Mat I = imread("D:\lena.jpg", IMREAD_GRAYSCALE);       //读入图像灰度图

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

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

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

    Mat planes[] = { Mat_<float>(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("输入图像", I);
    imshow("频谱图", magI);
    waitKey(0);


    return 0;
}

4.2.3 图像卷积

////////https://blog.csdn.net/keith_bb/article/details/53103026
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>

using namespace std;
using namespace cv;

int main()
{
    Mat srcImage = imread("D:\彩色lena.jpg");

    //判断图像是否加载成功
    if (srcImage.data)
        cout << "图像加载成功!" << endl << endl;
    else
    {
        cout << "图像加载失败!" << endl << endl;
        return -1;
    }
    namedWindow("srcImage", WINDOW_AUTOSIZE);
    imshow("srcImage", srcImage);

    Mat kern = (Mat_<char>(3, 3) << 0, -1, 0,
        -1, 5, -1,
        0, -1, 0);
    Mat dstImage;
    filter2D(srcImage, dstImage, srcImage.depth(), kern);
    namedWindow("dstImage", WINDOW_AUTOSIZE);
    imshow("dstImage", dstImage);


    waitKey(0);

    return 0;
}

拓展：

https://blog.csdn.net/qq_32864683/article/details/79748027

https://blog.csdn.net/chaipp0607/article/details/72236892?locationNum=9&fps=1