导向滤波算法——OpenGL实现

置顶 已于 2023-01-30 14:47:41 修改
阅读量2.2k 收藏 1
点赞数 3
分类专栏： 图像算法 OpenGL 文章标签： 算法 计算机视觉 opengl 图像处理 opengles
于 2023-01-30 14:15:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q345911572/article/details/128799773
版权

导向滤波

一、介绍

  • 导向滤波又称引导滤波，通过一张引导图片反映边缘、物体等信息，对输入图像进行滤波处理，使输出图像的内容由输入图像决定，但纹理与引导图片相似。

  • 导向滤波的原理是局部线性模型，在保持双边滤波的优势（有效保持边缘，非迭代计算）的同时计算速度很快，从而克服双边滤波速度慢的缺点。

  • 导向滤波（引导滤波）不仅能实现双边滤波的边缘平滑，而且在检测到边缘附近有很好的表现，可应用在图像增强、HDR压缩、图像抠图及图像去雾等场景。

  • 在进行保持边缘滤波时，可以采用原始图像自身或其预处理后的图像作为导向图片。

二、对比双边滤波的优势

  • 1.导向滤波比起双边滤波来说在边界附近效果较好；另外，它还具有 O(N) 的线性时间的速度优势。双边滤波器有非常大的计算复杂度O(N^2)，但导向滤波器因为并未用到过于复杂的数学计算，有线性的计算复杂度。
    在这里插入图片描述
  • 2.除了速度优势以外，导向滤波的一个很好的性能就是可以保持梯度，这是bilateral做不到的，因为会有梯度翻转现象。导向滤波器因为在数学上以线性组合为基础出发，输出图片（Output Image）与引导图片（Guidance Image）的梯度方向一致，不会出现梯度反转的问题。
    在这里插入图片描述

三、导向滤波的数学原理（比较复杂，这部分可以不看了）

这部分参考大佬的一篇文章：引导滤波/导向滤波（Guided Filter）

  • 引导滤波的思想用一张引导图像产生权重，从而对输入图像进行处理，这个过程可以表示为下面公式：
    在这里插入图片描述
  • 其中，p为输入图像，I 为导向图，q 为输出图像。在这里我们认为输出图像可以看成导向图 I 的一个局部线性变换，其中k是局部化的窗口的中点，因此属于窗口 ωk 的像素，都可以用导向图对应的像素通过（ak,bk）的系数进行变换计算出来。同时，我们认为输入图像 p 是由 q 加上我们不希望的噪声或纹理得到的，因此有 p = q + n 。
    接下来就是解出这样的系数，使得p和q的差别尽量小，而且还可以保持局部线性模型。这里利用了带有正则项的 linear ridge regression（岭回归）
    在这里插入图片描述
  • 求解以上方程得到a和b在局部的值，对于一个要求的像素可能含在多个窗口中，因此平均后得到：
    在这里插入图片描述
  • 最终得到算法：
    在这里插入图片描述

四、OpenGL实现导向滤波

  • 这里把原图当做导向图。那么上图算法中的I=P，于是方差和协方差是相等的。

  • 按照上面的算法，由于导向滤波需要把原始图片分别绘制a和b，还需要计算a和b的模糊图。为了节省绘制次数，把整个大算法分成2次渲染，第一次渲染求得a和b，第二次渲染求得最终的结果q

  • 思路如下图：
    在这里插入图片描述

  • 为了在2次draw call内完成导向滤波操作，这里用了一个比较巧妙的方式是，在通一个绘制里同时绘制a和b的结果，把它分别画到画布的左半边和右半边（当然也可以分成上下）。

    • 需要注意的是这个画布的宽需要原始图片宽的2倍大，在创建纹理的时候需要注意纹理的尺寸

  • 以下为2次绘制的opengl shader

  • GuidedSubFilter1 片源着色器：

precision highp float;

uniform sampler2D u_origin; // 原图
varying vec2 texcoordOut;

uniform vec2 offset;  // 单个像素步长
uniform float alpha;   // 模糊程度
uniform float eps;   // 正则化参数e

// 均值模糊，5*5
vec3 meanBlur(vec3 colors[25]) {
    highp vec3 sum = vec3(0.0);
    for (int i = 0; i < 25; i++) {
        sum += colors[i];
    }
    return sum * 0.04;
}

