引导滤波核心原理及 C++/Python 实现代码

2.2.2 代入公式计算斜率和截距

引导滤波通过最小化误差推导得到 a_k 和 b_k 的计算公式：

参数解析： 自引导时 p=I，\bar{p}_k = \bar{I}_k； ε 正则化参数 (防止分母为 0，比如取 10)。 代入数值计算：

2.2.3 线性系数的物理意义

斜率 a_k ≈ 0.98（接近 1）：说明这个窗口内有明显边缘（像素值从 60 到 130 变化大），滤波时要保留边缘 → 输出 q_i ≈ I_i（几乎不滤波）。

若窗口是平坦区域（比如所有像素都是 100），则

2.3 斜率和截距问题

问题：通过前面步骤讲解，掌握了每个小窗口内的斜率和截距计算方法，那么 a_k ≈ 0.98 和 b_k ≈ 1.89 具体是哪个像素的斜率和截距？是中心像素的吗？还是 3×3 小窗口内全局所有像素的斜率和截距都是一致？

答：a_k ≈ 0.98 和 b_k ≈ 1.89 是以中心像素 100 为核心的 3×3 窗口 ω_k 的全局线性系数，而非仅属于中心像素，但最终会通过加权平均让每个像素获得专属的 a、b，完成整幅图的滤波。

关于此疑惑，详见下面讲解。

2.4 基于窗口系数，初步计算窗口内所有像素的 q_i

2.4.1 引导滤波的完整逻辑

每个像素会被多个相邻窗口覆盖（比如中心像素会是自身窗口的中心，也是周围 8 个窗口的成员），因此每个像素的最终 a、b 是所有包含该像素的窗口的 a_k 和 b_k 的均值，最终输出是：

2.4.2 完整引导滤波实现过程（基于 3×3 窗口 + 具体像素值）

用以下 3×3 窗口 (记为窗口 W_5，中心像素为第 5 个像素，坐标 (1,1))，如下：

2.4.2.1 计算窗口 W_5 的 a_k 和 b_k

前面已经讲清楚各参数计算的来源，这里直接获取值，如下：

2.4.2.2 基于窗口系数、初步计算窗口内所有像素的 q_i

窗口内每个像素 i 的初步输出为：

参数解析：上标 (5) 表示来自窗口 W_5。

逐个计算 9 个像素的初步值，各像素的滤波输出（基于像素 5 的窗口系数）：

• 像素 1(60)：q_1^(5) = 0.98 × 60 + 1.89 = 60.69
• 像素 2(70)：q_2^(5) = 0.98 × 70 + 1.89 = 70.49
• 像素 3(80)：q_3^(5) = 0.98 × 80 + 1.89 = 80.29
• 像素 4(80)：q_4^(5) = 0.98 × 80 + 1.89 = 80.29
• 像素 5(100)：q_5^(5) = 0.98 × 100 + 1.89 = 99.89
• 像素 6(120)：q_6^(5) = 0.98 × 120 + 1.89 = 119.49
• 像素 7(100)：q_7^(5) = 0.98 × 100 + 1.89 = 99.89
• 像素 8(110)：q_8^(5) = 0.98 × 110 + 1.89 = 109.69
• 像素 9(130)：q_9^(5) = 0.98 × 130 + 1.89 = 129.29

2.4.2.3 考虑多窗口覆盖 (每个像素被多个窗口包含)

引导滤波中，每个像素会被多个相邻窗口覆盖，因此需要对所有包含该像素的窗口的 a_k、b_k 取均值，得到该像素的最终 \bar{a}_i，\bar{b}_i。

以中心像素 5（100）为例：像素 5 是窗口 W5 的中心，同时也是窗口 W_2（以像素 2 为中心）、W_4（以像素 4 为中心）、W_6（以像素 6 为中心）、W_8（以像素 8 为中心）的成员。

假设我们计算出这 4 个相邻窗口的系数，各窗口的系数计算：

• W_2(中心 70)：a_2 ≈ 0.95, b_2 ≈ 3.5
• W_4(中心 80)：a_4 ≈ 0.96, b_4 ≈ 3.2
• W_6(中心 120)：a_6 ≈ 0.98, b_6 ≈ 2.4
• W_8(中心 110)：a_8 ≈ 0.97, b_8 ≈ 2.9

