时域信号的功率谱估计

signal_process.h

#ifndef _signal_process_
#define _signal_process_
#include 
#include 
using namespace std;
const double pi = 3.1416;
extern double* hamming(const int size);
extern double* hanning(const int size);
extern int * inverse(int size);
extern complex*  fft(const double * data,const int size);
extern double* cabsfl(const complex *p,const int size);  
extern double *spectrum(double * data,const double * window,const int size);

#endif

signal_process.cpp

#include "Signal_Process.h"
#include 
#include 
using namespace std;
/*
* Copyright (c) 2013,中国海洋大学海洋遥感所 
* All rights reserved.
*
* 函数名称：汉明窗实现函数
* 函数标识：double* hanming(const int size)；
* 摘 要：简要描述本文件的内容
* 参考: matlab hanning()
* 输入: 1.输入为需要产生的汉明窗的大小，输入类型为int
* 输出：1.已经产生的汉明窗的地址
* 当前版本：1.0
* 作 者：陈震
* 完成日期：2013年3月25日
*
*/
double* hanning(const int size)
{
	

	double* data = new double[size];//声明变长数组
	int half;
	if(0 == size%2)
	{
		//输入数为偶数时，计算汉明窗数组
		half = size/2; 
		for(int i=0;i<=half-1;i++)
		{
			*(data +i) = 0.5*(1-cos(2*pi*(i+1)/(size+1)));
			*(data + size-1-i) =0.5*(1-cos(2*pi*(i+1)/(size+1)));
		}
	}
	else
	{
		//输入数为奇数时，计算汉明窗数组
		half = (size+1)/2;
		for(int i=0;i<=half-1;i++)
		{
			*(data +i) = 0.5*(1-cos(2*pi*(i+1)/(size+1)));
			*(data +size-1-i) = 0.5*(1-cos(2*pi*(i+1)/(size+1)));

		}
	}
	
	return data;  //返回汉明窗数组的地址
	
}
double* hamming(const int size)
{
	double pn = 2.0*pi/(size-1);
	double* data = new double[size];//声明变长数组
	for (int i=0;i *p,const int size)
* 摘 要：根据输入的复数信号进行求解绝对值
* 输入：1. 需要求绝对值的复数数组2.当前数据的大小，数据类型为int
* 输出：1.返回为复数绝对值的指针
* 备注: 复数绝对值
* 当前版本：1.0
* 作 者：陈震
* 完成日期：2014年9月11日
*
*/

double* cabsfl(const complex *p,const int size)
{
	double *temp = new double[size];
	for (int i=0;i*  fft(const double * data,const int size)
* 摘 要：对输入数进行傅里叶变换
* 输入：1.要进行傅里叶变换的数据 ,数据类型为double型数组 2.当前数据的大小，数据类型为int
* 输出：1.返回完成傅里叶变换数组的首地址,返回类型为complex
* 备注: 傅里叶变换
* 当前版本：1.0
* 作 者：陈震
* 完成日期：2013年3月28日
*
*/
complex*  fft(const double * data,const int size)
{
	
	complex *p = new complex[size];
	for (int i=0;i(*(data+i),0.0); //将输入的实数转换为复数
	}
	int stage = log(size)/log(2)+0.5; //计算分级
	//*.........FFT算法............*/
	for ( i=1;i<=stage;i++)
	{
		int m = pow(2,stage+1-i); //计算当前i级每个分组所含的节点数
		int n =m/2; //代表当前分组所包含的蝶形分组的数目
		//........蝶形运算..........//
		for (int j=1;j<=n;j++)
		{
			int r =(j-1)*pow(2,i-1);
			for (int k=j-1;k swap = *(p+k) + *(p+num);
				*(p+num) = (*(p+k) - *(p+num))*complex(cos(2*pi*r/size),-sin(2*pi*r/size));
				*(p+k) = swap;
				
			}
			
		}
		
	}
	
	return p;
}


double *spectrum(double * data,const double * window,const int size)
{
	for(int i =0;i *temp = new complex[size];
	double *result1 = new double[size];
	double *result2 = new double[size];
	int *num  = new int[size];
	num = inverse(size); //倒序序列生成
	temp = fft(data,size); //fft变换
	result1 = cabsfl(temp,size); //取绝对值
	for(i=0;i