c語言濾波演算法

㈠ c語言卡爾曼濾波演算法求教

Optimal_value = 23; //上次最優值，根據環境開始可以隨便設一個大概的數
{
for(i=0;i<10;i++)
這里多了一個花括弧也能運行？

㈡ 求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濾波器的簡述

第二個圖片上傳不了，直接給鏈接

http://image..com/i?ct=503316480&z=0&tn=imagedetail&word=%D2%BB%BD%D7iir%C2%CB%B2%A8%C6%F7&in=12708&cl=2&cm=1&sc=0&lm=-1&pn=0&rn=1&di=2607528304&ln=1054&fr=

圖中的Z-1是延時，iir濾波器也叫無限沖擊響應濾波器，是有反饋的，

圖中的是一階的，相對fir濾波器來說，iir濾波器可以用較低的階數來獲得較好的濾波特效。但是其相位特性較差。

鑒於實用性，還是建議樓主去圖書館借書看，網路不可能得到確實的方案，

樓主可以去借「數字信號處理」的書，國外的中譯本就有詳細介紹fir和iir以及fft還有其他變換，國內的dsp大都幾乎是dsp用戶手冊的中譯本，對上述問題都是很簡陋地帶過，不予置評。

本人推薦一本書在www.ouravr.com上面的dsp專欄有下載，40多M，叫DSP演算法、應用和設計，本人有這本實體書，寫的較好

㈢ c語言中值濾波問題

1. 是規定做中值濾波的點不含邊緣的點(取決於中值濾波窗口大小)。 2,對圖像邊緣部分的信息進行鏡像處理。

㈣ 請教C語言卡爾曼濾波演算法

網上能找到一些程序。
例如,卡爾曼濾波簡介＋ 演算法實現代碼 ：
http://blog.21ic.com/user1/349/archives/2009/55947.html
較詳細地 提供了 C 和 C++ 程序。可以同他的方法比較一下，如果結果接近，
則你的演算法沒問題。

㈤ 需要一些c語言寫得經典濾波，pid控制，模糊控制的演算法。

這個世界沒有免費的晚餐，還是多看資料，自己動手吧。 下面資料僅供參考
http://wenku..com/view/8466a429cfc789eb172dc86c.html
http://wenku..com/view/89b366e9e009581b6bd9ebf2.html
http://wenku..com/view/8e9d022f2af90242a895e593.html
http://wenku..com/view/55d3532f7375a417866f8fed.html
http://wenku..com/view/bb24150d76c66137ee0619dc.html
http://wenku..com/view/5b0fbce0524de518964b7ddd.html
http://wenku..com/view/90a2edf49e314332396893d3.html

㈥ 二階濾波器用C語言怎麼寫

這個可比你想像的復雜多了，s是個復變數，1/(s+1)極點在-1，要想用C語言寫，必須理解清楚下面幾個問題：
1、輸入必須是個有限序列，比如(x+yi)，x和y分別是兩個長度為N的數組
2、要過濾的頻率，必須是個整型值，或者是個整型區間
3、輸出結果同樣是兩個長度為N的數組(p+qi)
4、整個程序需要使用最基本的復數運算，這一點C語言本身不提供，必須手工寫復函數運算庫
5、實現的時候具體演算法還需要編，這里才是你問題的核心。

我可以送你一段FFT的程序，自己琢磨吧，和MATLAB的概念差別很大：
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include "complex.h"

extern "C" {

// Discrete Fourier Transform (Basic Version, Without Any Enhancement)
// return - Without Special Meaning, constantly, zero
int DFT (long count, CComplex * input, CComplex * output)
{
assert(count);
assert(input);
assert(output);

CComplex F, X, T, W; int n, i;

long N = abs(count); long Inversing = count < 0? 1: -1;

for(n = 0; n < N ; n++){ // compute from line 0 to N-1

F = CComplex(0.0f, 0.0f); // clear a line

for(i = 0; i < N; i++) {

T = input[i];

W = HarmonicPI2(Inversing * n * i, N);

X = T * W;

F += X; // fininshing a line

}//next i

// save data to outpus
memcpy(output + n, &F, sizeof(F));

}//next n

return 0;
}//end DFT

int fft (long count, CComplex * input, CComplex * output)
{
assert(count);
assert(input);
assert(output);

int N = abs(count); long Inversing = count < 0? -1: 1;

if (N % 2 || N < 5) return DFT(count, input, output);

long N2 = N / 2;

CComplex * iEven = new CComplex[N2]; memset(iEven, 0, sizeof(CComplex) * N2);
CComplex * oEven = new CComplex[N2]; memset(oEven, 0, sizeof(CComplex) * N2);
CComplex * iOdd = new CComplex[N2]; memset(iOdd , 0, sizeof(CComplex) * N2);
CComplex * oOdd = new CComplex[N2]; memset(oOdd , 0, sizeof(CComplex) * N2);

int i = 0; CComplex W;
for(i = 0; i < N2; i++) {
iEven[i] = input[i * 2];
iOdd [i] = input[i * 2 + 1];
}//next i

fft(N2 * Inversing, iEven, oEven);
fft(N2 * Inversing, iOdd, oOdd );

for(i = 0; i < N2; i++) {
W = HarmonicPI2(Inversing * (- i), N);
output[i] = oEven[i] + W * oOdd[i];
output[i + N2] = oEven[i] - W * oOdd[i];
}//next i
return 0;
}//end FFT

void __stdcall FFT(
long N, // Serial Length, N > 0 for DFT, N < 0 for iDFT - inversed Discrete Fourier Transform
double * inputReal, double * inputImaginary, // inputs
double * AmplitudeFrequences, double * PhaseFrequences) // outputs
{
if (N == 0) return;
if (!inputReal && !inputImaginary) return;
short n = abs(N);
CComplex * input = new CComplex[n]; memset(input, 0, sizeof(CComplex) * n);
CComplex * output= new CComplex[n]; memset(output,0, sizeof(CComplex) * n);
double rl = 0.0f, im = 0.0f; int i = 0;
for (i = 0; i < n; i++) {
rl = 0.0f; im = 0.0f;
if (inputReal) rl = inputReal[i];
if (inputImaginary) im = inputImaginary[i];
input[i] = CComplex(rl, im);
}//next i
int f = fft(N, input, output);

double factor = n;
//factor = sqrt(factor);

if (N > 0)
factor = 1.0f;
else
factor = 1.0f / factor;
//end if

for (i = 0; i < n; i++) {
if (AmplitudeFrequences) AmplitudeFrequences[i] = output[i].getReal() * factor;
if (PhaseFrequences) PhaseFrequences[i] = output[i].getImaginary() * factor;
}//next i
delete [] output;
delete [] input;
return ;
}//end FFT

int __cdecl main(int argc, char * argv[])
{
fprintf(stderr, "%s usage:\n", argv[0]);
fprintf(stderr, "Public Declare Sub FFT Lib \"wfft.exe\" \
(ByVal N As Long, ByRef inputReal As Double, ByRef inputImaginary As Double, \
ByRef freqAmplitude As Double, ByRef freqPhase As Double)");
return 0;
}//end main

};//end extern "C"

㈦ 快速查找二維數組的所有峰值，c語言實現最好，python也可以，最好能實現濾波。

#include<stdio.h>
#include<stdlib.h>
#include<limits.h>
#include<malloc.h>
#definemaxsize6//每個波形數據最大採集個數默認6

typedefstructarray1
{
int*data;
structarray1*next;
}ARR1;
ARR1*addNewArr(ARR1*arrHead,ARR1*arrTail);//插入一組波形數據節點返回尾節點
intfindMaxF(ARR1*arrHead);//查找最大峰值
intremoveMinF(ARR1*arrHead);//移除最小峰值數據組返回最小峰值
voidprintfArr(ARR1*arrHead);//列印數據鏈表

intmain()
{
ARR1*arrHead=(ARR1*)malloc(sizeof(ARR1));
arrHead->next=NULL;
ARR1*arrTail=NULL;

arrTail=addNewArr(arrHead,arrTail);//想插入幾組，就調用幾次我就測試6組
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);
arrTail=addNewArr(arrHead,arrTail);

printf("採集的原數據組為： ");
printfArr(arrHead);
printf("最大峰值：%d，最小峰值值：%d ",findMaxF(arrHead),removeMinF(arrHead));
printf("刪除最小峰值數據組後的數據為： ");
printfArr(arrHead);
return0;
}


