Comment déterminer une variante de couleur plus foncée ou plus claire d'une couleur donnée?

Question

Compte tenu d'une source de la couleur de la teinte par le système ou par l'utilisateur, je voudrais un algorithme simple que je peux utiliser pour une plus claire ou plus foncée variantes de la couleur sélectionnée. Semblables aux effets utilisés sur Windows Live Messenger pour le style de l'interface utilisateur.

La langue est C# avec .net 3.5.

Répondre au commentaire: Couleur format (Alpha)RVB. Avec les valeurs des octets ou des flotteurs.

Marquage réponse: Pour le cadre de mon utilisation (quelques simples effets d'INTERFACE), la réponse que je suis marquage comme acceptée est en fait le plus simple pour ce contexte. Cependant, j'ai abandonné la voix de la plus complexe des réponses précises et trop. Quiconque fait de plus avancé opérations de couleurs et de trouver ce fil dans l'avenir devrait certainement vérifier ceux. Merci. :)

Answer 1

Dans XNA, il est l' Color.Lerp méthode statique qui fait aussi la différence entre les deux couleurs.

Lerp est une opération mathématique entre les deux flotteurs qui modifie la valeur de la première par un rapport de la différence entre eux.

Voici une méthode d'extension pour le faire à un float:

public static float Lerp( this float start, float end, float amount)
{
    float difference = end - start;
    float adjusted = difference * amount;
    return start + adjusted;
}

Alors une simple lerp la coopération entre les deux couleurs en RVB serait:

public static Color Lerp(this Color colour, Color to, float amount)
{
    // start colours as lerp-able floats
    float sr = colour.R, sg = colour.G, sb = colour.B;

    // end colours as lerp-able floats
    float er = to.R, eg = to.G, eb = to.B;

    // lerp the colours to get the difference
    byte r = (byte) sr.Lerp(er, amount),
         g = (byte) sg.Lerp(eg, amount),
         b = (byte) sb.Lerp(eb, amount);

    // return the new colour
    return Color.FromArgb(r, g, b);
}

Un exemple de l'application de ce serait quelque chose comme:

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

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

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

Answer 2

Il suffit de multiplier les valeurs RVB par le montant que vous souhaitez modifier le niveau. Si l'une des couleurs est déjà à la valeur maximale, vous ne pouvez pas la rendre plus lumineuse (en utilisant les mathématiques HSV de toute façon.)

Cela donne exactement le même résultat avec beaucoup moins de maths que de passer à HSV puis de modifier V. Cela donne le même résultat que de basculer vers HSL puis de modifier L, tant que vous ne voulez pas perdre de la saturation.

Answer 3

HSV (Teinte / Saturation / Valeur) également appelé HSL (Teinte / Saturation / Luminosité) est simplement une représentation de couleur différente.

Cette représentation facilite le réglage de la luminosité. Convertissez donc RVB en HSV, éclaircissez le «V», puis reconvertissez-le en RVB.

Vous trouverez ci-dessous du code C à convertir

 void RGBToHSV(unsigned char cr, unsigned char cg, unsigned char cb,double *ph,double *ps,double *pv)
{
double r,g,b;
double max, min, delta;

/* convert RGB to [0,1] */

r = (double)cr/255.0f;
g = (double)cg/255.0f;
b = (double)cb/255.0f;

max = MAXx(r,(MAXx(g,b)));
min = MINx(r,(MINx(g,b)));

pv[0] = max;

/* Calculate saturation */

if (max != 0.0)
	ps[0] = (max-min)/max;
else
	ps[0] = 0.0; 

if (ps[0] == 0.0)
{
	ph[0] = 0.0f;	//UNDEFINED;
	return;
}
/* chromatic case: Saturation is not 0, so determine hue */
delta = max-min;

if (r==max)
{
	ph[0] = (g-b)/delta;
}
else if (g==max)
{
	ph[0] = 2.0 + (b-r)/delta;
}
else if (b==max)
{
	ph[0] = 4.0 + (r-g)/delta;
}
ph[0] = ph[0] * 60.0;
if (ph[0] < 0.0)
	ph[0] += 360.0;
}

void HSVToRGB(double h,double s,double v,unsigned char *pr,unsigned char *pg,unsigned char *pb)
{
int i;
double f, p, q, t;
double r,g,b;

if( s == 0 )
{
	// achromatic (grey)
	r = g = b = v;
}
else
{
	h /= 60;			// sector 0 to 5
	i = (int)floor( h );
	f = h - i;			// factorial part of h
	p = v * ( 1 - s );
	q = v * ( 1 - s * f );
	t = v * ( 1 - s * ( 1 - f ) );
	switch( i )
	{
	case 0:
		r = v;
		g = t;
		b = p;
	break;
	case 1:
		r = q;
		g = v;
		b = p;
	break;
	case 2:
		r = p;
		g = v;
		b = t;
	break;
	case 3:
		r = p;
		g = q;
		b = v;
	break;
	case 4:
		r = t;
		g = p;
		b = v;
	break;
	default:		// case 5:
		r = v;
		g = p;
		b = q;
	break;
	}
}
r*=255;
g*=255;
b*=255;

pr[0]=(unsigned char)r;
pg[0]=(unsigned char)g;
pb[0]=(unsigned char)b;
}
 

Answer 4

Riche Newman décrit couleur HSL à l'égard de .NET Système.De dessin.De la couleur sur son blog et même fournit une HSLColor classe qui fait tout le travail pour vous. Convertir votre Système.De dessin.De la couleur à une HSLColor, d'ajouter ou de soustraire des valeurs par rapport à la Luminosité, et de les convertir en arrière du Système.De dessin.De la couleur pour une utilisation dans votre application.

Answer 5

Vous pouvez convertir votre couleur dans la couleur HSL-espace, manipuler et convertir de nouveau à votre espace couleur de son choix (le plus probable est que du RGB)

Couleurs claires ont plus L-valeur, plus sombre, un inférieur.

Voici pertinentes trucs et toutes les équations:

http://en.wikipedia.org/wiki/HSL_color_space

Une autre méthode consiste simplement à interpoler votre couleur avec le blanc ou le noir. Cela permettra également de désaturer la couleur un peu mais c'est moins cher à calculer.