像素 5 的最终系数： \bar{a}_5 = \frac{a_5 + a_2 + a_4 + a_6 + a_8}{5} = \frac{0.98 + 0.95 + 0.96 + 0.98 + 0.97}{5} = 0.968 \bar{b}_5 = \frac{b_5 + b_2 + b_4 + b_6 + b_8}{5} = \frac{1.89 + 3.5 + 3.2 + 2.4 + 2.9}{5} = 2.778

像素 5 最终的滤波输出为： q_5 = \bar{a}_5 · I_5 + \bar{b}_5 = 0.968 × 100 + 2.778 = 99.578

三、实战代码

3.1 参数设置

学者在使用代码过程，需要修改的地方如下：

3.2 C++ 代码

下面是完整的 C++ 代码：

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

/**
 * @brief 通用引导滤波（保边降噪专用，无耗时优化，精度优先）
 * @param I 引导图（可以是原图自身 - 自引导，也可以是其他特征图 - 异引导）
 * @param p 待滤波的输入图（需要降噪的图像）
 * @param r 滤波窗口半径（降噪核心参数：r 越大，降噪越强，建议 3~15）
 * @param eps 正则化参数（保边核心参数：eps 越小，保边越强；eps 越大，平滑越强，建议 0.001~10）
 * @return 滤波后的降噪图像（与输入图尺寸、类型一致）
 * @note 1. 支持单通道灰度图/CV_8UC1、CV_32FC1；3 通道彩色图/CV_8UC3、CV_32FC3
 * 2. 降噪场景建议使用自引导（I=p），既保留边缘又滤除噪声
 * 3. 无任何耗时优化，全程高精度浮点计算，专注降噪效果
 */
Mat guidedFilterForDenoising(const Mat& I, const Mat& p, int r, float eps) {
    // ===================== 1. 输入合法性校验 =====================
    CV_Assert(!I.empty() && !p.empty()); // 图像非空
    CV_Assert(I.size() == p.size()); // 引导图与输入图尺寸一致
    CV_Assert(r >= 1); // 窗口半径至少为 1
    CV_Assert(eps > 0); // 正则化参数必须大于 0

    // 记录输入图像的原始类型（用于最终输出格式还原）
    int inputType = p.type();

    // 统一转为 32 位浮点型计算（避免 8 位整数运算的精度丢失，保证降噪精度）
    Mat I32f, p32f;
    if (I.depth() == CV_8U) {
        I.convertTo(I32f, CV_32F, 1.0 / 255.0); // 8 位转 32 位浮点，归一化到 0~1 区间
    } else {
        I32f = I.clone();
    }
    if (p.depth() == CV_8U) {
        p.convertTo(p32f, CV_32F, 1.0 / 255.0);
    } else {
        p32f = p.clone();
    }

    // 滤波窗口尺寸（半径 r → 尺寸 2r+1）
    Size winSize(2 * r + 1, 2 * r + 1);

    // ===================== 2. 计算窗口统计量（核心步骤） =====================
    // 2.1 计算引导图 I、输入图 p 的窗口均值 E[I]、E[p]
    Mat mean_I, mean_p;
    // boxFilter 参数说明：
    // - 第 4 个参数：输出类型（32 位浮点）
    // - 第 5 个参数：窗口尺寸
    // - 第 6 个参数：锚点（-1,-1 表示窗口中心）
    // - 第 7 个参数：是否归一化（true=求均值，false=求和）
    // - 第 8 个参数：边缘填充方式（复制边缘，避免边缘像素降噪效果异常）
    boxFilter(I32f, mean_I, CV_32F, winSize, Point(-1, -1), true, BORDER_REPLICATE);
    boxFilter(p32f, mean_p, CV_32F, winSize, Point(-1, -1), true, BORDER_REPLICATE);

    // 2.2 计算交叉均值 E[I*p] 和引导图平方的均值 E[I*I]
    Mat mean_Ip, mean_II;
    boxFilter(I32f.mul(p32f), mean_Ip, CV_32F, winSize, Point(-1, -1), true, BORDER_REPLICATE); // E[I*p]
    boxFilter(I32f.mul(I32f), mean_II, CV_32F, winSize, Point(-1, -1), true, BORDER_REPLICATE); // E[I²]

    // 2.3 计算协方差 cov(I,p) = E[I*p] - E[I]*E[p]
    Mat cov_Ip = mean_Ip - mean_I.mul(mean_p);

    // 2.4 计算引导图的方差 var(I) = E[I²] - (E[I])²
    Mat var_I = mean_II - mean_I.mul(mean_I);

    // ===================== 3. 计算引导滤波核心系数 =====================
    // 3.1 斜率 a：控制边缘保留程度（a≈1 → 边缘区域，几乎不滤波；a≈0 → 平坦区域，强降噪）
    // 公式：a = cov(I,p) / (var(I) + eps)
    Mat a = cov_Ip / (var_I + eps);

    // 3.2 截距 b：控制平坦区域的平滑程度（b = E[p] - a*E[I]）
    Mat b = mean_p - a.mul(mean_I);

    // ===================== 4. 平滑系数 a、b（避免块效应） =====================
    // 对 a、b 进行窗口均值滤波，保证系数空间连续性，消除滤波后的块效应
    Mat mean_a, mean_b;
    boxFilter(a, mean_a, CV_32F, winSize, Point(-1, -1), true, BORDER_REPLICATE);
    boxFilter(b, mean_b, CV_32F, winSize, Point(-1, -1), true, BORDER_REPLICATE);

    // ===================== 5. 计算最终滤波结果 =====================
    // 公式：q = a*I + b（逐像素计算，保边降噪的核心输出）
    Mat q32f = mean_a.mul(I32f) + mean_b;

    // ===================== 6. 还原为输入图像的原始格式 =====================
    Mat result;
    if (inputType == CV_8UC1) { // 灰度 8 位图：浮点转 8 位，反归一化（×255），钳位 0~255 避免溢出
        q32f.convertTo(result, CV_8UC1, 255.0, 0.0);
    } else if (inputType == CV_8UC3) { // 彩色 8 位图：同上
        q32f.convertTo(result, CV_8UC3, 255.0, 0.0);
    } else if (inputType == CV_32FC1) { // 灰度浮点图：直接克隆
        result = q32f.clone();
    } else if (inputType == CV_32FC3) { // 彩色浮点图：直接克隆
        result = q32f.clone();
    } else {
        cerr << "不支持的图像类型！" << endl;
        return Mat();
    }
    return result;
}

