Question

我有一个十六进制颜色，例如我希望将#F4F8FB（或rgb(244, 248, 251)）转换为 as-transparent-as-possible rgba颜色（当显示为白色时）。合理？我正在寻找一种算法，或者至少想一个算法来解决这个问题。

例如：

rgb( 128, 128, 255 ) --> rgba(   0,   0, 255,  .5 )
rgb( 152, 177, 202 ) --> rgba(  50, 100, 150,  .5 ) // can be better(lower alpha)

想法？

基于Guffa答案的FYI解决方案：

function RGBtoRGBA(r, g, b){
    if((g == null) && (typeof r === 'string')){
        var hex = r.replace(/^\s*#|\s*$/g, '');
        if(hex.length === 3){
            hex = hex.replace(/(.)/g, '$1$1');
        }
        r = parseInt(hex.substr(0, 2), 16);
        g = parseInt(hex.substr(2, 2), 16);
        b = parseInt(hex.substr(4, 2), 16);
    }

    var min, a = (255 - (min = Math.min(r, g, b))) / 255;

    return {
        r    : r = 0|(r - min) / a,
        g    : g = 0|(g - min) / a,
        b    : b = 0|(b - min) / a,
        a    : a = (0|1000*a)/1000,
        rgba : 'rgba(' + r + ', ' + g + ', ' + b + ', ' + a + ')'
    };
}

RGBtoRGBA(204, 153, 102) == RGBtoRGBA('#CC9966') == RGBtoRGBA('C96') == 
    {
       r    : 170,
       g    : 85 ,
       b    : 0  ,
       a    : 0.6,
       rgba : 'rgba(170, 85, 0, 0.6)' 
    }

Answer 1

获取最低颜色分量，并将其转换为alpha值。然后通过减去最低值并除以alpha值来缩放颜色分量。

示例：

152 converts to an alpha value of (255 - 152) / 255 ~ 0.404

152 scales using (152 - 152) / 0.404 = 0
177 scales using (177 - 152) / 0.404 ~ 62
202 scales using (202 - 152) / 0.404 ~ 123

因此，rgb(152, 177, 202)显示为rgba(0, 62, 123, .404)。

我已经在Photoshop中验证了颜色实际上是完美匹配的。

Answer 2

设r，g和b为输入值，r'，g'，b'和a'为输出值，所有缩放（现在，因为它使数学更漂亮）在1和0之间。然后，通过叠加颜色的公式：

r = a' * r' + 1 - a'
g = a' * g' + 1 - a'
b = a' * b' + 1 - a'

1 - a'术语代表背景贡献，其他术语代表前景。做一些代数：

r = a' * (r' - 1) + 1
r - 1 = a' * (r' - 1)
(r - 1) / (r' - 1) = a'
(r' - 1) / (r - 1) = 1 / a'
r' - 1 = (r - 1) / a'
r' = (r - 1) / a' + 1

直观地说，似乎最小颜色值将成为问题的限制因素，因此将其绑定到m：

m = min(r, g, b)

将相应的输出值m'设置为零，因为我们希望最大化透明度：

0 = (m - 1) / a' + 1
-1 = (m - 1) / a'
-a' = m - 1
a' = 1 - m

所以，在javascript中（沿途翻译从1到255）：

function rgba(r, g, b) {
    var a = 1 - Math.min(r, Math.min(g, b)) / 255;
    return [255 + (r - 255) / a, 255 + (g - 255) / a, 255 + (b - 255) / a, a];
}

请注意，我假设'在这里是不透明的。将它改为透明度是微不足道的 - 只需从'的公式中删除“1 - ”即可。需要注意的是，这似乎没有产生确切的结果 - 它表示上面给出的示例（128,128,255）的不透明度为0.498。但是，这非常接近。

Answer 3

我期待RGB＆lt; - ＆gt; HSL转换。即发光度==白色量==透明度。

对于您的示例rgb( 128, 128, 255 )，我们需要首先将RGB值移至0最大量，即rgb( 0, 0, 128 ) - 这将是我们的颜色尽可能少的白色。然后，使用亮度公式，我们计算我们需要添加到我们的深色以获得原始颜色的白色量 - 这将是我们的alpha：

L = (MAX(R,G,B) + MIN(R,G,B))/2
L1 = (255 + 128) / 2 = 191.5
L2 = (128 + 0) /2 = 64
A = (191,5 - 64) / 255 = 0,5;

希望这是有道理的。：）

Answer 4

对于那些使用SASS / SCSS的人，我写了一个小的SCSS函数，这样你就可以轻松使用@Guffa描述的算法

@function transparentize-on-white($color)
{
    $red: red($color);
    $green: green($color);
    $blue: blue($color);
    $lowestColorComponent: min($red, $green, $blue);
    $alpha: (255 - $lowestColorComponent) / 255;

    @return rgba(
        ($red - $lowestColorComponent) / $alpha,
        ($green - $lowestColorComponent) / $alpha,
        ($blue - $lowestColorComponent) / $alpha,
        $alpha
    );
}

Answer 5

我只是在描述算法的想法，没有完整的解决方案：

基本上，您有三个号码x，y，z，而您正在寻找三个新号码x'，y'，{{1} }和[0,1]范围内的乘数z'，使得：

这是以通道也采用[0,1]范围内的值的单位编写的。在8位离散值中，它是这样的：

x = a + (1 - a) x'
y = a + (1 - a) y'
z = a + (1 - a) z'

此外，您希望获得最大可能值x = 255 a + (1 - a) x' y = 255 a + (1 - a) y' z = 255 a + (1 - a) z'。你可以解决：

等。在实际值中，这有无限多个解决方案，只需插入任何实数a = (x - x')/(255 - x') x' = (x - 255 a)/(1 - a)，但问题是要找到离散误差最小的数字。

Answer 6

这应该这样做：

let x = min(r,g,b)
a = 1 - x/255                    # Correction 1
r,g,b = ( (r,g,b) - x ) / a      # Correction 2

Answer 7

最佳答案对我来说不适用于低色成分。例如，如果颜色为＃80000，则不会计算正确的alpha值。从技术上讲，它应该成为＃ff0000与alpha 0.5。要解决此问题，您需要使用RGB - ＆gt; HSL - ＆gt; RGBA转换。这是获取正确值的伪代码：

//Convert RGB to HSL
hsl = new HSL(rgb)

//Use lightness as alpha
alpha = hsl.Lightness

//For #80000 lightness is 0.5, so we have to take this into account.
//Lightness more than 0.5 converts to alpha 1 and below is a linear ratio
if (alpha > 0.5)
{
    alpha = 1;
}
else
{
    alpha = alpha / 0.5;
    //We need to drop the lightness of the color to 0.5 to get the actual color
    //that needs to display. Alpha blending will take care of that.
    hsl.Lightness = 0.5;
}

newRgb = hsl.convertToRgb()

“newRgb”将包含新调整颜色的值，并使用“alpha”变量来控制透明度。

将RGB转换为RGBA白色

7 个答案: