IIR型高斯滤波的原理及实现

二、实现

GIMP中有IIR型高斯滤波的实现，代码位于contrast-retinex.c中，读者可自行查看。下面给出本人实现的核心代码：

#include"stdafx.h"
typedef struct
{
    float B;
    float b[];
} gauss_coefs;

//参数计算
void compute_coefs3(gauss_coefs *c,float sigma)
{
    float q, q2, q3;
    if (sigma >= 2.5)
    {
        q = 0.98711 * sigma - 0.96330;
    }
    else if ((sigma >= 0.5) && (sigma < 2.5))
    {
        q = 3.97156 - 4.14554 * (float) sqrt ((float)  - 0.26891 * sigma);
    }
    else
    {
        q = 0.1147705018520355224609375;
    }
    q2 = q * q;
    q3 = q * q2;
    c->b[] = /(1.57825+(2.44413*q)+(1.4281 *q2)+(0.422205*q3));
    c->b[] = (        (2.44413*q)+(2.85619*q2)+(1.26661 *q3)) *c->b[];
    c->b[] = (                   -((1.4281*q2)+(1.26661 *q3)))*c->b[];
    c->b[] = (                                 (0.422205*q3)) *c->b[];
    c->B = 1.0-(c->b[]+c->b[]+c->b[]);

}

//IIR型高斯滤波
//**************************************************************//
//参考文献：Recursive implementation of the Gaussian filter
//Src:输入图像
//Dest:输出图像
//sigma:高斯标准差
//**************************************************************//
IS_RET  IIRGaussianFilter(TMatrix *Src,TMatrix *Dest,float sigma)
{
    int X,Y,Width=Src->Width,Height=Src->Height,Stride=Src->WidthStep,Channel=Src->Channel;
    gauss_coefs  c;
    compute_coefs3(&c,sigma);
    unsigned char *LinePS,*LinePD;
    float *Buff,*BPointer,*w1,*w2;
    Buff=(float*)malloc(sizeof(float)*Height*Width);//缓存
    if(Buff==NULL){return IS_RET_ERR_OUTOFMEMORY;}
    for(int i=;i<Channel;i++)
    {
        LinePS=Src->Data+i;
        LinePD=Dest->Data+i;
        //拷贝原图至缓存Buff
        BPointer=Buff;
        for (Y=;Y<Height;Y++)
        {
            for (X=;X<Width;X++)
            {
                BPointer[]=float(LinePS[]);
                BPointer++;
                LinePS+=Channel;
            }
            LinePS+=Stride-Width*Channel;
        }
        //横向滤波
        BPointer=Buff;
        w1=(float*)malloc(sizeof(float)*(Width+));
        if(w1==NULL){return IS_RET_ERR_OUTOFMEMORY;}
        w2=(float*)malloc(sizeof(float)*(Width+));
        if(w2==NULL){return IS_RET_ERR_OUTOFMEMORY;}
        for(Y=;Y<Height;Y++)
        {
            //前向滤波
            w1[]=w1[]=w1[]=BPointer[];
            for(int n=,i=;i<Width;n++,i++)
            {
                w1[n]=c.B*BPointer[i]+(c.b[]*w1[n-]+c.b[]*w1[n-]+c.b[]*w1[n-]);
            }
            //后向滤波
            w2[Width]=w2[Width+]=w2[Width+]=w1[Width+];
            for(int n=Width-;n>=;n--)
            {
                BPointer[n]=w2[n]=c.B*w1[n+]+(c.b[]*w2[n+]+c.b[]*w2[n+]+c.b[]*w2[n+]);
            }
            BPointer+=Width;
        }

        //纵向滤波
        BPointer=Buff;
        w1=(float*)realloc(w1,sizeof(float)*(Height+));
        if(w1==NULL){return IS_RET_ERR_OUTOFMEMORY;}
        w2=(float*)realloc(w2,sizeof(float)*(Height+));
        if(w2==NULL){return IS_RET_ERR_OUTOFMEMORY;}
        for (X=;X<Width;X++)
        {
            //前向滤波
            w1[]=w1[]=w1[]=BPointer[];
            for(int n=,i=;i<Height;n++,i++)
            {
                w1[n]=c.B*BPointer[i*Width]+(c.b[]*w1[n-]+c.b[]*w1[n-]+c.b[]*w1[n-]);
            }
            //后向滤波
            w2[Height]=w2[Height+]=w2[Height+]=w1[Height+];
            for(int n=Height-;n>=;n--)
            {
                BPointer[n*Width]=w2[n]=c.B*w1[n+]+(c.b[]*w2[n+]+c.b[]*w2[n+]+c.b[]*w2[n+]);
            }
            BPointer++;
        }
        //拷贝缓存至结果
        BPointer=Buff;
        for(Y=;Y<Height;Y++)
        {
            for(X=;X<Width;X++)
            {
                LinePD[]=BPointer[];
                if(BPointer[]>)LinePD[]=;
                if(BPointer[]<)LinePD[]=;
                BPointer++;
                LinePD+=Channel;
            }
            LinePD+=Stride-Width*Channel;
        }
        free(w1);
        free(w2);
    }
    return IS_RET_OK;
}

实验结果：对一幅1024*1024的彩色图像，算法耗时175ms。

参考文献：

Young I T, Van Vliet L J. Recursive implementation of the Gaussian filter[J]. Signal processing, 1995, 44(2): 139-151.