【经典算法实现 44】理解二维FFT快速傅里叶变换 及 IFFT快速傅里叶逆变换（迭代法 和 递归法）

最新推荐文章于 2024-04-24 14:24:35 发布
最新推荐文章于 2024-04-24 14:24:35 发布
阅读量9.6k 收藏 63
点赞数 11
分类专栏： # 数字图像处理 数据结构与算法 # 傅里叶变换
版权声明：本文为博主原创文章，禁止转载。
本文链接：https://blog.csdn.net/Ciellee/article/details/108503017
版权

【经典算法实现 44】理解二维FFT快速傅里叶变换 及 IFFT快速傅里叶逆变换（迭代法 和 递归法）

前面我们实现了一维快速傅里叶变换《【经典算法实现 43】理解FFT快速傅里叶变换 及 IFFT快速傅里叶逆变换（迭代法 和 递归法）》
本文开始二维傅里叶变换的公式推导及代码实现


一、二维 F F T FFT FFT快速傅里叶变换 公式推导

本文链接《【经典算法实现 44】理解二维FFT快速傅里叶变换 及 IFFT快速傅里叶逆变换（迭代法 和 递归法）》

二维傅里叶变换：

F ( u , v ) = ∑ M x = 0 M x − 1 ∑ M y = 0 M y − 1 f ( x , y ) e − j 2 π ( u x M x + v y M y ) ， u , v = 0 , 1 , 2 , ⋯   , M u − 1 ∣ M v − 1 F(u,v) = \sum_{M_x=0}^{M_x-1} \sum_{M_y=0}^{M_y-1} f(x,y) e^{-j 2\pi (\frac {ux} {M_x}+\frac {vy} {M_y})}， u,v=0,1,2,\cdots,Mu-1|Mv-1 F(u,v)=Mx​=0∑Mx​−1​My​=0∑My​−1​f(x,y)e−j2π(Mx​ux​+My​vy​)，u,v=0,1,2,⋯,Mu−1∣Mv−1

二维傅里叶逆变换：
f ( x , y ) = 1 M u ⋅ M v ∑ M u = 0 M u − 1 ∑ M v = 0 M v − 1 F ( u , v ) e − j 2 π ( u x M x + v y M y ) ， x , y = 0 , 1 , 2 , ⋯   , M x − 1 ∣ M y − 1 f(x,y) = {\frac 1 {M_u\cdot M_v}} \sum_{M_u=0}^{M_u-1} \sum_{M_v=0}^{M_v-1} F(u,v) e^{-j 2\pi (\frac {ux} {M_x}+\frac {vy} {M_y})}， x,y=0,1,2,\cdots,Mx-1|My-1 f(x,y)=Mu​⋅Mv​1​Mu​=0∑Mu​−1​Mv​=0∑Mv​−1​F(u,v)e−j2π(Mx​ux​+My​vy​)，x,y=0,1,2,⋯,Mx−1∣My−1

令 W M x x = e − j 2 π x M x W_{M_x}^x=e^{-j2\pi {\frac x {M_x}} } WMx​x​=e−j2πMx​x​，则可以得到：

e − j 2 π ( u x M x + v y M y ) = e − j 2 π u x M x ⋅ e − j 2 π v y M y = W M x u x ⋅ W M y v y e^{-j 2\pi (\frac {ux} {M_x}+\frac {vy} {M_y})} = e^{-j2\pi{\frac {ux} {M_x}}} \cdot e^{-j2\pi{\frac {vy} {M_y}}}=W_{M_x}^{ux}\cdot W_{M_y}^{vy} e−j2π(Mx​ux​+My​vy​)=e−j2πMx​ux​⋅e−j2πMy​vy​=WMx​ux​⋅WMy​vy​

代入傅里叶变换公式：

F ( u , v ) = ∑ M x = 0 M x − 1 ∑ M y = 0 M y − 1 f ( x , y ) ⋅ W M x u x ⋅ W M y v y ， u , v = 0 , 1 , 2 , ⋯   , M u − 1 ∣ M v − 1 F(u,v) = \sum_{M_x=0}^{M_x-1} \sum_{M_y=0}^{M_y-1} f(x,y) \cdot W_{M_x}^{ux}\cdot W_{M_y}^{vy}， u,v=0,1,2,\cdots,Mu-1|Mv-1 F(u,v)=Mx​=0∑Mx​−1​My​=0∑My​−1​f(x,y)⋅WMx​ux​⋅WMy​vy​，u,v=0,1,2,⋯,Mu−1∣Mv−1

令 w u x = W M x u x w^{ux} = W_{M_x}^{ux} wux=WMx​ux​，则上述公式可以进一步简化：
F ( u , v ) = ∑ M y = 0 M y − 1 { ∑ M x = 0 M x − 1 f ( x , y ) ⋅ w u x } ⋅ w v y ， u , v = 0 , 1 , 2 , ⋯   , M u − 1 ∣ M v − 1 F(u,v) = \sum_{M_y=0}^{M_y-1} \lbrace \sum_{M_x=0}^{M_x-1} f(x,y) \cdot w^{ux} \rbrace \cdot w^{vy}， u,v=0,1,2,\cdots,Mu-1|Mv-1 F(u,v)=My​=0∑My​−1​{Mx​=0∑Mx​−1​f(x,y)⋅wux}⋅wvy，u,v=0,1,2,⋯,Mu−1∣Mv−1

为更好理解，我们特画了一幅图
在这里插入图片描述

