algorithm - 双边过滤器

It's difficult to tell what is being asked here. This question is ambiguous, vague, incomplete, overly broad, or rhetorical and cannot be reasonably answered in its current form. For help clarifying this question so that it can be reopened, visit the help center。




9年前关闭。




给定高斯滤波器，如何实现双边滤波器？

最佳答案

一个简单的双边过滤器可以定义为

Inew(x，y)=求和(j = yn/2; j
其中普通的低通滤波器(例如高斯滤波器)基于从内核中心(x，y)到每个像素(i，j)的距离而具有权重w(i，j，x，y)。对于双边滤波器，权重是基于两个距离确定的:图像空间距离和色度空间距离。

下面是一个简单的C实现

void convolution(uchar4 *_in, uchar4 *_out, int width, int height, int ~ halfkernelsize, float id, float cd)
{
  int kernelDim = 2*halfkernelsize+1;

  for(int y=0; y

  float sumWeight = 0;

  unsigned int ctrIdx = y*width + x;

  float ctrPix[3];
  ctrPix[0] = _in[ctrIdx].x;
  ctrPix[1] = _in[ctrIdx].y;
  ctrPix[2] = _in[ctrIdx].z;

  // neighborhood of current pixel
  int kernelStartX, kernelEndX, kernelStartY, kernelEndY;
  kernelStartX = x-halfkernelsize;
  kernelEndX   = x+halfkernelsize;
  kernelStartY = y-halfkernelsize;
  kernelEndY   = y+halfkernelsize;

  for(int j= kernelStartY; j<= kernelEndY; j++)
    {
      for(int i= kernelStartX; i<= kernelEndX; i++)
    {
      unsigned int idx = max(0, min(j, height-1))*width + max(0, min(i,width-1));

      float curPix[3];
      curPix[0] = _in[idx].x;
      curPix[1] = _in[idx].y;
      curPix[2] = _in[idx].z;


      float currWeight;

      // define bilateral filter kernel weights
      float imageDist = sqrt( (float)((i-x)*(i-x) + (j-y)*(j-y)) );

      float colorDist = sqrt( (float)( (curPix[0] - ctrPix[0])*(curPix[0] - ctrPix[0]) +
                       (curPix[1] - ctrPix[1])*(curPix[1] - ctrPix[1]) +
                       (curPix[2] - ctrPix[2])*(curPix[2] - ctrPix[2]) ) );

      currWeight = 1.0f/(exp((imageDist/id)*(imageDist/id)*0.5)*exp((colorDist/cd)*(colorDist/cd)*0.5));
      sumWeight += currWeight;

      _sum[0] += currWeight*curPix[0];
      _sum[1] += currWeight*curPix[1];
      _sum[2] += currWeight*curPix[2];
    }
    }

  _sum[0] /= sumWeight;
  _sum[1] /= sumWeight;
  _sum[2] /= sumWeight;

  _out[ctrIdx].x = (int)(floor(_sum[0]));
  _out[ctrIdx].y = (int)(floor(_sum[1]));
  _out[ctrIdx].z = (int)(floor(_sum[2]));
  _out[ctrIdx].w = _in[ctrIdx].w;
}
}

}

关于algorithm - 双边过滤器，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/5695865/