如何 FFT(快速傅里叶变换) 求幅度、频率(超详细 含推导过程)


如何 FFT(快速傅里叶变换) 求幅度、频率(超详细 含推导过程)

为知道这个答案查了很多资料,总结一下。

注:本文代码的头文件等如下

import numpy as np
from scipy.fftpack import fft
import matplotlib.pyplot as plt
from matplotlib.pylab import mpl

mpl.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文
mpl.rcParams['axes.unicode_minus'] = False  # 显示负号


一. 打颗栗子


我们设

采样频率为Fs信号最高频率为F采样点数为N

并且有如下波形的一个信号。该信号由频率分量为0Hz200Hz400Hz600Hz的四个标准正弦函数组成。
原始信号图

对应完整代码

# 采样点选择1400个,因为设置的信号频率分量最高为600赫兹,根据采样定理知采样频率要大于信号频率2倍,
# 所以这里设置采样频率为1400赫兹(即一秒内有1400个采样点)
N = 1400  # 设置1400个采样点
x = np.linspace(0, 1, N)  # 将0到1平分成1400份

# 设置需要采样的信号,频率分量有0,200,400和600
y = 7 * np.sin(2 * np.pi * 200 * x) + 5 * np.sin(
    2 * np.pi * 400 * x) + 3 * np.sin(2 * np.pi * 600 * x) + 10  # 构造一个演示用的组合信号

plt.plot(x, y)
plt.title('原始波形')
plt.show()


可以看出,在这个例子中

采样频率Fs信号最高频率F采样点数N
1400Hz600Hz1400个



二. 求幅度

1. 快速傅里叶变换

在此基础上,我们进行快速傅里叶变换(FFT),得到N个复数。每一个复数值包含着一个特定频率的信息。根据这N个复数,可以知道拆分原始信号得到的各个频率和他们的幅度值。

对应代码

fft_y = fft(y)  # 使用快速傅里叶变换,得到的fft_y是长度为N的复数数组

根据此数据,可以画出下面这个不是很规则的图。
(在求幅度这一节,我们先把精力集中在纵轴,横轴将在下一节求频率的时候讲解。)

双边振幅未求绝对值

对应完整代码如下

N = 1400  # 设置1400个采样点
x = np.linspace(0, 1, N)  # 将0到1平分成1400份
y = 7 * np.sin(2 * np.pi * 200 * x) + 5 * np.sin(
    2 * np.pi * 400 * x) + 3 * np.sin(2 * np.pi * 600 * x) + 10  # 构造一个演示用的组合信号
fft_y = fft(y)  # 使用快速傅里叶变换,得到的fft_y是长度为N的复数数组

x = np.arange(N)  # 频率个数 (x的取值涉及到横轴的设置,这里暂时忽略,在第二节求频率时讲解)

plt.plot(x, fft_y, 'black')
plt.title('双边振幅谱(未求振幅绝对值)', fontsize=9, color='black')

plt.show()


2. 求出复数的绝对值

用复数直接画出的图不是我们需要的。应先求出全部N个复数的绝对值(模长)

abs_y = np.abs(fft_y)  # 取复数的绝对值,即复数的模

据此可画出下图

未归一化的双边振幅谱

3. 归一化

上图中,左侧第一个竖线的纵坐标值,是 从原始信号中提取出来的0Hz对应的信号强度(信号振幅),又称 直流分量。它对应的信号振幅为 当前值/FFT的采样点数N,即

0Hz对应振幅 = 当前值 / 采样点数N

注:

  1. 本例中,直流分量对应振幅 = 14000 / 1400 = 10
  2. 当前值为根据当前复数求出的绝对值(模长),对应图中竖线的纵坐标最大值

直流分量以外的分量所对应的信号振幅为 当前值/(采样点数N/2),即

其余频率对应的振幅 = 当前值 /(采样点数N / 2)

注:

  1. 本例中,200Hz对应振幅 = 5000 / (1400 / 2) ≈ 7.14(这里的5000是对200Hz对应纵坐标的估计值,只是为了举例,不一定准确),其余频率对应振幅算法相同。


于是,在归一化后,我们得到下图

双边归一化频谱
对应完整代码

N = 1400  # 设置1400个采样点
x = np.linspace(0, 1, N)  # 将0到1平分成1400份
y = 7 * np.sin(2 * np.pi * 200 * x) + 5 * np.sin(
    2 * np.pi * 400 * x) + 3 * np.sin(2 * np.pi * 600 * x) + 10  # 构造一个演示用的组合信号
fft_y = fft(y)  # 使用快速傅里叶变换,得到的fft_y是长度为N的复数数组

