Section courante

A propos

Section administrative du site

La quantification des couleurs

La quantification des couleurs (ou color quantization en anglais) dans LibGD fait référence à la réduction du nombre de couleurs utilisées dans une image tout en préservant autant que possible sa qualité visuelle. Ce processus est crucial pour diminuer la taille des images et les rendre plus adaptées à des formats avec des limitations de couleurs, comme le GIF ou le PNG-8. La quantification est souvent utilisée pour convertir des images en couleurs vraies (24 bits) en images à une palette réduite de couleurs, ce qui est particulièrement utile dans les contextes où la taille de fichier et les performances sont importantes. En réduisant le nombre de couleurs, les images peuvent être plus facilement manipulées et affichées dans des environnements où les ressources sont limitées.

Méthodes de quantification des couleurs

LibGD utilise plusieurs algorithmes pour effectuer la quantification des couleurs. L'un des plus courants est l'algorithme Median Cut, divisant l'espace des couleurs en sous-espaces en fonction de la distribution des couleurs dans l'image. Cet algorithme est efficace pour créer une palette représentant au mieux les couleurs les plus significatives de l'image. Un autre algorithme utilisé est l'octree quantization, construisant un arbre octal pour représenter les couleurs. Cette méthode est plus complexe mais permet d'obtenir des résultats plus fins et précis dans la quantification, en particulier pour les images ayant des dégradés subtils.

Optimisation et limites

Bien que la quantification des couleurs soit utile pour réduire la taille des images, elle présente des limitations. En effet, lors de la réduction du nombre de couleurs, certaines informations sont perdues, ce qui peut entraîner des artefacts visuels comme des bandes de couleurs ou des dégradés moins fluides. LibGD permet d'ajuster le nombre de couleurs dans la palette pour trouver un compromis entre la qualité visuelle et la taille du fichier. Il est essentiel d'optimiser cette réduction pour maintenir un bon équilibre entre les deux, surtout dans des applications où la performance est primordiale, telles que les sites web ou les applications mobiles.

Applications et cas d'utilisation

La quantification des couleurs est souvent utilisée dans les applications web et les jeux vidéo où les images doivent être compactes mais avec une qualité visuelle acceptable. Dans LibGD, la quantification des couleurs est particulièrement utile lors de la conversion d'images vers des formats comme GIF, ne supportant qu'une palette de 256 couleurs, ou PNG-8, qui est une version optimisée du PNG pour les images avec une palette réduite. Ces formats sont largement utilisés pour la transparence et les petites icônes, où une taille de fichier minimale est essentielle. Grâce à la quantification, LibGD permet aux développeurs de créer des images adaptées aux contraintes des plateformes tout en maintenant une bonne qualité visuelle.

Les fonctions

Voici les fonctions proposé par LibGD pour la conversion de couleur vraie vers une palette :

Nom Description
gdImageTrueColorToPaletteSetMethod Cette fonction permet de sélectionner la méthode de quantification.
gdImageTrueColorToPaletteSetQuality Cette fonction permet de choisir un intervalle de qualité pour la quantification.
gdImageCreatePaletteFromTrueColor Cette fonction permet de créer une nouvelle image avec palette à partir d'une image en couleur vraie.
gdImageTrueColorToPalette Cette fonction permet de convertir une image en couleur vraie en une image avec palette.

gdImageTrueColorToPaletteSetMethod

int gdImageTrueColorToPaletteSetMethod(gdImagePtr im, int method, int speed);

Cette fonction permet de sélectionner la méthode de quantification. Cette méthode de quantification est utilisée pour tous les appels ultérieurs à gdImageTrueColorToPaletteet gdImageCreatePaletteFromTrueColor.

Paramètre

Nom Description
im Ce paramètre permet d'indiquer l'image.
method Ce paramètre permet d'indiquer la méthode de quantification, voir gdPaletteQuantizationMethod.
speed Ce paramètre permet d'indiquer la vitesse de quantification entre 1 (qualité la plus élevée) et 10 (la plus rapide). 0 sélectionne une valeur par défaut spécifique à la méthode (recommandée).

Retour