void main()
{
    // 因为这个shader最终画到一个 2*w, h 尺寸的一个FBO上，左边是导向滤波的a结果，右边是导向滤波的b结果，所以这里需要计算在原始纹理上真实的采样坐标
    highp vec2 originTexcoord;
    if (texcoordOut.x < 0.5) {
        originTexcoord = vec2(texcoordOut.x * 2.0, texcoordOut.y);
    } else {
        originTexcoord = vec2((texcoordOut.x - 0.5) * 2.0, texcoordOut.y);
    }
    
    // 采样原图 I 的 5*5 个点
    highp vec3 origin[25];
    
    origin[0] = texture2D(u_origin, originTexcoord).rgb;
    
    origin[1] = texture2D(u_origin, originTexcoord + vec2(offset.x, 0.0)).rgb;
    origin[2] = texture2D(u_origin, originTexcoord + vec2(-offset.x, 0.0)).rgb;
    origin[3] = texture2D(u_origin, originTexcoord + vec2(0.0, offset.y)).rgb;
    origin[4] = texture2D(u_origin, originTexcoord + vec2(0.0, -offset.y)).rgb;
    
    origin[5] = texture2D(u_origin, originTexcoord + vec2(offset.x, offset.y)).rgb;
    origin[6] = texture2D(u_origin, originTexcoord + vec2(offset.x, -offset.y)).rgb;
    origin[7] = texture2D(u_origin, originTexcoord + vec2(-offset.x, offset.y)).rgb;
    origin[8] = texture2D(u_origin, originTexcoord + vec2(-offset.x, -offset.y)).rgb;
    
    origin[9] = texture2D(u_origin, originTexcoord + vec2(2.0 * offset.x, 0)).rgb;
    origin[10] = texture2D(u_origin, originTexcoord + vec2(-2.0 * offset.x, 0)).rgb;
    origin[11] = texture2D(u_origin, originTexcoord + vec2(0, 2.0 * offset.y)).rgb;
    origin[12] = texture2D(u_origin, originTexcoord + vec2(0, -2.0 * offset.y)).rgb;
    
    origin[13] = texture2D(u_origin, originTexcoord + vec2(2.0 * offset.x, 2.0 * offset.y)).rgb;
    origin[14] = texture2D(u_origin, originTexcoord + vec2(2.0 * offset.x, -2.0 * offset.y)).rgb;
    origin[15] = texture2D(u_origin, originTexcoord + vec2(-2.0 * offset.x, 2.0 * offset.y)).rgb;
    origin[16] = texture2D(u_origin, originTexcoord + vec2(-2.0 * offset.x, -2.0 * offset.y)).rgb;
    
    origin[17] = texture2D(u_origin, originTexcoord + vec2(2.0 * offset.x, offset.y)).rgb;
    origin[18] = texture2D(u_origin, originTexcoord + vec2(-2.0 * offset.x, offset.y)).rgb;
    origin[19] = texture2D(u_origin, originTexcoord + vec2(offset.x, 2.0 * offset.y)).rgb;
    origin[20] = texture2D(u_origin, originTexcoord + vec2(-offset.x, 2.0 * offset.y)).rgb;
    
    origin[21] = texture2D(u_origin, originTexcoord + vec2(2.0 * offset.x, -offset.y)).rgb;
    origin[22] = texture2D(u_origin, originTexcoord + vec2(-2.0 * offset.x, -offset.y)).rgb;
    origin[23] = texture2D(u_origin, originTexcoord + vec2(offset.x, -2.0 * offset.y)).rgb;
    origin[24] = texture2D(u_origin, originTexcoord + vec2(-offset.x, -2.0 * offset.y)).rgb;
    
    // 计算原图的平方 I*I
    highp vec3 origin2[25];
    for (int i = 0; i < 25; i++) {
        origin2[i] = origin[i] * origin[i];
    }
    
    // 原图 I 的均值模糊
    highp vec3 originMean = meanBlur(origin);
    // 原图平方 I*I 的均值模糊
    highp vec3 origin2Mean = meanBlur(origin2);
    
    originMean = mix(origin[0], originMean, alpha);
    origin2Mean = mix(origin2[0], origin2Mean, alpha);
    
    // 原图模糊的平方
    highp vec3 originMean2 = originMean * originMean;
    
    // 计算方差（对于磨皮来说引导图和原图是同一个图，方差和协方差是同一个）
    highp vec3 variance = origin2Mean - originMean2;
    
    // 计算导向滤波的AB结果
    highp vec3 A = variance / (variance + eps);
    highp vec3 B = originMean - A * originMean;
    
    // 把AB分别写到图像的左半部分和右半部分
    if (texcoordOut.x < 0.5) {
        gl_FragColor = vec4((A + 1.0) * 0.5, 1.0);
    } else {
        gl_FragColor = vec4((B + 1.0) * 0.5, 1.0);
    }
    
}
  • GuidedSubFilter2 片源着色器：
