二维数组、图像的傅里叶变换（附加反变换与滤波算法）

最新推荐文章于 2022-07-02 20:02:17 发布
最新推荐文章于 2022-07-02 20:02:17 发布
阅读量3.1k 收藏 20
点赞数 2
分类专栏： C++-算法 FFT 2D-FFT 文章标签： 算法 图像处理 二维傅里叶变化c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michael_June/article/details/70880664
版权
C++-算法 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
FFT
2 篇文章 0 订阅
订阅专栏
2D-FFT
2 篇文章 1 订阅
订阅专栏

FFT算法原理就不解释了，可以搜索一下百度即可。
在二维变换中，需要对矩阵进行一行一行，一列一列的FFT变换，具体公式为：
F(u,v)=sum(i=0->M-1)sum(j=0->N-1)f(i, j) * exp(-j2πui/M-j*2πvj/N)
也就可以表示为：F(u,v)=sum(i=0->M-1) * exp(-j*2πu*i*/M) * sum(j=0->N-1)f(i, j) * exp(-j*2πv*j/N)
剩下的就是两个for循环了，具体阅读代码吧。

#include "iostream"
#include <stdlib.h>
#include <math.h>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#define SIZE 256
#define VALUE_MAX 256
using namespace std;

/***************复数运算*****************/
typedef struct Complex{
    float real;
    float imagin;
};
//定义复数计算，包括乘法，加法，减法
void Add_Complex(Complex * src1,Complex *src2,Complex *dst){
    dst->imagin=src1->imagin+src2->imagin;
    dst->real=src1->real+src2->real;
}
void Sub_Complex(Complex * src1,Complex *src2,Complex *dst){
    dst->imagin=src1->imagin-src2->imagin;
    dst->real=src1->real-src2->real;
}
void Multy_Complex(Complex * src1,Complex *src2,Complex *dst){
    float r1=0.0,r2=0.0;
    float i1=0.0,i2=0.0;
    r1=src1->real;
    r2=src2->real;
    i1=src1->imagin;
    i2=src2->imagin;
    dst->imagin=r1*i2+r2*i1;
    dst->real=r1*r2-i1*i2;
}
//exp(-j2pi/N)
void getWN(float n,int size_n,Complex * dst){
    float x=2.0*M_PI*n/size_n;
    dst->imagin=-sin(x);
    dst->real=cos(x);
}
//定义DFT函数，利用DFT定义
void DFT(float * src,Complex * dst,int size){
    for(int m=0;m<size;m++){
        float real=0.0;
        float imagin=0.0;
        for(int n=0;n<size;n++){
            float x=M_PI*2*m*n;
            real+=src[n]*cos(x/size);
            imagin+=src[n]*(-sin(x/size));
        }
        dst[m].imagin=imagin;
        dst[m].real=real;
    }
}
//定义IDFT函数
void IDFT(Complex *src,Complex *dst,int size){
    for(int m=0;m<size;m++){
        float real=0.0;
        float imagin=0.0;
        for(int n=0;n<size;n++){
            float x=M_PI*2*m*n/size;
            real+=src[n].real*cos(x)-src[n].imagin*sin(x);
            imagin+=src[n].real*sin(x)+src[n].imagin*cos(x);
        }
        real/=size;
        imagin/=size;
        if(dst!=NULL){
            dst[m].real=real;
            dst[m].imagin=imagin;
        }
    }
}
//序数重排
int FFT_remap(float * src,int size_n){
    if(size_n==1)
        return 0;
    float * temp=(float *)malloc(sizeof(float)*size_n);
    for(int i=0;i<size_n;i++)
        if(i%2==0)
            temp[i/2]=src[i];
        else
            temp[(size_n+i)/2]=src[i];
    for(int i=0;i<size_n;i++)
        src[i]=temp[i];
    free(temp);
    FFT_remap(src, size_n/2);
    FFT_remap(src+size_n/2, size_n/2);
    return 1;
}
int FFT_remap(Complex * src,int size_n){
    if(size_n==1)
        return 0;
    Complex * temp=(Complex *)malloc(sizeof(Complex)*size_n);
    for(int i=0;i<size_n;i++)
        if(i%2==0)
            temp[i/2]=src[i];
        else
            temp[(size_n+i)/2]=src[i];
    for(int i=0;i<size_n;i++)
        src[i]=temp[i];
    free(temp);
    FFT_remap(src, size_n/2);
    FFT_remap(src+size_n/2, size_n/2);
    return 1;
}
//定义FFT
void FFT(float * src,Complex * dst,int size_n){

    FFT_remap(src, size_n);
    int k=size_n;
    int z=0;
    while (k/=2) {
        z++;
    }
    k=z;
    if(size_n!=(1<<k))
        exit(0);
    Complex * src_com=(Complex*)malloc(sizeof(Complex)*size_n);
    if(src_com==NULL)
        exit(0);
    for(int i=0;i<size_n;i++){
        src_com[i].real=src[i];
        src_com[i].imagin=0;
    }
    for(int i=0;i<k;i++){
        z=0;
        for(int j=0;j<size_n;j++){
            if((j/(1<<i))%2==1){
                Complex wn;
                getWN(z, size_n, &wn);
                Multy_Complex(&src_com[j], &wn,&src_com[j]);
                z+=1<<(k-i-1);
                Complex temp;
                int neighbour=j-(1<<(i));
                temp.real=src_com[neighbour].real;
                temp.imagin=src_com[neighbour].imagin;
                Add_Complex(&temp, &src_com[j], &src_com[neighbour]);
                Sub_Complex(&temp, &src_com[j], &src_com[j]);
            }
            else
                z=0;
        }
    }
    for(int i=0;i<size_n;i++){
        dst[i].imagin=src_com[i].imagin;
        dst[i].real=src_com[i].real;
    }    
}
void FFT(Complex * src,Complex * dst,int size_n){

    FFT_remap(src, size_n);
    int k=size_n;
    int z=0;
    while (k/=2) {
        z++;
    }
    k=z;
    if(size_n!=(1<<k))
        exit(0);
    Complex * src_com=(Complex*)malloc(sizeof(Complex)*size_n);
    if(src_com==NULL)
        exit(0);
    for(int i=0;i<size_n;i++){
        src_com[i].real=src[i].real;
        src_com[i].imagin=src[i].imagin;
    }
    for(int i=0;i<k;i++){
        z=0;
        for(int j=0;j<size_n;j++){
            if((j/(1<<i))%2==1){
                Complex wn;
                getWN(z, size_n, &wn);
                Multy_Complex(&src_com[j], &wn,&src_com[j]);
                z+=1<<(k-i-1);
                Complex temp;
                int neighbour=j-(1<<(i));
                temp.real=src_com[neighbour].real;
                temp.imagin=src_com[neighbour].imagin;
                Add_Complex(&temp, &src_com[j], &src_com[neighbour]);
                Sub_Complex(&temp, &src_com[j], &src_com[j]);
            }
            else
                z=0;
        }
    }
    for(int i=0;i<size_n;i++){
        dst[i].imagin=src_com[i].imagin;
        dst[i].real=src_com[i].real;
    }
}
void IFFT(Complex * src,Complex * dst,int size_n){

    FFT_remap(src, size_n);
    int k=size_n;
    int z=0;
    while (k/=2) {
        z++;
    }
    k=z;
    if(size_n!=(1<<k))
        exit(0);
    Complex * src_com=(Complex*)malloc(sizeof(Complex)*size_n);
    if(src_com==NULL)
        exit(0);
    for(int i=0;i<size_n;i++){
        src_com[i].real=src[i].real;
        src_com[i].imagin=src[i].imagin;
    }
    for(int i=0;i<k;i++){
        z=0;
        for(int j=0;j<size_n;j++){
            if((j/(1<<i))%2==1){
                Complex wn;
                getWN(-1.0*z, size_n, &wn);
                Multy_Complex(&src_com[j], &wn,&src_com[j]);
                z+=1<<(k-i-1);
                Complex temp;
                int neighbour=j-(1<<(i));
                temp.real=src_com[neighbour].real;
                temp.imagin=src_com[neighbour].imagin;
                Add_Complex(&temp, &src_com[j], &src_com[neighbour]);
                Sub_Complex(&temp, &src_com[j], &src_com[j]);
            }
            else
                z=0;
        }
    }
    for(int i=0;i<size_n;i++){
        dst[i].imagin=src_com[i].imagin/size_n;
        dst[i].real=src_com[i].real/size_n;
    }
}
void FFT_2D(float** temp, Complex **get, int size_n)
{
//  float temp[SIZE][SIZE] = { 0.0 };//存储图像数组
    float tempreal[SIZE][SIZE] = { 0.0 };//存储图像数组变换后的实部
    float tempimage[SIZE][SIZE] = { 0.0 };//存储图像数组变换后的虚部
    Complex src[SIZE];
    Complex dst[SIZE];
    ///对图像进行傅里叶变换
    //进行每一行的FFT变换
    for (int i = 0; i < SIZE; i++)
    {
        FFT(temp[i], dst, SIZE);//得到256长度复数数组dst
        for (int j = 0; j < SIZE; j++)
        {
            tempreal[i][j] = dst[j].real;//存储实部
            tempimage[i][j] = dst[j].imagin;//存储虚部
        }
    }
    //对已经进行行变换后的复数数组再进行列fft变换
    for (int j = 0; j<SIZE; j++)
    {
        for (int i = 0; i<SIZE; i++)//列复制
        {
            src[i].real = tempreal[i][j];
            src[i].imagin = tempimage[i][j];
        }//复制好第j列到src[SIZE]
        FFT(src, dst, SIZE);
        for (int i = 0; i<SIZE; i++)
        {
            tempreal[i][j] = dst[i].real;//把对第j列进行的fft再次填到原来的数组
            tempimage[i][j] = dst[i].imagin;
        }
    }//得到各个j列的fft变换，也就是图像的fft变换tempreal+j*tempimage = F(u,v)

    //再次输出变换后的某一个值
    cout << tempreal[10][10] << "+j" << tempimage[10][10] << endl;

    /********************************************
    ****************进行反傅里叶变换*************
    *********************************************/
    //对i行，每一行进行一维傅里叶变换
    for (int i = 0; i < SIZE; i++)
    {
        for (int j = 0; j < SIZE; j++)
        {
            //把F(u,v)每一行，这里是第i行存储到Complex 一维数组src
            src[j].real = tempreal[i][j];
            src[j].imagin = tempimage[i][j];
        }
        IFFT(src, dst, SIZE);
        FFT_remap(dst, SIZE);
        for (int j = 0; j < SIZE; j++)
        {
            tempreal[i][j] = dst[j].real;
            tempimage[i][j] = dst[j].imagin;
        }
    }
    //现在进行列变化
    for (int j = 0; j < SIZE; j++)
    {
        for (int i = 0; i < SIZE; i++)
        {
            src[i].real = tempreal[i][j];
            src[i].imagin = tempimage[i][j];
        }//复制好每一列
        IFFT(src, dst, SIZE);
        FFT_remap(dst, SIZE);
        for (int i = 0; i < SIZE; i++)
        {
            get[i][j].real = dst[i].real;           //tempreal[i][j] = dst[i].real;
            get[i][j].imagin = dst[i].imagin;       //tempimage[i][j] = dst[i].imagin;
        }
    }
}

