作者Alun

OpenGL 混合模式:原理、公式与实现

从 Photoshop 混合模式到 OpenCV 像素运算

OpenGL图形渲染混合模式
OpenGL 混合模式:原理、公式与实现
题图

做图片叠加时,“把两张图混合”其实包含两个问题:上层颜色应该怎样改变下层,以及上层只覆盖一部分时,两者怎样按透明度合成。正片叠底、滤色、叠加等名字回答的是前一个问题,图层透明度主要控制后一个问题。

如果一开始把二者揉进同一个公式,切换模式后很容易得到奇怪结果:透明区域变黑、Alpha 被平方,或者降低不透明度后颜色仍然不对。下面先从单通道颜色函数开始,理解几种模式的共同规律,再把它们接进完整的图层合成。

混合模式分为两步:先计算颜色函数 B(a, b),再按 Alpha 合成图层。本文以 a 表示基色、b 表示上层混合色,通道值归一化到 [0, 1],sat(x) 表示截断到该区间。RGB 三个通道分别运算,Alpha 单独处理。

下图按效果列出常见模式,并非某个 Photoshop 版本菜单的完整复刻。

混合模式按变暗、变亮、对比与颜色运算分组

1. 正常模式与透明度

正常模式的颜色函数是 B(a, b) = b,不是 a + b。当底图不透明、上层有效不透明度为 n 时,合成结果为 c = (1-n)*a + n*b。n = 0 完全透明,n = 1 完全不透明;上层透明度和图层不透明度同时存在时,需要相乘。

正常模式下不透明度从零到一的颜色变化

对任意混合函数,在不透明底图上的实现都是 mix(a, B(a,b), n)。不要直接把两个 RGBA 向量相加,也不要让 RGB 的混合公式作用于 Alpha。

2. 变暗与变亮

模式 单通道颜色函数 B(a,b) 特点
变暗 min(a,b) 每个通道分别取小值
变亮 max(a,b) 每个通道分别取大值
正片叠底 a*b 黑色使结果变黑,白色保持原色
滤色 1-(1-a)*(1-b) 黑色保持原色,白色使结果变白
线性加深 max(0,a+b-1) 结果需要截断
线性减淡 min(1,a+b) 结果需要截断

“深色/浅色”比较完整颜色后返回其中一个原像素,不等于逐通道 min/max。例如,以 RGB 总和作为比较指标时,深色取总和较小的颜色,浅色取总和较大的颜色。加权亮度、RGB 总和是不同指标,不能混写为同一个精确的 Photoshop 实现。

变暗逐通道取最小值与深色保留完整像素的对比

本地图解中,变暗得到棕色 (0.4,0.3,0.2),深色保留原来的绿色。它解释取值规则,并非 Photoshop 实测截图。

洋红青色黄色正片叠底,中心交叠为黑色

这里用理想 RGB 通道演示正片叠底的减色效果;真实印刷的 CMYK 油墨混合还涉及色彩配置与材料,不能直接等同。

红绿蓝滤色,中心交叠为白色

滤色具有加色效果,但它也不等于线性减淡的 a+b。

颜色加深与颜色减淡

除法模式必须明确边界。以下约定与 W3C 混合规范的对应模式一致:

  • 颜色加深:先判断 a == 1,结果为 1;否则 b == 0 时为 0;其余为 1-min(1,(1-a)/b)。
  • 颜色减淡:先判断 a == 0,结果为 0;否则 b == 1 时为 1;其余为 min(1,a/(1-b))。

分母分别是 b 与 (1-b)。写成 a/1-b 会因优先级而变成 a-b。本文限定有限的 [0,1] 输入,并在分支中处理精确端点;不要先算出无穷大或 NaN 再指望截断修复。不同软件在端点、填充不透明度和工作色彩空间上可能有差异。

比较效果时应固定输入、工作空间和不透明度,并检查端点约定;不能把数值大小、视觉对比和某次软件截图中的效果混为一个结论。

先记住中性色,再理解效果

不必一开始背下所有公式。先问某个混合色能否让基色保持不变:正片叠底乘以一仍是原值,所以白色不起作用;滤色与黑色混合仍是原值,所以黑色不起作用。用黑、白和灰做几组小样例,就能先建立直觉。

