Les couleurs en C#

Table des matières

Les couleurs de base lorsque nous désirons peindre sont le magenta (rouge), le cyan (bleu) et le jaune. En peinture, ces trois couleurs sont dites soustractives, c'est à dire que le mélange des trois donne du noir.

En imagerie numérique, les couleurs de base sont le rouge, le vert, et le bleu. Ces couleurs sont dites additives, ce qui signifie que le mélange des trois donne du blanc.

Nous avons donc un moyen d'identification des couleurs qui est le système RVB (Rouge-Vert-Bleu), plus souvent nommé RGB (Red-Green-Blue) en raison de l'influence anglophone dans la technologie numérique.

Les valeurs sont comprises entre 0 et 255. 8 bits sont donc nécessaires pour chaque valeur, le tout pour une couleur codée en 24 bits.

Nous retrouvons aussi des couleurs RGBA codées en 32 bits, 8 bits en plus permettant de gérer la transparence (Alpha).

Nous pouvons écrire la classe suivante pour manipuler les couleurs RGB :

Code c# (constantes R, G et B) (83 lignes)

using System;
using System.Collections.Generic;
using System.Text;
using BrolDev.Config;
using BrolDev.Utils;
using System.Drawing;
namespace BrolDev.Imaging.Colors
{
	public class RGB
	{
		#region declarations
		/// <summary>
		/// Red index of Bitmap pointers in GDI+
		/// </summary>
		public const short R = 2;
		/// <summary>
		/// Green index of Bitmap pointers in GDI+
		/// </summary>
		public const short G = 1;
		/// <summary>
		/// Index of blue component
		/// </summary>
		public const short B = 0;
		/// <summary>
		/// Red value
		/// </summary>
		public byte Red;
		/// <summary>
		/// Green value
		/// </summary>
		public byte Green;
		/// <summary>
		/// Blue value
		/// </summary>
		public byte Blue; 
		#endregion
		#region constructors
		/// <summary>
		/// Constructor of a RGB object
		/// </summary>
		public RGB() { }
		/// <summary>
		/// Constructor of a RGB object
		/// </summary>
		/// <param name="red">Red value</param>
		/// <param name="green">Green value</param>
		/// <param name="blue">Blue value</param>
		public RGB(byte red, byte green, byte blue)
		: this()
		{
			this.Red = red;
			this.Green = green;
			this.Blue = blue;
		}
		/// <summary>
		/// Constructor of a RGB object
		/// </summary>
		/// <param name="color">Initialize from specified Color</param>
		public RGB(System.Drawing.Color color)
		: this()
		{
			this.Red = color.R;
			this.Green = color.G;
			this.Blue = color.B;
		} 
		#endregion
		#region attributes
		/// <summary>
		/// Get or set the Color represented by the RGB object 
		/// </summary>
		public System.Drawing.Color Color
		{
			get { return Color.FromArgb(Red, Green, Blue); }
			set
			{
				Red = value.R;
				Green = value.G;
				Blue = value.B;
			}
		}
		#endregion
	}
}

Retourner au début du code

Attardons nous sur les lignes de codes de la déclarations des constantes :

Code c# (constantes R, G et B) (12 lignes)

/// <summary>
/// Red index of Bitmap pointers in GDI+
/// </summary>
public const short R = 2;
/// <summary>
/// Green index of Bitmap pointers in GDI+
/// </summary>
public const short G = 1;
/// <summary>
/// Index of blue component
/// </summary>
public const short B = 0;

Retourner au début du code

Ces constantes nous permettent d'atteindre à l'aide du bon index les valeurs RGB pour un pixel.
Vous ne remarquez rien d'étrange ?

Nous avons vu que les couleurs étaient codées en RGB, hors les valeurs des indexes nous donnent l'ordre BGR. Cela est du au fait que dans GDI+, les valeurs sont codées dans l'ordre BGR, et nous allons utiliser GDI+ pour manipuler nos images en C#.

Notre classe fournit un attribut Color qui permet de lire ou de définir la couleur qui correspond aux valeurs. Nous allons aussi stocker la couleur afin de ne pas devoir créer un nouvel objet Color à chaque demande.