Valeur Description
Entier Zéro si la méthode donnée n'est pas valide ou n'est pas disponible ; différent de zéro dans le cas contraire.

Voir également

gdImageTrueColorToPaletteSetQuality

void gdImageTrueColorToPaletteSetQuality(gdImagePtr im, int min_quality, int max_quality);

Cette fonction permet de choisir un intervalle de qualité pour la quantification. Cette intervalle de qualité est utilisée dans tous les appels ultérieurs à gdImageTrueColorToPalette et gdImageCreatePaletteFromTrueColor si la méthode de quantification est GD_QUANT_LIQ.

Paramètres

Nom Description
im Ce paramètre permet d'indiquer l'image.
min_quality La qualité minimale est comprise entre 1 et 100 (1 = moche, 100 = parfait). Si la palette ne peut pas représenter l'image avec au moins min_quality, aucune conversion n'est effectuée.
max_quality La qualité maximale dans l'intervalle 1 à 100 (1 = moche, 100 = parfait), qui doit être supérieure à la qualité minimale. Si la palette peut représenter l'image avec une qualité supérieure à la qualité maximale, alors moins de couleurs que demandé seront utilisées.

gdImageCreatePaletteFromTrueColor

gdImagePtr gdImageCreatePaletteFromTrueColor(gdImagePtr im, int dither, int colorsWanted);

Cette fonction permet de créer une nouvelle image de palette à partir d'une image en vraies couleurs.

Paramètres

Nom Description
im Ce paramètre permet d'indiquer l'image.
dither Ce paramètre permet d'indiquer si le tramage doit être appliqué.
colorsWanted Le nombre d'entrées de palette souhaitées.

Retour

Valeur Description
Pointeur Une image de palette nouvellement créée ; NULL en cas d'échec.

Voir également

gdImageTrueColorToPalette

int gdImageTrueColorToPalette(gdImagePtr im, int dither, int colorsWanted);

Cette fonction permet de convertir une image en vraies couleurs en une image de palette.

Paramètres

Nom Description
im Ce paramètre permet d'indiquer l'image.
dither Ce paramètre permet d'indiquer si le tramage doit être appliqué.
colorsWanted Ce paramètre permet d'indiquer le nombre d'entrées de palette souhaitées.

Retour

Valeur Description
Entier Différent de zéro si la conversion a réussi, zéro sinon.

Voir également

Utilisation pratique

Voici comment utiliser les fonctions de quantification des couleurs dans LibGD, en partant de la conversion d'une image en couleur vraie (truecolor) vers une image avec palette (palette-based). Le processus implique la sélection d'une méthode de quantification, le réglage de la qualité et la conversion proprement dite.

Initialisation de la bibliothèque et création de l'image en couleur vraie

Avant de commencer à manipuler les fonctions de quantification, vous devez charger ou créer une image en couleur vraie (24 bits, 8 bits par composante de couleur). Voici comment créer une image en couleur vraie simple avec LibGD :

  1. #include <gd.h>
  2. #include <stdio.h>
  3.  
  4. int main() {
  5.     /* Créer une image en couleur vraie de 100x100 pixels */
  6.     gdImagePtr img = gdImageCreateTrueColor(100, 100);
  7.  
  8.     /* Définir quelques couleurs */
  9.     int red = gdImageColorAllocate(img, 255, 0, 0);
  10.     int green = gdImageColorAllocate(img, 0, 255, 0);
  11.     int blue = gdImageColorAllocate(img, 0, 0, 255);
  12.  
  13.     /* Dessiner un rectangle de couleur rouge */
  14.     gdImageFilledRectangle(img, 10, 10, 50, 50, red);
  15.  
  16.     /* Dessiner un rectangle de couleur verte */
  17.     gdImageFilledRectangle(img, 60, 10, 90, 50, green);
  18.  
  19.     /* Dessiner un rectangle de couleur bleue */
  20.     gdImageFilledRectangle(img, 10, 60, 50, 90, blue);
  21.  
  22.     /* Sauvegarder l'image pour visualisation (optionnel) */
  23.     FILE *out = fopen("output_truecolor.png", "wb");
  24.     gdImagePng(img, out);
  25.     fclose(out);
  26.  
  27.     /* Libérer la mémoire */
  28.     gdImageDestroy(img);
  29.  
  30.     return 0;
  31. }