x = np.arange(N)  # 频率个数(x的取值涉及到横轴的设置,这里暂时忽略,在第二节求频率时讲解)

abs_y = np.abs(fft_y)  # 取复数的绝对值,即复数的模
normalization_y = abs_y / (N / 2)  # 归一化处理(双边频谱)
normalization_y[0] /= 2

plt.plot(x, abs_y, 'r')
plt.title('双边振幅谱(归一化)', fontsize=9, color='red')
plt.show()

小结

直流分量(0Hz)振幅其余频率振幅
fft得到的复数的绝对值 / Nfft得到的复数的绝对值 / (N / 2)


三. 求频率

这里先放上一段文字,这段话较为形象的解释了求频率的方法。

举个例子,你有一个最高频率f = 32kHz的模拟信号,采样频率 64kHz,对这个信号做一个16个点的FFT分析,采样点下标 n 的范围是0, 1, 2, 3, …, 15。那么64kHz的模拟频率被分成了16份,每一份是4kHz,这个4kHz被称为频率分辨率。
所以,频率图的横坐标中:
n=1 对应的f是4kHz
n=2 对应的f是8kHz

n=15 对应的f是60kHz
而频谱是关于n=8对称的,只需关心n = 0 ~ 7的频谱就足够了。因为,原信号的最高频率是32kHz。
(本段改编自参考资料1)


1. 频率公式

因此,在知道了采样频率Fs后,快速傅里叶变换(FFT)后的第x个(x从0开始)复数值对应的实际频率为

f(x) = x * (Fs / n)

于是,在这个例子中,

第0个点的频率 f(0) = 0 * (1400 / 1400) = 0
第1个点的频率 f(0) = 1 * (1400 / 1400) = 1
第2个点的频率 f(0) = 2 * (1400 / 1400) = 2

第200个点的频率 f(200) = 200 * (1400 / 1400) = 200

第1400个点的频率 f(200) = 1400 * (1400 / 1400) = 1400
(这里由于设置得很巧合,第x个点对应的频率恰好就是x)

现在便知,x轴坐标值为何如此设定。

2. 删去重复值

而只有0 ~ N/2 这一半的频率是有效的,另一半与这一半对称。去重后,我们便得到下图

归一化单边振幅频谱

对应完整代码:

N = 1400  # 设置1400个采样点
x = np.linspace(0, 1, N)  # 将0到1平分成1400份
y = 7 * np.sin(2 * np.pi * 200 * x) + 5 * np.sin(
    2 * np.pi * 400 * x) + 3 * np.sin(2 * np.pi * 600 * x) + 10  # 构造一个演示用的组合信号
fft_y = fft(y)  # 使用快速傅里叶变换,得到的fft_y是长度为N的复数数组

x = np.arange(N)  # 频率个数(x的取值涉及到横轴的设置,这里暂时忽略,在第二节求频率时讲解)
half_x = x[range(int(N / 2))]  # 取一半区间

abs_y = np.abs(fft_y)  # 取复数的绝对值,即复数的模
normalization_y = abs_y / (N / 2)  # 归一化处理(双边频谱)
normalization_y[0] /= 2
normalization_half_y = normalization_y[range(int(N / 2))]  # 由于对称性,只取一半区间(单边频谱)

plt.plot(half_x, normalization_half_y, 'blue')
plt.title('单边振幅谱(归一化)', fontsize=9, color='blue')
plt.show()

小结

FFT后得到的n个复数值中,第x个(x从0开始)复数值对应的频率f(x)为

f(x) = x * (Fs / n)



附录:完整代码

import numpy as np
from scipy.fftpack import fft
import matplotlib.pyplot as plt
from matplotlib.pylab import mpl

mpl.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文
mpl.rcParams['axes.unicode_minus'] = False  # 显示负号

# 采样点选择1400个,因为设置的信号频率分量最高为600赫兹,根据采样定理知采样频率要大于信号频率2倍,
# 所以这里设置采样频率为1400赫兹(即一秒内有1400个采样点,一样意思的)
N = 1400
x = np.linspace(0, 1, N)

# 设置需要采样的信号,频率分量有0,200,400和600
y = 7 * np.sin(2 * np.pi * 200 * x) + 5 * np.sin(
    2 * np.pi * 400 * x) + 3 * np.sin(2 * np.pi * 600 * x) + 10

fft_y = fft(y)  # 快速傅里叶变换

x = np.arange(N)  # 频率个数
half_x = x[range(int(N / 2))]   # 取一半区间

angle_y = np.angle(fft_y)       # 取复数的角度