F ( u , v ) = ∑ M y = 0 M y − 1 { ∑ M x = 0 M x − 1 f ( x , y ) ⋅ w u x } ⋅ w v y ， u , v = 0 , 1 , 2 , ⋯   , M u − 1 ∣ M v − 1 F(u,v) = \sum_{M_y=0}^{M_y-1} \lbrace \sum_{M_x=0}^{M_x-1} f(x,y) \cdot w^{ux} \rbrace \cdot w^{vy}， u,v=0,1,2,\cdots,Mu-1|Mv-1 F(u,v)=My​=0∑My​−1​{Mx​=0∑Mx​−1​f(x,y)⋅wux}⋅wvy，u,v=0,1,2,⋯,Mu−1∣Mv−1

我们假设
A ( x , y ) = ∑ M x = 0 M x − 1 f ( x , y ) ⋅ w u x ， x ∈ ( 1 , 2 , 3 , 4 , ⋯   , M x − 1 ) A(x,y) = \sum_{M_x=0}^{M_x-1} f(x,y) \cdot w^{ux}，x \in(1,2,3,4,\cdots,M_x-1) A(x,y)=Mx​=0∑Mx​−1​f(x,y)⋅wux，x∈(1,2,3,4,⋯,Mx​−1)

这样就相当于，对 某特定 y y y 行，对这一行的所有 f ( x , y ) f(x,y) f(x,y) 的一维傅里叶变换。

再假设
B ( x , y ) = ∑ M y = 0 M y − 1 f ( x , y ) ⋅ w v y ， y ∈ ( 1 , 2 , 3 , 4 , ⋯   , M x − 1 ) B(x,y) = \sum_{M_y=0}^{M_y-1} f(x,y) \cdot w^{vy}，y \in(1,2,3,4,\cdots,M_x-1) B(x,y)=My​=0∑My​−1​f(x,y)⋅wvy，y∈(1,2,3,4,⋯,Mx​−1)

这样就相当于，对某特定 x x x列，求这一列所有 f ( x , y ) f(x,y) f(x,y)的一维傅里叶变换

结合这两个式子：

F ( u , v ) = ∑ M y = 0 M y − 1 { ∑ M x = 0 M x − 1 f ( x , y ) ⋅ w u x } ⋅ w v y ， u , v = 0 , 1 , 2 , ⋯   , M u − 1 ∣ M v − 1 F(u,v) = \sum_{M_y=0}^{M_y-1} \lbrace \sum_{M_x=0}^{M_x-1} f(x,y) \cdot w^{ux} \rbrace \cdot w^{vy}， u,v=0,1,2,\cdots,Mu-1|Mv-1 F(u,v)=My​=0∑My​−1​{Mx​=0∑Mx​−1​f(x,y)⋅wux}⋅wvy，u,v=0,1,2,⋯,Mu−1∣Mv−1

F ( u , v ) = B ( A ( x , y ) ) F(u,v) = B( A(x,y) ) F(u,v)=B(A(x,y))

这样就，相当于，求先求每一行的傅里叶变换，再求每一列的傅里叶变换，
这样就成功的把二维傅里叶变换，变成了一维傅里叶变换的求解。


结合前面推导的一维傅里叶变换公式：
A 0 A_0 A0​为偶项， A 1 A_1 A1​为奇项， w = W M u = e − j u 2 π M = cos ⁡ ( j u 2 π M ) − j sin ⁡ ( j u 2 π M ) w = W_M^{u}=e^{-j u \frac {2\pi} M}= \cos(j u \frac {2\pi} M) - j \sin(j u \frac {2\pi} M) w=WMu​=e−juM2π​=cos(juM2π​)−jsin(juM2π​)

F ( u ) = A 0 + w ⋅ A 1 ， u ∈ ( 0 , 1 , 2 , 3 , 4... M / 2 − 1 ) F(u) = A_0+w \cdot A_1， u\in (0,1,2,3,4...M/2-1) F(u)=A0​+w⋅A1​，u∈(0,1,2,3,4...M/2−1)

F ( u + M 2 ) = A 0 − w ⋅ A 1 ， u ∈ ( 0 , 1 , 2 , 3 , 4... M / 2 − 1 ) F(u+\frac M 2) = A_0-w \cdot A_1，u\in (0,1,2,3,4...M/2-1) F(u+2M​)=A0​−w⋅A1​，u∈(0,1,2,3,4...M/2−1)

本文链接《【经典算法实现 44】理解二维FFT快速傅里叶变换 及 IFFT快速傅里叶逆变换（迭代法 和 递归法）》



二、二维 F F T FFT FFT 及 I F F T IFFT IFFT代码实现（迭代法）

变换思路就是：先对每一行做傅里叶变换，再针对变换结果的每一列做傅里叶变换。

c文件代码已上传：《二维快速傅里叶变换-C语言-迭代法.c》

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

#define MAX_VALUE 255

// 快速傅里叶变换的数据必须是 2^n  
#define NUM_x 	(int)(1<<3)
#define NUM_y 	(int)(1<<3)

struct _complex  f[NUM_y][NUM_x];		// 原始数据
struct _complex  F[NUM_y][NUM_x];		// 傅里叶变换的数据
struct _complex IF[NUM_y][NUM_x];		// 傅里叶逆变换的数据

void Init_data(void)
{	
	int x,y;
	srand(time(NULL));

	printf("初始化数据：\n");
	for(y = 0; y<NUM_y; y++){
		for(x = 0; x<NUM_x; x++){
			//f[y][x].x = rand()% MAX_VALUE;
			f[y][x].x = x+y;
			f[y][x].y = 0;
			printf("%3.0f  ", f[y][x].x); 
			
			F[y][x].x = 0;
			F[y][x].y = 0;
			
			IF[y][x].x = 0;
			IF[y][x].y = 0;
		}
		printf("\n");
	}
} 