/**
 * @brief RGB 彩色图像引导滤波去噪（逐通道自引导）
 * @param src 输入 RGB/BGR 彩色图像（CV_8UC3 或 CV_32FC3）
 * @param r 引导滤波窗口半径
 * @param eps 正则化参数
 * @return 去噪后的彩色图像
 */
Mat guidedFilterRGBForDenoising(const Mat& src, int r, float eps) {
    CV_Assert(!src.empty());
    CV_Assert(src.channels() == 3); // 拆分 RGB 三个通道
    vector<Mat> channels;
    split(src, channels);

    // 对每个通道分别进行'自引导滤波'
    for (int c = 0; c < 3; ++c) {
        channels[c] = guidedFilterForDenoising(channels[c], // 引导图 Ic
                                               channels[c], // 输入图 pc（自引导）
                                               r, eps);
    }

    // 合并通道
    Mat dst;
    merge(channels, dst);
    return dst;
}

/**
 * @brief 引导滤波降噪测试函数（灰度图示例）
 * @note 彩色图只需将 IMREAD_GRAYSCALE 改为 IMREAD_COLOR 即可
 */
int main() {
    // 1. 读取含噪声的灰度图像（替换为你的图像路径）
    Mat src = imread("testImages/monarch.png");
    if (src.empty()) {
        cerr << "图像读取失败，请检查路径！" << endl;
        return -1;
    }

    // 2. 设置引导滤波降噪参数（重点调参说明）
    int r = 3; // 滤波窗口半径：值越大，降噪越强（建议 3~15）
    float eps = 0.001f; // 正则化参数：值越小，保边越优；值越大，降噪越强

    // 降噪场景使用自引导：引导图=输入图（最常用的保边降噪方式）
    // Mat denoised = guidedFilterForDenoising(src, src, r, eps);
    Mat denoised = guidedFilterRGBForDenoising(src, r, eps);

    // 3. 显示并保存结果
    imshow("原始含噪图像", src);
    imshow("引导滤波降噪图像", denoised);
    // imwrite("denoised_image.png", denoised); // 保存降噪结果

    // 等待按键退出
    cout << "按任意键退出..." << endl;
    waitKey(0);
    return 0;
}