Comme les attributs Hue, Saturation et Luminance nous permettent de modifier les valeurs au travers de la méthode set{}, notre objet color risque d'être modifié. Nous allons donc définir un booléen qui déclarera que la couleur n'est plus valide si un de ces paramètres est modifié. Si la couleur n'est plus valide, elle est recréée au moment de son appel (je n'ai pas trouvé d'autre moyen de mettre à jour les valeurs HSL d'une couleur; si vous avez la solution, vos commentaires sont les bienvenus).

Systèmes de codage des couleurs

Mais nous pouvons rencontrer d'autres systèmes de codage des couleurs...

Le codage TSL (Teinte Saturation Luminosité), ou HSL (Hue Saturation Luminance) en anglais est lui aussi fort répendu. La valeur de teinte est comprise entre 0 et 359, et les valeurs de saturation et luminosité entre 0 et 100. Le codage HSL est plus intuitif, mais en général nous sommes obligés de travailler avec les valeurs RGB ou RGBA.

Voici une classe permettant de manipuler les couleurs HSL :

Code c# (HSL.cs) (109 lignes)

using System;
using System.Collections.Generic;
using System.Text;
using BrolDev.Config;
using System.Drawing;
namespace BrolDev.Imaging.Colors
{
	public class HSL
	{
		#region declarations and constructors
		private float hue, saturation, luminance;
		private Color color;
		private bool validColor;
		/// <summary>
		/// Constructor of a HSL object
		/// </summary>
		public HSL(){}
		/// <summary>
		/// Constructor of a HSL object
		/// </summary>
		/// <param name="hue">Hue value</param>
		/// <param name="saturation">Saturation value</param>
		/// <param name="luminance">Luminance value</param>
		public HSL(float hue, float saturation, float luminance)
		: this()
		{
			this.Hue = hue;
			this.Saturation = saturation;
			this.Luminance = luminance;
		}
		/// <summary>
		/// Constructor of a HSL object
		/// </summary>
		/// <param name="color">Color</param>
		public HSL(Color color)
		: this()
		{
			Color = color;
		} 
		#endregion
		#region attributes
		/// <summary>
		/// Hue value
		/// </summary>
		/// <remarks>Hue value is valid between 0 and 359</remarks>
		public float Hue
		{
			get { return hue; }
			set
			{
				hue = value;
				//color is modified, force Color attribute to get it
				validColor = false;
			}
		}
		/// <summary>
		/// Saturation value
		/// </summary>
		/// <remarks>Saturation value is valid between 0 and 100</remarks>
		public float Saturation
		{
			get { return saturation; }
			set
			{
				saturation = value;
				//color is modified, force Color attribute to get it
				validColor = false;
			}
		}
		/// <summary>
		/// Luminance value
		/// </summary>
		/// <remarks>Luminance value is valid between 0 and 100</remarks>
		public float Luminance
		{
			get { return luminance; }
			set
			{
				luminance = value;
				//color is modified, force Color attribute to get it
				validColor = false;
			}
		}
		/// <summary>
		/// Get or set the Color represented by the RGB object 
		/// </summary>
		public Color Color
		{
			get 
			{
				if (!validColor)
				{
					color = ColorsConverter.HSL2RGB(this).Color;
					validColor = true;
				}
				return color;
			}
			set
			{
				color = value;
				hue = color.GetHue();
				saturation = color.GetSaturation();
				luminance = color.GetBrightness();
				validColor = true;
			}
		} 
		#endregion
	}
}

Retourner au début du code

Conversions RGB vers HSL

Le framework AForge.NET¹ nous permet d'effectuer les conversions :

Code c# (RGB2HSL(RGB rgb, HSL hsl)) (44 lignes)

/// <summary>
/// Convert from RGB to HSL color space 
/// </summary>
/// <param name="rgb">Source color in <b>RGB</b> color space</param>
/// <param name="hsl">Destination color in <b>HSL</b> color space</param>
public static void RGB2HSL(RGB rgb, HSL hsl)
{
	double r = (rgb.Red / 255.0);
	double g = (rgb.Green / 255.0);
	double b = (rgb.Blue / 255.0);
	double min = Math.Min(Math.Min(r, g), b);
	double max = Math.Max(Math.Max(r, g), b);
	double delta = max - min;
	// get luminance value
	hsl.Luminance = (float)((max + min) / 2);
	if (delta == 0)
	{
		// gray color
		hsl.Hue = 0;
		hsl.Saturation = 0.0F;
	}
	else
	{
		// get saturation value
		hsl.Saturation = (hsl.Luminance < 0.5) ? (float)(delta / (max + min)) : (float)(delta / (2 - max - min));
		// get hue value
		double del_r = (((max - r) / 6) + (delta / 2)) / delta;
		double del_g = (((max - g) / 6) + (delta / 2)) / delta;
		double del_b = (((max - b) / 6) + (delta / 2)) / delta;
		double hue;
		if (r == max)
		hue = del_b - del_g;
		else if (g == max)
		hue = (1.0 / 3) + del_r - del_b;
		else
		hue = (2.0 / 3) + del_g - del_r;
		// correct hue if needed
		if (hue < 0)
		hue += 1;
		if (hue > 1)
		hue -= 1;
		hsl.Hue = (int)(hue * 360);
	}
}