// 以 {0，2，4，6， 1，3，5，7} 排序，
// 数组传参使用 &f[y][x] 的形式传入，取数据时使用 f[y*NUM_x + x].x 形式获取
// split_array(&f[u][0], &F[u][0], NUM_x, 0, 0);	// 对 x分组 
// split_array(&f[u][0], &F[u][0], 0, NUM_y, 1);	// 对 y分组 
// flag: 0 时，对x 分组 
// flag: 1 时，对y 分组 
void split_array(struct _complex *src, struct _complex *dst , int x_n, int y_n, int flag)
{	
	int i;
	struct _complex t[flag == 0 ? x_n/2 : y_n/2], *s = src, *d = dst;
	
	if(flag == 0){ 
		if(x_n <= 1)
			return;
		
		for(i = 0; i<x_n/2 ; i++){
			t[i].x = s[i*2 + 1].x;		// 暂存奇数项 
			t[i].y = s[i*2 + 1].y;
			
			d[i].x = s[i*2].x;			// 拷贝偶数项到低位 
			d[i].y = s[i*2].y;
		}
		for(i = 0; i<x_n/2 ; i++){
			d[i + x_n/2].x = t[i].x;	// 拷贝奇数项到高位 
			d[i + x_n/2].y = t[i].y;
		}
		split_array(dst, 		dst, 		x_n/2, y_n, flag);
		split_array(dst+x_n/2, 	dst+x_n/2, 	x_n/2, y_n, flag);	
	} 
	else{
		if(y_n <= 1) 
			return;
			
		for(i = 0; i<y_n/2 ; i++){
			t[i].x = s[(i*2 + 1)*NUM_x ].x;		// 暂存奇数项 
			t[i].y = s[(i*2 + 1)*NUM_x ].y;
			
			d[i*NUM_x ].x = s[(i*2)*NUM_x ].x;			// 拷贝偶数项到低位 
			d[i*NUM_x ].y = s[(i*2)*NUM_x ].y;
		}
		for(i = 0; i<y_n/2 ; i++){
			d[(i+y_n/2)*NUM_x ].x = t[i].x;	// 拷贝奇数项到高位 
			d[(i+y_n/2)*NUM_x ].y = t[i].y;
		}
		split_array(dst, 				dst, 				x_n, y_n/2, flag);
		split_array(dst+NUM_x*y_n/2, 	dst+NUM_x*y_n/2, 	x_n, y_n/2, flag);	
	} 
}

// src:源数组 &f[y][x]  dst:结果数组&F[y][x]   flag: 1:正变换   -1 逆变换
void fft(struct _complex *src, struct _complex *dst, int flag)
{
	int y, x, i, u, k , n;
	double wu;
	struct _complex w, a0, a1, t; 
	clock_t start, end;
	start = clock();
	/// 
	// 对x每一行做傅里叶变换 
	for(y = 0; y<NUM_y; y++){ 	
		// 先分割数组 
		split_array(&src[y*NUM_x+0], &dst[y*NUM_x+0], NUM_x, 0, 0);	// 对 x分组 	
		
		// 对 f[y][] 这一组数进行傅里叶变换 
		for(i = 0; i<log2(NUM_x); i++)	//计算次数为 2^n = num，即n = log2^num 
		{
			// 每次计算的间隔是 2^n,分别为 1，2，4，8 
			n = 2 * pow(2, i);				// 本轮一组个数为 2 * 2^n，分别为 2,4,8,则好3轮 
			for(k = 0; k<NUM_x/n; k++)		// num/n 为当前的组数，分别为 4，2，1 
			{
				for(u=0; u<n/2; u++)		// 对每组进行计算, a0 和 b0 的个数分别为 n/2 
				{ 
					wu = -1 * 2 * M_PI * u / n;	// 计算旋转因子
					w.x = cos(wu);
					w.y = flag * sin(wu);		//  如果是傅里叶逆变换，此处 flag = -1 
					
					a0 = dst[y*NUM_x + k*n + u];			// 奇数项 	[y][k*n+u]
					a1 = dst[y*NUM_x + k*n + u + n/2];		// 偶数项 	[y][k*n+u+n/2]
					
					t.x =  w.x*a1.x - w.y*a1.y;
					t.y =  w.x*a1.y + w.y*a1.x;
					
					dst[y*NUM_x + k*n + u].x =  a0.x + t.x;				// F[u] = A0 + wA1
					dst[y*NUM_x + k*n + u].y =  a0.y + t.y;
					dst[y*NUM_x + k*n + u + n/2].x =  a0.x - t.x;		// F[u+n/2] = A0 - wA1
					dst[y*NUM_x + k*n + u + n/2].y =  a0.y - t.y;
				}
			}
		}
		
		if(flag == -1){
			for(u = 0; u<NUM_x; u++){
				dst[y*NUM_x + u].x /= NUM_x;
				dst[y*NUM_x + u].y /= NUM_x;
			}
		}	
	}
	// 打印当变换结果 
	end = clock();
	printf("\n\n每行傅里叶%s变换结果为： 耗时%fs, NUM=%d x %d\n",flag==1?"":"逆", (double)(end-start)/CLOCKS_PER_SEC, NUM_y, NUM_x);
	for(y = 0; y<NUM_y; y++)
	{
		for(x = 0; x<NUM_x; x++){
			printf("[%7.2f+%7.2fj] ", dst[y*NUM_x +x].x, dst[y*NUM_x +x].y);
		}
		printf("\n");
	}
	
	/// 
	// 对y每一列做傅里叶变换 
	for(x = 0; x<NUM_x; x++){
		// 先分割数组 
		split_array(&dst[0*NUM_x+x], &dst[0*NUM_x+x], 0, NUM_y, 1);	// 对 y分组 	
		
		// 对 f[][x] 这一组数进行傅里叶变换 
		for(i = 0; i<log2(NUM_y); i++)	//计算次数为 2^n = num，即n = log2^num 
		{
			// 每次计算的间隔是 2^n,分别为 1，2，4，8 
			n = 2 * pow(2, i);				// 本轮一组个数为 2 * 2^n，分别为 2,4,8,则好3轮 
			for(k = 0; k<NUM_y/n; k++)		// num/n 为当前的组数，分别为 4，2，1 
			{
				for(u=0; u<n/2; u++)		// 对每组进行计算, a0 和 b0 的个数分别为 n/2 
				{ 
					wu = -1 * 2 * M_PI * u / n;	// 计算旋转因子
					w.x = cos(wu);
					w.y = flag * sin(wu);		//  如果是傅里叶逆变换，此处 flag = -1 
					
					a0 = dst[(k*n + u)*NUM_x 		+ x ];			// 奇数项 	[k*n+u][x]
					a1 = dst[(k*n + u + n/2)*NUM_x 	+ x ];		// 偶数项 		[(k*n + u + n/2)*NUM_y 	+ x ][x]
					
					t.x =  w.x*a1.x - w.y*a1.y;
					t.y =  w.x*a1.y + w.y*a1.x;
					
					dst[(k*n + u)*NUM_x 		+ x ].x =  a0.x + t.x;				// F[u] = A0 + wA1
					dst[(k*n + u)*NUM_x 		+ x ].y =  a0.y + t.y;
					dst[(k*n + u + n/2)*NUM_x 	+ x ].x =  a0.x - t.x;				// F[u+n/2] = A0 - wA1
					dst[(k*n + u + n/2)*NUM_x 	+ x ].y =  a0.y - t.y;
					
				}
			}
		}
		if(flag == -1){
			for(u = 0; u<NUM_y; u++){
				dst[u*NUM_x + x].x /= NUM_y;
				dst[u*NUM_x + x].y /= NUM_y;
			}
		}	
	}
	
	// 打印当变换结果 
	end = clock(); 
	printf("\n\n最终傅里叶%s变换结果为： 耗时%fs, NUM=%d x %d\n",flag==1?"":"逆", (double)(end-start)/CLOCKS_PER_SEC, NUM_y, NUM_x);
	for(y = 0; y<NUM_y; y++)
	{
		for(x = 0; x<NUM_x; x++){
			if(flag == 1) 
				printf("[%7.2f+%7.2fj] ", dst[y*NUM_x +x].x, dst[y*NUM_x +x].y);
			else
				printf("[%3.0f+%3.0fj] ", dst[y*NUM_x +x].x, dst[y*NUM_x +x].y); 
		}
		printf("\n");
	}
}

