2D-FFT（二维快速傅里叶变换） 源码

最新推荐文章于 2024-04-22 21:48:35 发布
最新推荐文章于 2024-04-22 21:48:35 发布
阅读量1.9w 收藏 27
点赞数 3
分类专栏： 转载 文章标签： fft 图像处理

2D-FFT（二维快速傅里叶变换）  



#include <stdio.h>
#include <stdlib.h>
#include <math.h>


#define intsize sizeof(int)
#define complexsize sizeof(complex)
#define PI 3.1415926


int *a,*b;
int nLen,init_nLen,mLen,init_mLen,N,M;
FILE *dataFile;


typedef struct{
    float real;
    float image;
}complex;


complex *A,*A_In,*W;


complex Add(complex, complex);
complex Sub(complex, complex);
complex Mul(complex, complex);
int calculate_M(int);
void reverse(int,int);
void readData();
void fft(int,int);
void printResult();




int main()
{
    int i,j;


    readData();


    A = (complex *)malloc(complexsize*nLen);
    reverse(nLen,N);
    for(i=0; i<mLen; i++)
    {
        for(j=0; j<nLen; j++)
        {
            A[j].real = A_In[i*nLen+b[j]].real;
            A[j].image = A_In[i*nLen+b[j]].image;
        }
        
        fft(nLen,N);
        for(j=0; j<nLen; j++)
        {
            A_In[i*nLen+j].real = A[j].real;
            A_In[i*nLen+j].image = A[j].image;
        }
    }
    free(A);
 
    A = (complex *)malloc(complexsize*mLen);
    reverse(mLen,M);
    for(i=0; i<nLen; i++)
    {
        for(j=0; j<mLen; j++)
        {
            A[j].real = A_In[b[j]*nLen+i].real;
            A[j].image = A_In[b[j]*nLen+i].image;
        }


        fft(mLen,M);
        for(j=0; j<mLen; j++)
        {
            A_In[j*nLen+i].real = A[j].real;
            A_In[j*nLen+i].image = A[j].image;
        }
    }
    free(A);


    printResult();
 
    return 0;
}




void readData()
{
     int i,j;


     dataFile = fopen("dataIn.txt","r");
     fscanf(dataFile,"%d %d",&init_mLen,&init_nLen);
     M = calculate_M(init_mLen);
     N = calculate_M(init_nLen);
     nLen = (int)pow(2,N);
     mLen = (int)pow(2,M);
    
     A_In = (complex *)malloc(complexsize*nLen*mLen);


     for(i=0; i<init_mLen; i++)
     {
         for(j=0; j<init_nLen; j++)
         {
             fscanf(dataFile,"%f",&A_In[i*nLen+j].real);
             A_In[i*nLen+j].image = 0.0;
         }
     }
     fclose(dataFile);


     for(i=0; i<mLen; i++)
     {
         for(j=init_nLen; j<nLen; j++)
         {
             A_In[i*nLen+j].real = 0.0;
             A_In[i*nLen+j].image = 0.0;
         }
     }


     for(i=init_mLen; i<mLen; i++)
     {
         for(j=0; j<init_nLen; j++)
         {
             A_In[i*nLen+j].real = 0.0;
             A_In[i*nLen+j].image = 0.0;
         }
     }


     printf("Reading initial datas:\n");
     for(i=0; i<init_mLen; i++)
     {
         for(j=0; j<init_nLen; j++)
         {
             if(A_In[i*nLen+j].image < 0)
             { 
                 printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);
             }
             else
             {
                 printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);
             }
         }
         printf("\n");
     }
  
     printf("\n");
  
     printf("Reading formal datas:\n");
     for(i=0; i<mLen; i++)
     {
         for(j=0; j<nLen; j++)
         {
             if(A_In[i*nLen+j].image < 0)
             { 
                 printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);
             }
             else
             {
                 printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);
             }
         }
         printf("\n");
     }
}




void fft(int fft_nLen, int fft_M)
{
     int i;
     int lev,dist,p,t;
     complex B;


     W = (complex *)malloc(complexsize*fft_nLen/2);


     for(lev=1; lev<=fft_M; lev++)
     {
         dist = (int)pow(2,lev-1);
         for(t=0; t<dist; t++)
         {
             p = t*(int)pow(2,fft_M-lev);
             W[p].real = (float)cos(2*PI*p/fft_nLen);
             W[p].image = (float)(-1*sin(2*PI*p/fft_nLen));
             for(i=t; i<fft_nLen; i=i+(int)pow(2,lev))
             {
                 B = Add(A[i],Mul(A[i+dist],W[p]));
                 A[i+dist] = Sub(A[i],Mul(A[i+dist],W[p]));
                 A[i].real = B.real;
                 A[i].image = B.image;
             }
         }
     }


     free(W);
}




