图像处理（六）递归双边滤波磨皮

递归双边滤波是双边滤波的一种加速算法，加速比非常大，就像高斯模糊快速算法一样，加速起来，速度跟原算法相比，提高了十几倍。双边滤波的加速算法很多，文献都比较老旧，我这边主要讲一下比较新的算法：递归双边滤波，对应的paper为：《Recursive Bilateral Filtering》

这个算法比我另外一篇博文将的双指数滤波快一点，两篇文献的基本思想一样：

递归公式跟双指数的递归公式基本上一样。于是写代码就轻轻松松了，之前写过双指数的算法，接着只要在双指数的基础上，把代码改一改就OK了，这里就不详细讲解算法流程了，有兴趣的同学可以到paper的作者主页上，里面有代码，不过他的代码好像是要实现立体匹配的，把里面的相关的代码扣出来就可以了，下面是部分重要函数的代码。

 void CBRF::recursive_bilateral_filter(double *data,unsigned char**disparity,double***in,unsigned char***texture,double sigma_spatial,double sigma_range,int height,int width,int nr_channel,double***temp,double***temp_2w)
 {
     double yp[100];
     double alpha=exp(-sqrt(2.0)/(sigma_spatial*width));//filter kernel size
     double inv_alpha=(1-alpha);
     double range_table[256];
     for(int i=0;i<=255;i++)
         range_table[i]=exp(-double(i)/(sigma_range*255));


     BYTE* p0 =m_pImage;
     const int nChannel = 4;
     int m_length =m_nWidth*m_nHeight;
 //水平迭代滤波
     //double***in_=in;/*horizontal filtering*/
     //double***out_=temp;
     double ***out=new double**[m_nHeight];
     for (int i=0;i<m_nHeight;i++)
     {
         out[i]=new double*[m_nWidth];
     }
     for (int i=0;i<m_nHeight;i++)
     {
         for (int j=0;j<m_nWidth;j++)
         {
             out[i][j]=new double [3];
         }
     }
     double ***out=new double**[m_nHeight];

     for(int i=0;i<m_nHeight;i++)
     {
         BYTE* p0 =m_pImage+i*m_nWidth;
         memcpy(out[i][0],p0,sizeof(double)*m_nWidth*nChannel);
         for(int j=1;j<width;j++)
         {
             double weight=range_table[euro_dist_rgb_max(out[i][j],out[i][j-1])];
             double alpha_=weight*alpha;
             for(int k=0;k<nChannel;k++)
             {
                 double ycc=inv_alpha*m_pImage[i*m_nWidth*nChannel+j*nChannel+k]+alpha_*yp[k];
                 out[i][j][k]=ycc
                 yp[k]=ycc;
             }
         }


         int w1=width-1;
         for(int c=0;c<nr_channel;c++)
             out[y][w1][c]=0.5*(out[y][w1][c]+in[y][w1][c]);
         memcpy(yp,out_[y][w1],sizeof(double)*nr_channel);
         for(int x=width-2;x>=0;x--)
         {
             double weight=range_table[euro_dist_rgb_max(texture[y][x],texture[y][x+1])];
             double alpha_=weight*alpha;
             for(int c=0;c<nr_channel;c++)
             {
                 double ycc=inv_alpha*in_[y][x][c]+alpha_*yp[c];
                 out_[y][x][c]=0.5*(out_[y][x][c]+ycc);
                 yp[c]=ycc;
             }
         }
     }




 //垂直迭代滤波
     /*in_=temp;
     alpha=exp(-sqrt(2.0)/(sigma_spatial*height));//filter kernel size
     inv_alpha=(1-alpha);
     double**ycy,**ypy,**xcy,**xpy;
     unsigned char**tcy,**tpy;
     memcpy(out[0][0],in_[0][0],sizeof(double)*width*nr_channel);
     for(int y=1;y<height;y++)
     {
         tpy=texture[y-1];
         tcy=texture[y];
         xcy=in_[y];
         ypy=out[y-1];
         ycy=out[y];
         for(int x=0;x<width;x++)
         {
             double weight=range_table[euro_dist_rgb_max(tcy[x],tpy[x])];
             double alpha_=weight*alpha;
             for(int c=0;c<nr_channel;c++)
                 ycy[x][c]=inv_alpha*xcy[x][c]+alpha_*ypy[x][c];
         }
     }
     int h1=height-1;
     ycy=temp_2w[0];
     ypy=temp_2w[1];
     memcpy(ypy[0],in_[h1][0],sizeof(double)*width*nr_channel);
     for(int x=0;x<width;x++)
     {
         unsigned char disp=0;
         double min_cost=0.5*(out[h1][x][0]+ypy[x][0]);
         for(int c=1;c<nr_channel;c++)
         {
             double cost=0.5*(out[h1][x][c]+ypy[x][c]);
             if(cost<min_cost)
             {
                 min_cost=cost;
                 disp=c;
             }
         }
         disparity[h1][x]=disp;
     }
     for(int y=h1-1;y>=0;y--)
     {
         tpy=texture[y+1];
         tcy=texture[y];
         xcy=in_[y];
         for(int x=0;x<width;x++)
         {
             double weight=range_table[euro_dist_rgb_max(tcy[x],tpy[x])];
             double alpha_=weight*alpha;
             unsigned char disp=0;
             double min_cost=255;
             for(int c=0;c<nr_channel;c++)
             {
                 ycy[x][c]=inv_alpha*xcy[x][c]+alpha_*ypy[x][c];
                 double cost=0.5*(out[y][x][c]+ycy[x][c]);
                 if(cost<min_cost)
                 {
                     min_cost=cost;
                     disp=c;
                 }
             }
             disparity[y][x]=disp;
         }
         memcpy(ypy[0],ycy[0],sizeof(double)*width*nr_channel);
     }*/
 }
 unsigned char CBRF::euro_dist_rgb_max(unsigned char *a,unsigned char *b)
 {
     unsigned char x,y,z;
     x=abs(a[0]-b[0]);
     y=abs(a[1]-b[1]);
     z=abs(a[2]-b[2]);
     return(max(max(x,y),z));
 }

看一些我用这个算法写的demo的测试结果：

原图

美图秀秀

递归双边滤波