运营活动页的徽章素材卡住了。设计稿里是一个红色圆底、蓝色圆面,两层各自设了 50% 不透明度,叠在白色卡片上,设计软件里取色器读到的是 (128, 64, 191)。视觉把徽章导出成一张透明背景的 PNG,前端放进页面,同一个位置取到的却是 (191, 159, 223),整块明显发白,蓝紫变成了浅粉紫。

设计师说导出时画布的不透明度是 100%,只把两层各设了 50%,没动过别的。前端说 CSS 只给父容器写了 opacity 0.5,子元素一个都没改。两边都认为自己按设计稿做了,但结果差了六十多个色阶,肉眼就能看出来。

问题出在「50% 加在哪一层」。给父容器加 opacity,等于把两个子层先合成到一个离屏缓冲,再把整组按 50% 叠到底;而设计稿里每层 50%,是两次独立的半透明合成。两种做法的 alpha 结果分别是 0.375 和 0.75,颜色自然差得远。这类问题还常以「透明 PNG 导出后边缘发黑」「半透明图层叠在透明底上颜色变深」的形式出现,根子都在 alpha 的存储方式和合成顺序上。

这篇拆开 alpha 合成公式,讲预乘与非预乘、合成顺序、组不透明度,再用标准库算几组真实数字。

现象真实原因第一步查什么
两个半透明层叠出来比设计稿白了一大截用了组不透明度,先拍平再整体调淡;设计稿是每层各自半透明确认 opacity 写在父容器上还是每个子层上
透明背景的素材叠上去,颜色变深一半颜色通道已经乘过 alpha(预乘),读取端却按非预乘解释取一个半透明像素,看 RGB 是不是等于原色乘 alpha
透明 PNG 缩放后边缘一圈黑边透明区域的 RGB 是黑色,插值把黑色混进了半透明边缘看图像是否预乘,缩放前是否做了边缘处理
放在深色背景上,边缘一圈浅色描边透明区域残留了白色 RGB,被插值或压缩带进可见区域检查导出时透明区的填充色和是否有预乘
调换两层顺序,颜色完全换了一种alpha 合成不满足交换律,先后顺序改变最终覆盖比例确认图层栈顺序和导出时的绘制顺序一致
半透明素材反复叠几次后边缘发脏每轮都量化到 8 位 alpha,再插值一次,误差累积看中间结果是否保存了 alpha,是否反复缩放
视频里带 alpha 的素材叠上去发灰视频编码对 alpha 的约定和图片不同,导入时没选对查导入设置里的 alpha 解释方式(具体编码器默认待确认)

一条公式:颜色要除以新的 alpha

先定义两个词。前景是正在往上叠的那一层,背景是已经合成好的当前结果。两者的颜色记作 C,透明度记作 a,取值都在 0 到 1。合成之后得到一个新的颜色和一个新的透明度。

透明度的合并很直观:前景盖住一部分,剩下的部分才轮到背景露出来。所以新的 alpha 等于前景 alpha 加上背景 alpha 乘以前景没盖住的比例。前景完全不透明时,结果也是完全不透明;前景全透明时,结果等于背景。

颜色的合并要复杂一点。前景贡献的是「自己的颜色乘自己的 alpha」,背景贡献的是「自己的颜色乘自己的 alpha 乘以前景透过去的那部分」,两者相加,再除以新的 alpha。最后这一步除法不能省,因为合成结果的 alpha 可能小于 1,颜色必须是「在完全不透明的假设下」的值,否则下次再合成时会被重复乘一次。

a_out = a_s + a_d * (1 - a_s)
C_out = (C_s * a_s + C_d * a_d * (1 - a_s)) / a_out

这里 s 指前景,d 指背景。注意等号右边除以的是 a_out,不是 1。很多人写合成代码时忘了这个除法,或者在 a_out 为 0 时直接返回黑色,结果就是透明区域的颜色被悄悄改掉,之后再怎么叠都不对。

当背景完全透明时,a_d 等于 0,公式退化成 C_out 等于 C_s、a_out 等于 a_s。也就是说,半透明红色叠在透明背景上,颜色仍然是纯红 (255, 0, 0),只是 alpha 变成 0.5。它不会自动变成暗红,变暗是另一件事。

这条公式假设颜色是「非预乘」的,也就是 RGB 存的是原始颜色,不含透明度信息。如果颜色通道已经乘过 alpha,公式会简化成另一副样子,下一节讲。

预乘 alpha:颜色通道里到底存了什么

预乘的意思很直白:在存像素之前,先把颜色乘上自己的 alpha。一个纯红、50% 不透明的像素,非预乘存成 (255, 0, 0, 128),预乘存成 (128, 0, 0, 128)。两种都描述了同一块颜色,只是把「乘」这一步提前做了。

