Gimp 的“Color to Alpha”背后的算法是什么？特征？

Question

对于那些还不熟悉 Gimp 的“Color to Alpha”功能的人，这里是 Gimp 文档中的页面：颜色到 Alpha。它做得非常好，我很想知道 Gimp 在颜色处理方面到底是如何做到的，无论颜色可能处于哪个颜色空间。非常感谢您的任何提示。

编辑1：根据像素与关键颜色（您在“颜色到Alpha”对话框中选择的颜色）的相似性生成像素的透明度信息，就像某些人在出于某种原因删除答案之前所建议的那样，听起来像是一个很好的见解，但我认为它比这更复杂。假设我们在 0.0 到 1.0 的单位范围内估计颜色相似度，并且我们有一个像素，其颜色例如为 0.4，类似于白色（就像您在“颜色到”中选择白色一样） Alpha”对话框），因此像素的 alpha 值为 0.6，那么当生成的像素在白色背景上显示时，如何改变像素的实际颜色来补偿亮度/光度/饱和度的松散阿尔法为 0.6？

编辑2：实际上是一个更新：与第一次编辑相关的子问题已在 如何在不改变结果颜色的情况下改变像素的 alpha？ 但这可能不是完整的故事，因为接下来会发生什么于Gimp 的“Color to Alpha”功能的来源并不那么简单，似乎是基于特定的算法而不是公式。

Answer 1

我看了一下源代码，它的核心是 colortoalpha 函数。参数*a1到*a4分别是输入/输出红、绿、蓝和alpha，c1到c3是制作alpha的颜色。

当您将两种颜色 c1 和 c2 与特定的 alpha a (0 ≤ a ≤ 1) 组合时，结果是

y = a * c1 + (1-a) * c2

这里我们正在执行相反的操作： 我们知道最终结果 y 和背景颜色 c2，并且想要算出c1和a。由于这是一个未指定的方程，因此有无限多个解。然而，范围 0 ≤ c1 ≤ 255 和 0 ≤ a ≤ 1 增加了解的范围。

Gimp 插件的工作方式是，对于每个像素，它最小化 alpha 值（即最大化透明度）。相反，这意味着对于每个不完全透明的结果像素（即不完全是背景颜色），RGB 分量之一是 0 或 255。

这会生成一个图像，当覆盖在指定颜色之上时，该图像将生成原始图像（没有舍入误差）并且每个像素具有最大透明度。

值得注意的是，整个过程是在 RGB 颜色空间中完成的，但也可以在其他颜色空间中执行，只要组合操作是在相同的颜色空间中完成即可。

Answer 2

我在编辑器 www.Photopea.com 的 Filter - Other - Color to Alpha 下实现了这个过滤器。结果与 GIMP 100% 相同。该算法极其简单。

想法：使用透明度值 A 将背景色 B 与前景色 F 组合，得到新颜色 N：

N = A * F  +  (1 - A) * B;

您知道 N（图像中的实际颜色）和 B（滤镜的参数），并且您想要恢复前景色 F 及其透明度 A。

这样做：

A = max( abs(N.r - B.r), abs(N.g - B.g), abs(N.b - B.b)  )  

现在，您知道了 N、B、A。只需使用上面的公式来计算 F。

Answer 3

所以我研究了 GIMP 源代码...呃！我让它变得通用且可读。
不过还是相当快。
有关数学解释，请参阅Sampo 的答案。
下面是 C# 实现（可以轻松转换为 C / C++）：

static class PixelShaders {