int main(void)
{
	int u,v;
	Init_data();
	
	fft(&f[0][0], &F[0][0], 1); 	// 快速傅里叶变换 
	
	fft(&F[0][0], &IF[0][0], -1); 	// 快速傅里叶逆变换 
	
	printf("\n\n");
	return 0;
}

2.1 运行结果

初始化数据：
  0    1    2    3
  1    2    3    4
  2    3    4    5
  3    4    5    6
  4    5    6    7
  5    6    7    8
  6    7    8    9
  7    8    9   10

每行傅里叶变换结果为： 耗时0.000000s, NUM=8 x 4
[   6.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  10.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  14.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  18.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  22.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  26.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  30.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]
[  34.00+   0.00j] [  -2.00+   2.00j] [  -2.00+   0.00j] [  -2.00+  -2.00j]

最终傅里叶变换结果为： 耗时0.002000s, NUM=8 x 4
[ 160.00+   0.00j] [ -16.00+  16.00j] [ -16.00+   0.00j] [ -16.00+ -16.00j]
[ -16.00+  38.63j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -16.00+  16.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -16.00+   6.63j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -16.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -16.00+  -6.63j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -16.00+ -16.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -16.00+ -38.63j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]

每行傅里叶逆变换结果为： 耗时0.000000s, NUM=8 x 4
[  28.00+   0.00j] [  36.00+   0.00j] [  44.00+   0.00j] [  52.00+  -0.00j]
[  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j]
[  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j]
[  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j]
[  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j]
[  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j]
[  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j]
[  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j]

最终傅里叶逆变换结果为： 耗时0.003000s, NUM=8 x 4
[  0+  0j] [  1+  0j] [  2+  0j] [  3+ -0j]
[  1+  0j] [  2+  0j] [  3+  0j] [  4+  0j]
[  2+ -0j] [  3+ -0j] [  4+ -0j] [  5+ -0j]
[  3+  0j] [  4+  0j] [  5+  0j] [  6+  0j]
[  4+  0j] [  5+  0j] [  6+  0j] [  7+ -0j]
[  5+ -0j] [  6+ -0j] [  7+ -0j] [  8+ -0j]
[  6+  0j] [  7+  0j] [  8+  0j] [  9+  0j]
[  7+ -0j] [  8+ -0j] [  9+ -0j] [ 10+ -0j]

在这里插入图片描述



三、二维 F F T FFT FFT 及 I F F T IFFT IFFT代码实现（递归法）

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

#define MAX_VALUE 255

// 快速傅里叶变换的数据必须是 2^n  
#define NUM_x 	(int)(1<<3)
#define NUM_y 	(int)(1<<3)

struct _complex  f[NUM_y][NUM_x];		// 原始数据
struct _complex  F[NUM_y][NUM_x];		// 傅里叶变换的数据
struct _complex IF[NUM_y][NUM_x];		// 傅里叶逆变换的数据

void Init_data(void)
{	
	int x,y;
	srand(time(NULL));

	printf("初始化数据：\n");
	for(y = 0; y<NUM_y; y++){
		for(x = 0; x<NUM_x; x++){
			//f[y][x].x = rand()% MAX_VALUE;
			f[y][x].x = x+y;
			f[y][x].y = 0;
			printf("%3.0f  ", f[y][x].x); 
			
			F[y][x].x = 0;
			F[y][x].y = 0;
			
			IF[y][x].x = 0;
			IF[y][x].y = 0;
		}
		printf("\n");
	}
} 

