c语言傅里叶函数滤波波函数的傅里叶变换

c语言中值滤波问题？

1. 是规定做中值滤波的点不含边缘的点(取决于中值滤波窗口大小)。 2,对图像边缘部分的信息进行镜像处理。

“只有客户发展了，才有我们的生存与发展！”这是成都创新互联的服务宗旨！把网站当作互联网产品，产品思维更注重全局思维、需求分析和迭代思维，在网站建设中就是为了建设一个不仅审美在线，而且实用性极高的网站。创新互联对做网站、网站制作、网站制作、网站开发、网页设计、网站优化、网络推广、探索永无止境。

求IIR及FIR数字滤波器的C语言实现。（VC++）

这个问题比较复杂，最近本人也在研究数字滤波，

结合图片说一下

第一个图是fir的流程图，其中Z-1是延迟，是单个采样时间1/fs

n阶的fir滤波器就是选取最近的n+1个样本，然后使他们各自乘以自己的滤波器系数即图中的F（n），[一般其他书的表示是h（n）]

然后相加得到输出的y（n）就是一个输出点

，其中F（n）的得出需要根据采样频率和滤波器的通带和阻带来决定

其中为了改善旁瓣的幅值，一般在采样后给样本或者h（n）加窗，当然可以用“最佳方法”来做

得出h（n）大致方法是先将矩形窗进行DFT，得出h（n），然后对h（n）进行加窗得出h（k），然后将∑h（k）×x（n）=y（n），假如阶数较多可以用傅里叶变换使时域变频域后再将卷积相加，可以利用FFT来改进实时性，提升速度

上面就是fir滤波器的简述

第二个图片上传不了，直接给链接

;amp;z=0tn=baiduimagedetailword=%D2%BB%BD%D7iir%C2%CB%B2%A8%C6%F7in=12708cl=2cm=1sc=0lm=-1pn=0rn=1di=2607528304ln=1054fr=

图中的Z-1是延时，iir滤波器也叫无限冲击响应滤波器，是有反馈的，

图中的是一阶的，相对fir滤波器来说，iir滤波器可以用较低的阶数来获得较好的滤波特效。但是其相位特性较差。

鉴于实用性，还是建议楼主去图书馆借书看，百度不可能得到确实的方案，

楼主可以去借“数字信号处理”的书，国外的中译本就有详细介绍fir和iir以及fft还有其他变换，国内的dsp大都几乎是dsp用户手册的中译本，对上述问题都是很简陋地带过，不予置评。

本人推荐一本书在上面的dsp专栏有下载，40多M，叫DSP算法、应用和设计，本人有这本实体书，写的较好

C语言实现fir1函数

#include stdio.h

#ifdef WIN32

#include conio.h

#endif

#define SAMPLE double /* define the type used for data samples */

void clear(int ntaps, SAMPLE z[])

