整数颜色Alpha混合超出字节范围问题排查与修复咨询

我实现了一套Alpha混合算法，起初运行正常，但特定场景下出现异常结果。经排查发现算法计算出的颜色值超过255。我编写了C#程序定位触发问题的颜色/透明度组合，代码如下：

class Program
{
    static void Main(string[] args)
    {
        var parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 16;

        Parallel.For(0, 256, parallelOptions, bA =>
        {
            Console.WriteLine($"bA: {bA}...");

            for (int tA = 0; tA < 256; tA++)
            {
                for (int bR = 0; bR < 256; bR++)
                    for (int tR = 0; tR < 256; tR++)
                    {
                        int a = (((bA + tA) * 255) - tA * bA) / 255;
                        if (a > 0)
                        {
                            var R = ((255u - tA) * bA * bR / 255 + tA * tR) / a;
                            if (R > 255)
                            {
                                Console.WriteLine($"{bA}, {bR}, {tA}, {tR} => {R}");
                            }
                        }
                     }
            }
        });

        Console.ReadKey();
    }
}

运行后出现例如bA=1、bR=58、tA=1、tR=255时R=312的异常结果。改用浮点运算时结果不会超过256（仅偶尔略超255，应为浮点精度问题）。我尝试调整公式让除法后置，但仍存在值超255的情况。请问该问题成因是什么？如何修改公式避免颜色值超出255？

问题成因 #

• 整数除法截断误差累积：公式中多次使用整数除法，每次除法都会丢弃小数部分，导致中间结果精度丢失。比如计算(255u - tA) * bA * bR / 255时，整数除法会把实际浮点值（如案例中的~57.77）截断为57，后续加上tA*tR后再除以极小的a（案例中为1），就会把之前的误差放大，最终结果溢出255。
• 中间运算精度不足：原始Alpha混合公式基于浮点逻辑，直接转整数运算时未使用足够大的整数类型存储中间乘积，不仅容易出现截断，极端值下还可能触发隐性溢出。

以你提到的异常案例为例：

1. 计算a = ((1+1)*255 -1*1)/255 = 509/255 = 1（整数除法截断为1）
2. 计算(255-1)*1*58 /255 = 14732/255 = 57（浮点值约57.77，截断为57）
3. 加上tA*tR=255得到312，除以a=1后直接溢出。

修复方案 #

方案1：使用64位整数优化公式，减少截断误差 #

重新推导公式，将所有中间运算用long类型执行，只在最后做一次除法，最大程度保留精度：

class Program
{
    static void Main(string[] args)
    {
        var parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 16;

        Parallel.For(0, 256, parallelOptions, bA =>
        {
            Console.WriteLine($"bA: {bA}...");

            for (int tA = 0; tA < 256; tA++)
            {
                for (int bR = 0; bR < 256; bR++)
                    for (int tR = 0; tR < 256; tR++)
                    {
                        // 用long计算最终透明度，避免溢出
                        long aNumerator = ((long)(bA + tA) * 255) - (long)tA * bA;
                        int a = (int)(aNumerator / 255);
                        if (a > 0)
                        {
                            // 通分后合并分子，仅做一次除法
                            long rNumerator = (long)(255 - tA) * bA * bR + (long)tA * tR * 255;
                            int R = (int)(rNumerator / (a * 255));
                            // 强制钳位到0-255范围
                            R = Math.Clamp(R, 0, 255);
                            if (R > 255)
                            {
                                Console.WriteLine($"{bA}, {bR}, {tA}, {tR} => {R}");
                            }
                        }
                     }
            }
        });

        Console.ReadKey();
    }
}

公式推导说明：
原始公式R = [ ((255-tA)*bA*bR/255) + tA*tR ] / a
通分后转换为R = [ (255-tA)*bA*bR + tA*tR*255 ] / (a*255)，仅做一次除法，截断误差仅出现一次，大幅降低溢出概率。

方案2：浮点运算+钳位兜底 #

如果性能允许，直接使用浮点运算实现原始算法逻辑，最后用Math.Clamp限制结果范围：

class Program
{
    static void Main(string[] args)
    {
        var parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 16;

        Parallel.For(0, 256, parallelOptions, bA =>
        {
            Console.WriteLine($"bA: {bA}...");
            float bAlpha = bA / 255f;

            for (int tA = 0; tA < 256; tA++)
            {
                float tAlpha = tA / 255f;
                float finalAlpha = bAlpha + tAlpha * (1 - bAlpha);

                for (int bR = 0; bR < 256; bR++)
                    for (int tR = 0; tR < 256; tR++)
                    {
                        if (finalAlpha > 0)
                        {
                            float r = (bR * bAlpha * (1 - tAlpha) + tR * tAlpha) / finalAlpha;
                            int R = (int)Math.Round(r);
                            // 强制限制在合法颜色范围
                            R = Math.Clamp(R, 0, 255);
                            if (R > 255)
                            {
                                Console.WriteLine($"{bA}, {bR}, {tA}, {tR} => {R}");
                            }
                        }
                     }
            }
        });

        Console.ReadKey();
    }
}

这种方式精度最高，完全贴合Alpha混合的数学定义，仅需处理浮点精度导致的微小溢出，用钳位即可解决。

方案3：强制钳位结果（兜底方案） #

无论采用哪种计算方式，最后都添加Math.Clamp(R, 0, 255)，直接将结果限制在0-255的合法范围内。这是最简单的兜底手段，即使计算中仍有误差，也能保证输出颜色值合法。

内容的提问来源于stack exchange，提问作者Spook