Algorithme Additif Mélange de Couleurs pour les Valeurs RVB

À se mélanger à l'aide des canaux alpha, vous pouvez utiliser ces formules:

r = new Color();
r.A = 1 - (1 - fg.A) * (1 - bg.A);
if (r.A < 1.0e-6) return r; //Fully transparent -- R,G,B not important
r.R = fg.R * fg.A / r.A + bg.R * bg.A * (1 - fg.A) / r.A;
r.G = fg.G * fg.A / r.A + bg.G * bg.A * (1 - fg.A) / r.A;
r.B = fg.B * fg.A / r.A + bg.B * bg.A * (1 - fg.A) / r.A;

fg est la couleur de la peinture. bg est l'arrière-plan. r est la couleur résultante. 1.0e-6 est juste un très petit nombre, pour compenser les erreurs d'arrondi.

REMARQUE: Toutes les variables utilisées ici sont dans l'intervalle [0.0, 1.0]. Vous devez diviser ou multiplier par 255 si vous souhaitez utiliser des valeurs dans l'intervalle [0, 255].

Par exemple, 50% de rouge sur le dessus de 50% vert:

//background, 50% green
var bg = new Color { R = 0.00, G = 1.00, B = 0.00, A = 0.50 };
//paint, 50% red
var fg = new Color { R = 1.00, G = 0.00, B = 0.00, A = 0.50 };
//The result
var r = new Color();
r.A = 1 - (1 - fg.A) * (1 - bg.A); //0.75
r.R = fg.R * fg.A / r.A + bg.R * bg.A * (1 - fg.A) / r.A; //0.67
r.G = fg.G * fg.A / r.A + bg.G * bg.A * (1 - fg.A) / r.A; //0.33
r.B = fg.B * fg.A / r.A + bg.B * bg.A * (1 - fg.A) / r.A; //0.00

De couleurs qui en résulte est: (0.67, 0.33, 0.00, 0.75), ou 75% brun (ou orange foncé).

---

Vous pouvez également inverser ces formules:

var bg = new Color();
if (1 - fg.A <= 1.0e-6) return null; //No result -- 'fg' is fully opaque
if (r.A - fg.A < -1.0e-6) return null; //No result -- 'fg' can't make the result more transparent
if (r.A - fg.A < 1.0e-6) return bg; //Fully transparent -- R,G,B not important
bg.A = 1 - (1 - r.A) / (1 - fg.A);
bg.R = (r.R * r.A - fg.R * fg.A) / (bg.A * (1 - fg.A));
bg.G = (r.G * r.A - fg.G * fg.A) / (bg.A * (1 - fg.A));
bg.B = (r.B * r.A - fg.B * fg.A) / (bg.A * (1 - fg.A));

ou

var fg = new Color();
if (1 - bg.A <= 1.0e-6) return null; //No result -- 'bg' is fully opaque
if (r.A - bg.A < -1.0e-6) return null; //No result -- 'bg' can't make the result more transparent
if (r.A - bg.A < 1.0e-6) return bg; //Fully transparent -- R,G,B not important
fg.A = 1 - (1 - r.A) / (1 - bg.A);
fg.R = (r.R * r.A - bg.R * bg.A * (1 - fg.A)) / fg.A;
fg.G = (r.G * r.A - bg.G * bg.A * (1 - fg.A)) / fg.A;
fg.B = (r.B * r.A - bg.B * bg.A * (1 - fg.A)) / fg.A;

Les formules permet de calculer que l'arrière-plan ou la couleur de la peinture devrait être de produire de la donnée de couleurs qui en résulte.

---

Si votre fond est opaque, le résultat serait aussi opaque. La couleur de premier plan pourrait alors prendre une fourchette de valeurs avec différentes valeurs alpha. Pour chaque canal (rouge, vert et bleu), vous avez pour vérifier la gamme des alphas résultats dans les valeurs valides (0 - 1).

Quelques points:

• Je pense que vous voulez utiliser min au lieu de max
• Je pense que vous voulez utiliser 255 au lieu de 256

Cela donnera:

(r1, g1, b1) + (r2, g2, b2) = (min(r1+r2, 255), min(g1+g2, 255), min(b1+b2, 255))

Cependant, La façon "naturelle" de couleurs de mélange consiste à utiliser la moyenne, et puis vous n'avez pas besoin de le min:

