形态开闭运算 :抑制波形中的异常冲击;
matlab code:
function f_gg=kaibilvbo(f,g,flag_1)
%求f与g的开-闭滤波与闭-开滤波;,
%flag_1值为1代表开-闭滤波,flag_1值为2代表闭-开滤波,%幅值变低,
lengthf=length(f);
lengthg=length(g);
if flag_1=='1'
for n=1:length(f)
a=[];
for m=1:min(lengthg,length(f)+1-n);
a1=f(n+m-1)-g(m);
a=[a a1];
end
f_g1(n)=min(a);%----完成腐蚀运算
end
for n=1:length(f_g1)
a=[];
for m=1:min(n,lengthg)
a1=f_g1(n-m+1)+g(m);
% disp(num2str([min(n,lengthg),n,m,n-m+1,m]))
a=[a a1];
end
f_gg1(n)=max(a);%---完成膨胀运算,---也完成开运算
end
for n=1:length(f_gg1)
a=[];
for m=1:min(n,lengthg)
a1=f_gg1(n-m+1)+g(m);
% disp(num2str([min(n,lengthg),n,m,n-m+1,m]));
a=[a a1];
end
f_g2(n)=max(a); %---完成膨胀运算
end
for n=1:length(f_g2)
a=[];
for m=1:min(length(f_g2)-n+1,lengthg)
a1=f_g2(n+m-1)-g(m);
a=[a a1];
end
f_gg(n)=min(a);%完成腐蚀运算,也完成闭运算
end
%-----------
elseif flag_1=='2'
for n=1:length(f)
a=[];
for m=1:min(n,lengthg)
a1=f(n-m+1)+g(m);
a=[a a1];
end
f_g1(n)=max(a);%膨胀
end
for n=1:length(f_g1)
a=[];
for m=1:min(lengthg,length(f_g1)+1-n);
a1=f_g1(n+m-1)-g(m);
a=[a a1];
end
f_gg1(n)=min(a);%腐蚀----完成闭运算
end
%完成闭运算
for n=1:length(f_gg1)
a=[];
for m=1:min(lengthg,length(f_gg1)+1-n);
a1=f_gg1(n+m-1)-g(m);
a=[a a1];
end
f_g2(n)=min(a);%--再腐蚀
end
for n=1:length(f_g2)
a=[];
for m=1:min(n,lengthg)
a1=f_g2(n-m+1)+g(m);
a=[a a1];
end
f_gg(n)=max(a);%再膨胀,--完成开运算-完成闭开运算
end
end
end
C code:
/**************************************
输入:int InputSignal[]:输入波形 int Structure[] :结构元素数组
int SignalLength: 波形长度 int StructureLength:结构长度
开闭运算标记:char Flag='1'
输出:int ReturnSignal[]:
author:enjoy_learn@126.com
***************************************/
void kaibilvbo(int InputSignal[],int Structure[] ,int SignalLength,int StructureLength,
char Flag,int ReturnSignal[])
{
int lengthf=SignalLength;
int lengthg=StructureLength;
int i,m,n;
int min_value;
int a1;
/*int a[8]={0};*/
int *a=(int *)malloc(sizeof(int) * StructureLength);
int *f_g1=(int *)malloc(sizeof(int) * SignalLength);//一次腐蚀存储
int *f_gg1=(int *)malloc(sizeof(int) * SignalLength);//一次膨胀存储
int *f_g2=(int *)malloc(sizeof(int) * SignalLength);//二次膨胀存储
int *f_gg=(int *)malloc(sizeof(int) * SignalLength);//二次腐蚀存储
if (Flag!='1'){
printf("error input :kaibilvbo Flag !=1\n;");
return ;
}
for (n=0;n<lengthf;n++){
min_value=min(lengthg,(lengthf-n));
if (min_value!=lengthg)
RENEW(a,int,min_value);
for ( m=0;m<min_value;m++){
a1=InputSignal[n+m]-Structure[m];
a[m]=a1;
}
f_g1[n]= min_array(a,min_value);
}
//完成腐蚀运算
for (n=0;n<SignalLength;n++){
min_value=min(n+1,lengthg);
if (min_value!=lengthg)
RENEW(a,int,min_value);
for (m=0;m<min_value;m++){
a1=f_g1[n-m]+Structure[m];
a[m]=a1;
}
f_gg1[n]=max_array(a,min_value+1);
}
//完成膨胀运算;------------完成一次开运算。
//write_file(f_gg1, SignalLength);//test:ok !
for (n=0;n<SignalLength;n++){
min_value=min(n+1,lengthg);
if (min_value!=lengthg){
RENEW(a,int,min_value);
}
for (m=0;m<min_value;m++){
a1=f_gg1[n-m]+Structure[m];
a[m]=a1;
}
f_g2[n]=max_array(a,min_value);
}
//完成二次膨胀运算
//write_file(f_g2, SignalLength);//test ok!!!
for (n=0;n<SignalLength;n++){
min_value=min((lengthf-n),lengthg);
if (min_value!=lengthg){
RENEW(a,int,min_value);
}
for (m=0;m<min_value;m++){
a1=f_g2[n+m]-Structure[m];
a[m]=a1;
}
f_gg[n]=min_array(a,min_value);
}
//完成二次腐蚀运算。完成闭运算。
//write_file(f_gg, SignalLength);//test ok
//memcpy(ReturnSignal,f_gg,SignalLength);
for (i=0;i<SignalLength;i++)
ReturnSignal[i]=f_gg[i];
free(f_g1);
f_g1=NULL;
free(f_gg1);
f_gg1=NULL;
free(f_g2);
f_g2=NULL;
free(f_gg);
f_gg=NULL;
free(a);
a=NULL;
}