详解——导向滤波(Guided Filter)和快速导向滤波

导读

在图像滤波算法中，导向滤波、双边滤波、最小二乘滤波并称三大保边滤波器，他们是各向异性滤波器。相对于常见的均值滤波、高斯滤波等各向同性滤波器，他们最大的特点是在去除噪声的同时，能最大限度保持边缘不被平滑。本文讲解导向滤波及其应用。
总的来讲，导向滤波就是尽可能让输出图像的梯度和导向图相似，同时让输出图像的灰度(亮度)与输入图像相似，以此来保留边缘并且滤除噪声。

---

原理推导

我们先看下图：

输入图像$p$，经过引导图像$I$, 滤波得到输出图像$q$, 导向滤波算法中有一个重要假设：即在局部窗口$w_k$上，导向图$I$和输出图$q$存在局部线性关系：
$q_i = a_kI_i + b_k, \forall{i\in{w_k}}\tag{1}$
同时在窗口$w_k$上, 滤波后的图像$q$和输入图像$p$有如下关系：
$q_i = p_i - n_i，\forall{i\in{w_k}}\tag{2}$
这样公式$(1)$的线性关系保证了如果在每个局部窗口$w_k$中，如果导向图$I$中存在一个边缘，输出图像$q$将保持边缘不变。同时，滤波结果图$q$要尽可能与输入图像$p$相同以此减小滤波带来的信息损失，该算法的最小二乘表示即：
$argmin\sum_{i\in{w_k}}(q_i-p_i)^2 = argmin\sum_{i\in{w_k}}(a_kI_i+b_k-p_i)^2$
这是求解最优值的问题，引入一个正则化参数$\epsilon$防止$a_k$过大，得到损失函数：
$E(a_k,b_k)=\sum_{i\in{w_k}}((a_kI_i+b_k-p_i)^2+\epsilon{a_k^2})\tag{3}$
运用最小二乘法求解极小值，利用极小值处导数为0，求解过程如下：
$\begin{aligned} \frac{\delta{E}}{a_k} &= \sum_{i\in{w_k}}(2(a_kI_i+b_k-p_i)I_i+2\epsilon{a_k}) = 0 \\ & \Rightarrow \sum_{i\in{w_k}}(a_kI_i^2+b_kI_i-p_iI_i+\epsilon{a_k}) = 0 \\ \frac{\delta{E}}{b_k} & = \sum_{i\in{w_k}}2(a_kI_i+b_k-p_i)= 0 \\ & \Rightarrow a_k\sum_{i\in{w_k}}{I_i}-\sum_{i\in{w_k}}{p_i}+\sum_{i\in{w_k}}{b_k} = 0 \\ & \Rightarrow |w|b_k = \sum_{i\in{w_k}}{p_i}-a_k\sum_{i\in{w_k}}{I_i} \end{aligned}$
由上面推到得出：
$\begin{aligned} a_k &= \frac{\sum_{i\in{w_k}}p_iI_i-b_k\sum_{i\in{w_k}}I_i}{\sum_{i\in{w_k}}(I_i^2+\epsilon)} \\ b_k &= \frac{\sum_{i\in{w_k}}{p_i}-a_k\sum_{i\in{w_k}}{I_i}}{|w|} \\ & = \overline{p}_k - a_k\mu_k \tag{4} \end{aligned}$
其中：$\begin{aligned} & \mu_k——窗口w_k范围内引导图I的均值；\\ & \overline{p}_k——窗口w_k范围内输入图p的均值。 \end{aligned}$
将$b_k$代入$a_k$计算可得：
$a_k = \frac{\sum_{i\in{w_k}}p_iI_i-b_k\sum_{i\in{w_k}}I_i}{\sum_{i\in{w_k}}(I_i^2+\epsilon)}$
$\Rightarrow a_k = \frac{\sum_{i\in{w_k}}(p_iI_i-\overline{p}_kI_i)}{\sum_{i\in{w_k}}(I_i^2+\mu_kI_i+\epsilon)}$
$\Rightarrow a_k = \frac{\sum_{i\in{w_k}}(p_iI_i-\overline{p}_kI_i {\color{red}{+\mu_kp_i-\mu_k\overline{p}_k}})}{\sum_{i\in{w_k}}(I_i^2-\mu_kI_i{\color{red}{-\mu_kI_i+\mu_k^2}}+\epsilon)}$
上下两边同除以$|w|$,$|w|$为窗口$w_k$像素数量。得到：
$a_k = \frac{\frac{1}{|w|}\sum_{i\in{w_k}}p_iI_i-\overline{p}_k\mu_k{\color{red}{+\mu_k\overline{p}_k-\mu_k\overline{p}_k}}}{\sum_{i\in{w_k}}(I_i-\mu_k)^2+\epsilon}$
最后：
$\color{red}{a_k = \frac{\frac{1}{|w|}\sum_{i\in{w_k}}p_iI_i{ - \mu_k\overline{p}_k}}{\sigma_k^2+\epsilon}} \tag{5}$
$\color{red}{b_k = \overline{p}_k+a_k\mu_k} \tag{6}$
得到上述公式后，可以对每个窗口$w_k$计算一个$(a_k,b_k)$，但是，每个像素都被包含在多个窗口中，对每个像素，都能计算出多个$(a_k,b_k)$，我么将使用多个$(a_k,b_k)$计算得到的$q_i$值求平均得到输出$q_i$值，上述过程描述如下:
$\begin{aligned} q_i &= \frac{1}{w_k}\sum_{k,i\in{w_k}}(a_kI_i+b_k) \\ & = \overline{a}_iI_i+\overline{b}_i \end{aligned}$
其中：$\begin{aligned} & \overline{a}_i——窗口w_k范围内所有像素计算得到的a_k的均值；\\ & \overline{b}_i——窗口w_k范围内所有像素计算得到的b_k的均值。 \end{aligned}$

导向滤波的应用

• 保边滤波
  当$I=p$时，该算法成为一个保边滤波器。上述$(a_k,b_k)$计算公式变化为:
  $a_k = \frac{\sigma_k^2}{\sigma_k^2+\epsilon} \\ b_k = (1-a_k)\overline{p}_k$
  考虑以下两种情况：
  • Case 1：平坦区域。如果在某个滤波窗口内，该区域是相对平滑的，方差$\sigma_k^2$将远远小于$\epsilon$。从而$a_k≈0,b_k≈\overline{p}_k$。相当于对该区域作均值滤波。
  • Case 2：高方差区域。相反，如果该区域是边缘区域，方差很大，$\sigma_k^2$将远远大于$\epsilon$。从而$a_k≈1,b_k≈0$。相当于在区域保持原有梯度。
    以上可以出:$\epsilon$为界定平滑区域和边缘区域的阈值。
• 图像去雾
  在图像去雾中，导向滤波一般用来细化透射率图像，以原图的灰度图为导向图，以粗投射率图为输入图，能得到非常精细的透射率图像。

当然，导向滤波的应用不止以上两种，网上还有图像融合等应用，本人没有去了解。

导向滤波的实现

导向滤波的代码实现较为简单，我们直接贴出计算流程

快速导向滤波的实现

由于导向滤波效率问题，何凯明博士在2015年，对其做了优化，基本原理是将导向图，输入图都进行下采样计算$(a_k,b_k)$，然后对$(a_k,b_k)$进行上采样恢复原始大小，整个算法流程如下：

算法效果

我们演示一下保边滤波效果：

代码

接下来，废话不多说，我们上代码：https://github.com/EthanAndEvan/ImageAlgorithmDraft，为防止github无法访问，我们直接贴上代码：

• 导向滤波

#include <opencv2/opencv.hpp>
//导向滤波
void GuidedFilter(cv::Mat& srcImage, cv::Mat& guidedImage, cv::Mat& outputImage, int filterSize, double eps)
{
	try
	{
		if (srcImage.empty() || guidedImage.empty() || filterSize <= 0 || eps < 0 ||
			srcImage.channels() != 1 || guidedImage.channels() != 1)
		{
			throw "params input error";
		}
		cv::Mat srcImageP, srcImageI, meanP, meanI, meanIP, meanII, varII, alfa, beta;
		srcImage.convertTo(srcImageP, CV_32FC1);
		guidedImage.convertTo(srcImageI, CV_32FC1);
		cv::boxFilter(srcImageP, meanP, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(srcImageI, meanI, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(srcImageI.mul(srcImageP), meanIP, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(srcImageI.mul(srcImageI), meanII, CV_32FC1, cv::Size(filterSize, filterSize));
		varII = meanII - meanI.mul(meanI); 
		alfa = (meanIP - meanI.mul(meanP)) / (varII + eps);
		beta = meanP - alfa.mul(meanI);
		cv::boxFilter(alfa, alfa, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(beta, beta, CV_32FC1, cv::Size(filterSize, filterSize));
		outputImage = (alfa.mul(srcImageI) + beta);
	}
	catch (cv::Exception& e)
	{
		throw e;
	}
	catch (std::exception& e)
	{
		throw e;
	}
}

• 快速导向滤波

#include <opencv2/opencv.hpp>
//快速导向滤波
void FastGuidedFilter(cv::Mat& srcImage, cv::Mat& guidedImage, cv::Mat& outputImage, int filterSize, double eps, int samplingRate)
{
	try
	{
		if (srcImage.empty() || guidedImage.empty() || filterSize <= 0 || eps < 0 ||
			srcImage.channels() != 1 || guidedImage.channels() != 1 || samplingRate < 1)
		{
			throw "params input error";
		}
		cv::Mat srcImageP, srcImageSubI, srcImageI, meanP, meanI, meanIP, meanII, var, alfa, beta;
		
		cv::resize(srcImage, srcImageP, cv::Size(srcImage.cols / samplingRate, srcImage.rows / samplingRate));
		cv::resize(guidedImage, srcImageSubI, cv::Size(srcImage.cols / samplingRate, srcImage.rows / samplingRate));

		filterSize = filterSize / samplingRate;

		srcImageP.convertTo(srcImageP, CV_32FC1);
		guidedImage.convertTo(srcImageI, CV_32FC1);
		srcImageSubI.convertTo(srcImageSubI, CV_32FC1);
		cv::boxFilter(srcImageP, meanP, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(srcImageSubI, meanI, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(srcImageSubI.mul(srcImageP), meanIP, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(srcImageSubI.mul(srcImageSubI), meanII, CV_32FC1, cv::Size(filterSize, filterSize));
		var = meanII - meanI.mul(meanI);
		alfa = (meanIP - meanI.mul(meanP)) / (var + eps);
		beta = meanP - alfa.mul(meanI);
		cv::boxFilter(alfa, alfa, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::boxFilter(beta, beta, CV_32FC1, cv::Size(filterSize, filterSize));
		cv::resize(alfa, alfa, cv::Size(srcImage.cols, srcImage.rows));
		cv::resize(beta, beta, cv::Size(srcImage.cols, srcImage.rows));
		outputImage = alfa.mul(srcImageI) + beta;
	}
	catch (cv::Exception& e)
	{
		throw e;
	}
	catch (std::exception& e)
	{
		throw e;
	}
}

参考

[1] 视觉一只白 .《导向滤波的原理及实现》[DB/OL].
[2] lsflll.《导向滤波(Guided Filter)公式详解》[DB/OL]
[3] SongpingWang.《OpenCV—Python 导向滤波》[DB/OL]