void printResult()
{
     int i,j;
 
     printf("Output results:\n");
     for(i=0; i<mLen; i++)
     {
         for(j=0; j<nLen; j++)
         {
             if(A_In[i*nLen+j].image < 0)
             {
                 printf("%f%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);
             }
             else
             {
                 printf("%f+%fi\t",A_In[i*nLen+j].real,A_In[i*nLen+j].image);
             }
         }
         printf("\n");
     }
 
     free(A_In);
}


int calculate_M(int len)
{
    int i;
    int k;
 
    i = 0;
    k = 1;
    while(k < len)
    {
        k = k*2;
        i++;
    }
 
    return i;
}


void reverse(int len, int M)
{
    int i,j;
 
    a = (int *)malloc(intsize*M);
    b = (int *)malloc(intsize*len);
 
    for(i=0; i<M; i++)
    {
        a[i] = 0;
    }
 
    b[0] = 0;
    for(i=1; i<len; i++)
    {
        j = 0;
        while(a[j] != 0)
        {
            a[j] = 0;
            j++;
        }
  
        a[j] = 1;
        b[i] = 0;
        for(j=0; j<M; j++)
        {
            b[i] = b[i]+a[j]*(int)pow(2,M-1-j);
        }
    }
}


complex Add(complex c1, complex c2)
{
    complex c;
    c.real = c1.real+c2.real;
    c.image = c1.image+c2.image;
    return c;
}


complex Sub(complex c1, complex c2)
{
    complex c;
    c.real = c1.real-c2.real;
    c.image = c1.image-c2.image;
    return c;
}


complex Mul(complex c1, complex c2)
{
    complex c;
    c.real = c1.real*c2.real-c1.image*c2.image;
    c.image = c1.real*c2.image+c2.real*c1.image;
    return c;
}


测试：


dataIn.txt文件的内容如下：


5 6
1 2 3 4 4 5
3 2 1 2 4 5
2 3 4 5 1 2
2 4 5 2 1 2
3 2 4 8 9 0


结果：


Reading initial datas:
1.000000+0.000000i 2.000000+0.000000i 3.000000+0.000000i 4.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i
3.000000+0.000000i 2.000000+0.000000i 1.000000+0.000000i 2.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i
2.000000+0.000000i 3.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i 1.000000+0.000000i 2.000000+0.000000i
2.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i 2.000000+0.000000i 1.000000+0.000000i 2.000000+0.000000i
3.000000+0.000000i 2.000000+0.000000i 4.000000+0.000000i 8.000000+0.000000i 9.000000+0.000000i 0.000000+0.000000i


Reading formal datas:
1.000000+0.000000i 2.000000+0.000000i 3.000000+0.000000i 4.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




3.000000+0.000000i 2.000000+0.000000i 1.000000+0.000000i 2.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




2.000000+0.000000i 3.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i 1.000000+0.000000i 2.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




2.000000+0.000000i 4.000000+0.000000i 5.000000+0.000000i 2.000000+0.000000i 1.000000+0.000000i 2.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




3.000000+0.000000i 2.000000+0.000000i 4.000000+0.000000i 8.000000+0.000000i 9.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i 0.000000+0.000000i




Output results:
95.000000+0.000000i  -23.556349-31.142136i  13.000000-6.000000i 7.556350+2.857865i


-1.000000+0.000000i 7.556349-2.857865i   13.000000+6.000000i  -23.556351+31.142136i




-6.292893-40.334526i -15.606602+17.020815i  -6.707107-11.535534i 7.292892-1.292893i


-9.707107+3.707107i 2.292893-11.363961i   6.020815+7.878680i   12.363961-8.363960i




28.000000-1.000000i  -8.828428-1.000000i 10.000000-5.000000i -4.100504-2.071068i 


6.000000+1.000000i  -3.171573-1.000000i  12.000000-11.000000i -23.899494+12.071068i




-7.707106-6.334524i  8.707107+2.707107i  -18.020817-12.121321i 5.606601+7.020816i


-8.292893-2.292893i -0.363960-4.363961i  -5.292893+4.464466i  3.707107-1.363961i




29.000000+0.000000i  -16.485281-14.899494i  5.000000+12.000000i  0.485282-4.899495i 


 1.000000+0.000000i  0.485281+4.899495i   5.000000-12.000000i  -16.485283+14.899494i




-7.707106+6.334524i  3.707107+1.363961i   -5.292893-4.464466i  -0.363961+4.363961i 


-8.292893+2.292893i  5.606602-7.020816i   -18.020815+12.121321i  8.707107-2.707106i




28.000000+1.000000i  -23.899496-12.071068i 12.000000+11.000000i -3.171573+1.000000i 


 6.000000-1.000000i  -4.100505+2.071068i  10.000000+5.000000i  -8.828426+1.000000i




-6.292895+40.334526i 12.363961+8.363962i  6.020816-7.878679i 2.292892+11.363961i  


-9.707107-3.707107i   7.292893+1.292893i  -6.707107+11.535534i  -15.606600-17.020817i
Press any key to continue
lxdfigo
关注
  • 3
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2维FFT的FPGA实现
02-17
xilinx FPGA的二维FFT实现，有完整的testbench代码，绝对是不容错过的优秀代码。经过matlab仿真对比，精度令人满意。
matlab绘制雷达图和二维FFT变换图
qingfengxd1的博客
02-25 411
NMO组及NORMAL组 RNFL层、GCL层、IPL层、GCC层、ORL层请分别做雷达图（共10张），作图要求：1.为了比较NMO及normal组各层厚度差别，每层NMO及normal组颜色条的范围及颜色对应厚度值一样；2.每张图单独一个文件，样式仿照右上图。NMO组及NORMAL组 RNFL层、GCL层、IPL层、GCC层、ORL层做雷达图（共10张）matlab绘制雷达图和二维FFT变换图。49-可以交流、咨询、答疑。
fft2 二维快速傅里叶变换（Matlab）
热门推荐
仗剑走天涯
04-22 1万+
1.语法：         Y = fft2(X)         Y = fft2(X,m,n) 2.说明：         Y = fft2(X) 使用快速...
二维分数傅里叶变换源代码
06-08
二维分数傅里叶变换的源代码，matlab编写，便于理解，在图像加密方面用的比较多
重生之——毫米波雷达与我不得不说的一些事
m0_60524373的博客
02-17 2130
（1）绪论 1.早期雷达基本组成 天线：发射信号，接收回波 发射机：产生射频信号 接收机：接收信号。其频段分为（射频，中频，视频） 基本雷达信号：连续波，脉冲波 2.雷达的任务 早期：测距 现代：测距，角度（方向），速度，形状 雷达基本工作原理：当主播发送被物体反射之后，得到回波。先假设两点距离为R，且物体静止状态下，电磁波需要跑的距离为2R，速度为光速，tr是需要的时间。 3.信号处理机 本振：通过本地振荡器产生一个较低的频率和接收到的射频进行混频得到中频。.
形象理解二维傅里叶变换
forfuture3513的博客
03-18 1257
形象理解二维傅里叶变换
基于2D-FFT的变换域信息隐写
Natukiaaa的博客
09-13 1472
《信息隐藏》课程中实现的基于2D-FFT的变换域信息隐写，希望对你的课设或者项目有所帮助 摘要 本文提出一直基于FFT变换域的信息隐写，包括图片水印抗攻击的嵌入隐写、基于Logistics图像混沌加密以及AES加密文件流的信息隐写。其中加密过程的Logistics密钥流用于图像加密，AES密钥用于加密文件比特流信息。实验结果显示，该算法中分别兼顾了安全性、隐蔽性以及鲁棒性的需求，可针对不同应用场景灵活使用。 关键词：FFT;图像加密;信息隐写;Logistics;AES 信息隐藏是自20世纪90年代开始便一
FFT原理（基2DIT-FFT）及C语言编程思路及实现
小张爱学习哦的博客
02-07 9776
基2DIT-FFT原理及c语言编程思路
数字图像处理中的傅立叶变换
dbt67865的博客
10-28 848
二维Fourier变换的应用 前面已经提到了Fourier变换有两个好处，即：可以获得信号的频域特性；可以将卷积运算转换为乘积运算。 因此二维Fourier变换的应用也是根据这两个特点来进行的。 在图像滤波中的应用 首先，我们来看Fourier变换后的图像，中间部分为低频部分，越靠外边频率越高。因此，我们可以在Fourier变换图中，选择所需要的高频或是低频滤波。 在图像...
C++实现二维图形的傅里叶变换
09-04
主要介绍了C++实现二维图形的傅里叶变换的方法,是C++程序设计里一个重要的应用,需要的朋友可以参考下
自己编写的二维快速傅里叶变换fft程序 matlab平台
01-14
没有调用matlab自带的fft函数，而是自己编写的二维快速傅里叶变换fft程序 matlab平台 没有调用matlab自带的fft函数，而是自己编写的二维快速傅里叶变换fft程序 matlab平台
基于MATLAB实现了极坐标下的傅里叶变换，对一个给定 n×n 的二维信号，其计算复杂度等价于笛卡尔坐标下的2D-FFT
03-23
资源名：基于MATLAB实现了极坐标下的傅里叶变换，对一个给定 n×n 的二维信号，其计算复杂度等价于笛卡尔坐标下的2D-FFT 资源类型：matlab项目全套源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的...
fft.zip_C语言 二维fft_二维fft_快速傅里叶变换
09-14
本程序是用于二维快速傅里叶变换的C语言实现方法
二维快速傅里叶变换干涉图相位提取误差分析
03-04
基于ZYGO干涉仪实测干涉图，利用二维快速傅里叶变换(FFT)法进行相位提取，并与相移干涉相位测量结果进行比对，对影响FFT法相位提取精度的边缘误差、窗函数、滤波器设计、干涉图延拓以及载波条纹数等因素进行了综合...
【C++风云录】发现天空之美：使用C++库进行气象图像处理与分析
记录我的学习历程
04-22 1022
本文介绍了环境监测与气象学领域的一些重要的C++库，包括Poco::Net、MeteoIO、CppUTest、Boost.Geometry、GDAL和OpenCV。这些库提供了丰富的功能和工具，用于处理和分析环境监测和气象学相关的数据。Poco::Net用于网络通信和数据传输，MeteoIO用于气象数据处理和分析，CppUTest用于C++单元测试，Boost.Geometry用于地理空间数据处理，GDAL用于地理信息系统开发，OpenCV用于图像处理和计算机视觉算法。通过使用这些库，开发人员可以更高效地
深度剖析图像处理—边缘检测
Ochazuke的博客
04-22 636
数字图像处理，bmp图像的边缘检测，图像边缘增强和边缘分割的基础，深度剖析各种算子和实现方法，内附实例讲解个人心得，文末附源码，希望对您有所帮助
node-v12.16.3-x86.msi
最新发布
04-25
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
云计算基础课件—架构dr.pptx
04-25
云计算基础课件—架构dr.pptx
二维快速傅里叶变换（2D FFT）进行图像处理的步骤以及每一步的公式
05-28
二维快速傅里叶变换（2D FFT）是一种常用的图像处理技术，其步骤如下： 1. 将输入的二维图像转换为复数形式。 2. 对每一行进行一维快速傅里叶变换（1D FFT）。 3. 对每一列进行一维快速傅里叶变换（1D FFT）。 4. 对得到的二维频域数据进行变换后，得到输出的二维图像。 具体的公式如下： 1. 将输入的二维图像转换为复数形式： $$f(x,y) \rightarrow F(u,v) = \sum_{x=0}^{M-1}\sum_{y=0}^{N-1}f(x,y) e^{-i2\pi(\frac{ux}{M}+\frac{vy}{N})}$$ 其中，$f(x,y)$ 为输入的二维图像的像素值，$F(u,v)$ 为转换后的复数形式。 2. 对每一行进行一维快速傅里叶变换（1D FFT）： $$F(u,v) \rightarrow F(u,k) = \sum_{x=0}^{M-1}F(u,v) e^{-i2\pi\frac{kv}{N}}$$ 其中，$F(u,v)$ 为输入的二维频域数据，$F(u,k)$ 为变换后的频域数据。 3. 对每一列进行一维快速傅里叶变换（1D FFT）： $$F(u,k) \rightarrow F(i,k) = \sum_{u=0}^{M-1}F(u,k) e^{-i2\pi\frac{iu}{M}}$$ 其中，$F(u,k)$ 为输入的二维频域数据，$F(i,k)$ 为变换后的频域数据。 4. 对得到的二维频域数据进行变换后，得到输出的二维图像： $$F(i,k) \rightarrow f(x,y) = \frac{1}{MN}\sum_{i=0}^{M-1}\sum_{k=0}^{N-1}F(i,k) e^{i2\pi(\frac{ix}{M}+\frac{ky}{N})}$$ 其中，$F(i,k)$ 为输入的二维频域数据，$f(x,y)$ 为输出的二维图像的像素值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值