Couleur en C#

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 :

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using BrolDev.Config;
  5. using BrolDev.Utils;
  6. using System.Drawing;
  7. namespace BrolDev.Imaging.Colors
  8. {
  9. public class RGB
  10. {
  11. #region declarations
  12. /// <summary>
  13. /// Red index of Bitmap pointers in GDI+
  14. /// </summary>
  15. public const short R = 2;
  16. /// <summary>
  17. /// Green index of Bitmap pointers in GDI+
  18. /// </summary>
  19. public const short G = 1;
  20. /// <summary>
  21. /// Index of blue component
  22. /// </summary>
  23. public const short B = 0;
  24. /// <summary>
  25. /// Red value
  26. /// </summary>
  27. public byte Red;
  28. /// <summary>
  29. /// Green value
  30. /// </summary>
  31. public byte Green;
  32. /// <summary>
  33. /// Blue value
  34. /// </summary>
  35. public byte Blue;
  36. #endregion
  37. #region constructors
  38. /// <summary>
  39. /// Constructor of a RGB object
  40. /// </summary>
  41. public RGB() { }
  42. /// <summary>
  43. /// Constructor of a RGB object
  44. /// </summary>
  45. /// <param name="red">Red value</param>
  46. /// <param name="green">Green value</param>
  47. /// <param name="blue">Blue value</param>
  48. public RGB(byte red, byte green, byte blue)
  49. : this()
  50. {
  51. this.Red = red;
  52. this.Green = green;
  53. this.Blue = blue;
  54. }
  55. /// <summary>
  56. /// Constructor of a RGB object
  57. /// </summary>
  58. /// <param name="color">Initialize from specified Color</param>
  59. public RGB(System.Drawing.Color color)
  60. : this()
  61. {
  62. this.Red = color.R;
  63. this.Green = color.G;
  64. this.Blue = color.B;
  65. }
  66. #endregion
  67. #region attributes
  68. /// <summary>
  69. /// Get or set the Color represented by the RGB object
  70. /// </summary>
  71. public System.Drawing.Color Color
  72. {
  73. get { return Color.FromArgb(Red, Green, Blue); }
  74. set
  75. {
  76. Red = value.R;
  77. Green = value.G;
  78. Blue = value.B;
  79. }
  80. }
  81. #endregion
  82. }
  83. }

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

  1. /// <summary>
  2. /// Red index of Bitmap pointers in GDI+
  3. /// </summary>
  4. public const short R = 2;
  5. /// <summary>
  6. /// Green index of Bitmap pointers in GDI+
  7. /// </summary>
  8. public const short G = 1;
  9. /// <summary>
  10. /// Index of blue component
  11. /// </summary>
  12. public const short B = 0;

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).