预乘的好处是合成时只剩加法:结果的预乘颜色等于前景的预乘颜色加上背景的预乘颜色乘以前景透过去的部分,不用除法,也不会在 alpha 很小时把噪声放大。GPU 的混合方程天然就是这种形式,所以实时渲染管线几乎都用预乘。

非预乘:颜色与透明度分开存

RGB 是原始颜色,alpha 单独一个通道。PNG 规范存的就是这种,Canvas 的 getImageData 读出来也是这种。好处是取色、调色都直观;坏处是每次合成都要除以新的 alpha,低 alpha 时数值会被放大,舍入误差明显。

预乘:颜色已经乘过透明度

合成只需加法,边缘插值不会把透明黑混进来,实时渲染和视频合成常用。坏处是直接看 RGB 会偏暗,改颜色前必须先除回去,8 位存储时低 alpha 下的颜色台阶会被压得很粗。

两种存法本身没有对错,错的是「存的时候用一种、读的时候按另一种」。上面那个徽章的例子就是:导出工具把半透明区域的 RGB 乘了 alpha,前端读出来当成原始颜色,再乘一次透明度,红色 255 被读成 128,叠到白底上就成了 (191, 128, 128),而不是正确的 (255, 128, 128)。

图片格式的选择也有影响。PNG 按规范是非预乘,WebP 的无损模式同样按非预乘解释,但一些合成软件和视频编码在内部用预乘。跨工具搬运素材时,导入导出对话框里那个「alpha 已预乘」的勾选项,值得停下来看一眼。

透明背景上,像素到底变成什么

很多人第一次做透明素材会把 RGB 也调暗,以为这样才叫「半透明」。这一步就把非预乘数据做成了半预乘的混合体,之后再合成,颜色会暗一半。

理解这件事的关键是分清「颜色」和「可见量」。颜色描述的是这块区域发光是什么颜色,alpha 描述的是它盖住背景的程度。50% 的纯红叠在白底上,可见结果是一半红一半白,也就是 (255, 128, 128);叠在黑底上则是 (128, 0, 0)。同一个像素,在不同背景下呈现不同,正是 alpha 的意义。

一个像素从图层到屏幕
读前景 RGBA
读背景 RGBA
算新 alpha
算新颜色
写回缓冲
整组叠到画布

「发灰」通常不是这一步算错,而是链路中间丢了信息。最常见的三种:把带 alpha 的图拍平到白底再当透明图用;把预乘数据当非预乘读;以及缩放或压缩时透明区域的 RGB 参与插值。第三种在图标、logo 上特别明显,因为边缘正好是一圈 alpha 从 0 渐变到 255 的像素。

还有一种情况是「透明背景上看着正常,放到深色背景上出现白边」。原因是透明区域的 RGB 不是黑色而是白色,平时看不见,一旦缩放、模糊或做色彩转换,白色就被混进边缘的半透明像素里。解决办法不是手动擦边,而是导出时确保透明区域的颜色和边缘颜色一致,或者干脆用预乘。

顺序不能反:alpha 合成不满足交换律

普通加法可以交换,1 加 2 和 2 加 1 一样。alpha 合成不行。因为每一层都会挡住下面一部分,谁先谁后决定了谁被谁挡。把红色 50% 和蓝色 50% 叠在白底上,红在下蓝在上,结果是 (128, 64, 191);蓝在下红在上,结果是 (191, 64, 128)。两端正好对调,中间那点混合色也变了。

这不是精度问题,是语义问题。图层栈的「从下往上」不是随便定的,它对应现实中「后面的东西盖住前面的东西」。设计工具、CSS、Canvas、视频合成器都按这个顺序折叠。如果你在代码里从上往下遍历图层,得到的就是镜像的结果。

排序不只发生在图层之间。3D 场景里两个半透明面片互相穿插时,按物体中心排序会出错,因为一个面片的这一半可能在另一个前面、那一半在后面。正确做法是按像素深度排序,或者用与顺序无关的近似合成。根子和图层顺序一样:半透明的东西不能随便换顺序。

把整组图层拍平成一张图再继续合成,看起来省事,实际上会永久丢掉组内的层间关系。之后想单独调某一层、想换背景、想改混合模式,都做不到了。分层文件要保留到最终导出前一步。

顺序还影响「透明度」的叠加方式。两层 50% 叠在一起,总覆盖不是 100%,而是 75%,因为第二层只能盖住第一层没盖住的另一半。三层就是 87.5%。这个数列会一直逼近 1 但永远到不了,理解这一点,就不会奇怪为什么叠了很多层还是能透出背景。