接着再问交换上下层会怎样。乘法和滤色在这里具有对称性,交换后单通道结果不变;到了叠加与强光,分支依据不同,交换图层就会改变解释。调试时明确基色和混合色的角色,比只看函数参数叫 a 还是 b 更重要。

例如一层柔和的亮部纹理,滤色会按自身颜色改变底图,但这不表示它与简单加法相同。两种结果在接近白色时的变化方式不同,先对照公式与数值,再看画面,能避免把“都变亮”误解为同一个模式。

3. 对比系

  • 叠加以基色 a 分段:a <= 0.5 ? 2*a*b : 1-2*(1-a)*(1-b)。
  • 强光以混合色 b 分段:b <= 0.5 ? 2*a*b : 1-2*(1-a)*(1-b)。交换两层可在这两个模式间转换,这不叫颜色反相。
  • 柔光在本文采用 W3C 定义:b <= 0.5 时为 a-(1-2*b)*a*(1-a);否则为 a+(2*b-1)*(D(a)-a),其中 a <= 0.25 时 D(a)=((16*a-12)*a+4)*a,否则 D(a)=sqrt(a)。旧版平方根近似与该定义不能混用。
  • 亮光:b <= 0.5 时使用颜色加深 Burn(a,2*b),否则使用颜色减淡 Dodge(a,2*b-1),复用上文的端点规则。
  • 线性光:sat(a+2*b-1)。
  • 点光:b <= 0.5 ? min(a,2*b) : max(a,2*b-1)。
  • 实色混合:本文定义为 a+b >= 1 ? 1 : 0,即通道二值化;满不透明度 RGB 结果最多只有八种颜色。

叠加、强光与线性光在相同灰度输入下的效果

4. 差值、排除与相消运算

模式 颜色函数
差值 abs(a-b)
排除 a+b-2*a*b
减去 max(0,a-b)
划分 本文约定 b==0 时为 1,否则 min(1,a/b)

划分在 0/0 处没有数学定义,上述返回白色是显式选择的实现约定。它未包含在本文引用的 W3C 模式列表中,不能据此承诺与所有图像软件一致。归一化输入下,非零分母的划分会使基色变亮或不变。

差值和排除的灰度混合结果,白色混合色产生反相

把公式放回整张图

单通道公式很容易测试,整张图的处理还要额外考虑位置。上层图可能比底图小,也可能带着负偏移移到画面外。应先求两层真正相交的区域,再在区域内把底图坐标换成上层坐标。没有交集的位置直接保留底图。

这样做也便于隔离错误。若单个像素的混合结果正确,移动图层后却错位,应先看坐标映射;若只有半透明区域出现黑边,则检查 Alpha 约定;如果整张图偏亮或偏暗,再核对颜色空间和输入数值范围。每次把一种因素固定住,比同时改颜色公式与边界循环更容易找到原因。

5. 可复用的 C++ 通道实现

下面是 C++17 代码,模式编号与后文 GLSL 一致。输入为有限的归一化通道值;函数同时截断越界数值,但不接受 NaN。这里实现逐通道模式,不包含需要联合 RGB 运算的色相、饱和度、颜色、明度及深色/浅色。

#include <algorithm>
#include <cmath>