Retourner au début du code

Ajoutons une méthode qui effectue la conversion et nous retourne un objet HSL :

Code c# (RGB2HSL(RGB rgb)) (10 lignes)

/// <summary>
/// Convert from RGB to HSL color space 
/// </summary>
/// <param name="rgb">Source color in <b>RGB</b> color space</param>
public static HSL RGB2HSL(RGB rgb)
{
	HSL hsl = new HSL();
	RGB2HSL(rgb, hsl);
	return hsl;
}

Conversions HSL vers RGB

Voici donc les deux méthodes pour convertir une couleur HSL en couleur RGB :

Code c# (HSL2RGB(HSL hsl, RGB rgb)) (49 lignes)

/// <summary>
/// Convert from HSL to RGB color space 
/// </summary>
/// <param name="hsl">Source color in <b>HSL</b> color space</param>
/// <param name="rgb">Destination color in <b>RGB</b> color space</param>
public static void HSL2RGB(HSL hsl, RGB rgb)
{
	if (hsl.Saturation == 0)
	{
		// gray values
		rgb.Red = rgb.Green = rgb.Blue = (byte)(hsl.Luminance * 255);
	}
	else
	{
		double v1, v2;
		double hue = (double)hsl.Hue / 360;
		v2 = (hsl.Luminance < 0.5) ?
		(hsl.Luminance * (1 + hsl.Saturation)) :
		((hsl.Luminance + hsl.Saturation) - (hsl.Luminance * hsl.Saturation));
		v1 = 2 * hsl.Luminance - v2;
		rgb.Red = (byte)(255 * Hue_2_RGB(v1, v2, hue + (1.0 / 3)));
		rgb.Green = (byte)(255 * Hue_2_RGB(v1, v2, hue));
		rgb.Blue = (byte)(255 * Hue_2_RGB(v1, v2, hue - (1.0 / 3)));
	}
}
private static double Hue_2_RGB(double v1, double v2, double vH)
{
	if (vH < 0)
	{
		vH += 1;
	}
	if (vH > 1)
	{
		vH -= 1;
		}
	if ((6 * vH) < 1)
	{
		return (v1 + (v2 - v1) * 6 * vH);
	}
	if ((2 * vH) < 1)
	{
		return v2;
	}
	if ((3 * vH) < 2)
	{
		return (v1 + (v2 - v1) * ((2.0 / 3) - vH) * 6);
	}
	return v1;
}

Retourner au début du code

Ajoutons une méthode qui effectue la conversion et nous retourne un objet RGB :

Code c# (HSL2RGB(HSL hsl)) (10 lignes)

/// <summary>
/// Convert from HSL to RGB color space 
/// </summary>
/// <param name="hsl">Source color in <b>HSL</b> color space</param>
public static RGB HSL2RGB(HSL hsl)
{
	RGB rgb = new RGB();
	HSL2RGB(hsl, rgb);
	return rgb;
}

Version en cache

21/11/2024 09:34:39 Cette version de la page est en cache (à la date du 21/11/2024 09:34:39) afin d'accélérer le traitement. Vous pouvez activer le mode utilisateur dans le menu en haut pour afficher la dernère version de la page.

Document créé le 06/05/2007, dernière modification le 02/09/2020
Source du document imprimé : https://www.gaudry.be/csharp-rgb-hsl.html

L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.

Notes

↑ AForge.NET : Framework C# opensource utilisé dans l'intelligence artificielle, le traitement d'image, les réseaux neuronaux, etc.

Table des matières Haut

Références

Codage informatique des couleurs : Algorithmes de conversion RGB vers HSL sur Wikipedia

Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.

Table des matières Haut