Autres systèmes :

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 :

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using BrolDev.Config;
  5. using System.Drawing;
  6. namespace BrolDev.Imaging.Colors
  7. {
  8. public class HSL
  9. {
  10. #region declarations and constructors
  11. private float hue, saturation, luminance;
  12. private Color color;
  13. private bool validColor;
  14. /// <summary>
  15. /// Constructor of a HSL object
  16. /// </summary>
  17. public HSL(){}
  18. /// <summary>
  19. /// Constructor of a HSL object
  20. /// </summary>
  21. /// <param name="hue">Hue value</param>
  22. /// <param name="saturation">Saturation value</param>
  23. /// <param name="luminance">Luminance value</param>
  24. public HSL(float hue, float saturation, float luminance)
  25. : this()
  26. {
  27. this.Hue = hue;
  28. this.Saturation = saturation;
  29. this.Luminance = luminance;
  30. }
  31. /// <summary>
  32. /// Constructor of a HSL object
  33. /// </summary>
  34. /// <param name="color">Color</param>
  35. public HSL(Color color)
  36. : this()
  37. {
  38. Color = color;
  39. }
  40. #endregion
  41. #region attributes
  42. /// <summary>
  43. /// Hue value
  44. /// </summary>
  45. /// <remarks>Hue value is valid between 0 and 359</remarks>
  46. public float Hue
  47. {
  48. get { return hue; }
  49. set
  50. {
  51. hue = value;
  52. //color is modified, force Color attribute to get it
  53. validColor = false;
  54. }
  55. }
  56. /// <summary>
  57. /// Saturation value
  58. /// </summary>
  59. /// <remarks>Saturation value is valid between 0 and 100</remarks>
  60. public float Saturation
  61. {
  62. get { return saturation; }
  63. set
  64. {
  65. saturation = value;
  66. //color is modified, force Color attribute to get it
  67. validColor = false;
  68. }
  69. }
  70. /// <summary>
  71. /// Luminance value
  72. /// </summary>
  73. /// <remarks>Luminance value is valid between 0 and 100</remarks>
  74. public float Luminance
  75. {
  76. get { return luminance; }
  77. set
  78. {
  79. luminance = value;
  80. //color is modified, force Color attribute to get it
  81. validColor = false;
  82. }
  83. }
  84. /// <summary>
  85. /// Get or set the Color represented by the RGB object
  86. /// </summary>
  87. public Color Color
  88. {
  89. get
  90. {
  91. if (!validColor)
  92. {
  93. color = ColorsConverter.HSL2RGB(this).Color;
  94. validColor = true;
  95. }
  96. return color;
  97. }
  98. set
  99. {
  100. color = value;
  101. hue = color.GetHue();
  102. saturation = color.GetSaturation();
  103. luminance = color.GetBrightness();
  104. validColor = true;
  105. }
  106. }
  107. #endregion
  108. }
  109. }

Conversions RGB vers HSL

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

  1. /// <summary>
  2. /// Convert from RGB to HSL color space
  3. /// </summary>
  4. /// <param name="rgb">Source color in <b>RGB</b> color space</param>
  5. /// <param name="hsl">Destination color in <b>HSL</b> color space</param>
  6. public static void RGB2HSL(RGB rgb, HSL hsl)
  7. {
  8. double r = (rgb.Red / 255.0);
  9. double g = (rgb.Green / 255.0);
  10. double b = (rgb.Blue / 255.0);
  11. double min = Math.Min(Math.Min(r, g), b);
  12. double max = Math.Max(Math.Max(r, g), b);
  13. double delta = max - min;
  14. // get luminance value
  15. hsl.Luminance = (float)((max + min) / 2);
  16. if (delta == 0)
  17. {
  18. // gray color
  19. hsl.Hue = 0;
  20. hsl.Saturation = 0.0F;
  21. }
  22. else
  23. {
  24. // get saturation value
  25. hsl.Saturation = (hsl.Luminance < 0.5) ? (float)(delta / (max + min)) : (float)(delta / (2 - max - min));
  26. // get hue value
  27. double del_r = (((max - r) / 6) + (delta / 2)) / delta;
  28. double del_g = (((max - g) / 6) + (delta / 2)) / delta;
  29. double del_b = (((max - b) / 6) + (delta / 2)) / delta;
  30. double hue;
  31. if (r == max)
  32. hue = del_b - del_g;
  33. else if (g == max)
  34. hue = (1.0 / 3) + del_r - del_b;
  35. else
  36. hue = (2.0 / 3) + del_g - del_r;
  37. // correct hue if needed
  38. if (hue < 0)
  39. hue += 1;
  40. if (hue > 1)
  41. hue -= 1;
  42. hsl.Hue = (int)(hue * 360);
  43. }
  44. }

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

  1. /// <summary>
  2. /// Convert from RGB to HSL color space
  3. /// </summary>
  4. /// <param name="rgb">Source color in <b>RGB</b> color space</param>
  5. public static HSL RGB2HSL(RGB rgb)
  6. {
  7. HSL hsl = new HSL();
  8. RGB2HSL(rgb, hsl);
  9. return hsl;
  10. }