float sat(float x) { return std::clamp(x, 0.0f, 1.0f); }
float burn(float a, float b) {
    if (a >= 1.0f) return 1.0f;
    if (b <= 0.0f) return 0.0f;
    return 1.0f - std::min(1.0f, (1.0f - a) / b);
}
float dodge(float a, float b) {
    if (a <= 0.0f) return 0.0f;
    if (b >= 1.0f) return 1.0f;
    return std::min(1.0f, a / (1.0f - b));
}
float blendChannel(float a, float b, int mode) {
    a = sat(a); b = sat(b);
    switch (mode) {
    case 0: return b;                                      // Normal
    case 1: return a * b;                                  // Multiply
    case 2: return burn(a, b);
    case 3: return dodge(a, b);
    case 4: return 1.0f - (1.0f-a)*(1.0f-b);                // Screen
    case 5: {                                             // SoftLight
        float d = a <= 0.25f ? ((16*a-12)*a+4)*a : std::sqrt(a);
        return b <= 0.5f ? a-(1-2*b)*a*(1-a) : a+(2*b-1)*(d-a);
    }
    case 6: return std::max(a, b);                         // Lighten
    case 7: return std::min(a, b);                         // Darken
    case 8: return std::abs(a-b);                          // Difference
    case 9: return a+b-2*a*b;                              // Exclusion
    case 10: return a <= 0.5f ? 2*a*b : 1-2*(1-a)*(1-b);  // Overlay
    case 11: return b <= 0.5f ? 2*a*b : 1-2*(1-a)*(1-b);  // HardLight
    case 12: return b <= 0.5f ? burn(a,2*b) : dodge(a,2*b-1);
    case 13: return sat(a+2*b-1);                          // LinearLight
    case 14: return b <= 0.5f ? std::min(a,2*b) : std::max(a,2*b-1);
    case 15: return sat(a+b-1);                            // LinearBurn
    case 16: return sat(a+b);                              // LinearDodge
    case 17: return a+b >= 1 ? 1.0f : 0.0f;               // HardMix
    case 18: return sat(a-b);                              // Subtract
    case 19: return b <= 0 ? 1.0f : sat(a/b);              // Divide
    default: return b;
    }
}

OpenCV:位置偏移与重叠区域

旧示例把 Point.x 当成行号,且给底图与叠加图使用同一坐标,移位后可能越界。下例约定 offset.x 为列偏移、offset.y 为行偏移。两图都是 CV_32FC3,通道范围 [0,1],底图不透明;不处理四通道 Alpha。

#include <opencv2/core.hpp>

cv::Mat blendImages(const cv::Mat& base, const cv::Mat& layer,
                    cv::Point offset, int mode, float opacity) {
    CV_Assert(!base.empty() && !layer.empty());
    CV_Assert(base.type() == CV_32FC3 && layer.type() == CV_32FC3);
    CV_Assert(std::isfinite(opacity));
    opacity = sat(opacity);
    cv::Mat result = base.clone();
    // 使用宽整数先计算交集,支持负偏移与完全不相交的图层。
    const auto x0 = std::max(0LL, static_cast<long long>(offset.x));
    const auto y0 = std::max(0LL, static_cast<long long>(offset.y));
    const auto x1 = std::min(static_cast<long long>(base.cols),
                            static_cast<long long>(offset.x) + layer.cols);
    const auto y1 = std::min(static_cast<long long>(base.rows),
                            static_cast<long long>(offset.y) + layer.rows);
    for (auto y = y0; y < y1; ++y) {
        for (auto x = x0; x < x1; ++x) {
            auto& dst = result.at<cv::Vec3f>(static_cast<int>(y), static_cast<int>(x));
            const auto a = base.at<cv::Vec3f>(static_cast<int>(y), static_cast<int>(x));
            const auto b = layer.at<cv::Vec3f>(static_cast<int>(y-offset.y), static_cast<int>(x-offset.x));
            for (int k = 0; k < 3; ++k)
                dst[k] = a[k]*(1-opacity) + blendChannel(a[k], b[k], mode)*opacity;
        }
    }
    return result;
}

用 cv::imread 读到的通常是 BGR 八位图,应先 convertTo(floatImage, CV_32F, 1.0/255.0)。逐通道函数对 BGR 同样适用,但上传至 OpenGL 时要确认通道顺序。数据转换只做归一化,不等于 sRGB 到线性光的变换。

6. GLSL 实现与 Alpha 合成

以下为 GLSL ES 1.00 片段着色器,可配合输出 vUV 的全屏顶点着色器。必须分别绑定两张输入纹理与输出目标;不能同时采样正在写入的同一纹理。为兼容不支持片段 highp 的 ES 2.0 设备,声明精度回退;跨 CPU/GPU 对照允许浮点误差。

#version 100
#ifdef GL_FRAGMENT_PRECISION_HIGH
precision highp float;
#else
precision mediump float;
#endif
uniform sampler2D baseTexture;
uniform sampler2D layerTexture;
uniform int blendMode;
uniform float opacity;
varying vec2 vUV;