/*end 复数运算*******************************/

int main(int argc, const char * argv[]) {
    float input[SIZE];
    float temp[SIZE][SIZE] = {0.0};//存储图像数组，可以导入，也可以赋初值
    float tempreal[SIZE][SIZE] = { 0.0 };//存储图像数组变换后的实部
    float tempimage[SIZE][SIZE] = { 0.0 };//存储图像数组变换后的虚部
    Complex src[SIZE];
    Complex dst[SIZE];
    /****************************************/
    ///对图像进行傅里叶变换
    //进行每一行的FFT变换
    for (int i = 0; i < SIZE; i++)
    {
        FFT(temp[i], dst, SIZE);//得到256长度复数数组dst
        for (int j = 0; j < SIZE; j++)
        {
            tempreal[i][j] = dst[j].real;//存储实部
            tempimage[i][j] = dst[j].imagin;//存储虚部
        }
    }
    //对已经进行行变换后的复数数组再进行列fft变换
    for(int j=0;j<SIZE;j++)
    {
        for(int i=0;i<SIZE;i++)//列复制
        {
            src[i].real = tempreal[i][j];
            src[i].imagin = tempimage[i][j];
        }//复制好第j列到src[SIZE]
        FFT(src,dst,SIZE);
        for(int i=0;i<SIZE;i++)
        {
            tempreal[i][j]=dst[i].real;//把对第j列进行的fft再次填到原来的数组
            tempimage[i][j]=dst[i].imagin;
        }
    }//得到各个j列的fft变换，也就是图像的fft变换tempreal+j*tempimage = F(u,v)

    /***************  低通滤波  ***************/
    /*for (int i = 0; i < SIZE; i++)
    {
        for (int j = 0; j < SIZE; j++)
        if (sqrt(pow(tempreal[i][j], 2) + pow(tempimage[i][j], 2)) < 1000)
            tempreal[i][j] = tempimage[i][j] = 0.0;
    }
    */
    /**************   高通滤波  *****************/
    /*for (int i = 0; i < SIZE; i++)
    {
        for (int j = 0; j < SIZE; j++)
        if (sqrt(pow(tempreal[i][j], 2) + pow(tempimage[i][j], 2)) > 4000)
            tempreal[i][j] = tempimage[i][j] = 0.0;
    }
    */
    /*******************附加一个反变换的算法*******************
    ****************进行反傅里叶变换*************
    *********************************************/
    //对i行，每一行进行一维傅里叶变换
    for (int i = 0; i < SIZE; i++)
    {
        for (int j = 0; j < SIZE; j++)
        {
            //把F(u,v)每一行，这里是第i行存储到Complex 一维数组src
            src[j].real = tempreal[i][j];
            src[j].imagin = tempimage[i][j];
        }
        IFFT(src, dst, SIZE);
        FFT_remap(dst, SIZE);
        for (int j = 0; j < SIZE; j++)
        {
            tempreal[i][j] = dst[j].real;
            tempimage[i][j] = dst[j].imagin;
        }
    }
    //现在进行列变化
    for (int j = 0; j < SIZE; j++)
    {
        for (int i = 0; i < SIZE; i++)
        {
            src[i].real = tempreal[i][j];
            src[i].imagin = tempimage[i][j];
        }//复制好每一列
        IFFT(src, dst, SIZE);
        FFT_remap(dst, SIZE);
        for (int i = 0; i < SIZE; i++)
        {
            tempreal[i][j] = dst[i].real;
            tempimage[i][j] = dst[i].imagin;
        }
    }
    /***************************************/
    //对比输出一下，选择前20X20矩阵
    cout << "\n\n**************************************\n\n";
    for (int i = 0; i < 20; i++)
    {
        for (int j = 0; j <10; j++)
        {
            cout << temp[i][j] << '\t' << tempreal[i][j] << '\t' << tempimage[i][j] << endl;

        }
        cout << endl;
    }
    putchar('\n');
    return 0;
}
KeyHero
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Matlab实现二维傅里叶变换（FFT2）
08-28
本程序主要实现了二维傅里叶变换，其中先对图像矩阵进行预处理（即图像中心化），然后进行行傅里叶变换，再对其进行列变换，进行行列变换是调用自己写的一维傅里叶变换函数ImFFT实现的。程序输入为图像矩阵A，输出为其傅里叶变换结果Fuv，并绘制了其频谱图
二维傅立叶变换
极客神殿
09-30 2054
最糟糕的是人们在生活中经常受到错误志向的阻碍而不自知，真到摆脱了那些阻碍时才能明白过来。 —— 歌德页面代码:<html xmlns="http://www.w3.org/1999/xhtml"> <head runat="server"> <title></title> </head> <body> <pre class="csharp" name="code"> <%--
c语言数组进行傅里叶变换,急求：C语言如何实现快速傅里叶变换
weixin_30771489的博客
05-23 204
该楼层疑似违规已被系统折叠隐藏此楼查看此楼数据处理用过，保存成.c然后用#include "fftt2.c"包含进去。#include #include #define PI 3.141592653int fftt2(x,y,n,f)double *x;double *y;int n;double f;{int i,i0,i1,j,l1,ns,n1,k;double s,c,s1,c1,sc,...
傅里叶变换 二维快速傅里叶变换（快速的二维离散傅里叶变换、分治法）
qq_36511401的博客
11-13 1万+
可以看作M行N列的二维数组，先对每行做一维FFT，将结果作为一个新的二维数组。而在处理二维IFFT的时候，跟二维FFT差不多，只要在公共方法中控制正负值，来区分是FFT还是IFFT。如果是FFT的话，刚开始的时候，要将double转为Complex复数，如果是IFFT的话，要在结束的时候，将每个值都除以MN。还要将DFT的代码注释了，不然跑不动。设置行列大小都为128的时候，发现二维DFT和二维FFT差距还是很明显的，随着行列的增大，差距只会越来越大。的写法，相结合的话，就可以很容易得出二维FFT的写法。
傅里叶变换 二维离散傅里叶变换
热门推荐
qq_36511401的博客
11-07 2万+
DFT:(Discrete Fourier Transform)离散傅里叶变换是傅里叶变换在时域和频域上都呈离散的形式，将信号的时域采样变换为其DTFT的频域采样。会发现原数组和经过离散傅里叶变换DFT及逆离散傅里叶变换IDFT之后的数组是一模一样的，就可以验证出算法和公式是对的。二维离散傅里叶因为涉及到4个嵌套循环，时间复杂度十分的大，所以在实际应用场景上得不到使用，现在的照片小的差不多也要500*500的大小，但是二维离散傅里叶处理大小60*60的时候，就已经显得十分的吃力了。2、生成随机的二维数组。
二维离散傅立叶变换性质验证等.rar
05-23
1. **二维离散傅立叶变换（2D DFT）**：2D DFT是一个复数运算，它将一个二维数组（图像）转换为等大小的复数矩阵，其中每个元素对应于原图像中特定频率的幅度和相位。MATLAB中的`fft2`函数可以方便地进行二维DFT操作...
用快速傅里叶变换实现图像的低通滤波.pptx
03-21
用快速傅里叶变换实现图像的低通滤波，来对图形做一个简单的处理。低通滤波器指去除图像中的高频成分，而低通滤波器指去除图像中的高频成分。考虑的有三种低通滤波器：理想滤波器、布特沃斯滤波器和高斯滤波器
matlabcode_二维图像频谱_图像傅里叶变换_
10-04
"matlabcode_二维图像频谱_图像傅里叶变换_"这一主题主要涉及使用MATLAB编程实现对二维图像进行傅里叶变换以及频谱分析的过程。 图像傅里叶变换是将图像的像素值分布转化为对应的频率分布，这种变换在数学上由离散...
数字图像处理实验二 图像傅里叶变换 实验报告 附代码 结果 数据
12-16
本实验旨在深入理解图像频域处理的意义，掌握二维傅里叶变换的原理和方法，并通过MATLAB编程实践来体验其在图像分析中的应用。 实验一的核心知识点： 1. **图像频域处理的意义**：频域分析可以帮助我们理解图像中...
图像二维离散傅里叶变换与性质_数字图像处理 matlab
07-14
数字图像处理课程的基础实验内容， 图像二维离散傅里叶变换与性质
二维傅里叶变换（自己编的程序）
04-05
这是一个我自己用matlab编的二维傅里叶变换程序，和fft2结果几乎一样，希望对大家有用
二维傅里叶变换的C++实现
03-13
资源为二维傅里叶变换的C++实现，内含多个示例，比较详细。
C#数字滤波器实例及算法
02-23
C#数字滤波器实例及算法
C# 滤波算法 KalmanFa
12-08
花了20分下载的，太黑了，分享给大家，鄙视那些。。。呵呵。。
C++实现二维快速傅里叶变换（FFT）
海盗Isaac
12-31 1万+
上一篇文章里，我根据DFT公式用C++实现了二维离散傅里叶变换。但跑一张300*300的图片都要好几分钟，速度实在太慢了。我研究了下快速傅里叶变换，在网上找了一些资料，然后用C++实现了二维快速傅里叶变换，速度超级快，512*512的图片在0.1秒内就能处理完。 我们知道一维离散傅里叶变换公式如下 其中。 用矩阵表示即为： ...
傅里叶变换 一维和二维快速傅里叶变换（代码和性能的优化）
qq_36511401的博客
11-13 1万+
在类FourierUtils的fftProgress方法中，有这个代码段，我们可以将Complext.euler(flag * i)提前计算好，设置大小为2次幂N，如果没有的话，也要调节到2次幂N。我们设置大小为N,求得复数数组，前半部分存储给FFT使用的，后半部分给IFFT使用。中测试大小为行为800，列为900时，花费了时间4s多。而现在只要2s左右。中测试大小为1百万时，花费了时间6s多。2、其中复数类和工具类代码不变。5、测试一维快速傅里叶。6、测试二维快速傅里叶。的复数类和工具类代码。
二维傅里叶变换
dingding_tao的博客
07-13 3255
二维傅里叶变换 第一种做法是拆成一维的做。 #include &lt;iostream&gt; #include &lt;cmath&gt; #include &lt;algorithm&gt; using namespace std; const int N = 1000; const double PI = acos(-1); int a[N][N], b[N][N], c[N][N...
python 实现快速傅里叶变换（二维）
颹蕭蕭
03-27 1万+
python 实现二维快速傅里叶变换
Python——快速傅里叶变换
Thattear的博客
07-02 7057
1.题目 给出时域函数,对其采样获得采样数据，并画出对应的x-t曲线；然后对上述采样数据进行傅里叶变换，画出频谱图。运行该程序，需要从键盘输入N中的r值，该程序可以接受的值为5-10的整数。2.算法及分析 一般地来说，若具有N个采样点，第L层节点的值为： 在处理该问题的时候，我们要确定的指数值。对于节点,其p值的可以按照下列方式确定。首先将n用r位二进制形式表示出来，再将改二进制右移r-l位，左边空位补零；然后在将码序倒置，最后再将改二进制写出十进制形式，就确定p值。 而上式中涉及
MATLAB实现的二维DFT图像傅里叶变换详解
首先，我们来探讨一维傅里叶变换，无论是连续函数的傅立叶变换（如连续傅立叶变换F(u)的定义和反变换）还是离散函数的离散傅立叶变换（如DFT，通过欧拉公式将函数与特定频率的正弦和余弦相乘）。在离散情况下，通过...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值