C #: Erstellen Sie ein heller / dunkler Farbe basiert auf einem System, Farbe
Frage
Duplizieren
Wie stelle ich die Helligkeit einer Farbe?
Wie bestimme ich, dunkler oder hellere Farbe Variante einer bestimmten Farbe?
Programmatically eine Farbe Erleichtern
Sagen, ich habe
var c = Color.Red;
Jetzt möchte ich eine neue Color
zu schaffen, als diese Farbe heller oder dunkler ist. Wie kann ich tun, ohne zu viel Aufwand?
Lösung
Control .Light .Dark .DarkDark, etc.
Color lightRed = ControlPaint.Light( Color.Red );
Andere Tipps
Ich habe vor kurzem über diese gebloggt . Die Hauptidee ist es, einen vorgegebenen Korrekturfaktor auf jede der Farbkomponenten anzuwenden. Die folgende statische Methode modifiziert die Helligkeit einer bestimmten Farbe mit einem Korrekturfaktor spezifiziert und erzeugt eine dunklere oder hellere eine Variante dieser Farbe:
/// <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);
}
Sie können auch tun dies eine Lerp
Funktion. Es gibt eine in XNA, aber es ist leicht, sich selbst zu schreiben.
Siehe
Die meisten dieser Methoden machen die Farbe dunkler, aber sie stellen Sie den Farbton Art und Weise zu viel, so das Ergebnis sieht nicht sehr gut aus. Die beste Antwort ist auf Rich-Newmans HSLColor Klasse und stellen Sie die Helligkeit verwendet werden. public Color Darken(Color color, double darkenAmount) {
HSLColor hslColor = new HSLColor(color);
hslColor.Luminosity *= darkenAmount; // 0 to 1
return hslColor;
}
Hier ist ein Javascript-Code, den ich für Aufhellung verwenden / eine bestimmte Farbe verdunkeln. Man könnte es als Basis für eine äquivalente C # Funktion
Es funktioniert durch eine Entfernung von reinem Weiß jeder der RGB-Komponenten berechnen und stellt dann diese Distanz durch den vorgesehenen Faktor. Die neue Strecke wird die neue Farbe zu berechnen. Ein Faktor zwischen 0 und 1 dunkelt, ein Faktor von mehr als 1 Hellt
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;
}
Unter dem Kern Methode des @ Pavel Antwort ich die folgenden zwei kleinen Erweiterungsmethoden für eine intuitivere vorbereitet (zumindest für mich) Unterschrift.
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);
}
änderte ich Pavel Vladov Funktion auch RGB-Komponente zu ändern, um Schatten auf einer beliebigen Kombination von R / G / B Richtungen zu erhalten:
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
Sie können auch einfach auf dem RGB Prozentsatz arbeiten, um es heller oder dunkler zu erhalten, wie Sie wollen, hier ist ein Beispiel dafür, wie eine Farbe dunkler x% zu machen, als es ist:
//_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));
}
Eine weitere Sache, wir können auch den umzukehren, um stattdessen leichter zu sein, nur wir das Ergebnis von 255 bekommen - RGB und multiplizieren sie dann mit dem Prozentsatz wir wie im folgenden Beispiel wollen:
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))
);
}
Ich hoffe, das hilft.
Mit HSI-Konverter-Bibliothek (Google-Suche). Und dann stelle ich für heller / dunkler Farbe kanalisieren.
Werfen Sie einen Blick auf die Control Klasse:
habe ich eine Website, die diese colorglower.com kann es eine Demo zu sehen, aus.
Hier ist der Javascript-Code i verwendet.
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;
}
Was dieser Code tut, ist es eine Hex-Farbe erhält und gibt es dann 10 hellste Farbe Versionen davon und legt in der Anordnung in. Sie können die Helligkeit verändern, was auch immer Sie den Schatten Prozentsatz anpassen möchten. Um die Farben verdunkeln müssen Sie nur ändern:
luminosity -= calcPercentage();