abs_y = np.abs(fft_y)               # 取复数的绝对值,即复数的模(双边频谱)
normalization_y = abs_y / (N / 2)   # 归一化处理(双边频谱)
normalization_y[0] /= 2             # 归一化处理(双边频谱)
normalization_half_y = normalization_y[range(int(N / 2))]  # 由于对称性,只取一半区间(单边频谱)


plt.subplot(231)
plt.plot(x, y)
plt.title('原始波形')

plt.subplot(232)
plt.plot(x, fft_y, 'black')
plt.title('双边振幅谱(未求振幅绝对值)', fontsize=9, color='black')

plt.subplot(233)
plt.plot(x, abs_y, 'r')
plt.title('双边振幅谱(未归一化)', fontsize=9, color='red')

plt.subplot(234)
plt.plot(x, angle_y, 'violet')
plt.title('双边相位谱(未归一化)', fontsize=9, color='violet')

plt.subplot(235)
plt.plot(x, normalization_y, 'g')
plt.title('双边振幅谱(归一化)', fontsize=9, color='green')

plt.subplot(236)
plt.plot(half_x, normalization_half_y, 'blue')
plt.title('单边振幅谱(归一化)', fontsize=9, color='blue')

plt.show()


附录:原理解释 & 推导过程

深入浅出的原理解释视频请见:快速傅里叶变换(FFT)——有史以来最巧妙的算法

硬核直接的公式推导推荐这篇文章:傅里叶变换中,圆频率w与频率f之间的公式转化




参考资料:

  1. 数字信号处理中的归一化频率
  2. 使用python(scipy和numpy)实现快速傅里叶变换(FFT)最详细教程
  3. FFT后得到复数,如何根据这个复数求频率?
  4. FFT之频率与幅值的确定
  5. 傅里叶变换中,圆频率w与频率f之间的公式转化
  6. 快速傅里叶变换(FFT)——有史以来最巧妙的算法 - 知乎
  • 197
    点赞
  • 1255
    收藏
    觉得还不错? 一键收藏
  • 30
    评论