    /// <summary>
    /// Generic color space color to alpha.
    /// </summary>
    /// <param name="pA">Pixel alpha.</param>
    /// <param name="p1">Pixel 1st channel.</param>
    /// <param name="p2">Pixel 2nd channel.</param>
    /// <param name="p3">Pixel 3rd channel.</param>
    /// <param name="r1">Reference 1st channel.</param>
    /// <param name="r2">Reference 2nd channel.</param>
    /// <param name="r3">Reference 3rd channel.</param>
    /// <param name="mA">Maximum alpha value.</param>
    /// <param name="mX">Maximum channel value.</param>
    static void GColorToAlpha(ref double pA, ref double p1, ref double p2, ref double p3, double r1, double r2, double r3, double mA = 1.0, double mX = 1.0) {
        double aA, a1, a2, a3;
        // a1 calculation: minimal alpha giving r1 from p1
        if (p1 > r1) a1 = mA * (p1 - r1) / (mX - r1);
        else if (p1 < r1) a1 = mA * (r1 - p1) / r1;
        else a1 = 0.0;
        // a2 calculation: minimal alpha giving r2 from p2
        if (p2 > r2) a2 = mA * (p2 - r2) / (mX - r2);
        else if (p2 < r2) a2 = mA * (r2 - p2) / r2;
        else a2 = 0.0;
        // a3 calculation: minimal alpha giving r3 from p3
        if (p3 > r3) a3 = mA * (p3 - r3) / (mX - r3);
        else if (p3 < r3) a3 = mA * (r3 - p3) / r3;
        else a3 = 0.0;
        // aA calculation: max(a1, a2, a3)
        aA = a1;
        if (a2 > aA) aA = a2;
        if (a3 > aA) aA = a3;
        // apply aA to pixel:
        if (aA >= mA / mX) {
            pA = aA * pA / mA;
            p1 = mA * (p1 - r1) / aA + r1;
            p2 = mA * (p2 - r2) / aA + r2;
            p3 = mA * (p3 - r3) / aA + r3;
        } else {
            pA = 0;
            p1 = 0;
            p2 = 0;
            p3 = 0;
        }
    }

}

GIMP 的实现 (此处) 使用 RGB 颜色空间，使用 alpha 值作为 0 到 1 范围内的 float，以及 R、G、B 作为从 0 到 255 的 float。

当图像具有 JPEG 伪影时，RGB 实现会严重失败，因为它们意味着可感知的颜色偏差不显着，但绝对 R、G、B 偏差却相当显着。使用 LAB 色彩空间应该可以解决这个问题。

如果您只想从图像中删除纯色背景，颜色到 Alpha 算法并不是最佳选择。使用 LAB 色彩空间计算每个像素的色彩空间距离时，我得到了很好的结果。然后将计算出的距离应用于原始图像的 Alpha 通道。这与 Alpha 颜色之间的主要区别是像素的色调不会改变。背景删除只是将 alpha（不透明度）设置为色彩空间差异。如果前景图像中没有出现背景颜色，则效果很好。如果确实如此，则无法删除背景，或者必须使用 BFS 算法仅遍历外部像素（类似于在 GIMP 中使用魔术棒选择，然后删除选择）。

如果前景图像同时存在孔洞和颜色与背景颜色相似的像素，则无法删除背景。此类图像需要一些手动处理。

Answer 4

您需要想出一种比较颜色相似度的机制。您可以在多种颜色空间中执行此操作。 RGB 通常不是此类事物的最佳选择。但您可以使用 HSV、YCbCr 或其他一些亮度/色度空间。通常，这些空间之一中的距离会给您比 RGB 中的欧几里得距离更好的答案。获得距离后，您可以将其除以最大距离以获得百分比。作为一种可能性，该百分比将是您想要使用的 alpha 的倒数。

如果你想知道 GIMP 是如何做到的，你可以查看源码。例如，这是最近的一项代码更改< /a> 到该插件。

Answer 5

我尽我所能将 colortoalpha 方法从 gimp 翻译成 C#。问题是 RGBA 值在 ImageSharp 等库中被视为每个通道的字节。有些转换在转换过程中会丢失数据，但我尽力保留尽可能多的数据。这使用 ImageSharp 进行图像突变。 ImageSharp 是完全托管的，因此它可以跨平台工作。它也很快。整个方法的运行时间约为 10 毫秒（不到 10 毫秒）。

以下是C#实现的代码：

