Web 图形与 3D / 系统课时

通过邻域采样生成高斯模糊

通过邻域采样生成高斯模糊

本课把一张带有清晰边缘的测试纹理送入 WebGL2,分别使用单次 5×5 二维卷积和两次五点采样生成模糊。完成后,你将得到可直接运行的三栏对比页面,并理解采样权重、模糊半径、离屏纹理和多 Pass 性能之间的关系。

学习目标

  • 根据纹理尺寸计算相邻像素的 UV 偏移,并构造归一化模糊权重。
  • 使用 GLSL ES 3.00 实现 5×5 二维模糊和水平、垂直可分离模糊。
  • 使用 WebGL2 Framebuffer 连接两个渲染 Pass,验证结果并比较采样成本。

从邻域像素计算模糊颜色

普通纹理采样只获取当前 UV 位置的颜色。模糊则围绕该位置读取多个像素,再按照距离分配权重:中心像素权重大,远处像素权重小。这样可以削弱高频细节,让硬边变成柔和过渡。

对于尺寸为 256×256 的纹理,相邻像素中心的 UV 间距是 (1.0 / 256.0, 1.0 / 256.0)。实际编写 Shader 时应使用纹理自身的宽高,而不是直接使用画布尺寸;当源纹理与输出画布分辨率不同时,两者并不相等。

本例采用五点二项式权重近似高斯分布:

w=[1,4,6,4,1]/16w=[1,4,6,4,1]/16

五个权重之和为 1,左右对称,中心权重最大。二维 5×5 模糊核由水平和垂直权重相乘得到,25 个系数的总和同样为 1。

例如,假设中心像素为白色、其余 24 个邻居全黑,中心输出灰度为 6×6/256=0.1406256\times6/256=0.140625。如果所有邻居均为白色,归一化后的输出仍为白色,不会因为累加而过曝。

这组离散权重可视为标准差约为 1 像素的高斯近似,采样半径为 2 像素。它不是任意标准差的精确连续高斯核,但足够用于验证基本模糊算法。

对比二维卷积和可分离模糊

直接二维卷积对每个输出像素采样 5×5 个位置。由于本例二维权重等于两个一维权重的乘积,可以先水平模糊,再对中间结果进行垂直模糊。

实现方式 渲染 Pass 每像素纹理采样 额外中间纹理
单次二维 5×5 1 25 不需要
水平 5 点+垂直 5 点 2 10 需要 1 张

两种方法在精确计算下使用相同卷积核,因此数学结果相等。可分离版本需要多一次全屏渲染,却将每个输出像素的模糊采样总数从 25 次降为 10 次。

单次二维卷积与两次可分离模糊的纹理采样和数据流对比

可分离模糊的关键是读写顺序:水平 Pass 读取源纹理并写入中间纹理;垂直 Pass 再读取中间纹理并写入另一张目标纹理。不能在一次渲染中同时采样正在作为颜色附件写入的同一纹理,否则会形成无效的纹理反馈回路。

实际 GPU 上的加速比例不一定等于 25/10,因为可分离方案还增加了渲染目标切换、纹理读写和一次 Draw Call。模糊半径越大,减少采样次数通常越有价值。

运行 WebGL2 模糊对比实验

新建 index.html,粘贴下面的完整代码,在支持 WebGL2 的浏览器中打开。页面不需要第三方库或外部图片,测试纹理由 JavaScript 生成,包括高对比棋盘格和橙色圆形,方便观察模糊前后的边缘。

程序创建三张结果纹理:二维卷积输出、水平模糊中间结果、可分离模糊最终输出。随后将原图和两种结果分别绘制到同一画布的三个区域。