{

int ii;

for (ii = 0; ii ntaps; ii++) {

z[ii] = 0;

}

SAMPLE fir_basic(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[])

{

int ii;

SAMPLE accum;

/* store input at the beginning of the delay line */

z[0] = input;

/* calc FIR */

accum = 0;

for (ii = 0; ii ntaps; ii++) {

accum += h[ii] * z[ii];

}

/* shift delay line */

for (ii = ntaps - 2; ii = 0; ii--) {

z[ii + 1] = z[ii];

}

return accum;

}

SAMPLE fir_circular(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

int *p_state)

{

int ii, state;

SAMPLE accum;

state = *p_state; /* copy the filter's state to a local */

/* store input at the beginning of the delay line */

z[state] = input;

if (++state = ntaps) { /* incr state and check for wrap */

state = 0;

}

/* calc FIR and shift data */

accum = 0;

for (ii = ntaps - 1; ii = 0; ii--) {

accum += h[ii] * z[state];

if (++state = ntaps) { /* incr state and check for wrap */

state = 0;

}

*p_state = state; /* return new state to caller */

return accum;

}

SAMPLE fir_shuffle(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[])

{

int ii;

SAMPLE accum;

/* store input at the beginning of the delay line */

z[0] = input;

/* calc FIR and shift data */

accum = h[ntaps - 1] * z[ntaps - 1];

for (ii = ntaps - 2; ii = 0; ii--) {

accum += h[ii] * z[ii];

z[ii + 1] = z[ii];

}

return accum;

}

SAMPLE fir_split(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

int *p_state)

{

int ii, end_ntaps, state = *p_state;

SAMPLE accum;

SAMPLE const *p_h;

SAMPLE *p_z;

/* setup the filter */

accum = 0;

p_h = h;

/* calculate the end part */

p_z = z + state;

*p_z = input;

end_ntaps = ntaps - state;

for (ii = 0; ii end_ntaps; ii++) {

accum += *p_h++ * *p_z++;

}

/* calculate the beginning part */

p_z = z;

for (ii = 0; ii state; ii++) {

accum += *p_h++ * *p_z++;

}

/* decrement the state, wrapping if below zero */

if (--state 0) {

state += ntaps;

}

*p_state = state; /* return new state to caller */

return accum;

}

SAMPLE fir_double_z(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

int *p_state)

{

SAMPLE accum;

int ii, state = *p_state;

SAMPLE const *p_h, *p_z;

/* store input at the beginning of the delay line as well as ntaps more */

z[state] = z[state + ntaps] = input;

/* calculate the filter */

p_h = h;

p_z = z + state;

accum = 0;

for (ii = 0; ii ntaps; ii++) {

accum += *p_h++ * *p_z++;

}

/* decrement state, wrapping if below zero */

if (--state 0) {

state += ntaps;

}

*p_state = state; /* return new state to caller */

return accum;

}

SAMPLE fir_double_h(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

int *p_state)

{

SAMPLE accum;

int ii, state = *p_state;

SAMPLE const *p_h, *p_z;

/* store input at the beginning of the delay line */

z[state] = input;

/* calculate the filter */

p_h = h + ntaps - state;

p_z = z;

accum = 0;

for (ii = 0; ii ntaps; ii++) {

accum += *p_h++ * *p_z++;

}

/* decrement state, wrapping if below zero */

if (--state 0) {

state += ntaps;

}

*p_state = state; /* return new state to caller */

return accum;

}

int main(void)

{

#define NTAPS 6

static const SAMPLE h[NTAPS] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };

static SAMPLE h2[2 * NTAPS];

static SAMPLE z[2 * NTAPS];

#define IMP_SIZE (3 * NTAPS)

static SAMPLE imp[IMP_SIZE];

SAMPLE output;

int ii, state;

/* make impulse input signal */

clear(IMP_SIZE, imp);

imp[5] = 1.0;

/* create a SAMPLEd h */

for (ii = 0; ii NTAPS; ii++) {

h2[ii] = h2[ii + NTAPS] = h[ii];

}

/* test FIR algorithms */

printf("Testing fir_basic:\n ");

clear(NTAPS, z);

for (ii = 0; ii IMP_SIZE; ii++) {

output = fir_basic(imp[ii], NTAPS, h, z);

printf("%3.1lf ", (double) output);

}

printf("\n\n");

printf("Testing fir_shuffle:\n ");

clear(NTAPS, z);

state = 0;

for (ii = 0; ii IMP_SIZE; ii++) {

output = fir_shuffle(imp[ii], NTAPS, h, z);

printf("%3.1lf ", (double) output);

}

printf("\n\n");

printf("Testing fir_circular:\n ");

clear(NTAPS, z);

state = 0;

for (ii = 0; ii IMP_SIZE; ii++) {

output = fir_circular(imp[ii], NTAPS, h, z, state);

printf("%3.1lf ", (double) output);

}

printf("\n\n");

printf("Testing fir_split:\n ");

clear(NTAPS, z);

state = 0;

for (ii = 0; ii IMP_SIZE; ii++) {

output = fir_split(imp[ii], NTAPS, h, z, state);

printf("%3.1lf ", (double) output);

}

printf("\n\n");

printf("Testing fir_double_z:\n ");

clear(2 * NTAPS, z);

state = 0;

for (ii = 0; ii IMP_SIZE; ii++) {

output = fir_double_z(imp[ii], NTAPS, h, z, state);

printf("%3.1lf ", (double) output);

}

printf("\n\n");

printf("Testing fir_double_h:\n ");

clear(NTAPS, z);

state = 0;

for (ii = 0; ii IMP_SIZE; ii++) {

output = fir_double_h(imp[ii], NTAPS, h2, z, state);

printf("%3.1lf ", (double) output);

}

#ifdef WIN32

printf("\n\nHit any key to continue.");

getch();

#endif

return 0;

}

1. fir_basic: 实现基本的FIR滤波器

2. fir_circular: 说明环行buffer是如何实现FIR的。

3. fir_shuffle: 一些TI的处理器上使用的shuffle down技巧

4. fir_split: 把FIR滤波器展开为两块，避免使用环行缓存。

5. fir_double_z: 使用双精度的延迟线，使可以使用一个flat buffer。

6. fir_double_h: 使用双精度的系数，使可以使用一个flat buffer。

C语言编写一个一维傅里叶函数

#includestdio.h

#include math.h

class complex //定义一个类,实现复数的所有操作

{

double Real,Image; //实部与虚部

public:

complex(double r="0",double i="0"){Real=r;Image=i;}

double GetR(){return Real;} //取出实部

double GetI(){return Image;} //取出虚部

complex operator + (complex ); //复数加法

complex operator - (complex ); //复数减法

complex operator * (complex ); //复数乘法

void operator =(complex ); //复数赋值

};

complex complex::operator + (complex c) //复数加法

{

complex t;

t.Real=Real+c.Real;

t.Image=Image+c.Image;

return t;

}

complex complex::operator - (complex c) //复数减法

{

complex t;

t.Real=Real-c.Real;

t.Image=Image-c.Image;

return t;

}

complex complex::operator * (complex c) //复数乘法

{

complex t;

t.Real=Real*c.Real-Image*c.Image;

t.Image=Real*c.Image+Image*c.Real;

return t;

}

void complex::operator = (complex c) //复数赋值

{

Real=c.Real;

Image=c.Image;

}

void fft(complex a[],int length,int jishu) //实现fft的函数

{

const double PI="3".141592653589793;

complex u,Wn,t;

int i,j,k,m,kind,distance,other;

double tmp;

for(i=0;ilength;i++) //实现倒叙排列

{

k="i";

j=0;

for(m=0;mjishu;m++)

{

j="j"*2+k%2;

k/=2;

}

if(ij)

{

t="a";

a=a[j];

a[j]=t;

}

for(m=1;m=jishu;m++) //第m级蝶形运算,总级数为jishu

{

kind = (int)pow(2,m-1); //第m级有2^(m-1)种蝶形运算

distance = 2*kind; //同种蝶形结相邻距离为2^m

u=complex(1,0); //旋转因子初始值为 1

tmp=PI/kind;

Wn=complex(cos(tmp),-sin(tmp));//旋转因子Wn

for(j=0;jkind;j++) //每种蝶形运算的起始点为j,共有kind种

{

for(i=j;ilength;i+=distance) //同种蝶形运算

{

other=i+kind;//蝶形运算的两个因子对应单元下标的距离为2^(m-1)

t=a[other]*u; // 蝶形运算的乘积项

a[other]=a-t; //蝶形运算

a=a+t; //蝶形运算

}

u="u"*Wn; //修改旋转因子,多乘一个基本DFT因子WN

}

void main(void)

{

double a,b;

complex x[8]; //此程序以8点序列测试

printf("8点序列:\n");

for(int i="0";i8;i++) //初始化并输出原始序列

{

x=complex(i,i+1);

printf("x(%d) = %lf + %lf i\n",i+1,x.GetR(),x.GetI());

}

fft(x,8,3); //调用fft函数

printf("fft变换的结果为:\n");

for(i=0;i8;i++) //输出结果

printf("X(%d)= %lf + %lf i\n",i+1,x.GetR(),x.GetI());

}

一个关于128点的快速傅立叶的C语言程序

这是我写的1024点的快速傅里叶变换程序，下面有验证，你把数组

double

A[2049]={0};

double

B[1100]={0};

double

powerA[1025]={0};

改成

A[256]={0};

B[130]={0};

power[129]={0};就行了，

void

FFT(double

data[],

int

nn,

int

isign)

的程序可以针对任何点数，只要是2的n次方

具体程序如下：

#include

iostream.h

#include

"math.h"

#includestdio.h

#includestring.h

#include

stdlib.h

#include

fstream.h

#include

afx.h

void

FFT(double

data[],

int

nn,

int

isign)

{

//复数的快速傅里叶变换

int

n,j,i,m,mmax,istep;

double

tempr,tempi,theta,wpr,wpi,wr,wi,wtemp;

nn;

for

i=n

;

i=i+2)

//这个循环进行的是码位倒置。

{

if(

{

tempr

data[j];

tempi

data[j

1];

data[j]

data[i];

data[j

data[i

1];

data[i]

tempr;

data[i

tempi;

}

while

{

}

mmax

while(

mmax

)

{

istep

mmax;

//这里表示一次的数字的变化。也体现了级数，若第一级时，也就是书是的第0级，其为两个虚数，所以对应数组应该增加4，这样就可以进入下一组运算

theta

-6.28318530717959

(isign

mmax);

wpr

-2.0

sin(0.5

theta)*sin(0.5

theta);

wpi

sin(theta);

1.0;

0.0;

for(

m=mmax;

m=m+2)

{

for

i=n;

i=i+istep)

{

mmax;

tempr=double(wr)*data[j]-double(wi)*data[j+1];//这两句表示蝶形因子的下一个数乘以W因子所得的实部和虚部。

tempi=double(wr)*data[j+1]+double(wi)*data[j];

data[j]

data[i]

tempr;

//蝶形单元计算后下面单元的实部，下面为虚部，注意其变换之后的数组序号与书上蝶形单元是一致的

data[j

data[i

tempi;

data[i]

tempr;

data[i

tempi;

}

wtemp

wr;

wpr

wpi

wr;

wpr

wtemp

wpi

wi;

}

mmax

istep;

}

void

main()

{

//本程序已经和MATLAB运算结果对比，准确无误，需要注意的的是，计算中数组都是从1开始取得，丢弃了A[0]等数据

double

A[2049]={0};

double

B[1100]={0};

double

powerA[1025]={0};

char

line[50];

char

dataA[20],

dataB[20];

int

ij;

char

ch1[3]="\t";

char

ch2[3]="\n";

int

strl1,strl2;

CString

str1,str2;

ij=1;

//********************************读入文件data1024.txt中的数据,

其中的数据格式见该文件

FILE

*fp

fopen("data1024.txt","r");

if(!fp)

{

cout"Open

file

failing!"endl;

return;

}

while(!feof(fp))

//feof(fp)有两个返回值:如果遇到文件结束，函数feof（fp）的值为1，否则为0。

{

memset(line,0,50);

//清空为0

memset(dataA,0,20);

memset(dataB,0,20);

fgets(line,50,fp);

//函数的功能是从fp所指文件中读入n-1个字符放入line为起始地址的空间内

sscanf(line,

"%s%s",

dataA,

dataB);

//我同时读入了两列值，但你要求1024个，那么我就只用了第一列的1024个值

//dataA读入第一列，dataB读入第二列

B[ij]=atof(dataA);

//将字符型的dataA值转化为float型

ij++;

}

for

(int

mm=1;mm1025;mm++)//A[2*mm-1]是实部，A[2*mm]是虚部，当只要输入实数时，那么保证虚部A[mm*2]为零即可

{

A[2*mm-1]=B[mm];

A[2*mm]=0;

}

//*******************************************正式计算FFT

FFT(A,1024,1);

//********************************************写入数据到workout.txt文件中

for

(int

k=1;k2049;k=k+2)

{

powerA[(k+1)/2]=sqrt(pow(A[k],2.0)+pow(A[k+1],2.0));//求功率谱

FILE

*pFile=fopen("workout.txt","a+");

//?a+只能在文件最后补充，光标在结尾。没有则创建

memset(ch1,0,15);

str1.Format("%.4f",powerA[(k+1)/2]);

(A[k+1]=0)

str2.Format("%d\t%6.4f%s%6.4f

%s",(k+1)/2,A[k],"+",A[k+1],"i");//保存fft计算的频谱，是复数频谱

else

str2.Format("%d\t%6.4f%6.4f

%s",(k+1)/2,A[k],A[k+1],"i");

strl1=strlen(str1);

strl2=strlen(str2);

用

法:fwrite(buffer,size,count,fp);

buffer：是一个指针，对fwrite来说，是要输出数据的地址。

size：要写入的字节数；

count:要进行写入size字节的数据项的个数；

fp:目标文件指针。

fwrite(str2,1,strl2,pFile);

fwrite(ch1,1,3,pFile);

fwrite(str1,1,strl1,pFile);

fwrite(ch2,1,3,pFile);

fclose(pFile);

}

cout"计算完毕，到fft_test\workout.txt查看结果"endl;

}

网站栏目：c语言傅里叶函数滤波波函数的傅里叶变换
本文网址：http://cdiso.cn/article/hehese.html

c语言傅里叶函数滤波 波函数的傅里叶变换

c语言中值滤波问题？

求IIR及FIR数字滤波器的C语言实现。（VC++）

C语言实现fir1函数

C语言编写一个一维傅里叶函数

一个关于128点的快速傅立叶的C语言程序

其他资讯

c语言傅里叶函数滤波波函数的傅里叶变换