### 回答1: 快速傅里叶变换FFT)是一种高效的计算时间域信号的频域表示的算法。下面是基于C语言的快速傅里叶变换FFT)算法,注释说明了每个步骤的作用。 ```c #include <stdio.h> #include <complex.h> #include <math.h> // 前置声明函数 void fft(complex double x[], int N); void bit_reverse(complex double x[], int N); int main() { // 定义输入信号和长度 complex double x[] = {1, 1, 1, 1, 0, 0, 0, 0}; int N = sizeof(x) / sizeof(x[0]); // 执行FFT变换 fft(x, N); // 输出结果 for (int i = 0; i < N; i++) { printf("%f + %f i\n", creal(x[i]), cimag(x[i])); } return 0; } // 快速傅里叶变换算法 void fft(complex double x[], int N) { // 将输入信号按位反转 bit_reverse(x, N); for (int N_s = 2; N_s <= N; N_s *= 2) { // 计算旋转因子 complex double Wn = cexp(-2 * M_PI * I / N_s); // 迭代计算每个级别的蝶形运算 for (int k = 0; k < N; k += N_s) { complex double w = 1; for (int j = 0; j < N_s / 2; j++) { complex double t = w * x[k + j + N_s / 2]; complex double u = x[k + j]; // 蝶形运算 x[k + j] = u + t; x[k + j + N_s / 2] = u - t; w *= Wn; } } } } // 按位反转函数 void bit_reverse(complex double x[], int N) { int i, j, k; for (i = 1, j = N / 2; i < N - 1; i++) { if (i < j) { complex double temp = x[j]; x[j] = x[i]; x[i] = temp; } k = N / 2; while (j >= k) { j -= k; k /= 2; } j += k; } } ``` 该代码实现了一个简单的8点FFT算法。首先,需要定义一个复数数组`x[]`来存储输入信号,并指定输入信号的长度`N`。然后,通过调用`fft()`函数来执行FFT变换,并将结果存储在输入信号数组中。最后,使用循环输出变换后的信号结果。 在`fft()`函数中,首先调用`bit_reverse()`函数按位反转输入信号数组。然后,通过循环进行迭代计算,每次迭代都完成当前级别的蝶形运算,直到完成全部级别的计算。在蝶形运算过程中,使用旋转因子`Wn`来乘以输入信号数组的一部分,并进行加法和减法运算,得到新的输出结果。 `bit_reverse()`函数用于按位反转输入信号数组。通过循环将输入信号的位进行反转以实现这一目标。 请注意,这只是一个简单的示例代码,用于说明FFT算法的基本原理。在实际应用中,可能需要优化计算过程以提高性能,并处理更大的输入信号。 ### 回答2: 快速傅里叶变换FFT)是一种高效计算离散傅里叶变换(DFT)的算法,它能够将一个长度为N的序列转换为频域上的N个频率成分。下面是一个基于C语言的FFT算法的示例: ```c #include <stdio.h> #include <math.h> #define PI 3.14159265359 // 定义复数结构体 typedef struct { double real; // 实部 double imag; // 虚部 } Complex; // 计算FFT void fft(Complex* x, int N) { if (N <= 1) { return; } // 将输入序列拆分成奇偶部分 Complex* even = (Complex*) malloc(N/2 * sizeof(Complex)); Complex* odd = (Complex*) malloc(N/2 * sizeof(Complex)); for (int i = 0; i < N/2; i++) { even[i] = x[2 * i]; odd[i] = x[2 * i + 1]; } // 递归计算奇偶部分的FFT fft(even, N/2); fft(odd, N/2); // 合并奇偶部分的结果 for (int k = 0; k < N/2; k++) { double angle = -2*PI*k/N; Complex w = {cos(angle), sin(angle)}; Complex t = {w.real * odd[k].real - w.imag * odd[k].imag, w.real * odd[k].imag + w.imag * odd[k].real}; x[k] = {even[k].real + t.real, even[k].imag + t.imag}; x[k + N/2] = {even[k].real - t.real, even[k].imag - t.imag}; } free(even); free(odd); } int main() { // 输入序列与长度 Complex x[] = {{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}, {7, 0}}; int N = sizeof(x) / sizeof(x[0]); // 计算FFT fft(x, N); // 输出结果 for (int i = 0; i < N; i++) { printf("X[%d] = %f + %fi\n", i, x[i].real, x[i].imag); } return 0; } ``` 上述代码实现了一个FFT算法,并打印出计算结果。首先定义了一个复数结构体,然后使用递归方式计算FFT。在计算过程中,将输入序列拆分成奇偶部分,然后递归计算奇偶部分的FFT,最后合并奇偶部分的结果。 在主函数中,定义了一个输入序列x,并调用fft函数计算FFT。最后输出计算结果。 这段代码可以通过将输入序列修改为需要计算FFT的序列,然后运行程序来获得FFT的结果。 ### 回答3: 快速傅里叶变换FFT)算法是一种高效的计算离散傅里叶变换(DFT)的方法,广泛应用于信号处理、图像处理和音频处理等领域。下面是基于C语言实现的FFT算法,包详细的注释: ```c #include <stdio.h> #include <math.h> // 计算FFT void fft(double real[], double imag[], int N) { int i, j, k; int m, n, L, Lk; double theta, wpr, wpi, wr, wi, tmpReal, tmpImag; // 确定计算层数L L = log2(N); // 通过蝶形运算计算FFT for (m = 1; m <= L; ++m) { // 计算蝶形运算的间隔 n = pow(2, m); Lk = N / n; // 计算旋转因子e^(-2*pi*i/N) theta = -2 * M_PI / n; wpr = cos(theta); wpi = sin(theta); // 循环遍历每个蝶形运算 for (k = 0; k < N; k += n) { wr = 1; wi = 0; // 进行蝶形运算 for (j = 0; j < Lk; ++j) { // 计算下标 i = k + j; // 计算蝶形运算 tmpReal = real[i + Lk] * wr - imag[i + Lk] * wi; tmpImag = imag[i + Lk] * wr + real[i + Lk] * wi; // 更新结果 real[i + Lk] = real[i] - tmpReal; imag[i + Lk] = imag[i] - tmpImag; real[i] += tmpReal; imag[i] += tmpImag; // 更新旋转因子 tmpReal = wr; wr = wr * wpr - wi * wpi; wi = wi * wpr + tmpReal * wpi; } } } } int main() { int N = 8; // 输入序列长度 double real[] = {1, 2, 3, 4, 0, 0, 0, 0}; // 实部 double imag[] = {0, 0, 0, 0, 0, 0, 0, 0}; // 虚部 int i; // 输出原始数据 printf("原始数据:\n"); for (i = 0; i < N; ++i) { printf("%.2f + %.2fi\n", real[i], imag[i]); } // 计算FFT fft(real, imag, N); // 输出FFT结果 printf("FFT结果:\n"); for (i = 0; i < N; ++i) { printf("%.2f + %.2fi\n", real[i], imag[i]); } return 0; } ``` 以上代码实现了一个简单的FFT算法示例,
评论 30
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值