组不透明度:先拍平,再整体调淡

图层不透明度作用在单个图层上,组不透明度作用在整组上。两者的区别可以用一句话概括:组不透明度是先把组内的内容按正常规则合成到一个离屏缓冲,再把这个缓冲当成一层,按组的透明度叠到下面。

回到徽章的例子。红 50% 在下、蓝 50% 在上,组内合成得到的预乘颜色是 (85, 0, 170),内部 alpha 是 0.75。此时再乘组透明度 0.5,实际参与叠加的 alpha 变成 0.375,叠在白底上就是 (191, 159, 223)。而如果两层各自 50% 直接叠在白底上,第二次合成的 alpha 是 0.75,白底只透出 25%,结果是 (128, 64, 191)。

像素 alpha:每个像素自己的透明度,跟着像素走,缩放时会被插值
图层不透明度:整层统一乘一个系数,层内所有像素一起变淡
组不透明度:整组先合成到离屏缓冲,再统一乘系数,组内关系不变但整体变淡
最终合成:把上面这些结果按顺序叠到画布,得到屏幕上的像素

大多数工具和 CSS 的父级 opacity 都是组语义。它和「把每个子层的透明度都乘 0.5」不等价。组内两层各 50%,乘 0.5 后总覆盖 43.75%;组透明度 0.5 是把已经 75% 覆盖的整组降到 37.5%。两个数不一样,颜色也不一样。

离屏合成还有一个实际影响:它需要额外的缓冲区。一张 4K 的 RGBA 缓冲约 33MB,组里再套组,缓冲就要开好几层。移动端做复杂动效时,组透明度用多了会明显掉帧,因为每一组都意味着一次额外的全屏合成。

实测:同一组颜色,三种叠法

下面这段脚本用标准库实现非预乘合成,把红蓝两层按三种方式叠到白底:每层各自 50%、整组 50%、调换顺序。

def comp(cs, a_s, cd, a_d):
    ao = a_s + a_d * (1 - a_s)
    if ao == 0:
        return (0.0, 0.0, 0.0), 0.0
    return tuple(cs[i] * a_s / ao + cd[i] * a_d * (1 - a_s) / ao
                 for i in range(3)), ao

def r8(x):
    return min(255, max(0, int(x + 0.5)))

white, red, blue = (255.0, 255.0, 255.0), (255.0, 0.0, 0.0), (0.0, 0.0, 255.0)
c, a = comp(red, 0.5, (0.0, 0.0, 0.0), 0.0)
print("red over transparent:", tuple(r8(x) for x in c), "alpha", r8(a * 255))
print("red over white:", tuple(r8(x) for x in comp(red, 0.5, white, 1.0)[0]))

p1, _ = comp(red, 0.5, white, 1.0)
p2, _ = comp(blue, 0.5, p1, 1.0)
print("per-layer:", tuple(r8(x) for x in p2))

g1, ga1 = comp(red, 0.5, (0.0, 0.0, 0.0), 0.0)
g2, ga2 = comp(blue, 0.5, g1, ga1)
print("group raw:", tuple(r8(x) for x in g2), "alpha", r8(ga2 * 255))
g3, _ = comp(g2, ga2 * 0.5, white, 1.0)
print("group 50%:", tuple(r8(x) for x in g3))

r1, _ = comp(blue, 0.5, white, 1.0)
r2, _ = comp(red, 0.5, r1, 1.0)
print("reversed:", tuple(r8(x) for x in r2))

本机实际输出:

red over transparent: (255, 0, 0) alpha 128
red over white: (255, 128, 128)
per-layer: (128, 64, 191)
group raw: (85, 0, 170) alpha 191
group 50%: (191, 159, 223)
reversed: (191, 64, 128)

第一行是本文最该记住的一条:半透明红色叠在透明背景上,颜色仍是 (255, 0, 0),alpha 是 128,没有任何变暗。想验证自己的流程有没有偷偷预乘,就对这一行。

第二行是同一个红色叠在白底上的结果 (255, 128, 128)。它和第一行是同一块像素、不同的背景,说明颜色和可见结果必须分开看。第三行是每层 50% 叠出来的 (128, 64, 191),和设计稿的读数一致。

第四、五行是组不透明度的两个阶段。组内合成的原始结果是 (85, 0, 170),alpha 191,也就是 0.75。乘上 0.5 再叠白底,得到 (191, 159, 223),正是前端页面上的读数。两组数字差 32 到 95 个色阶,比「头发丝级别的偏色」严重得多。