float sat(float x) { return clamp(x, 0.0, 1.0); }
float burn(float a, float b) {
    if (a >= 1.0) return 1.0;
    if (b <= 0.0) return 0.0;
    return 1.0 - min(1.0, (1.0-a)/b);
}
float dodge(float a, float b) {
    if (a <= 0.0) return 0.0;
    if (b >= 1.0) return 1.0;
    return min(1.0, a/(1.0-b));
}
float blendChannel(float a, float b, int mode) {
    a = sat(a); b = sat(b);
    if (mode == 0) return b;
    if (mode == 1) return a*b;
    if (mode == 2) return burn(a,b);
    if (mode == 3) return dodge(a,b);
    if (mode == 4) return 1.0-(1.0-a)*(1.0-b);
    if (mode == 5) {
        float d = a <= 0.25 ? ((16.0*a-12.0)*a+4.0)*a : sqrt(a);
        return b <= 0.5 ? a-(1.0-2.0*b)*a*(1.0-a) : a+(2.0*b-1.0)*(d-a);
    }
    if (mode == 6) return max(a,b);
    if (mode == 7) return min(a,b);
    if (mode == 8) return abs(a-b);
    if (mode == 9) return a+b-2.0*a*b;
    if (mode == 10) return a <= 0.5 ? 2.0*a*b : 1.0-2.0*(1.0-a)*(1.0-b);
    if (mode == 11) return b <= 0.5 ? 2.0*a*b : 1.0-2.0*(1.0-a)*(1.0-b);
    if (mode == 12) return b <= 0.5 ? burn(a,2.0*b) : dodge(a,2.0*b-1.0);
    if (mode == 13) return sat(a+2.0*b-1.0);
    if (mode == 14) return b <= 0.5 ? min(a,2.0*b) : max(a,2.0*b-1.0);
    if (mode == 15) return sat(a+b-1.0);
    if (mode == 16) return sat(a+b);
    if (mode == 17) return a+b >= 1.0 ? 1.0 : 0.0;
    if (mode == 18) return sat(a-b);
    if (mode == 19) return b <= 0.0 ? 1.0 : sat(a/b);
    return b;
}
void main() {
    vec4 base = texture2D(baseTexture, vUV);
    vec4 layer = texture2D(layerTexture, vUV);
    // 输入与输出均为非预乘 Alpha 颜色。
    vec3 mixed = vec3(blendChannel(base.r, layer.r, blendMode),
                      blendChannel(base.g, layer.g, blendMode),
                      blendChannel(base.b, layer.b, blendMode));
    float ab = base.a;
    float asrc = layer.a * sat(opacity);
    float ao = asrc + ab*(1.0-asrc);
    vec3 premul = asrc*(1.0-ab)*layer.rgb
                + asrc*ab*mixed + (1.0-asrc)*ab*base.rgb;
    gl_FragColor = vec4(ao > 0.0 ? premul/ao : vec3(0.0), ao);
}

上述 source-over 合成采用非预乘输入,并显式形成预乘中间值,最后除以输出 Alpha。若输入已经预乘,需先按约定还原颜色再应用混合函数,不能重复乘 Alpha。底图不透明时,式子退化为前面的 mix(a,B(a,b),n)。

着色器已经完成两层合成;向独立结果纹理写出时应关闭固定功能 GL_BLEND,避免二次混合。只做普通 source-over、输入非预乘而目标存储预乘颜色时,可以让固定功能完成合成:RGB 因子为 GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,Alpha 因子为 GL_ONE, GL_ONE_MINUS_SRC_ALPHA,用 glBlendFuncSeparate 分别设置。直接用同一组因子处理 Alpha 会把源 Alpha 再乘一次。

7. 验证与工作色彩空间

检查 a/b 的 0、0.25、0.5、1 等边界,验证颜色加深/减淡不产生 NaN、叠加与交换图层后的强光一致、所有结果有限且在 [0,1]。图层位置应覆盖负偏移、超出右下边界和完全不相交三种情况。

显示编码的 RGB 与线性光 RGB 运算结果不同。例如黑白各半的插值在 sRGB 编码值中为 0.5,在以线性光混合后重新编码时约为 0.735。比较图像软件效果前,必须统一工作空间、Alpha 表示和不透明度;本文图解直接对归一化通道值运算,不代表物理光照模拟。

进一步查阅:W3C 混合与合成定义、OpenGL ES 2.0 规范。

评论