Conversions HSL vers RGB

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

  1. /// <summary>
  2. /// Convert from HSL to RGB color space
  3. /// </summary>
  4. /// <param name="hsl">Source color in <b>HSL</b> color space</param>
  5. /// <param name="rgb">Destination color in <b>RGB</b> color space</param>
  6. public static void HSL2RGB(HSL hsl, RGB rgb)
  7. {
  8. if (hsl.Saturation == 0)
  9. {
  10. // gray values
  11. rgb.Red = rgb.Green = rgb.Blue = (byte)(hsl.Luminance * 255);
  12. }
  13. else
  14. {
  15. double v1, v2;
  16. double hue = (double)hsl.Hue / 360;
  17. v2 = (hsl.Luminance < 0.5) ?
  18. (hsl.Luminance * (1 + hsl.Saturation)) :
  19. ((hsl.Luminance + hsl.Saturation) - (hsl.Luminance * hsl.Saturation));
  20. v1 = 2 * hsl.Luminance - v2;
  21. rgb.Red = (byte)(255 * Hue_2_RGB(v1, v2, hue + (1.0 / 3)));
  22. rgb.Green = (byte)(255 * Hue_2_RGB(v1, v2, hue));
  23. rgb.Blue = (byte)(255 * Hue_2_RGB(v1, v2, hue - (1.0 / 3)));
  24. }
  25. }
  26. private static double Hue_2_RGB(double v1, double v2, double vH)
  27. {
  28. if (vH < 0)
  29. {
  30. vH += 1;
  31. }
  32. if (vH > 1)
  33. {
  34. vH -= 1;
  35. }
  36. if ((6 * vH) < 1)
  37. {
  38. return (v1 + (v2 - v1) * 6 * vH);
  39. }
  40. if ((2 * vH) < 1)
  41. {
  42. return v2;
  43. }
  44. if ((3 * vH) < 2)
  45. {
  46. return (v1 + (v2 - v1) * ((2.0 / 3) - vH) * 6);
  47. }
  48. return v1;
  49. }

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

  1. /// <summary>
  2. /// Convert from HSL to RGB color space
  3. /// </summary>
  4. /// <param name="hsl">Source color in <b>HSL</b> color space</param>
  5. public static RGB HSL2RGB(HSL hsl)
  6. {
  7. RGB rgb = new RGB();
  8. HSL2RGB(hsl, rgb);
  9. return rgb;
  10. }

Pour plus d'informations, je vous propose de consulter les algorithmes de conversion RGB vers HSL à cette adresse : http://fr.wikipedia.org/wiki/Codage_informatique_des_couleurs#RVB_vers_TSL

Réseaux sociaux

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher les interactions avec les réseaux sociaux sur ces pages.

 

Nuage de mots clés

13 mots clés dont 0 définis manuellement (plus d'information...).

Avertissement

Cette page ne possède pas encore de mots clés manuels, ceci est donc un exemple automatique (les niveaux de pertinence sont fictifs, mais les liens sont valables). Pour tester le nuage avec une page qui contient des mots définis manuellement, vous pouvez cliquer ici.

Vous pouvez modifier vos préférences dans votre profil pour ne plus afficher le nuage de mots clés.

 

Astuce pour imprimer les couleurs des cellules de tableaux : http://www.gaudry.be/ast-rf-450.html
Aucun commentaire pour cette page

© Ce document issu de l′infobrol est enregistré sous le certificat Cyber PrInterDeposit Digital Numbertection. Enregistrement IDDN n° 5329-11746
Document créé le 06/05/07 18:31, dernière modification le Vendredi 17 Juin 2011, 12:11
Source du document imprimé : http:///www.gaudry.be/csharp-RGB-HSL.html
St.Gaudry©07.01.02
Outils (masquer)
||
Recherche (afficher)
Recherche :

Utilisateur (masquer)
Apparence (afficher)
Stats (afficher)
15838 documents
455 astuces.
550 niouzes.
3107 definitions.
447 membres.
8121 messages.

Document genere en :
0,14 seconde

Mises à jour :
Mises à jour du site
Citation (masquer)
Une idée devient une force lorsqu'elle s'empare des masses.

Karl Marx
 
l'infobrol
Nous sommes le Lundi 26 Juin 2017, 19:19, toutes les heures sont au format GMT+1.00 Heure, heure d'été (+1)