// 以 {0，2，4，6， 1，3，5，7} 排序，
// 数组传参使用 &f[y][x] 的形式传入，取数据时使用 f[y*NUM_x + x].x 形式获取
// split_array(&f[u][0], &F[u][0], NUM_x, 0, 0);	// 对 x分组 
// split_array(&f[u][0], &F[u][0], 0, NUM_y, 1);	// 对 y分组 
// flag: 0 时，对x 分组 
// flag: 1 时，对y 分组 
void split_array(struct _complex *src, struct _complex *dst , int x_n, int y_n, int flag)
{	
	int i;
	struct _complex t[flag == 0 ? x_n/2 : y_n/2], *s = src, *d = dst;
	
	if(flag == 0){ 
		if(x_n <= 1)
			return;
		
		for(i = 0; i<x_n/2 ; i++){
			t[i].x = s[i*2 + 1].x;		// 暂存奇数项 
			t[i].y = s[i*2 + 1].y;
			
			d[i].x = s[i*2].x;			// 拷贝偶数项到低位 
			d[i].y = s[i*2].y;
		}
		for(i = 0; i<x_n/2 ; i++){
			d[i + x_n/2].x = t[i].x;	// 拷贝奇数项到高位 
			d[i + x_n/2].y = t[i].y;
		}
		//split_array(dst, 		dst, 		x_n/2, y_n, flag);
		//split_array(dst+x_n/2, 	dst+x_n/2, 	x_n/2, y_n, flag);	
	} 
	else{
		if(y_n <= 1) 
			return;
			
		for(i = 0; i<y_n/2 ; i++){
			t[i].x = s[(i*2 + 1)*NUM_x ].x;		// 暂存奇数项 
			t[i].y = s[(i*2 + 1)*NUM_x ].y;
			
			d[i*NUM_x ].x = s[(i*2)*NUM_x ].x;			// 拷贝偶数项到低位 
			d[i*NUM_x ].y = s[(i*2)*NUM_x ].y;
		}
		for(i = 0; i<y_n/2 ; i++){
			d[(i+y_n/2)*NUM_x ].x = t[i].x;	// 拷贝奇数项到高位 
			d[(i+y_n/2)*NUM_x ].y = t[i].y;
		}
		//split_array(dst, 				dst, 				x_n, y_n/2, flag);
		//split_array(dst+NUM_y*y_n/2, 	dst+NUM_y*y_n/2, 	x_n, y_n/2, flag);	
	} 
}

//flag =1	: FFT快速傅里叶变换
//flag =-1	: IFFT快速傅里叶逆变换
void fft_x(struct _complex *src, struct _complex *dst, int num, int flag)
{
	int u;
	double x;
	struct _complex w, a0, a1, t;
	
	if(num ==1) return;
	
	split_array(src, dst, num, 0, 0);		// 分割 x 数组
	
	fft_x(dst, 		dst,		num/2, flag);			// 递归
	fft_x(dst+num/2, 	dst+num/2,	num/2, flag);
	
 	for(u = 0; u<num/2; u++){
		x = -1* 2 * M_PI * u / num; // 计算旋转因子 
		w.x = cos(x);
		w.y = flag * sin(x);		// 正变换，此处为 +，逆变以换，此处为 - 
		
		a0 = dst[u];				// 偶项 
		a1 = dst[u + num/2];		// 奇项 
		
		t.x = a1.x*w.x - a1.y*w.y;	// 计算 t = a1 * w
		t.y = a1.y*w.x + a1.x*w.y;
		
		dst[u].x = a0.x + t.x;
		dst[u].y = a0.y + t.y;
		
		dst[u+num/2].x = a0.x - t.x; 
		dst[u+num/2].y = a0.y - t.y;
	}
	
	if(num == NUM_x && flag == -1)
	for(u = 0; u<NUM_x; u++)
	{
		dst[u].x /= (double)NUM_x;
		dst[u].y /= (double)NUM_x;
	}

}

//flag =1	: FFT快速傅里叶变换
//flag =-1	: IFFT快速傅里叶逆变换
void fft_y(struct _complex *src, struct _complex *dst, int num, int flag)
{
	int u;
	double x;
	struct _complex w, a0, a1, t;
	
	if(num ==1) return;
	
	split_array(src, dst, 0, num, 1);		// 分割 x 数组
	
	fft_y(dst, 					dst,				num/2, flag);			// 递归
	fft_y(dst+NUM_x*(num/2), 	dst+NUM_x*(num/2),	num/2, flag);
	
 	for(u = 0; u<num/2; u++){
		x = -1* 2 * M_PI * u / num; // 计算旋转因子 
		w.x = cos(x);
		w.y = flag * sin(x);		// 正变换，此处为 +，逆变以换，此处为 - 
		
		a0 = dst[u*NUM_x];				// 偶项 
		a1 = dst[(u+num/2)*NUM_x];		// 奇项 
		
		t.x = a1.x*w.x - a1.y*w.y;	// 计算 t = a1 * w
		t.y = a1.y*w.x + a1.x*w.y;
		
		dst[u*NUM_x].x = a0.x + t.x;
		dst[u*NUM_x].y = a0.y + t.y;
		
		dst[(u+num/2)*NUM_x].x = a0.x - t.x; 
		dst[(u+num/2)*NUM_x].y = a0.y - t.y;
	}
	
	if(num == NUM_y && flag == -1)
	for(u = 0; u<NUM_y; u++)
	{
		dst[u*NUM_x].x /= (double)NUM_y;
		dst[u*NUM_x].y /= (double)NUM_y;
	}
	
}

