C# : Créer une couleur plus claire/foncée basée sur une couleur système

Question

Duplicate

Comment puis-je régler la luminosité d'une couleur ?
Comment déterminer la variante plus foncée ou plus claire d'une couleur donnée ?
Éclaircir une couleur de façon programmée

---

Disons que j'ai

var c = Color.Red;

Maintenant, je veux créer un nouveau Color qui est plus clair ou plus foncé que cette couleur. Comment puis-je faire ça sans trop de problèmes ?

Answer 1

ControlPaint .Light .Dark .DarkDark, etc.

Color lightRed = ControlPaint.Light( Color.Red );

Answer 2

J'ai récemment a fait un blog sur ce sujet . L'idée principale est d'appliquer un facteur de correction donné à chacune des composantes de la couleur. La méthode statique suivante modifie la luminosité d'une couleur donnée avec un facteur de correction spécifié et produit une variante plus sombre ou plus claire de cette couleur :

/// <summary>
/// Creates color with corrected brightness.
/// </summary>
/// <param name="color">Color to correct.</param>
/// <param name="correctionFactor">The brightness correction factor. Must be between -1 and 1. 
/// Negative values produce darker colors.</param>
/// <returns>
/// Corrected <see cref="Color"/> structure.
/// </returns>
public static Color ChangeColorBrightness(Color color, float correctionFactor)
{
    float red = (float)color.R;
    float green = (float)color.G;
    float blue = (float)color.B;

    if (correctionFactor < 0)
    {
        correctionFactor = 1 + correctionFactor;
        red *= correctionFactor;
        green *= correctionFactor;
        blue *= correctionFactor;
    }
    else
    {
        red = (255 - red) * correctionFactor + red;
        green = (255 - green) * correctionFactor + green;
        blue = (255 - blue) * correctionFactor + blue;
    }

    return Color.FromArgb(color.A, (int)red, (int)green, (int)blue);
}

Answer 3

Vous pouvez également le faire en utilisant un Lerp fonction. Il y en a une dans XNA, mais il est facile de l'écrire soi-même.

Ver ma réponse à cette question similaire pour une mise en œuvre en C#.

Cette fonction vous permet de le faire :

// make red 50% lighter:
Color.Red.Lerp( Color.White, 0.5 );

// make red 75% darker:
Color.Red.Lerp( Color.Black, 0.75 );

// make white 10% bluer:
Color.White.Lerp( Color.Blue, 0.1 );

Answer 4

La plupart de ces méthodes assombrissent effectivement la couleur, mais elles ajustent beaucoup trop la teinte, de sorte que le résultat n'est pas très beau. La meilleure solution est d'utiliser HSLColor de Rich Newman et ajustez la luminosité.

public Color Darken(Color color, double darkenAmount) {
    HSLColor hslColor = new HSLColor(color);
    hslColor.Luminosity *= darkenAmount; // 0 to 1
    return hslColor;
}

Answer 5

Voici un code javascript que j'utilise pour éclaircir/assombrir une couleur donnée. Vous pouvez l'utiliser comme base pour une fonction C# équivalente.

Il fonctionne en calculant une distance par rapport au blanc pur de chacune des composantes RVB, puis ajuste cette distance par le facteur fourni. La nouvelle distance est utilisée pour calculer la nouvelle couleur. Un facteur compris entre 0 et 1 assombrit la couleur, un facteur supérieur à 1 l'éclaircit.

function Darken( hexColor, factor )
    {   
        if ( factor < 0 ) factor = 0;

        var c = hexColor;
        if ( c.substr(0,1) == "#" )
        {
            c = c.substring(1);
        }

        if ( c.length == 3 || c.length == 6 )
        {
            var i = c.length / 3;

            var f;  // the relative distance from white

            var r = parseInt( c.substr(0, i ), 16 );
            f = ( factor * r / (256-r) );
            r = Math.floor((256 * f) / (f+1));

            r = r.toString(16);
            if ( r.length == 1 ) r = "0" + r;

            var g = parseInt( c.substr(i, i), 16);
            f = ( factor * g / (256-g) );
            g = Math.floor((256 * f) / (f+1));
            g = g.toString(16);
            if ( g.length == 1 ) g = "0" + g;

            var b = parseInt( c.substr( 2*i, i),16 );
            f = ( factor * b / (256-b) );
            b = Math.floor((256 * f) / (f+1));
            b = b.toString(16);
            if ( b.length == 1 ) b = "0" + b;

            c =  r+g+b;
         }   

         return "#" + c;

    }