public static unsafe void ColorToAlpha(this Image<Rgba32> image, Rgba32 color)
    {
        double alpha1, alpha2, alpha3, alpha4;
        double* a1, a2, a3, a4;

        a1 = &alpha1;
        a2 = &alpha2;
        a3 = &alpha3;
        a4 = &alpha4;

        for (int j = 0; j < image.Height; j++)
        {
            var span = image.GetPixelRowSpan(j);

            for (int i = 0; i < span.Length; i++)
            {
                ref Rgba32 pixel = ref span[i];

                // Don't know what this is for
                // *a4 = pixel.A;

                if (pixel.R > color.R)
                    *a1 = (pixel.R - color.R) / (255.0 - color.R);
                else if (pixel.R < color.R)
                    *a1 = (color.R - pixel.R) / color.R;
                else
                    *a1 = 0.0;

                if (pixel.G > color.G)
                    *a2 = (pixel.G - color.G) / (255.0 - color.G);
                else if (pixel.G < color.G)
                    *a2 = (color.G - pixel.G) / color.G;
                else
                    *a2 = 0.0;

                if (pixel.B > color.B)
                    *a3 = (pixel.B - color.B) / (255.0 - color.B);
                else if (pixel.B < color.B)
                    *a3 = (color.B - pixel.B) / color.B;
                else
                    *a3 = 0.0;

                if (*a1 > *a2)
                    *a4 = *a1 > *a3 ? *a1 * 255.0 : *a3 * 255.0;
                else
                    *a4 = *a2 > *a3 ? *a2 * 255.0 : *a3 * 255.0;

                if (*a4 < 1.0)
                    return;

                pixel.R = (byte)Math.Truncate((255.0 * (*a1 - color.R) / *a4 + color.R));
                pixel.G = (byte)Math.Truncate((255.0 * (*a2 - color.G) / *a4 + color.G));
                pixel.B = (byte)Math.Truncate((255.0 * (*a3 - color.B) / *a4 + color.B));

                pixel.A = (byte)Math.Truncate(*a4);
            }
        }
    }

Answer 6

我遇到了同样的问题，并在 Python 中实现了 colortoalpha ，这样我就可以轻松地编写批处理操作的脚本。它似乎与 GIMP 输出完美匹配！

import PIL.Image
import numpy as np

# Color to make transparent.
BG_COLOR_RGB = [255, 255, 255] # white

# 8 bits for every channel including alpha: 24-bit RGB input, 32-bit RGBA output
MAX_CHANNEL = 255
MAX_ALPHA = 255

# Open file and convert the data to NumPy
input_image = PIL.Image.open('input.jpg')
input = np.asarray(input_image)
bg_color = np.array(BG_COLOR_RGB, dtype=np.uint8)

# Inversing the formula: Img = alpha * Fg + (1-alpha) * Bg
alpha_per_channel = (0
                    + np.greater(input, bg_color)
                    * np.divide(input - bg_color, MAX_CHANNEL - bg_color,
                                where=np.greater(MAX_CHANNEL - bg_color, 0))
                    + np.less(input, bg_color)
                    * np.divide(bg_color - input, bg_color,
                                where=np.greater(bg_color,0)))
alpha = np.amax(alpha_per_channel, axis=2, keepdims=True)
foreground = np.divide(input - (1-alpha) * bg_color, alpha,
                       where=np.greater(alpha, 1e-4))

# Output has 4 channels (RGBA)
output = np.zeros([input.shape[0],input.shape[1],4], dtype=np.uint8)
# Set RGB channels
output[:, :, 0:3] = foreground
# Set alpha channel
output[:, :, 3:4] = alpha * MAX_ALPHA

# Save the file preserving DPI settings
PIL.Image.fromarray(output).save('output.png', dpi=input_image.info.get('dpi'))

您可以在这里找到完整的源代码： https://github.com/unicilindro /color2alpha/blob/main/color2alpha.py

Answer 7

我最近尝试弄清楚 Gimp 的颜色擦除混合模式背后的数学原理（基本上与颜色到 Alpha 过滤器相同），这就是我最终得到的结果：
[C++ 代码]
工作原理。]

[详细说明其 其要点是：
由于底层完全不透明，法线混合只是线性插值。由于两个图层都完全不透明，“颜色擦除”是“法线混合”的逆操作。

在您选择的颜色空间中，追踪一条穿过顶部颜色和底部颜色的线。从底部开始，沿着远离顶部的线走，直到遇到单位立方体的边界（即色域的限制）。那一点就是你得到的颜色。其不透明度是顶部到底部的距离与顶部到结果的距离的比例。