void fft(struct _complex *src, struct _complex *dst, int flag)
{
	int x,y;
	 
	for(y = 0; y<NUM_y; y++)					// 对每一行递归做傅里叶变换 
		fft_x(src+y*NUM_x, dst+y*NUM_x, NUM_x, flag); 		// 快速傅里叶变换 
		
	printf("\n\n每行傅里叶%s变换结果为： NUM=%d x %d\n",flag==1?"":"逆", NUM_y, NUM_x);
	for(y = 0; y<NUM_y; y++)
	{
		for(x = 0; x<NUM_x; x++){
			printf("[%7.2f+%7.2fj] ", dst[y*NUM_x + x].x, dst[y*NUM_x + x].y);
		}
		printf("\n");
	} 
	
		
	for(x = 0; x<NUM_x; x++)					// 对每一列递归做傅里叶变换 
		fft_y(dst+x, dst+x, NUM_y, flag); 		// 快速傅里叶变换 
			
	printf("\n\n最终傅里叶%s变换结果为： NUM=%d x %d\n",flag==1?"":"逆", NUM_y, NUM_x);
	for(y = 0; y<NUM_y; y++)
	{
		for(x = 0; x<NUM_x; x++){
			printf("[%7.2f+%7.2fj] ", dst[y*NUM_x + x].x, dst[y*NUM_x + x].y);
		}
		printf("\n");
	} 
}

int main(void)
{
	int x,y;
	Init_data();	

	fft(&f[0][0], &F[0][0], 1);			// 傅里叶变换 
	fft(&F[0][0], &IF[0][0], -1);		// 傅里叶逆变换 
	
	return 0;
}

3.1 运行结果

初始化数据：
  0    1    2    3    4    5    6    7
  1    2    3    4    5    6    7    8
  2    3    4    5    6    7    8    9
  3    4    5    6    7    8    9   10
  4    5    6    7    8    9   10   11
  5    6    7    8    9   10   11   12
  6    7    8    9   10   11   12   13
  7    8    9   10   11   12   13   14

每行傅里叶变换结果为： NUM=8 x 8
[  28.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  36.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  44.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  52.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  60.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  68.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  76.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]
[  84.00+   0.00j] [  -4.00+   9.66j] [  -4.00+   4.00j] [  -4.00+   1.66j] [  -4.00+   0.00j] [  -4.00+  -1.66j] [  -4.00+  -4.00j] [  -4.00+  -9.66j]

最终傅里叶变换结果为： NUM=8 x 8
[ 448.00+   0.00j] [ -32.00+  77.25j] [ -32.00+  32.00j] [ -32.00+  13.25j] [ -32.00+   0.00j] [ -32.00+ -13.25j] [ -32.00+ -32.00j] [ -32.00+ -77.25j]
[ -32.00+  77.25j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -32.00+  32.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -32.00+  13.25j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -32.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -32.00+ -13.25j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -32.00+ -32.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]
[ -32.00+ -77.25j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j] [   0.00+   0.00j]

每行傅里叶逆变换结果为： NUM=8 x 8
[  28.00+   0.00j] [  36.00+   0.00j] [  44.00+  -0.00j] [  52.00+   0.00j] [  60.00+   0.00j] [  68.00+  -0.00j] [  76.00+   0.00j] [  84.00+  -0.00j]
[  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j] [  -4.00+   9.66j]
[  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j] [  -4.00+   4.00j]
[  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j] [  -4.00+   1.66j]
[  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j] [  -4.00+   0.00j]
[  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j] [  -4.00+  -1.66j]
[  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j] [  -4.00+  -4.00j]
[  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j] [  -4.00+  -9.66j]

最终傅里叶逆变换结果为： NUM=8 x 8
[   0.00+   0.00j] [   1.00+   0.00j] [   2.00+  -0.00j] [   3.00+   0.00j] [   4.00+   0.00j] [   5.00+  -0.00j] [   6.00+   0.00j] [   7.00+  -0.00j]
[   1.00+   0.00j] [   2.00+   0.00j] [   3.00+   0.00j] [   4.00+   0.00j] [   5.00+   0.00j] [   6.00+   0.00j] [   7.00+   0.00j] [   8.00+   0.00j]
[   2.00+  -0.00j] [   3.00+   0.00j] [   4.00+  -0.00j] [   5.00+   0.00j] [   6.00+  -0.00j] [   7.00+  -0.00j] [   8.00+   0.00j] [   9.00+  -0.00j]
[   3.00+   0.00j] [   4.00+   0.00j] [   5.00+   0.00j] [   6.00+   0.00j] [   7.00+   0.00j] [   8.00+   0.00j] [   9.00+   0.00j] [  10.00+  -0.00j]
[   4.00+   0.00j] [   5.00+   0.00j] [   6.00+  -0.00j] [   7.00+   0.00j] [   8.00+   0.00j] [   9.00+  -0.00j] [  10.00+   0.00j] [  11.00+  -0.00j]
[   5.00+  -0.00j] [   6.00+   0.00j] [   7.00+  -0.00j] [   8.00+   0.00j] [   9.00+  -0.00j] [  10.00+  -0.00j] [  11.00+  -0.00j] [  12.00+  -0.00j]
[   6.00+   0.00j] [   7.00+   0.00j] [   8.00+   0.00j] [   9.00+   0.00j] [  10.00+   0.00j] [  11.00+  -0.00j] [  12.00+   0.00j] [  13.00+  -0.00j]
[   7.00+  -0.00j] [   8.00+   0.00j] [   9.00+  -0.00j] [  10.00+  -0.00j] [  11.00+  -0.00j] [  12.00+  -0.00j] [  13.00+  -0.00j] [  14.00+  -0.00j]