precision highp float;

uniform sampler2D u_origin; // 原图
uniform sampler2D u_AB;    // guided1的结果，左边是导向滤波的a结果，右边是导向滤波的b结果
varying vec2 texcoordOut;

uniform vec2 offset;  // 单个像素步长
uniform float alpha;   // 模糊程度

// 均值模糊，5*5
vec3 meanBlur(vec3 colors[25]) {
    highp vec3 sum = vec3(0.0);
    for (int i = 0; i < 25; i++) {
        sum += colors[i];
    }
    return sum * 0.04;
}

void main()
{
    // 采样图 A 的 5*5 个点
    highp vec3 colorA[25];
    highp vec2 texcoordA = vec2(texcoordOut.x * 0.5, texcoordOut.y);
    
    colorA[0] = texture2D(u_AB, texcoordA).rgb;
    
    colorA[1] = texture2D(u_AB, texcoordA + vec2(offset.x, 0.0)).rgb;
    colorA[2] = texture2D(u_AB, texcoordA + vec2(-offset.x, 0.0)).rgb;
    colorA[3] = texture2D(u_AB, texcoordA + vec2(0.0, offset.y)).rgb;
    colorA[4] = texture2D(u_AB, texcoordA + vec2(0.0, -offset.y)).rgb;
    
    colorA[5] = texture2D(u_AB, texcoordA + vec2(offset.x, offset.y)).rgb;
    colorA[6] = texture2D(u_AB, texcoordA + vec2(offset.x, -offset.y)).rgb;
    colorA[7] = texture2D(u_AB, texcoordA + vec2(-offset.x, offset.y)).rgb;
    colorA[8] = texture2D(u_AB, texcoordA + vec2(-offset.x, -offset.y)).rgb;
    
    colorA[9] = texture2D(u_AB, texcoordA + vec2(2.0 * offset.x, 0)).rgb;
    colorA[10] = texture2D(u_AB, texcoordA + vec2(-2.0 * offset.x, 0)).rgb;
    colorA[11] = texture2D(u_AB, texcoordA + vec2(0, 2.0 * offset.y)).rgb;
    colorA[12] = texture2D(u_AB, texcoordA + vec2(0, -2.0 * offset.y)).rgb;
    
    colorA[13] = texture2D(u_AB, texcoordA + vec2(2.0 * offset.x, 2.0 * offset.y)).rgb;
    colorA[14] = texture2D(u_AB, texcoordA + vec2(2.0 * offset.x, -2.0 * offset.y)).rgb;
    colorA[15] = texture2D(u_AB, texcoordA + vec2(-2.0 * offset.x, 2.0 * offset.y)).rgb;
    colorA[16] = texture2D(u_AB, texcoordA + vec2(-2.0 * offset.x, -2.0 * offset.y)).rgb;
    
    colorA[17] = texture2D(u_AB, texcoordA + vec2(2.0 * offset.x, offset.y)).rgb;
    colorA[18] = texture2D(u_AB, texcoordA + vec2(-2.0 * offset.x, offset.y)).rgb;
    colorA[19] = texture2D(u_AB, texcoordA + vec2(offset.x, 2.0 * offset.y)).rgb;
    colorA[20] = texture2D(u_AB, texcoordA + vec2(-offset.x, 2.0 * offset.y)).rgb;
    
    colorA[21] = texture2D(u_AB, texcoordA + vec2(2.0 * offset.x, -offset.y)).rgb;
    colorA[22] = texture2D(u_AB, texcoordA + vec2(-2.0 * offset.x, -offset.y)).rgb;
    colorA[23] = texture2D(u_AB, texcoordA + vec2(offset.x, -2.0 * offset.y)).rgb;
    colorA[24] = texture2D(u_AB, texcoordA + vec2(-offset.x, -2.0 * offset.y)).rgb;
    
    // 采样图 B 的 5*5 个点
    highp vec3 colorB[25];
    highp vec2 texcoordB = vec2(texcoordOut.x * 0.5 + 0.5, texcoordOut.y);
    
    colorB[0] = texture2D(u_AB, texcoordB).rgb;
    
    colorB[1] = texture2D(u_AB, texcoordB + vec2(offset.x, 0.0)).rgb;
    colorB[2] = texture2D(u_AB, texcoordB + vec2(-offset.x, 0.0)).rgb;
    colorB[3] = texture2D(u_AB, texcoordB + vec2(0.0, offset.y)).rgb;
    colorB[4] = texture2D(u_AB, texcoordB + vec2(0.0, -offset.y)).rgb;
    
    colorB[5] = texture2D(u_AB, texcoordB + vec2(offset.x, offset.y)).rgb;
    colorB[6] = texture2D(u_AB, texcoordB + vec2(offset.x, -offset.y)).rgb;
    colorB[7] = texture2D(u_AB, texcoordB + vec2(-offset.x, offset.y)).rgb;
    colorB[8] = texture2D(u_AB, texcoordB + vec2(-offset.x, -offset.y)).rgb;
    
    colorB[9] = texture2D(u_AB, texcoordB + vec2(2.0 * offset.x, 0)).rgb;
    colorB[10] = texture2D(u_AB, texcoordB + vec2(-2.0 * offset.x, 0)).rgb;
    colorB[11] = texture2D(u_AB, texcoordB + vec2(0, 2.0 * offset.y)).rgb;
    colorB[12] = texture2D(u_AB, texcoordB + vec2(0, -2.0 * offset.y)).rgb;
    
    colorB[13] = texture2D(u_AB, texcoordB + vec2(2.0 * offset.x, 2.0 * offset.y)).rgb;
    colorB[14] = texture2D(u_AB, texcoordB + vec2(2.0 * offset.x, -2.0 * offset.y)).rgb;
    colorB[15] = texture2D(u_AB, texcoordB + vec2(-2.0 * offset.x, 2.0 * offset.y)).rgb;
    colorB[16] = texture2D(u_AB, texcoordB + vec2(-2.0 * offset.x, -2.0 * offset.y)).rgb;
    
    colorB[17] = texture2D(u_AB, texcoordB + vec2(2.0 * offset.x, offset.y)).rgb;
    colorB[18] = texture2D(u_AB, texcoordB + vec2(-2.0 * offset.x, offset.y)).rgb;
    colorB[19] = texture2D(u_AB, texcoordB + vec2(offset.x, 2.0 * offset.y)).rgb;
    colorB[20] = texture2D(u_AB, texcoordB + vec2(-offset.x, 2.0 * offset.y)).rgb;
    
    colorB[21] = texture2D(u_AB, texcoordB + vec2(2.0 * offset.x, -offset.y)).rgb;
    colorB[22] = texture2D(u_AB, texcoordB + vec2(-2.0 * offset.x, -offset.y)).rgb;
    colorB[23] = texture2D(u_AB, texcoordB + vec2(offset.x, -2.0 * offset.y)).rgb;
    colorB[24] = texture2D(u_AB, texcoordB + vec2(-offset.x, -2.0 * offset.y)).rgb;
    
    // 分别对图A和图B做均值模糊
    highp vec3 meanA = meanBlur(colorA);
    highp vec3 meanB = meanBlur(colorB);
    
    meanA = meanA * 2.0 - 1.0;
    meanB = meanB * 2.0 - 1.0;
    
    meanA = mix(colorA[0] * 2.0 - 1.0, meanA, alpha);
    meanB = mix(colorB[0] * 2.0 - 1.0, meanB, alpha);
    
    // 导向滤波的最后一步融合
    highp vec3 originColor = texture2D(u_origin, texcoordOut).rgb;
    highp vec3 resultColor = meanA * originColor + meanB;
    resultColor = mix(originColor, resultColor, alpha);
    
    gl_FragColor = vec4(resultColor, 1.0);
}

