Par programme Éclaircir une Couleur

Comme Wedge a dit, vous voulez multiplier pour rendre les choses plus lumineux, mais qui ne fonctionne que jusqu'à ce que l'une des couleurs devient saturé (c'est à dire hits 255 ou plus). À ce point, vous pouvez simplement pince les valeurs à 255, mais vous serez subtilement changer la teinte que vous obtenez plus léger. Pour garder la teinte, vous voulez maintenir le ratio (moyen-bas)/(plus haut-plus bas).

Voici deux fonctions en Python. La première met en œuvre l'approche naïve qui vient de brides les valeurs RVB 255 si ils vont. La deuxième permet de redistribuer l'excédent des valeurs de garder la teinte intacte.

def clamp_rgb(r, g, b):
    return min(255, int(r)), min(255, int(g)), min(255, int(b))

def redistribute_rgb(r, g, b):
    threshold = 255.999
    m = max(r, g, b)
    if m <= threshold:
        return int(r), int(g), int(b)
    total = r + g + b
    if total >= 3 * threshold:
        return int(threshold), int(threshold), int(threshold)
    x = (3 * threshold - total) /(3 * m - total)
    gray = threshold - x * m
    return int(gray + x * r), int(gray + x * g), int(gray + x * b)

J'ai créé un dégradé de départ avec la valeur RVB (224,128,0) et en le multipliant par 1.0, 1.1, 1.2, etc. jusqu'à 2.0. La moitié supérieure est le résultat de l'utilisation de clamp_rgb et la moitié inférieure est le résultat avec redistribute_rgb. Je pense qu'il est facile de voir que la redistribution de la déborde donne un bien meilleur résultat, sans avoir à quitter l'espace de couleurs RVB.

Pour comparaison, voici le même dégradé dans le HLS et HSV espaces de couleurs, tel que mis en œuvre par Python colorsys module. Seul le L a été modifié, et le serrage a été réalisée sur les valeurs RVB. Les résultats sont similaires, mais ils nécessitent de l'espace couleur de conversions pour chaque pixel.

ControlPaint de classe dans le Système.De Windows.Les formes de l'espace de noms a des méthodes statiques de la Lumière et de l'Obscurité:

public static Color Dark(Color baseColor, float percOfDarkDark);

Ces méthodes à l'usage privé de la mise en œuvre de HLSColor. Je souhaite que cette structure était public et dans le Système.De dessin.

Alternativement, vous pouvez utiliser GetHue, GetSaturation, GetBrightness sur la Couleur de la structure (struct) pour obtenir HSB composants. Malheureusement, je n'ai pas trouvé la conversion inverse.

Afin d'obtenir un briquet ou d'une version plus sombre d'une couleur donnée, vous devez modifier sa luminosité. Vous pouvez le faire facilement, même sans la conversion de votre couleur HSL ou de couleur TSV. Par exemple, pour rendre une couleur plus légère, vous pouvez utiliser le code suivant:

float correctionFactor = 0.5f;
float red = (255 - color.R) * correctionFactor + color.R;
float green = (255 - color.G) * correctionFactor + color.G;
float blue = (255 - color.B) * correctionFactor + color.B;
Color lighterColor = Color.FromArgb(color.A, (int)red, (int)green, (int)blue);

Si vous avez besoin de plus de détails, lire l'article complet sur mon blog.

J'ai utilisé Andrew réponse de Marc et de réponses cette (comme de 1/2013 pas de plage d'entrée pour les ff).

function calcLightness(l, r, g, b) {
    var tmp_r = r;
    var tmp_g = g;
    var tmp_b = b;

    tmp_r = (255 - r) * l + r;
    tmp_g = (255 - g) * l + g;
    tmp_b = (255 - b) * l + b;

    if (tmp_r > 255 || tmp_g > 255 || tmp_b > 255) 
        return { r: r, g: g, b: b };
    else 
        return { r:parseInt(tmp_r), g:parseInt(tmp_g), b:parseInt(tmp_b) }
}

Je l'ai fait en deux manières, vous obtenez beaucoup de meilleurs résultats avec la Possibilité de 2.

Toute simple algorithme de vous construire pour la Possibilité 1 sera sans doute bien seul pour une gamme limitée de départ des saturations.

Vous voulez regarder dans les points de vente 1 si (1) vous pouvez restreindre les couleurs et de luminosité utilisé, et (2) vous effectuez le calcul d'un lot dans un rendu.

Génération de l'arrière-plan de l'INTERFACE utilisateur n'aurez pas besoin de beaucoup d'ombrage calculs, alors je vous suggère de les Poss 2.

-Al.

Méthode 1: Convertir RVB en HSL, ajuster la LGV, à le reconvertir en RGB.

Méthode 2: Lerp les valeurs de couleurs RVB - http://en.wikipedia.org/wiki/Lerp_(computing)

Voir ma réponse à cette question similaire pour un C# de mise en œuvre de la méthode 2.

Je n'ai pas trouvé cette question jusqu'à ce que après c'est devenu une question liée à ma question initiale.

Cependant, l'utilisation de la perspicacité à partir de ces réponses. J'ai rassemblé un joli deux-liner fonction de cela:

Par programme pour Éclaircir ou Assombrir une couleur hexadécimale (ou rvb, et de mélanger les couleurs)

Sa version de la méthode 1. Mais avec plus de saturation pris en compte. Comme Keith a dit dans sa réponse ci-dessus; l'utilisation Lerp convenable pour résoudre le même problème de Marque mentionnés, mais sans redistribution. Les résultats de shadeColor2 devrait être beaucoup plus proche de le faire de la bonne façon avec de la LGV, mais sans les frais généraux.

J'aurais essayé numéro #1 en premier, mais #2 semble assez bonne. Essayez de le faire vous-même et voir si vous êtes satisfait avec les résultats, il semble que cela vous prendra seulement 10 minutes pour concocter un test.

Vous trouverez le code pour convertir entre les espaces de couleurs dans le couleur-outils ruby bibliothèque

Voici un exemple de la foudre une couleur RVB en Python:

def lighten(hex, amount):
    """ Lighten an RGB color by an amount (between 0 and 1),

    e.g. lighten('#4290e5', .5) = #C1FFFF
    """
    hex = hex.replace('#','')
    red = min(255, int(hex[0:2], 16) + 255 * amount)
    green = min(255, int(hex[2:4], 16) + 255 * amount)
    blue = min(255, int(hex[4:6], 16) + 255 * amount)
    return "#%X%X%X" % (int(red), int(green), int(blue))