这是我第一次尝试使用C ++生成正弦信号的频谱图。 要生成频谱图：
我将实际正弦信号分为B块
在每个块上应用Hanning窗口（我假设没有重叠）。这应该为我提供fft，in[j][k]的输入，其中k是块编号
对每个块fft申请in[j][k]并存储。
这是脚本：
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <fftw3.h>
#include <iostream>
#include <cmath>
#include <fstream>
using namespace std;
int main(){
int i;
int N = 500; // sampled
int Windowsize = 100;
double Fs = 200; // sampling frequency
double T = 1 / Fs; // sample time
double f = 50; // frequency
double *in;
fftw_complex *out;
double t[N]; // time vector
fftw_plan plan_forward;
std::vector<double> signal(N);
int B = N / Windowsize; //number of blocks
in = (double*)fftw_malloc(sizeof(double) * N);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
//Generating the signal
for(int i = 0; i < = N; i++){
t[i] = i * T;
signal[i] = 0.7 * sin(2 * M_PI * f * t[i]);// generate sine waveform
}
//Applying the Hanning window function on each block B
for(int k = 0; i <= B; k++){
for(int j = 0; j <= Windowsize; j++){
double multiplier = 0.5 * (1 - cos(2 * M_PI * j / (N-1))); // Hanning Window
in[j][k] = multiplier * signal[j];
}
plan_forward = fftw_plan_dft_r2c_1d (Windowsize, in, out, FFTW_ESTIMATE );
fftw_execute(plan_forward);
v[j][k]=(20 * log(sqrt(out[i][0] * out[i][0] + out[i][1] * out[i][1]))) / N;
}
fftw_destroy_plan(plan_forward);
fftw_free(in);
fftw_free(out);
return 0;
}
所以，问题是：声明in[j][k]和v[j][k]变量的正确方法是什么。
更新：我已将v [j] [k]声明为矩阵：double v [5][249];根据此网站：http://www.cplusplus.com/doc/tutorial/arrays/所以现在我的脚本如下：
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <fftw3.h>
#include <iostream>
#include <cmath>
#include <fstream>
using namespace std;
int main()
{
int i;
double y;
int N=500;//Number of pints acquired inside the window
double Fs=200;//sampling frequency
int windowsize=100;
double dF=Fs/N;
double T=1/Fs;//sample time
double f=50;//frequency
double *in;
fftw_complex *out;
double t[N];//time vector
double tt[5];
double ff[N];
fftw_plan plan_forward;
double v [5][249];
in = (double*) fftw_malloc(sizeof(double) * N);
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
plan_forward = fftw_plan_dft_r2c_1d ( N, in, out, FFTW_ESTIMATE );
for (int i=0; i<= N;i++)
{
t[i]=i*T;
in[i] =0.7 *sin(2*M_PI*f*t[i]);// generate sine waveform
}
for (int k=0; k< 5;k++){
for (int i = 0; i<windowsize; i++){
double multiplier = 0.5 * (1 - cos(2*M_PI*i/(windowsize-1)));//Hanning Window
in[i] = multiplier * in[i+k*windowsize];
fftw_execute ( plan_forward );
for (int i = 0; i<= (N/2); i++)
{
v[k][i]=(20*log10(sqrt(out[i][0]*out[i][0]+ out[i][1]*out[i] [1])));//Here I have calculated the y axis of the spectrum in dB
}
}
}
for (int k=0; k< 5;k++)//Center time for each block
{
tt[k]=(2*k+1)*T*(windowsize/2);
}
fstream myfile;
myfile.open("example2.txt",fstream::out);
myfile << "plot '-' using 1:2" << std::endl;
for (int k=0; k< 5;k++){
for (int i = 0; i<= ((N/2)-1); i++)
{
myfile << v[k][i]<< " " << tt[k]<< std::endl;
}
}
myfile.close();
fftw_destroy_plan ( plan_forward );
fftw_free ( in );
fftw_free ( out );
return 0;
}
我不会再出现错误，但光谱图不正确。
答案 0 :(得分：2)
如FFTW's documentation所示，使用out时输出的大小（fftw_plan_dft_r2c_1d）与输入的大小不同。更具体地，对于N实数样本的输入，输出包括N/2+1个复数值。然后，您可以使用以下内容分配out
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * (N/2 + 1));
对于频谱图输出，您将为每个(N/2+1)块同样具有B幅度，从而产生2D阵列：
double** v = new double*[B];
for (int i = 0; i < B; i++){
v[i] = new double[(N/2+1)];
}
另外，请注意，您可以为每次迭代重用输入缓冲区in（将其填入新块的数据）。但是，由于您已选择计算N点FFT并将存储较小的Windowsize个样本块（在本例中为N=500和Windowsize=100），因此请务必初始化其余的样本用零：
in = (double*)fftw_malloc(sizeof(double) * N);
for (int i = 0; i < N; i++){
in[i] = 0;
}
请注意，除了in和v变量的声明和分配之外，您发布的代码还有一些其他问题：
Windowsize-1而不是N-1（因为在您的情况下N对应于FFT大小）。signal范围内的j建立索引，因此您反复对[0,Windowsize]的同一块进行FFT。每次处理不同的块时，您很可能希望添加偏移量。fftw_destroy_plan）。还有一些其他要点可能需要一些想法：
N来缩放对数比例的幅度可能不符合您的想法。您更有可能想要缩放线性比例的幅度（即在取对数之前除以幅度）。请注意，这将导致频谱曲线的恒定偏移，这对于许多应用来说并不那么重要。如果缩放对您的应用程序很重要，您可以查看another answer of mine以获取更多详细信息。20*log10(x)使用基数为10的对数而不是自然log（基数e~2.7182）函数，您可以使用＃ 39;使用过。这将导致乘法缩放（拉伸），根据您的应用程序，这可能是也可能不重要。总而言之，以下代码可能更符合您的尝试：
// Allocate & initialize buffers
in = (double*)fftw_malloc(sizeof(double) * N);
for (int i = 0; i < N; i++){
in[i] = 0;
}
out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * (N/2 + 1));
v = new (double*)[B];
for (int i = 0; i < B; i++){
v[i] = new double[(N/2+1)];
}
// Generate the signal
...
// Create the plan once
plan_forward = fftw_plan_dft_r2c_1d (Windowsize, in, out, FFTW_ESTIMATE);
// Applying the Hanning window function on each block B
for(int k = 0; k < B; k++){
for(int j = 0; j < Windowsize; j++){
// Hanning Window
double multiplier = 0.5 * (1 - cos(2 * M_PI * j / (Windowsize-1)));
in[j] = multiplier * signal[j+k*Windowsize];
}
fftw_execute(plan_forward);
for (int j = 0; j <= N/2; j++){
// Factor of 2 is to account for the fact that we are only getting half
// the spectrum (the other half is not return by a R2C plan due to symmetry)
v[k][j] = 2*(out[j][0] * out[j][0] + out[j][1] * out[j][1])/(N*N);
}
// DC component and at Nyquist frequency do not have a corresponding symmetric
// value, so should not have been doubled up above. Correct those special cases.
v[k][0] *= 0.5;
v[k][N/2] *= 0.5;
// Convert to decibels
for (int j = 0; j <= N/2; j++){
// 20*log10(sqrt(x)) is equivalent to 10*log10(x)
// also use some small epsilon (e.g. 1e-5) to avoid taking the log of 0
v[k][j] = 10 * log10(v[k][j] + epsilon);
}
}
// Clean up
fftw_destroy_plan(plan_forward);
fftw_free(in);
fftw_free(out);
// Delete this last one after you've done something useful with the spectrogram
for (int i = 0; i < B; i++){
delete[] v[i];
}
delete[] v;
答案 1 :(得分：1)
您似乎错过了＆＃39; v＆＃39;的初始声明。完全和＆＃39;在＆＃39;未正确宣布。
有关在C ++中创建2D数组的相关问题，请参阅this页面。据我所知，fftw_malloc（）基本上是new（）或malloc（），但为FFTW算法正确对齐变量。
由于您未提供＆＃39; v＆＃39;对于与FFTW相关的任何内容，您可以使用标准的malloc（）。