voidprintfArr(ARR1*arrHead)//列印數據鏈表
{
while(arrHead->next!=NULL)
{
printf("%d,%d,%d,%d,%d,%d ",arrHead->next->data[0],arrHead->next->data[1],arrHead->next->data[2],arrHead->next->data[3],arrHead->next->data[4],arrHead->next->data[5]);
arrHead=arrHead->next;
}
}
ARR1*addNewArr(ARR1*arrHead,ARR1*arrTail)//插入一組波形數據返回尾節點
{
int*data=(int*)malloc(sizeof(int)*maxsize),i;
printf("採集一組波形數據（最大採集個數%d）：",maxsize);
for(i=0;i<maxsize;i++)
scanf("%d",&data[i]);

ARR1*arrNew=(ARR1*)malloc(sizeof(ARR1));
arrNew->data=data;
arrNew->next=NULL;

if(arrHead->next==NULL)//插入第一組數組作為首節點
arrHead->next=arrNew;
else
arrTail->next=arrNew;

arrTail=arrNew;
returnarrTail;
}
intfindMaxF(ARR1*arrHead)//查找最大峰值
{
inti,maxNum=0,maxf=0;
while(arrHead->next!=NULL)
{
maxNum=0;
for(i=0;i<maxsize;i++)//獲取每組數據的峰值
{
if(arrHead->next->data[i]>maxNum)
maxNum=arrHead->next->data[i];
}
if(maxNum>maxf)//獲取最大峰值
maxf=maxNum;
arrHead=arrHead->next;
}
returnmaxf;
}
intremoveMinF(ARR1*arrHead)//移除最小峰值數據組返回最小峰值
{
inti,maxNum=0,minf=INT_MAX;
ARR1*minDataSave=NULL,*arrHeadSave=arrHead;
while(arrHead->next!=NULL)
{
maxNum=0;
for(i=0;i<maxsize;i++)//獲取每組數據的峰值
{
if(arrHead->next->data[i]>maxNum)
maxNum=arrHead->next->data[i];
}
if(maxNum<minf)//獲取最小峰值
{
minDataSave=arrHead->next;
minf=maxNum;
}
arrHead=arrHead->next;
}

arrHead=arrHeadSave;
//移除最小峰值數據組
while(arrHead->next!=NULL)
{
if(arrHead->next==minDataSave)//刪除節點重組鏈表
{
arrHead->next=minDataSave->next;
minDataSave->next=NULL;
free(minDataSave->data);//釋放節點內存
free(minDataSave);
break;
}
arrHead=arrHead->next;
}

returnminf;
}