在这里插入图片描述



《【数字图像处理】2.4:二维FFT,IFFT,c语言实现》

"小夜猫&小懒虫&小财迷"的男人
关注
  • 11
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
实验二:fft算法的matlab实现_C语言系列之FFT算法实现
weixin_39973410的博客
12-03 2628
0x10 序言 长文预警，详细介绍FFT算法的编程原理和C实现，并在文章的最后附上了本文的所有源代码。0x11 速览1）FFT背后的数学原理2）码位倒序3）蝶形运算设计4）利用复数FFT编写复数IFT，实数FFT和实数IFFT5）总结0x20 FFT背后的数学原理01前言本文阅读前提知识准备：已经初步了解傅里叶变换。傅里叶变换公式： 本文不刨根问底，只讲跟FFT编程相关必须知道的知识，相...
数字图像处理中的傅立叶变换
dbt67865的博客
10-28 879
二维Fourier变换的应用 前面已经提到了Fourier变换有两个好处，即：可以获得信号的频域特性；可以将卷积运算转换为乘积运算。 因此二维Fourier变换的应用也是根据这两个特点来进行的。 在图像滤波中的应用 首先，我们来看Fourier变换后的图像，中间部分为低频部分，越靠外边频率越高。因此，我们可以在Fourier变换图中，选择所需要的高频或是低频滤波。 在图像...
图像处理|关于二维傅里叶变换的学习笔记（实用版）
qq_44654715的博客
04-24 948
需要注意，一般将两个方向的剪切依次结合会产生不同的结果。换句话说，先进性水平剪切，后进行垂直剪切，与先进行垂直剪切，后进行水平剪切得到的效果是。傅里叶变换是将图像从空间域转换到频域，其逆变换是将图像从频域转到空间域。将图像在图像空间旋转一定的角度，其傅里叶变换在频谱空间旋转。因为图像至少是2D的，所以在数字图像处理中使用的都是。因为沿水平方向的纯剪切仅使像素的水平坐标发生与像素的。，即梯度的大小，即该点的频域大小。，沿垂直方向的纯剪切仅使像素的垂直坐标发生。的平移不影响其傅里叶变换的幅值。
傅里叶变换 二维快速傅里叶变换（快速的二维离散傅里叶变换、分治法）
qq_36511401的博客
11-13 1万+
可以看作M行N列的二维数组，先对每行做一维FFT，将结果作为一个新的二维数组。而在处理二维IFFT的时候，跟二维FFT差不多，只要在公共方法中控制正负值，来区分是FFT还是IFFT。如果是FFT的话，刚开始的时候，要将double转为Complex复数，如果是IFFT的话，要在结束的时候，将每个值都除以MN。还要将DFT的代码注释了，不然跑不动。设置行列大小都为128的时候，发现二维DFT和二维FFT差距还是很明显的，随着行列的增大，差距只会越来越大。的写法，相结合的话，就可以很容易得出二维FFT的写法。
二维傅里叶变换
jk_101的博客
05-28 3942
fft2 函数将二维数据变换为频率空间。例如，可以变换二维光学掩膜以揭示其衍射模式。 二维傅里叶变换 以下公式定义 m×n 矩阵 X 的离散傅里叶变换 Y。 和 是以下方程所定义的复单位根。 i 是虚数单位，p 和 j 是值范围从 0 到 m–1 的索引，q 和 k 是值范围从 0 到 n–1 的索引。在此公式中，X 和 Y 的索引平移 1 位，以反映 MATLAB®中的矩阵索引。 计算 X 的二维傅里叶...
通过二维FFT变换对比加入窗函数之后的图像频谱和相位
FPGA/MATLAB学习教程/源码/项目合作开发
01-01 3474
另外，在功率谱估计中也要遇到窗函数加权问题。做法是从信号中截取一个时间片段，然后用截取的信号时间片段进行周期延拓处理，得到虚拟的无限长的信号，然后就可以对信号进行傅里叶变换、相关分析等数学处理。做法是从信号中截取一个时间片段，然后用截取的信号时间片段进行周期延拓处理，得到虚拟的无限长的信号，然后就可以对信号进行傅里叶变换、相关分析等数学处理。加窗实质是用一个所谓的窗函数与原始的时域信号作乘积的过程（当然加窗也可以在频域进行，但时域更为普遍），使得相乘后的信号似乎更好地满足傅立叶变换的周期性要求。
二维傅里叶变换简化方式
wuduanxian的博客
12-21 1962
在处理二维矩阵时，常想着如何把时域转换到频域来处理，因此翻来了以往数分里面的常用的傅里叶(Fourier Transform); （Notes:一下公式中 M,N分别为二维矩阵的列数和行数，f(x,y) 代表改二维矩阵，F(u,v)为转换后的矩阵）； I. 傅里叶变换的公式： 拆分到这里，我也很开心的掏出祖传的Matlab写了几行代码来实现： function [Fuv] = Myft2(fxy) [N,M,dim] = size(fxy); if dim > 1 txy = doub
二维离散付立叶变换及其性质
逍遥剑客
04-22 1万+
　　一、概述　　离散付立叶变换（Discrete Fourier Transform── 简称DFT）在数字信号处理和数字图像处理中应用十分广泛。它建立了离散时域和离散之间的联系。如果直接应用卷积和相关运算在时域中处理，计算量将随着取样点数 数学 的平方而增加，这使计算机的计算量大，很费时，很难达到实时处理的要求。因此，一般可采用 DFT方法，将输入的数字信号首先进行 DFT变换，在频
C++实现二维快速傅里叶变换（FFT）
海盗Isaac
12-31 1万+
上一篇文章里，我根据DFT公式用C++实现了二维离散傅里叶变换。但跑一张300*300的图片都要好几分钟，速度实在太慢了。我研究了下快速傅里叶变换，在网上找了一些资料，然后用C++实现了二维快速傅里叶变换，速度超级快，512*512的图片在0.1秒内就能处理完。 我们知道一维离散傅里叶变换公式如下 其中。 用矩阵表示即为： ...
数字信号处理FFT快速傅立叶变换MATLAB实现+源码
最新发布
07-02
数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT快速傅立叶变换MATLAB实现+源码 数字信号处理FFT...
实验4 快速傅立叶变换(FFT).doc
07-06
快速傅立叶变换（FFT）是数字信号处理领域中一种至关重要的算法，它极大地提高了离散傅立叶变换（DFT）的计算效率。DFT是连续傅立叶变换在离散时间序列上的应用，然而，由于DFT的计算复杂度为O(N^2)，对于大数据量的...
FFT.rar_FFT 变换_c fft_傅立叶变换_快速傅立叶
09-24
快速傅立叶变换（FFT）是数字信号处理领域中一种重要的算法，用于高效地计算离散傅立叶变换（DFT）及其逆变换。在标题"FFT.rar_FFT 变换_c fft_傅立叶变换_快速傅立叶"中，我们可以看到这个压缩包包含了关于C语言...
FFT.rar_fft_fft c++_傅立叶_快速傅立叶_快速傅立叶变换
09-19
在标题“FFT.rar_fft_fft c++_傅立叶_快速傅立叶_快速傅立叶变换”中，我们可以看到关键词“FFT”、“c++”以及“傅立叶”，这表明这个压缩包包含的是用C++编程语言实现的快速傅立叶变换算法。而描述中的“快速傅立...
fft.zip_C语言 二维fft_二维fft_快速傅里叶变换
09-14
本程序"fft.zip"包含一个名为"fft.c"的C语言源代码文件，专注于实现二维FFT，即对二维数据进行快速傅里叶变换。 在数字信号处理中，一维FFT通常用于分析一维信号的时间域与频域之间的关系，而二维FFT则常用于图像...
二维离散傅里叶（DFT）与快速傅里叶（FFT）的实现
asmartplum的博客
05-04 1万+
前言源于图像处理与模式识别课作业。最初接触是在大一数学分析课上，小远姐的一次大作业要求是写一篇关于傅里叶变换的应用的文章，当时有去图书馆查阅一些信号处理的书籍，第一了解到傅里叶变换。之后暑假中参与学校实验室做图像处理项目的时候，看书看到傅里叶变换，一是当时觉得太复杂了，二是所做的项目对于实时性要求较高，即便是fft可能对于3000*2000以上的图片也难以达到实时性，主要用到的边缘检测方面Sobe...
形象理解二维傅里叶变换
forfuture3513的博客
03-18 2629
形象理解二维傅里叶变换
二维FFT的阵列方向图快速计算公式推导
qq_38151438的博客
10-29 4340
二维FFT公式 二维阵列方向图表达式 令k=[M/λdxsinθcosφ]，l=[N/λdysinθsinφ]，则k=-M/2,…,0,…,M/2-1, l=-N/2,…,0,…,N/2-1 得到 对w做二维FFT得到 比较式（3）和式（4），对于式（4）做IFFTSHIFT，便可得到式（3），从而 ...
二维离散傅里叶变换与逆变换的原理与实现(Matlab)
热门推荐
仗剑走天涯
03-20 2万+
前言 在野外数据采集中，虽然单个仪器采集的是一维信号，但是当把多台仪器数据汇总并生成做二维剖面的图像时，噪声可不只有一维的，更有x,y两个方差同时存在的"二维噪声"！我们已经知道一维噪声可以用一维傅里叶变换到频域滤波，同理二维噪声也可以用二维傅里叶变换到"频率滤波"。 二维傅里叶正变换的原理 笔者很讨厌一上来就看到一连串复杂的公式！因此当我看懂一个原理后，我就会用最好理解的方式来重述它，毕竟我更偏...
利用C语言实现FFT、IFFT运算
mddh_123的博客
11-01 1万+
一、FFT、IFFT算法实现 上述分别为FFT、IFFT公式。下面首先讨论FFT的算法实现。本文采用输入逆序、输出顺序的FFT计算方法。**实质上就是在时域对x(n)进行“奇偶分类”、在频域上对X(k)进行“前后分类”。**值得说明的是，这里的“奇”和“偶”是相对的概念，并不完全是通常我们所理解的“奇”和“偶”。下面将给出一个例子进行说明： ...
快速傅立叶变换(fft)算法设计
05-26
快速傅立叶变换(FFT)算法是一种高效的计算傅立叶变换的算法，它可以在O(n log n)的时间复杂度下完成n点离散傅立叶变换(DFT)的计算。下面是FFT算法的设计步骤： 1. 将输入序列分为偶数项和奇数项，分别进行DFT计算得到两个序列，这个过程可以递归地进行。 2. 将得到的两个序列合并起来，得到最终的结果。 具体实现时，可以使用迭代式的算法，也可以使用递归式的算法。下面是递归式的FFT算法的伪代码： ``` FFT(A, n): if n == 1: return A else: A_even = [A[2*i] for i in range(n//2)] A_odd = [A[2*i+1] for i in range(n//2)] Y_even = FFT(A_even, n//2) Y_odd = FFT(A_odd, n//2) Y = [0] * n for k in range(n): t = complex(0, -2 * pi * k / n) Y[k] = Y_even[k % (n//2)] + t * Y_odd[k % (n//2)] return Y ``` 其中，A表示输入序列，n表示序列的长度，Y表示输出序列。这个算法的时间复杂度为O(n log n)。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

"小夜猫&小懒虫&小财迷"的男人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值