Sélectionner la méthode de quantification

LibGD propose différentes méthodes de quantification des couleurs. Vous pouvez choisir celle correspondant le mieux à vos besoins. Voici comment sélectionner une méthode de quantification à l'aide de la fonction gdImageTrueColorToPaletteSetMethod :

  1. #include <gd.h>
  2. #include <stdio.h>
  3.  
  4. int main() {
  5.     /* Charger une image en couleur vraie (par exemple, une image préexistant) */
  6.     FILE *in = fopen("input_truecolor.png", "rb");
  7.     gdImagePtr img = gdImageCreateFromPng(in);
  8.     fclose(in);
  9.  
  10.     /* Sélectionner la méthode de quantification (par exemple, Median Cut) */
  11.     gdImageTrueColorToPaletteSetMethod(img, GD_QUANTIZE_MEDIAN_CUT);
  12.  
  13.     /* Sauvegarder l'image pour visualisation */
  14.     FILE *out = fopen("output_palette.png", "wb");
  15.     gdImagePng(img, out);
  16.     fclose(out);
  17.  
  18.     /* Libérer la mémoire */
  19.     gdImageDestroy(img);
  20.  
  21.     return 0;
  22. }

Choisir une plage de qualité pour la quantification

La fonction gdImageTrueColorToPaletteSetQuality permet d'ajuster la qualité de la quantification. Vous pouvez spécifier un facteur de qualité pour obtenir un meilleur compromis entre la taille du fichier et la fidélité des couleurs. Voici un exemple de réglage de la qualité de quantification :

  1. #include <gd.h>
  2. #include <stdio.h>
  3.  
  4. int main() {
  5.     /* Charger une image en couleur vraie */
  6.     FILE *in = fopen("input_truecolor.png", "rb");
  7.     gdImagePtr img = gdImageCreateFromPng(in);
  8.     fclose(in);
  9.  
  10.     /* Choisir un niveau de qualité pour la quantification (entre 0 et 100) */
  11.     gdImageTrueColorToPaletteSetQuality(img, 90);  // 90 pour une qualité élevée
  12.  
  13.     /* Sauvegarder l'image avec palette */
  14.     FILE *out = fopen("output_quality_palette.png", "wb");
  15.     gdImagePng(img, out);
  16.     fclose(out);
  17.  
  18.     /* Libérer la mémoire */
  19.     gdImageDestroy(img);
  20.  
  21.     return 0;
  22. }

Convertir l'image en couleur vraie en image avec palette

La fonction gdImageTrueColorToPalette effectue la conversion finale d'une image en couleur vraie vers une image avec une palette de couleurs réduite. Vous pouvez spécifier la taille de la palette (généralement 256 couleurs au maximum pour le format GIF ou PNG-8).

  1. #include <gd.h>
  2. #include <stdio.h>
  3.  
  4. int main() {
  5.     /* Charger l'image en couleur vraie */
  6.     FILE *in = fopen("input_truecolor.png", "rb");
  7.     gdImagePtr img = gdImageCreateFromPng(in);
  8.     fclose(in);
  9.  
  10.     /* Convertir l'image en couleur vraie en image avec palette */
  11.     gdImageTrueColorToPalette(img, 256);  /* Utilise une palette de 256 couleurs */
  12.  
  13.     /* Sauvegarder l'image avec palette */
  14.     FILE *out = fopen("output_converted_palette.png", "wb");
  15.     gdImagePng(img, out);
  16.     fclose(out);
  17.  
  18.     /* Libérer la mémoire */
  19.     gdImageDestroy(img);
  20.  
  21.     return 0;
  22. }

Finalisation et nettoyage

Assurez-vous de libérer la mémoire après chaque manipulation d'image avec la fonction gdImageDestroy. Cela est essentiel pour éviter les fuites de mémoire dans votre programme :

  1. gdImageDestroy(img);

Dernière mise à jour : Mardi, le 8 octobre 2024