(r1, g1, b1) + (r2, g2, b2) = ((r1+r2)/2, (g1+g2)/2, (b1+b2)/2)

PYTHON COULEUR MÉLANGE PAR PLUS DANS CMJN ESPACE

Une façon de le faire est d'abord de convertir les couleurs en CMJN format, ajoutez-les, puis il se reconvertir à RVB.

Voici un exemple de code en Python:

rgb_scale = 255
cmyk_scale = 100


def rgb_to_cmyk(self,r,g,b):
    if (r == 0) and (g == 0) and (b == 0):
        # black
        return 0, 0, 0, cmyk_scale

    # rgb [0,255] -> cmy [0,1]
    c = 1 - r /float(rgb_scale)
    m = 1 - g /float(rgb_scale)
    y = 1 - b /float(rgb_scale)

    # extract out k [0,1]
    min_cmy = min(c, m, y)
    c = (c - min_cmy) 
    m = (m - min_cmy) 
    y = (y - min_cmy) 
    k = min_cmy

    # rescale to the range [0,cmyk_scale]
    return c*cmyk_scale, m*cmyk_scale, y*cmyk_scale, k*cmyk_scale

def cmyk_to_rgb(self,c,m,y,k):
    """
    """
    r = rgb_scale*(1.0-(c+k)/float(cmyk_scale))
    g = rgb_scale*(1.0-(m+k)/float(cmyk_scale))
    b = rgb_scale*(1.0-(y+k)/float(cmyk_scale))
    return r,g,b

def ink_add_for_rgb(self,list_of_colours):
    """input: list of rgb, opacity (r,g,b,o) colours to be added, o acts as weights.
    output (r,g,b)
    """
    C = 0
    M = 0
    Y = 0
    K = 0

    for (r,g,b,o) in list_of_colours:
        c,m,y,k = rgb_to_cmyk(r, g, b)
        C+= o*c
        M+=o*m
        Y+=o*y 
        K+=o*k 

    return cmyk_to_rgb(C, M, Y, K)

Le résultat à votre question serait alors (en supposant que la moitié de la moitié du mélange de vos deux couleurs:

r_mix, g_mix, b_mix = ink_add_for_rgb([(r1,g1,b1,0.5),(r2,g2,b2,0.5)])

où les 0.5 s sont là pour dire que nous mélanger 50% de la première couleur, avec 50% de la deuxième couleur.

Ont écrit/utilisé quelque chose comme @Markus Jarderot's sRGB mélange de réponse (qui n'est pas gamma corrigé puisque c'est la valeur par défaut héritage) à l'aide de C++

//same as Markus Jarderot's answer
float red, green, blue;
alpha = (1.0 - (1.0 - back.alpha)*(1.0 - front.alpha));
red   = (front.red   * front.alpha /alpha + back.red   * back.alpha * (1.0 - front.alpha));
green = (front.green * front.alpha /alpha + back.green * back.alpha * (1.0 - front.alpha));
blue  = (front.blue  * front.alpha /alpha + back.blue  * back.alpha * (1.0 - front.alpha));

//faster but equal output
alpha = (1.0 - (1.0 - back.alpha)*(1.0 - front.alpha));
red   = (back.red   * (1.0 - front.alpha) + front.red   * front.alpha);
green = (back.green * (1.0 - front.alpha) + front.green * front.alpha);
blue  = (back.blue  * (1.0 - front.alpha) + front.blue  * front.alpha);

//even faster but only works when all values are in range 0 to 255
int red, green, blue;
alpha = (255 - (255 - back.alpha)*(255 - front.alpha));
red   = (back.red   * (255 - front.alpha) + front.red   * front.alpha) /255;
green = (back.green * (255 - front.alpha) + front.green * front.alpha) /255;
blue  = (back.blue  * (255 - front.alpha) + front.blue  * front.alpha) /255;

plus d'infos: qu'est-ce-tous-codeur-devez-savoir-sur-gamma

Voici un très optimisé, autonome, classe c++, le domaine public, avec virgule flottante et les deux différemment optimisé 8 bits mélange de mécanismes à la fois la fonction de macro et de formats, ainsi qu'une discussion technique à la fois le problème et comment, et de l'importance de l'optimisation de cette question:

https://github.com/fyngyrz/colorblending