3.3 Python 代码

下面是完整的 Python 代码：

import cv2
import numpy as np
import sys

def guidedFilterForDenoising(I, p, r, eps):
    """
    通用引导滤波（保边降噪专用，无耗时优化，精度优先）
    Parameters:
        I: 引导图（numpy 数组），可以是原图自身（自引导）或其他特征图（异引导）
        p: 待滤波的输入图（numpy 数组），需要降噪的图像
        r: 滤波窗口半径（降噪核心参数：r 越大，降噪越强，建议 3~15）
        eps: 正则化参数（保边核心参数：eps 越小，保边越强；eps 越大，平滑越强，建议 0.001~10）
    Returns:
        result: 滤波后的降噪图像（numpy 数组），与输入图尺寸、类型一致
    Notes:
        1. 支持单通道灰度图（uint8/float32）、3 通道彩色图（uint8/float32）
        2. 降噪场景建议使用自引导（I=p），既保留边缘又滤除噪声
        3. 无任何耗时优化，全程高精度浮点计算，专注降噪效果
    """
    # ===================== 1. 输入合法性校验 =====================
    if I is None or p is None:
        raise ValueError("引导图或输入图不能为空！")
    if I.shape != p.shape:
        raise ValueError("引导图与输入图尺寸必须一致！")
    if r < 1:
        raise ValueError("滤波窗口半径 r 必须大于等于 1！")
    if eps <= 0:
        raise ValueError("正则化参数 eps 必须大于 0！")

    # 记录输入图像的原始类型和形状（用于最终输出格式还原）
    input_dtype = p.dtype
    h, w = p.shape[:2]
    is_color = len(p.shape) == 3 and p.shape[2] == 3

    # ===================== 2. 统一转为 32 位浮点型计算 =====================
    # 8 位 uint 转 32 位 float，归一化到 0~1 区间（避免精度丢失）
    if I.dtype == np.uint8:
        I32f = I.astype(np.float32) / 255.0
    else:
        I32f = I.copy().astype(np.float32)
    if p.dtype == np.uint8:
        p32f = p.astype(np.float32) / 255.0
    else:
        p32f = p.copy().astype(np.float32)

    # 滤波窗口尺寸（半径 r → 尺寸 2r+1）
    win_size = (2 * r + 1, 2 * r + 1)

    # ===================== 3. 计算窗口统计量（核心步骤） =====================
    # OpenCV-Python 的 boxFilter 参数说明：
    # - ddepth=-1：输出与输入深度一致；这里手动指定为 CV_32F 保证精度
    # - ksize：窗口尺寸
    # - anchor=(-1,-1)：窗口中心
    # - normalize=True：求均值（False 为求和）
    # - borderType=cv2.BORDER_REPLICATE：复制边缘填充
    # 3.1 计算引导图 I、输入图 p 的窗口均值 E[I]、E[p]
    mean_I = cv2.boxFilter(I32f, cv2.CV_32F, win_size, anchor=(-1, -1), normalize=True, borderType=cv2.BORDER_REPLICATE)
    mean_p = cv2.boxFilter(p32f, cv2.CV_32F, win_size, anchor=(-1, -1), normalize=True, borderType=cv2.BORDER_REPLICATE)

    # 3.2 计算交叉均值 E[I*p] 和引导图平方的均值 E[I*I]
    # 逐像素相乘（对应 C++ 的 mul 函数）
    I_mul_p = I32f * p32f
    I_mul_I = I32f * I32f
    mean_Ip = cv2.boxFilter(I_mul_p, cv2.CV_32F, win_size, anchor=(-1, -1), normalize=True, borderType=cv2.BORDER_REPLICATE)
    mean_II = cv2.boxFilter(I_mul_I, cv2.CV_32F, win_size, anchor=(-1, -1), normalize=True, borderType=cv2.BORDER_REPLICATE)

    # 3.3 计算协方差 cov(I,p) = E[I*p] - E[I]*E[p]
    cov_Ip = mean_Ip - mean_I * mean_p

    # 3.4 计算引导图的方差 var(I) = E[I²] - (E[I])²
    var_I = mean_II - mean_I * mean_I

    # ===================== 4. 计算引导滤波核心系数 =====================
    # 4.1 斜率 a：控制边缘保留程度（a≈1→边缘，a≈0→平坦区域）
    # 公式：a = cov(I,p) / (var(I) + eps)
    a = cov_Ip / (var_I + eps)

    # 4.2 截距 b：控制平坦区域的平滑程度（b = E[p] - a*E[I]）
    b = mean_p - a * mean_I

    # ===================== 5. 平滑系数 a、b（避免块效应） =====================
    mean_a = cv2.boxFilter(a, cv2.CV_32F, win_size, anchor=(-1, -1), normalize=True, borderType=cv2.BORDER_REPLICATE)
    mean_b = cv2.boxFilter(b, cv2.CV_32F, win_size, anchor=(-1, -1), normalize=True, borderType=cv2.BORDER_REPLICATE)

    # ===================== 6. 计算最终滤波结果 =====================
    # 公式：q = a*I + b（逐像素计算）
    q32f = mean_a * I32f + mean_b

    # ===================== 7. 还原为输入图像的原始格式 =====================
    # 反归一化（×255），钳位 0~255 避免溢出，转回 uint8
    if input_dtype == np.uint8:
        # 浮点转 8 位 uint，确保值在 0~255 之间
        q32f = np.clip(q32f * 255.0, 0, 255)
        result = q32f.astype(np.uint8)
    else:
        # 浮点型直接返回
        result = q32f.astype(input_dtype)
    return result

