形态开闭运算　：抑制波形中的异常冲击；

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;
}