绘制结果：

正则化参数eps=0.02正则化参数eps=0.02
正则化参数eps=0.02
正则化参数eps=0.02

动态效果展示
  • 1.固定模糊程度（0.5），修改正则化参数eps（变化范围 0~0.1）
    请添加图片描述
  • 2.固定正则化参数eps（0.05），修改模糊程度0~1
    请添加图片描述

源代码Git：https://github.com/sysu-huangwei/GuidedFilter

Rayyyyyyyyy
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
导向滤波原理以及解释
01-04
基于导向滤波的work论文，写的非常详细，希望能够帮助到广大科研人员
导向滤波小结：从导向滤波（guided filter）到快速导向滤波（fast guide filter）的原理，应用及opencv实现代码
生命在于折腾！
10-29 3万+
1. 导向滤波简介 导向滤波是何凯明在学生时代提出的一个保边滤波（edge-preserving smoothing）算法。何凯明在cv圈应该算是名人了，学生时代关于图像去雾的研究就以第一作者的身份获得Best Paper Award（CVPR 2009），而且今年刚刚又斩获Marr Prize（ICCV 2017）。更多关于何凯明的最新研究动态可以点击以下链接何凯明。 导向滤波顾名思义，就是
导向滤波-Guided Image Filtering
Nick Blog
12-17 1845
1. 简介 之前已经介绍过了双边滤波核联合双边滤波，其中双边滤波是一种非线性的保边滤波器，而联合双边滤波相当于将值域高斯核的来源从原始影像替换成另外一副引导图。本文介绍的导向滤波，其与联合双边滤波类似，也需要除原始影像之外另外一副引导图，是一种保边滤波器，当然其也可以用作图像去雾、HDR压缩等。 2. 算法原理 2.1 导向滤波框架 在算法框架中，要对p进行滤波而得到q，还得需要一个引导图像I。此时，滤波器的数学公式为： 注意，这里的Wij(I)就表示由引导图像I来确定加权平均运算中所采用的权值，并且权值
这个何同学不一般——导向滤波
zcg1942的博客
08-29 875
首先，导向滤波可以在滤波的同时保留图像边缘。双边滤波，导向滤波，最小二乘滤波被称为三大保持 边缘滤波器。导向滤波其实是何恺明为了解决暗通道去雾的一个计算过程提出的一种滤波方法。 如果我们想要滤波的同时保留边缘，很自然地会想到先使用边缘检测器得到边缘图，滤波的时候就可以以此作为参考。导向滤波其实也一样，需要一幅guidance image，特别地，可以将原图作为guidance image，此时的结果输出就是保留边缘的平滑结果，在这个过程中其实就利用了guidance image中的结构信息。作为边缘保持滤
导向滤波(Guided Filter)简要介绍
修行之路
06-01 605
导向滤波(Guided Filter)简要介绍
导向滤波(Guided Filter)的解析与实现
热门推荐
白马负金羁
07-10 8万+
导引滤波（Guided Filter）是由Dr. Kaiming He等人提出的一种滤波算法（现在MATLAB的图像处理工具箱中已经内置了实现该算法的函数）。导引滤波不仅可以实现edge-preserving的图像平滑效果，亦可广泛应用于图像去雾、图像抠图，以及图像增强（主要是高动态光照渲染方面的应用）等领域。导向滤波的核心是求解一个最小二乘问题，本文将讨论其背后的数学原理并解析其MATLAB实现代码
导向滤波
阿兵-AI医疗的专栏
03-28 1949
基本原理 导向滤波（Guided Fliter）显式地利用 guidance image 计算输出图像，其中 guidance image 可以是输入图像本身或者其他图像。导向滤波比起双边滤波来说在边界附近效果较好；另外，它还具有 O(N) 的线性时间的速度优势。细节请查阅论文《Guided Image Filtering》 除了速度优势以外，导向滤波的一个很好的性能就是可以保持梯度，这是bilateral做不到的，因为会有梯度翻转现象。（Preserves edges, but not gradient
计算机图形学——opengl实现fbx模型导入
03-08
opengl实现fbx模型导入，有UV贴图
msdfgl：MSDF算法的OpenGL实现
02-04
msdfgl：MSDF算法的OpenGL实现
OpenGL实现不规则区域填充算法
01-20
本文实例为大家分享了OpenGL实现不规则区域填充算法，供大家参考，具体内容如下 一、简单递归 利用Dfs实现简单递归填充。 核心代码： // 简单深度搜索填充 （四连通） void DfsFill(int x, int y) { if (x < 0>23 ...
导向滤波-何凯明
10-04
导向滤波，何凯明的最新成果，主要用于去雾
OpenGL中纹理贴图、滤波、光照和雾化效果编程初步
07-04
OpenGL中纹理贴图、滤波、光照和雾化效果编程初步 源代码
扫描线填充算法的OpenGL实现
02-28
基于AEL（活化边表）的扫描线填充算法的OpenGL实现。该算法包含一个基于GLUT的事件捕获框架用于绘制多边形。
【滤波·1】导向滤波
mjiansun的专栏
02-11 768
不太理解目标函数的意义，等后续有新的理解来补充。
导向滤波原理浅析
TracelessLe的专栏
01-19 3795
前言 在图像处理上，导向滤波器（Guided Image Filter）是一种能使图像平滑化的非线性滤波器。与双边滤波器（Bilateral Filter）相同，这个滤波器同样能够在清楚保持图像边界的情况下，达到让图像平滑的效果。 但不同于双边滤波器，导向滤波器有两个优点： 首先，双边滤波器有非常大的计算复杂度（O(N^2)），但导向滤波器因为并未用到过于复杂的数学计算，有线性的计算复杂度。 双边滤波器因为数学模型的缘故，在某些时候会发生梯度反转（gradient reverse）的状况，出现图像有损；
详解——导向滤波(Guided Filter)和快速导向滤波
EthanAndEvan的博客
03-09 7572
文章目录导读原理推导 导读 在图像滤波算法中，导向滤波、双边滤波、最小二乘滤波并称三大保边滤波器，他们是各向异性滤波器。相对于常见的均值滤波、高斯滤波等各向同性滤波器，他们最大的特点是在去除噪声的同时，能最大限度保持边缘不被平滑。本文讲解导向滤波及其应用。 原理推导 我们先看下图： 输入图像ppp，经过引导图像III, 滤波得到输出图像qqq, 导向滤波算法中有一个重要假设：即在局部窗口wk...
图像导向滤波
吃葡萄不吐葡萄皮
11-19 492
导向滤波（Guided Filter）是一种基于局部线性模型的滤波方法，用于图像处理中的去噪、图像增强和边缘保留等任务。它结合了引导图像（guide image）和输入图像来实现对输入图像的滤波操作。
引导滤波原理
magic_shuang的博客
03-25 3879
原理 导向滤波的大前提： 如图所示，算法认为目标图像 Q上相邻的点是线性相关的，之所以待处理图 P不清晰是因为，不相关的部分（噪声）， 引导图I是另一个输入，它与P有相同的梯度，当滤波时可以设置I=P.用线性相关的核W去更新像素点，就会使得P更接近Q.那么能使得P最接近Q的核就是我们求解的目标 换句话说就是：求P-Q最小值时，核W是多少？ 用公式来表示就是： 其中： i 是坐标点 pi是待处理图像,i位置的像素点 qi是目标图像, i位置的像素点 wk是核 由大前提可以.
【OpenCV 例程200篇】61. 导向滤波（Guided filter）
youcans的博客
12-18 1万+
导向滤波又称引导滤波，通过一张引导图片反映边缘、物体等信息，对输入图像进行滤波处理，使输出图像的内容由输入图像决定，但纹理与引导图片相似。 导向滤波的原理是局部线性模型，在保持双边滤波的优势（有效保持边缘，非迭代计算）的同时计算速度很快，从而克服双边滤波速度慢的缺点。 导向滤波（导向滤波）不仅能实现双边滤波的边缘平滑，而且在检测到边缘附近有很好的表现，可应用在图像增强、HDR压缩、图像抠图及图像去雾等场景。
opengl语言写出功能强大的双边滤波算法
最新发布
04-11
双边滤波算法是一种图像处理算法，用于平滑图像并保留边缘信息。它结合了空间域和灰度值域的信息，能够有效地去除噪声同时保持图像的细节。下面是使用OpenGL语言实现双边滤波算法的示例代码[^1]： ```c #version 330 core in vec2 TexCoords; out vec4 FragColor; uniform sampler2D image; uniform float sigma_s; uniform float sigma_r; const int kernelSize = 9; const int halfSize = kernelSize / 2; float gaussian(float x, float sigma) { return exp(-(x * x) / (2.0 * sigma * sigma)) / (2.0 * 3.14159 * sigma * sigma); } void main() { vec2 texelSize = 1.0 / textureSize(image, 0); vec3 center = texture(image, TexCoords).rgb; vec3 result = vec3(0.0); float totalWeight = 0.0; for (int i = -halfSize; i <= halfSize; ++i) { for (int j = -halfSize; j <= halfSize; ++j) { vec2 offset = vec2(i, j) * texelSize; vec3 current = texture(image, TexCoords + offset).rgb; float spatialWeight = gaussian(length(offset), sigma_s); float rangeWeight = gaussian(distance(center, current), sigma_r); float weight = spatialWeight * rangeWeight; result += current * weight; totalWeight += weight; } } FragColor = vec4(result / totalWeight, 1.0); } ``` 这段代码使用了OpenGL的着色器语言(GLSL)来实现双边滤波算法。它首先计算了每个像素周围的空间权重和灰度值权重，然后根据这些权重对像素进行加权平均，从而得到平滑的图像。 请注意，这只是一个示例代码，实际使用时需要将其集成到OpenGL应用程序中，并根据具体需求进行适当的调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值