def guidedFilterRGBForDenoising(src, r, eps):
    """
    RGB 彩色图像引导滤波去噪（逐通道自引导）
    Parameters:
        src: 输入彩色图像（H×W×3，uint8 或 float32，OpenCV 默认 BGR）
        r: 引导滤波窗口半径
        eps: 正则化参数
    Returns:
        dst: 去噪后的彩色图像
    """
    if src is None:
        raise ValueError("输入图像不能为空！")
    if src.ndim != 3 or src.shape[2] != 3:
        raise ValueError("输入必须是 3 通道彩色图像！")

    # 拆分 BGR 三个通道
    channels = cv2.split(src)

    # 对每个通道独立执行'自引导滤波'
    denoised_channels = []
    for c in channels:
        denoised_c = guidedFilterForDenoising(c, c, r, eps)
        denoised_channels.append(denoised_c)

    # 合并通道
    dst = cv2.merge(denoised_channels)
    return dst

def main():
    """
    引导滤波降噪测试函数（灰度图示例）
    彩色图只需将 cv2.IMREAD_GRAYSCALE 改为 cv2.IMREAD_COLOR 即可
    """
    # 1. 读取含噪声的灰度图像（替换为你的图像路径）
    img_path = "Images/removeStrips/lenna.png"
    src = cv2.imread(img_path)
    if src is None:
        print("图像读取失败，请检查路径！", file=sys.stderr)
        return -1

    # 2. 设置引导滤波降噪参数
    r = 3  # 滤波窗口半径
    eps = 0.005  # 正则化参数

    # 降噪场景使用自引导：引导图=输入图
    # denoised = guidedFilterForDenoising(src, src, r, eps)

    # RGB 彩色引导滤波去噪
    denoised = guidedFilterRGBForDenoising(src, r, eps)

    # 3. 显示并保存结果
    cv2.imshow("原始含噪图像", src)
    cv2.imshow("引导滤波降噪图像", denoised)
    cv2.imwrite("denoised_image.png", denoised)  # 保存降噪结果

    # 等待按键退出
    print("按任意键退出...")
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    return 0

if __name__ == "__main__":
    main()

四、去噪实例效果

使用本博文教程中代码去噪结果如下，左图为原图，右图为引导滤波去噪后结果：

五、总结

本文详细介绍了引导滤波（Guided Filter）的原理与实现方法。文章通过具体示例（3×3 窗口）逐步解析了斜率和截距的计算过程，包括均值、方差及协方差的计算，并演示了如何通过线性模型得到滤波结果。此外，还探讨了窗口系数的物理意义及像素级滤波输出的计算方法，展示了引导滤波在边缘保留和平滑效果上的优势。引导滤波具有线性计算复杂度（O(N)），适用于图像去噪、HDR 压缩、语义分割后处理等场景，是计算机视觉领域的重要滤波技术。