html
<!doctype html>
<html lang='zh-CN'>
<head>
<meta charset='utf-8'>
<title>WebGL2 高斯模糊对比</title>
<style>
  body { font: 15px sans-serif; color: #334155; padding: 20px; }
  .labels { display: grid; grid-template-columns: repeat(3, 1fr);
    width: 768px; max-width: 100%; text-align: center; }
  canvas { display: block; max-width: 100%; height: auto; }
</style>
</head>
<body>
<div class='labels'>
  <span>原始纹理</span>
  <span>二维 5×5</span>
  <span>可分离 5+5</span>
</div>
<canvas id='view' width='768' height='256'></canvas>
<script>
const N = 256;
const gl = document.getElementById('view').getContext('webgl2');
if (!gl) throw new Error('当前浏览器不支持 WebGL2');

// 用 gl_VertexID 生成全屏三角形,无需上传顶点数据。
const vs = `#version 300 es
precision highp float;
out vec2 vUV;
void main() {
  vec2 p = vec2(float((gl_VertexID << 1) & 2),
                float(gl_VertexID & 2));
  vUV = p;
  gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);
}`;

const fsCopy = `#version 300 es
precision highp float;
in vec2 vUV;
uniform sampler2D uTex;
out vec4 outColor;
void main() {
  outColor = texture(uTex, vUV);
}`;

const fs2D = `#version 300 es
precision highp float;
in vec2 vUV;
uniform sampler2D uTex;
uniform vec2 uTexel;
out vec4 outColor;
void main() {
  float w[5] = float[5](1.0, 4.0, 6.0, 4.0, 1.0);
  vec4 sum = vec4(0.0);
  // 横纵权重相乘,得到25个二维核系数。
  for (int y = 0; y < 5; ++y) {
    for (int x = 0; x < 5; ++x) {
      vec2 offset = vec2(float(x - 2), float(y - 2)) * uTexel;
      sum += texture(uTex, vUV + offset) * w[x] * w[y];
    }
  }
  outColor = sum / 256.0;
}`;

const fsSep = `#version 300 es
precision highp float;
in vec2 vUV;
uniform sampler2D uTex;
uniform vec2 uTexel;
uniform vec2 uDir;
out vec4 outColor;
void main() {
  float w[5] = float[5](1.0, 4.0, 6.0, 4.0, 1.0);
  vec4 sum = vec4(0.0);
  // 通过uDir切换水平和垂直采样方向。
  for (int i = 0; i < 5; ++i) {
    vec2 offset = float(i - 2) * uTexel * uDir;
    sum += texture(uTex, vUV + offset) * w[i];
  }
  outColor = sum / 16.0;
}`;

function compile(type, source) {
  const shader = gl.createShader(type);
  gl.shaderSource(shader, source);
  gl.compileShader(shader);
  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
    throw new Error(gl.getShaderInfoLog(shader));
  }
  return shader;
}

function program(fs) {
  const p = gl.createProgram();
  gl.attachShader(p, compile(gl.VERTEX_SHADER, vs));
  gl.attachShader(p, compile(gl.FRAGMENT_SHADER, fs));
  gl.linkProgram(p);
  if (!gl.getProgramParameter(p, gl.LINK_STATUS)) {
    throw new Error(gl.getProgramInfoLog(p));
  }
  return p;
}

function texture(bytes = null) {
  const t = gl.createTexture();
  gl.bindTexture(gl.TEXTURE_2D, t);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
  gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA8,
    N, N, 0, gl.RGBA, gl.UNSIGNED_BYTE, bytes);
  return t;
}

function target() {
  const tex = texture();
  const fbo = gl.createFramebuffer();
  gl.bindFramebuffer(gl.FRAMEBUFFER, fbo);
  gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
    gl.TEXTURE_2D, tex, 0);
  if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) !==
      gl.FRAMEBUFFER_COMPLETE) {
    throw new Error('Framebuffer 不完整');
  }
  return { tex, fbo };
}

// 创建橙色圆形与高对比棋盘格测试纹理。
const pixels = new Uint8Array(N * N * 4);
const orange = [244, 151, 85, 255];
const pale = [232, 245, 246, 255];
const dark = [31, 96, 113, 255];
for (let y = 0; y < N; ++y) {
  for (let x = 0; x < N; ++x) {
    const disk = (x - 128) ** 2 + (y - 128) ** 2 < 48 ** 2;
    const bright = ((x >> 4) + (y >> 4)) % 2 === 0;
    pixels.set(disk ? orange : bright ? pale : dark,
      (y * N + x) * 4);
  }
}

const source = texture(pixels);
const twoD = target();
const horizontal = target();
const separated = target();
const pCopy = program(fsCopy);
const p2D = program(fs2D);
const pSep = program(fsSep);
gl.bindVertexArray(gl.createVertexArray());

