hexadecimal - custom color c#

C#: crea un color más claro/más oscuro según el color del sistema

Question

Duplicar

¿Cómo ajusto el brillo de un color?
¿Cómo determino la variante de color más oscura o más clara de un color dado?
Aligerar programáticamente un color

Digamos que tengo

var c = Color.Red;

Ahora quiero crear un Color nuevo que sea más claro o más oscuro que ese color. ¿Cómo puedo hacer eso sin demasiada molestia?

Answer 1

Aquí hay algunos códigos de JavaScript que uso para aclarar / oscurecer un color determinado. Podrías usarlo como base para una función C # equivalente

Funciona calculando una distancia desde el blanco puro de cada uno de los componentes RGB y luego ajusta esta distancia por el factor proporcionado. La nueva distancia se usa para calcular el nuevo color. Un factor de entre 0 y 1 se oscurece, un factor mayor que 1 se aclara

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;

    }

Answer 2

Cambié la función Pavel Vladov para modificar incluso el componente RGB, para obtener sombras en cualquier combinación de direcciones R / G / B:

Public Function ChangeColorShades(color As Color, correctionFactor As Single, bR As Boolean, bG As Boolean, bB As Boolean) As Color


    Dim red As Single = CSng(color.R)
    Dim green As Single = CSng(color.G)
    Dim blue As Single = CSng(color.B)

    If (correctionFactor < 0) Then

        correctionFactor = 1 + correctionFactor
        If bR Then
            red *= correctionFactor
        End If
        If bG Then
            green *= correctionFactor
        End If
        If bB Then
            blue *= correctionFactor
        End If


    Else
        If bR Then
            red = (255 - red) * correctionFactor + red
        End If
        If bG Then
            green = (255 - green) * correctionFactor + green
        End If
        If bB Then
            blue = (255 - blue) * correctionFactor + blue
        End If

    End If

    Return color.FromArgb(color.A, CInt(red), CInt(green), CInt(blue))
End Function

Answer 3

Eche un vistazo a la clase ControlPaint:

MSDN: miembros de ControlPaint

Answer 4

Hace poco publiqué sobre esto . La idea principal es aplicar un factor de corrección dado a cada uno de los componentes de color. El siguiente método estático modifica el brillo de un color determinado con un factor de corrección especificado y produce una variante más oscura o más clara de ese color:

/// <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 5

Hice un sitio que hace esto colorglower.com Puedes verlo para ver una demostración.

Aquí está el código de JavaScript que utilicé.

function lighten(color) {

// convert to decimal and change luminosity
var luminosity = 0.01
var computedColors = new Array();
var newColor = "#",
    c, i, n, black = 0,
    white = 255;
for (n = 0; n < 10; n++) {
    for (i = 0; i < 3; i++) {
        c = parseInt(color.substr(i * 2, 2), 16);
        c = Math.round(Math.min(Math.max(black, c + (luminosity * white)), white)).toString(16);
        newColor += ("00" + c).substr(c.length);
    }

    computedColors[n] = newColor;
    var arrayUnique = checkIfArrayIsUnique(computedColors);
    if (arrayUnique == false) {
        computedColors.pop();
        break;
    }

    computedColors[n] = newColor;
    newColor = "#";
    luminosity += calcPercentage();
}

return computedColors;

}

Lo que hace este código es que recibe un color hexadecimal y luego emite 10 versiones de color más claras y lo coloca en el conjunto. Puede cambiar la luminosidad a lo que quiera para ajustar el porcentaje de sombreado. Para oscurecer los colores, solo necesitas cambiar:

luminosity -= calcPercentage();

Answer 6

La mayoría de estos métodos oscurecen el color, pero ajustan mucho el tono, por lo que el resultado no se ve muy bien. La mejor respuesta es usar la clase HSLColor de Rich Newman y ajustar la luminosidad.

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

Answer 7

También puede simplemente trabajar en el porcentaje de RGB para que sea más claro o más oscuro como desee. Aquí hay un ejemplo de cómo hacer que un color sea más oscuro x% de lo que es:

//_correctionfactory in percentage, e.g 50 = make it darker 50%
    private Color DarkerColor(Color color, float correctionfactory = 50f)
    {
        const float hundredpercent = 100f;                        
        return Color.FromArgb((int)(((float)color.R / hundredpercent) * correctionfactory),
            (int)(((float)color.G / hundredpercent) * correctionfactory), (int)(((float)color.B / hundredpercent) * correctionfactory));
    }

Una cosa más también podemos revertir el proceso para que sea más claro en su lugar, solo estamos obteniendo el resultado de 255 - RGB y luego lo multiplicamos por el porcentaje que queremos como el siguiente ejemplo:

private Color LighterColor(Color color, float correctionfactory = 50f)
    {
        correctionfactory = correctionfactory / 100f;
        const float rgb255 = 255f;
        return Color.FromArgb((int)((float)color.R + ((rgb255 - (float)color.R) * correctionfactory)), (int)((float)color.G + ((rgb255 - (float)color.G) * correctionfactory)), (int)((float)color.B + ((rgb255 - (float)color.B) * correctionfactory))
            );
    }

Espero que ayude.

Answer 8

También puedes hacer esto usando una función Lerp . Hay uno en XNA, pero es fácil escribir usted mismo.

Vea mi respuesta a esta pregunta similar para una implementación de C #.

La función te permite hacer esto:

// 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 9

Tomando el método central de la respuesta de @Pavel , preparé los siguientes dos pequeños métodos de extensión para una firma más intuitiva (al menos para mí).

public static Color LightenBy(this Color color, int percent)
{
    return ChangeColorBrightness(color, percent/100.0);
}

public static Color DarkenBy(this Color color, int percent)
{
    return ChangeColorBrightness(color, -1 * percent / 100.0); 
}

Answer 10

Usando la biblioteca de convertidores HSI (búsqueda de google). Y luego, ajuste el canal I para un color más claro / más oscuro.

Answer 11

ControlPaint .Light .Dark .DarkDark, etc.

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