最后一行是对调顺序的结果 (191, 64, 128)。它的绿通道和正序一样都是 64,红蓝两端换了个位置,肉眼看上去从蓝紫变成了红粉。这就是「顺序不能反」的具体代价。

落地时怎么选、怎么查

选哪种存储方式,取决于下游是谁。图片素材走 PNG、WebP,多数场景按非预乘存,浏览器解码后交给合成器;实时渲染、视频合成、GPU 混合走预乘,因为硬件混合方程就是为它设计的。真正麻烦的是跨过去的那一步。

场景常见约定要留意
PNG 图片非预乘半透明边缘的 RGB 最好和边缘色一致,避免黑边或白边
Canvas 像素读写非预乘内部可能是预乘,getImageData 会除回来,低 alpha 时有精度损失
WebGL 纹理两种都可能上传时要显式声明是否预乘,混合方程要和它匹配
CSS 父级 opacity组语义会触发离屏合成,子层的混合模式作用范围也会变
视频带 alpha随编码器而变导入导出时选对解释方式,具体默认值建议实测确认
3D 渲染预乘半透明物体要排序,深度写入通常要关掉

排查有固定顺序。先取一个半透明像素,看 RGB 是不是等于原色,明显偏暗就先怀疑预乘。再把它叠在纯白和纯黑上分别取色,两种背景都不对,问题在数据本身;只在某个背景下不对,问题在合成链路。最后看组结构,确认 opacity 写在哪一层。

还有一个工程习惯值得养成:所有中间结果保留 alpha,不要提前拍平到白底。白底预览图可以另存一份给人看,但不要拿它当素材继续用。拍平是不可逆的,之后再想换背景、调透明度,只能重做。

判断一张透明图是不是预乘,可以把 alpha 调到很低再看 RGB。非预乘图的 RGB 不随 alpha 变化,预乘图的 RGB 会跟着变小。这个检查不需要工具支持,写两行代码就能做。

边界与代价

第一个代价是精度。8 位 alpha 只有 256 个台阶,1/255 约等于 0.0039。非预乘存储在 alpha 很低时要把颜色除回去,除以 0.0039 等于放大 255 倍,颜色通道的噪声被一起放大。实测里 alpha 为 3 时,原始颜色 200 被存成预乘值 2,再除回来变成 170,直接丢了 30 个色阶;alpha 为 1 时干脆除到 255,多出 55 个色阶的偏差。

第二个代价是内存和带宽。保留 alpha 意味着每个像素四个通道而不是三个,显存和传输量多出三分之一。做组透明度还要额外的离屏缓冲,4K 一层就是三十多兆,嵌套几层就很可观。移动端通常会在「效果」和「能不能跑满 60 帧」之间做取舍。

第三个代价是插值。缩放、旋转、模糊时,边缘像素会和邻居混合。如果透明区域的 RGB 是黑色,半透明边缘就会被拉暗,出现黑边;如果是白色,就会出现白边。这不是算法错,是数据在透明区域没有定义好颜色。修法是导出前做边缘扩展,把边缘颜色往透明区域里渗几个像素,或者全程用预乘。

第四个代价是排序。半透明物体不能靠深度缓冲自动解决遮挡,必须由应用按顺序绘制,层数一多,排序本身就成了开销。

当天能自己验证的五个练习

  1. 用上面的 comp 函数,把红蓝两层换成你项目里的两个品牌色,分别算每层 50% 和整组 50% 的结果,记录差值。
  2. 随便找一张带透明边缘的 PNG,读出边缘像素的 RGBA,判断它的透明区域 RGB 是黑还是白。
  3. 把同一张透明 PNG 分别放在白底和黑底上截图,比较边缘颜色,看有没有黑边或白边。
  4. 在页面上给一个父容器加 opacity 0.5,里面放两个各 50% 的子层,截图取色,再和去掉父级 opacity 的版本对比。
  5. 写一段代码把一张图的 alpha 从 255 逐步降到 1,观察非预乘 RGB 是否保持不变,以及低 alpha 下颜色是否开始跳变。

小结

三句话:alpha 合成算的是「前景盖住多少、背景透出多少」,颜色最后要除以新的 alpha;预乘和非预乘描述的是同一件事,混用就会让颜色暗一半或亮一半;组不透明度不是把每层透明度乘一下,而是先拍平再整体调淡,顺序也不能随便换。

下一篇换到声音。画面里的图层可以一层层叠,声音的多条轨道也可以用同样的思路混成一路,但那里的「叠加」是波形相加,不是覆盖关系。两路都接近满幅的信号加在一起会削波,这个问题和 alpha 叠多了发灰一样,都是「以为可以随便加」惹的祸。