function pass(p, input, framebuffer, direction = [0, 0], column = 0) {
  gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
  gl.viewport(framebuffer ? 0 : column * N, 0, N, N);
  gl.useProgram(p);
  gl.activeTexture(gl.TEXTURE0);
  gl.bindTexture(gl.TEXTURE_2D, input);
  gl.uniform1i(gl.getUniformLocation(p, 'uTex'), 0);
  const texelLoc = gl.getUniformLocation(p, 'uTexel');
  if (texelLoc !== null) gl.uniform2f(texelLoc, 1 / N, 1 / N);
  const dirLoc = gl.getUniformLocation(p, 'uDir');
  if (dirLoc !== null) {
    gl.uniform2f(dirLoc, direction[0], direction[1]);
  }
  gl.drawArrays(gl.TRIANGLES, 0, 3);
}

// 每个Pass从一个纹理读取,写入另一个渲染目标。
pass(p2D, source, twoD.fbo);
pass(pSep, source, horizontal.fbo, [1, 0]);
pass(pSep, horizontal.tex, separated.fbo, [0, 1]);

pass(pCopy, source, null, [0, 0], 0);
pass(pCopy, twoD.tex, null, [0, 0], 1);
pass(pCopy, separated.tex, null, [0, 0], 2);

console.log('二维核:25 次采样/像素');
console.log('可分离核:10 次采样/像素');
</script>
</body>
</html>

预期输出(浏览器开发者工具控制台):

text
二维核:25 次采样/像素
可分离核:10 次采样/像素

页面应出现从左到右排列的三个正方形画面:原始纹理具有清晰的棋盘格和圆形边缘;二维模糊与可分离模糊都产生柔和过渡;两种模糊结果肉眼看起来应基本一致。

pass() 负责统一设置 Framebuffer、Viewport、纹理单元和 Shader uniform。uDir=(1,0) 只在水平方向偏移 UV,uDir=(0,1) 只在垂直方向偏移。最终三个显示区域由 gl.viewport() 划分,显示步骤不参与模糊卷积本身。

验证结果并处理性能边界

检查结果时,先观察橙色圆形的轮廓,再观察棋盘格交界处。原图应保留硬边,两个模糊版本应出现近似相同的两像素邻域过渡。这里的 5×5 采样核和两次五点采样使用完全相同的权重,因此明显不同的模糊宽度通常意味着方向设置、权重归一化或 UV 偏移存在错误。

需要注意以下工程边界:

  1. 中间纹理精度:本例使用 RGBA8。可分离版本在水平 Pass 后会发生一次 8 位量化,而二维版本只在最终写入时量化,所以两者理论等价,不要求输出像素逐字节完全一致。
  2. 边缘处理:CLAMP_TO_EDGE 会让越界采样重复边界像素,避免纹理另一侧的颜色混入。改成 REPEAT 会让模糊跨越左右或上下边缘连接,不适合普通屏幕后处理。
  3. 采样间距:uTexel 必须对应当前输入纹理的尺寸。若改成 512×512,应使用 (1/512, 1/512),并同步调整实际纹理尺寸及渲染目标大小,否则模糊半径会偏离预期。
  4. 核尺寸与性能:将半径扩大到 4 像素时,9×9 二维核需要 81 次采样;可分离核只需 9+9=18 次采样。两次 Pass 通常更适合较大的模糊核,但仍应通过实际 GPU 耗时测量性能。
  5. 颜色与透明度:本例所有测试像素的 Alpha 均为 255,重点演示空间卷积。正式项目应在线性颜色空间进行颜色加权;透明图层通常还需要预乘 Alpha,避免透明边缘出现异常色晕。

可以进一步将渲染目标改为原宽高的一半,再执行水平和垂直模糊。这样每个 Pass 的处理像素数约减少到四分之一,但同样的五点核会覆盖原图中更大的范围,细节损失也会增加。必须同步更新纹理尺寸、Viewport 和采样偏移,并在最终合成时重新放大结果。

当目标是全屏景深、辉光或背景柔化等大面积模糊时,优先考虑可分离 Pass;只有模糊半径很小、减少渲染目标切换更有利,或者卷积核本身无法分解时,才更值得评估单次二维采样。实际选择应以目标设备的 GPU 计时结果为准。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

通过邻域采样生成高斯模糊

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通