ImageMagick Examples -- Quantification des couleurs et tramage

Préface et index des ImageMagick Examples

Introduction à la réduction des couleurs (ce qui est en jeu)

Les couleurs d'une image (quelles couleurs une image utilise)

• Extraire les couleurs d'une image

• Comparer deux couleurs

  Quantification des couleurs (réduire le nombre de couleurs d'une image)

• L'opérateur de quantification des couleurs

• Quantification des couleurs et espace colorimétrique
• La quantification ne préserve pas les couleurs

• Quantification des couleurs et transparence

  Tramage par correction d'erreur (ou tramage pseudo-aléatoire)

• Méthodes de tramage E-Dither

• Fonctionnement d'un E-Dither
• Le E-Dither est sensible aux changements
• Mouchetage de pixels par E-Dither
• Images bitmap monochromes tramées
• Quantification à deux couleurs
• Tramer à l'aide de tables de couleurs prédéfinies
• Table de couleurs commune ou « optimale »
• Utiliser les couleurs Web-Safe
• Tables de couleurs uniformes
• Table de couleurs uniforme 332
• Table de couleurs TrueColor 16 bits ou 556
• Tables de couleurs uniformes corrigées en gamma

• Postériser, recolorer à l'aide d'une table de couleurs uniforme

  Méthodes de tramage par seuil

• Images à seuil

• Tramage aléatoire avec seuillage

  Tramages à motifs ordonnés (à l'aide d'une carte de seuils en mosaïque)

• Tramage par diffusion de pixels

• Tramages en similigravure numérique
• Tramage en similigravure avec décalage
• Cartes de seuils XML
• Tramage ordonné avec niveaux de couleurs uniformes

• Améliorer les résultats du tramage ordonné

  Motifs de tramage et cartes de seuils DIY (tramer les images à votre manière)

• Motifs de tramage bitmap multi-images

• Cartes de seuils de tramage ordonné DIY
• Tramage DIY par lignes horizontales
• Tramer avec des motifs de symboles

Réduire le nombre de couleurs ou remplacer des couleurs précises est une étape très complexe et difficile du traitement d'images ; c'est le sujet abordé dans ces pages d'exemples. Cela comprend la détermination des couleurs à utiliser (quantification des couleurs) et la façon de placer ces couleurs sur l'image (tramage et création de motifs). Cela comprend aussi la génération d'images bitmap ou à deux couleurs, et même la gestion de la transparence booléenne (activée/désactivée). C'est si important que la réduction ou la quantification des couleurs se produit souvent automatiquement et en coulisses, simplement pour qu'ImageMagick puisse accomplir sa tâche première : convertir des images d'un format de fichier vers un autre format moins riche en couleurs, comme les formats GIF, XPixmap et XBitmap. Savoir comment cela fonctionne vous permet de mieux maîtriser le processus, afin d'améliorer l'image obtenue enregistrée dans un format de fichier donné.

Introduction à la réduction des couleurs

La réduction des couleurs est un aspect très important d'ImageMagick. Par exemple, pour convertir une image JPEG ou PNG contenant des millions de couleurs en une image GIF contenant au maximum 256 couleurs, il faut vraiment être capable de réduire les couleurs de façon efficace et pertinente. Souvent, lors d'une conversion de format d'image, cela se produit automatiquement en coulisses, mais il arrive que vous vouliez le faire manuellement. Réduire le nombre de couleurs d'une image est généralement un processus en trois étapes,

1. D'abord, il faut généralement examiner les couleurs utilisées par une image. Non seulement pour voir combien de couleurs sont réellement utilisées, mais aussi à quelle fréquence une couleur donnée l'est. Il ne sert à rien de préserver une couleur précise si un seul pixel l'utilise, même s'il faut parfois quand même le faire.
2. Ensuite, il faut décider d'une manière ou d'une autre de l'ensemble final de couleurs auquel vous voulez limiter votre image. Vous pouvez souhaiter qu'IM tente de déterminer le « meilleur » ensemble de couleurs pour une image donnée. D'autres fois, vous voudrez quelque chose de plus général et global applicable à n'importe quelle image. Vous pouvez même vouloir ajouter ou retirer précisément une couleur de l'ensemble des couleurs qui seront utilisées.
3. Et enfin, il faut modifier l'image de manière à n'utiliser que les couleurs sélectionnées. De préférence, vous voulez que le résultat ait un bon rendu, ou peut-être qu'il se compresse, se compare ou s'optimise bien.

Pour compliquer encore les choses, ces étapes sont souvent liées entre elles, car une méthode de remplacement des couleurs ne peut souvent s'appliquer qu'avec des ensembles de couleurs précis. Et si vous utilisez un ensemble de couleurs donné, faire un relevé des couleurs n'est pas nécessaire, ou peut-être devez-vous faire des exceptions pour des couleurs précises. Fondamentalement, même si la réduction des couleurs est souvent gérée automatiquement en coulisses, il est bon d'être au moins conscient de ce qui se passe et de ses effets.

Relevé des couleurs

C'est probablement l'étape la moins importante et, même si IM vous offre des méthodes pour effectuer un relevé, les utilisateurs le font rarement dans le but de réduire les couleurs. Je réserve toute discussion plus approfondie à la section concernée, Extraire les couleurs d'une image.

Sélection des couleurs (quantification)

Pour un bon aperçu initial, voir Wikipedia, Color Quantization. Il existe quatre méthodes fondamentales pour la sélection des couleurs. Ces quatre méthodes de contrôle des couleurs — Quantification, Table de couleurs prédéfinie, Couleurs uniformes et Seuil — ont toutes leurs limites, comme vous le verrez. Voici un exemple de chacune de ces quatre méthodes...

  magick colorwheel.png +dither    -colors 32          color_quantize.gif
  magick colorwheel.png +dither -remap colortable.gif  color_predefined.gif
  magick colorwheel.png +dither   -posterize 3         color_uniform.gif
  magick colorwheel.png \
                  -separate -threshold 50% -combine     color_threshold.gif

Le nombre de couleurs dans chacune des images finales n'est qu'un ensemble représentatif, mais approximativement 32 couleurs dans chaque cas (sauf pour le seuil qui n'en a que 8). Cela vous donne une idée de ce que vous pouvez attendre de chacune. Toutes les autres méthodes disposent d'un ensemble fixe de couleurs (selon l'argument de l'opérateur) quelle que soit l'image dont on réduit les couleurs. Seule la première méthode (« [-colors](https://imagemagick.org/command-line-options/#colors) ») choisira réellement les couleurs en fonction du contenu de l'image courante. Comme l'image de test est majoritairement blanche, beaucoup de couleurs claires sont sélectionnées. Elle relève les couleurs d'une image à l'aide d'une technique dite « Adaptive Spatial Subdivision » utilisant des oct-trees. Puis elle tente de choisir un ensemble de couleurs précis correspondant au mieux à une image donnée, dans les limites indiquées. Voir L'opérateur de quantification des couleurs ci-dessous. « [-remap](https://imagemagick.org/command-line-options/#remap) » vous permet de fournir à IM votre propre ensemble de couleurs prédéfinies (voir Tables de couleurs définies par l'utilisateur). La table de couleurs « [colortable.gif](../static/img/images/colortable.gif) » utilisée ci-dessus est un ensemble de 32 couleurs choisies spécifiquement pour une ancienne X Window Icon Library et conçue pour des icônes de type dessin animé. (Voir AIcon Library, X Icon Color Selection pour les détails.) « [-posterize](https://imagemagick.org/command-line-options/#posterize) » peut aussi diviser mathématiquement chaque canal de couleur en un ensemble de niveaux ou d'intensités, produisant une « table de couleurs uniforme ». C'est-à-dire une table de couleurs dont chaque canal est fixé à un ensemble constant de valeurs ou d'intensités. Et enfin, « [-threshold](https://imagemagick.org/command-line-options/#threshold) » peut s'appliquer à tous les canaux de couleur de l'image ou à certains d'entre eux, rendant chaque canal de couleur purement booléen, c'est-à-dire activé/désactivé. Autrement dit, chaque canal de couleur peut recevoir une valeur de zéro ou de MaxRGB (selon le niveau « Q » d'IM). Cela ne produit toutefois qu'un ensemble minimal d'environ 8 couleurs. Un ensemble de couleurs très limité. Le seuil équivaut aussi à un « [-posterize](https://imagemagick.org/command-line-options/#posterize) » de niveau « 1 » qui choisit 2 couleurs.

Appliquer un ensemble de couleurs

Une fois que vous disposez d'un ensemble de couleurs, le problème suivant est d'appliquer les couleurs à une image de sorte que les couleurs existantes soient remplacées par l'ensemble de couleurs sélectionné. Cela s'appelle le « tramage » (dithering), ainsi nommé en raison de sa nature d'alternative, « dois-je choisir ceci, ou dois-je choisir cela ? ». Fondamentalement, l'idée du tramage est de placer des pixels de couleurs différentes les uns près des autres de manière à tromper l'œil et lui faire percevoir plus de couleurs dans l'image qu'il n'en est réellement utilisé. Autrement dit, la couleur dans cette zone de l'image correspond plus étroitement à la couleur d'origine, en raison de la façon dont l'œil humain « fusionne » les couleurs voisines. L'une des meilleures introductions au tramage se trouve sur Wikipedia, bien qu'il faille passer la section « Audio Dithering » du début. Elle présente un excellent ensemble d'exemples des avantages d'un motif de pixels tramé lorsque l'on dispose d'un nombre limité de couleurs. Les styles fondamentaux de remplacement des couleurs comprennent...

• Mappage direct des couleurs (seuil et postérisation)
• Tramage aléatoire (placement purement aléatoire des pixels)
• Tramages par correction d'erreur (motifs de pixels pseudo-aléatoires)
• Tramage ordonné par diffusion de pixels (motifs réguliers de pixels)
• Similigravure numérique (points de tailles différentes)

Le mappage direct vers la couleur la plus proche d'un ensemble donné correspond à ce qui a été montré ci-dessus. Fondamentalement, vous obtenez des zones distinctes de couleurs unies et invariables. Appliqué à une image dont la couleur varie lentement, comme une photo réelle de ciel, on obtient des bandes de couleurs sur l'image, en particulier dans ce qui serait autrement un dégradé de couleurs régulier, comme dans les zones de ciel. Le résultat est généralement considéré comme médiocre. Le seul cas où le mappage direct des couleurs est habituellement jugé acceptable concerne les logos, symboles, icônes et images de type dessin animé. Ce n'est en réalité que rarement une option. C'est pourquoi il faut généralement désactiver la méthode de tramage normale si vous ne voulez pas mapper directement les couleurs de vos images. Le tramage a cependant son propre problème. Une fois qu'une image est tramée, un motif de couleurs fait partie de l'image. Une fois qu'un tel motif est présent, il est extrêmement difficile à retirer. De plus, il est généralement déconseillé de retramer une image plusieurs fois, car cela ne fait que la dégrader. Pour cette raison, la plupart des exemples de quantification ci-dessous vous montreront en général comment créer des versions non tramées pour chaque technique. C'est fait ainsi pour que vous puissiez voir quelles sélections de couleurs sont effectuées avant que le tramage ne masque cette information. Le tramage aléatoire est la méthode de tramage la plus simple qui ait été créée. Elle est aussi considérée comme la pire méthode de tramage possible. Elle a toutefois quelques usages particuliers. Dans IM, elle ne fonctionne qu'avec deux couleurs, elle est donc habituellement réservée au cas particulier du tramage bitmap. Pour en savoir plus, voir Tramage aléatoire avec seuil ci-dessous. Le tramage par correction d'erreur est généralement considéré comme la meilleure méthode générale de tramage des couleurs sur les images, car il produit l'approximation la plus proche de la couleur d'origine des zones de l'image. C'est aussi actuellement la seule méthode capable de tramer n'importe quel ensemble de couleurs, et à ce titre elle peut servir pour les quatre techniques de réduction des couleurs. Voir Fonctionnement des E-Dithers ci-dessous pour plus de détails. Le tramage par correction d'erreur présente toutefois de sérieux problèmes, notamment en ce qui concerne les animations d'images. Les deux dernières techniques de tramage, la diffusion ordonnée de pixels et la similigravure numérique, sont aussi considérées comme de bonnes méthodes qui fonctionnent bien pour les animations, mais elles ne peuvent actuellement pas utiliser n'importe quel ensemble de couleurs, seulement un ensemble fixe de couleurs uniformes. Elles fournissent un moyen de colorer une image à l'aide de motifs, ce qui vous permet de produire des effets intéressants qu'il ne serait pas facile de produire autrement.
Tous ces aspects de la réduction des couleurs sont des techniques importantes et, avec de la compréhension, vous pouvez améliorer les résultats de vos opérations sur les images, au-delà des valeurs par défaut générales fournies par IM. Cela vaut vraiment la peine de les étudier.

Les couleurs d'une image

Les informations sur les images, comme le nombre de couleurs utilisées et leur répartition globale, peuvent être très importantes pour les programmes et les scripts qui tentent de décider des meilleures techniques à employer. J'examine ici quelques méthodes utilisables pour déterminer ce type d'information, et pas uniquement pour la réduction des couleurs.

Extraire les couleurs d'une image

Extraire la table de couleurs

Vous extrayez une palette de couleurs d'une image à l'aide d'un « [identify](basics.html#identify) » verbeux, en utilisant l'une de ces méthodes qui font toutes exactement la même chose.

  magick identify -verbose  image.png
  magick image.png miff:- | identify -verbose -
  magick image.png  -verbose -identify null:
  magick image.png  -verbose info:

| La sortie de n'importe laquelle des identifications verbeuses ci-dessus ne renverra pas les tables de couleurs ni l'histogramme s'il y a plus de 1024 couleurs ! Ainsi, pour les grandes images colorées, c'est une affaire de chance et ce n'est pas recommandé, même si cela peut rester utile.
---|---
La meilleure façon consiste toutefois à générer un « [histogram:](files.html#histogram) » de l'image et à extraire le commentaire inclus dans le résultat. | |

  magick tree.gif  -format %c  -depth 8  histogram:info:-

|

| Le format de sortie « info: » a été ajouté à IM v6.2.4. Pour les versions d'IM antérieures, utilisez.. |

  magick tree.gif histogram:- | identify -depth 8 -format %c -

Le problème avec ces méthodes est qu'on vous donne une sortie en texte brut des couleurs, que vous devrez analyser selon vos propres besoins. Cependant, depuis IM v6.2.8-8, l'opérateur « [-unique-colors](https://imagemagick.org/command-line-options/#unique-colors) » convertit une image en une image plus petite ne contenant qu'un pixel par couleur unique trouvée dans l'image d'origine, le tout sur une seule ligne. Cela signifie que vous pouvez convertir une image en une image de table de couleurs plus simple, listant chaque couleur présente. La largeur de l'image renvoie le nombre de couleurs et, si vous devez réellement lister les couleurs, vous pouvez la sortir dans un format d'image « [txt:](files.html#txt) ». Par exemple, voici la table de couleurs de l'image de l'arbre. |

  magick tree.gif -unique-colors -scale 1000%  tree_colors.gif
  magick tree.gif -unique-colors -depth 16  txt:-

Cette table de couleurs réduite est aussi très importante comme moyen de stocker une table de couleurs générée dans un très petit fichier. De telles tables sont particulièrement importantes pour l'opérateur de réduction des couleurs « [-remap](https://imagemagick.org/command-line-options/#remap) ». (Voir Tables de couleurs prédéfinies ci-dessous.) Si vous souhaitez obtenir une image contenant non seulement les couleurs d'une image mais aussi le nombre d'occurrences de chaque couleur, voici une solution d'histogramme de couleurs élaborée à partir d'une discussion sur le forum IM.

  magick rose: -colors 256 -format %c histogram:info:- |
    sed 's/:.*#/ #/' |
      while read count color colorname; do
        magick -size 1x$count xc:$color miff:-
      done |
        magick - -alpha set -gravity south -background none +append \
                unique_color_histogram.png

Extraire la couleur moyenne

La couleur moyenne d'une image se trouve très rapidement en utilisant « [-scale](https://imagemagick.org/command-line-options/#scale) » pour réduire une image à un seul pixel. Voici par exemple la couleur moyenne de l'image « rose: » intégrée. Je sors la couleur au moyen du format d'échappement FX qui renvoie une chaîne de couleur utilisable directement dans IM sans modification.

  magick rose: -scale 1x1\! -format '%[pixel:s]' info:-

Le problème avec l'échappement FX « %[pixel:...] » est qu'il peut renvoyer un nom de couleur comme « white » ou « silver » au lieu d'une valeur RVB. Vous pouvez toutefois simuler cela en utilisant trois échappements FX pour renvoyer les valeurs RVB réelles à la profondeur de bits souhaitée. Par exemple...

  magick rose: -scale 1x1\! \
     -format '%[fx:int(255*r+.5)],%[fx:int(255*g+.5)],%[fx:int(255*b+.5)]' info:-

Depuis IM v6.3.9, il existe un certain nombre de nouveaux échappements « [-format](https://imagemagick.org/command-line-options/#format) » utiles pour extraire des informations plus précises sur les images sans avoir à analyser une sortie « [identify](basics.html#identify) » ou « [info:](files.html#info) » verbeuse. Par exemple, vous pouvez obtenir la couleur moyenne du canal rouge en récupérant la valeur en niveaux de gris « %[mean] » de l'image du canal rouge de l'image.

  magick rose: -channel R -separate -format '%[mean]' info:

Extraire une couleur précise

En ligne de commande, il existe deux façons fondamentales d'extraire la couleur d'un pixel précis d'une image. Soit utiliser un échappement FX comme « %[pixel:...] » ou « %[fx:...] » (voir ci-dessus) sur un emplacement de pixel précis...

  magick rose: -format '%[pixel:p{40,30}]' info:-

Vous pouvez sinon simplifier l'image en utilisant « [-crop](https://imagemagick.org/command-line-options/#crop) » pour découper un seul pixel qui vous intéresse, et employer l'une des méthodes précédentes. Par exemple...

  magick rose: -crop 1x1+40+30 -depth 8 txt:-

Compter une couleur précise (ou proche)

Cela peut servir à obtenir le nombre de pixels ou le pourcentage d'une couleur précise. Ce que vous faites, c'est rendre noir tout ce qui n'est pas cette couleur, puis rendre cette couleur blanche. Par exemple, obtenons le nombre de couleurs du soleil « yellow » dans l'image « tree ».

  magick tree.gif -fill black +opaque yellow \
                   -fill white -opaque yellow \
                   -print "yellow sun pixels = %[fx:w*h*mean]\n"   null:

Il y a une réserve : cela ne fonctionnera pas si la couleur testée est elle-même noire. Pour gérer le noir (ou des couleurs très sombres), inversez les remplissages afin de mapper les couleurs non noires vers le blanc, puis négativez le résultat pour générer le masque blanc de tous les pixels noirs. N'oubliez pas que l'option « [-print](https://imagemagick.org/command-line-options/#print) » équivaut à utiliser « -format ... -write info: » et peut être employée n'importe où dans votre traitement d'image. J'ai ensuite jeté l'image indésirable en utilisant le format de fichier spécial « [null:](files.html#null) ». Vous pouvez aussi enregistrer l'image pour l'utiliser comme masque dans un travail ultérieur. Notez que si cela fonctionne bien pour de petites images, avec des images beaucoup plus grandes (comme des photos numériques haute résolution), la « mean » ne sera pas assez précise pour obtenir un décompte exact de pixels ! Fondamentalement, l'usage de la « mean » ci-dessus convient pour générer un ratio, mais pas pour un décompte exact de pixels. Pour obtenir un décompte exact de pixels, il vaut mieux utiliser une sortie de « commentaire » d'histogramme qui comporte les décomptes exacts de pixels (voir ci-dessus). Ce qui précède peut aussi utiliser une option de facteur de flou (Fuzz) « [-fuzz](https://imagemagick.org/command-line-options/#fuzz) » avant l'opérateur « [-opaque](https://imagemagick.org/command-line-options/#opaque) » pour préciser également les couleurs « proches ».

Comparer deux couleurs

Vous avez donc deux couleurs précises et vous voulez les comparer. Vous pouvez utiliser « magick compare » pour obtenir la RMSE (sur l'erreur standard)...

  magick compare -metric RMSE xc:Navy xc:blue null:

C'est utile car cela vous donne la distance entre les deux couleurs, à la fois en valeurs et en pourcentage normalisé de la distance du noir au blanc. Cette méthode ne gère toutefois pas correctement la transparence. Par exemple, comparer un « noir entièrement transparent » à un « blanc entièrement transparent ».

  magick compare -metric RMSE xc:'#0000' xc:'#FFF0' null:

Les couleurs transparentes devraient en réalité avoir une distance nulle, car un « entièrement transparent » est identique quelle que soit la couleur sous-jacente. À la place, nous avons obtenu une distance d'hypercube en 4 dimensions). Ainsi, la méthode de distance de couleur ci-dessus ne convient que pour comparer des couleurs entièrement opaques.
Plutôt que d'obtenir une distance réelle, vous pouvez aussi utiliser un facteur de flou (Fuzz) pour vérifier si deux couleurs sont proches.

  magick compare -fuzz 20% -metric AE xc:Navy xc:Blue null:
  magick compare -fuzz 30% -metric AE xc:Navy xc:Blue null:

N'oubliez pas cependant que le résultat sera « 1 » si les pixels ne correspondent pas (nombre de pixels en erreur). Pour obtenir la distance réelle du facteur de « flou » qui sépare les valeurs, vous pouvez utiliser la métrique « FUZZ ».

  magick compare -metric FUZZ xc:Navy xc:Blue null:

La valeur « normalisée » montre que la distance réelle est de 28,7 %. Utiliser le facteur de flou (Fuzz) diffère du calcul de la RMSE lorsque la transparence est en jeu. En effet, le facteur de flou est conçu de sorte que deux couleurs entièrement transparentes soient traitées comme égales. Ainsi, un « noir entièrement transparent » et un « blanc entièrement transparent » sont exactement équivalents (produisant une valeur de 0, soit aucun pixel en erreur)...

  magick compare -metric FUZZ xc:'#0000' xc:'#FFF0' null:

Une autre méthode de comparaison de couleurs consiste à tenter de remplacer les couleurs avec un pourcentage de facteur de flou (Fuzz) approprié. Par exemple...

  magick xc:Navy  -fuzz 20% -fill Blue -opaque Blue txt:

Comme « Navy » n'a pas changé en « Blue », il diffère de plus de 20 % de « Blue ». Alors que

  magick xc:Navy  -fuzz 30% -fill Blue -opaque Blue txt:

Ceci a bien changé la couleur en « Blue », donc nous savons maintenant que « Navy » se situe entre 20 % et 30 % de distance l'un de l'autre. Pour faire cela dans un script, utilisez quelque chose comme...

  fuzz=%1
  color1="red"
  color2="#e00"

  color2=`magick xc:"$color2" -format '%[pixel:s]' info:`
  result=`magick xc:"$color1" -alpha set -channel RGBA -fuzz $fuzz \
            -fill $color2 -opaque $color2 -format '%[pixel:s]' info:`
  if [ "$result" = "$color2" ]; then
    echo "Colors match according to Fuzz Factor"
  else
    echo "Colors DO NOT match"
  fi

Les options spéciales « -alpha set -channel RGBA » sont importantes pour nous permettre la correspondance floue des couleurs transparentes et quasi transparentes.

Quantification des couleurs

Opérateur de quantification des couleurs

Le principal outil de la quantification des couleurs, et ce qui est utilisé en interne pour toute réduction automatique des couleurs, est l'opérateur « [-colors](https://imagemagick.org/command-line-options/#colors) ». Il implémente un algorithme de réduction des couleurs par « subdivision spatiale adaptative » (Adaptive Spatial Subdivision), et c'est un algorithme de réduction des couleurs extrêmement bon. Voici un exemple typique : nous disposons d'une image de « roue chromatique » contenant beaucoup de couleurs, et nous demandons à IM de réduire le nombre de couleurs à seulement 64, en utilisant diverses méthodes de tramage.

  magick colorwheel.png  -dither None       -colors 64  colors_64_no.gif
  magick colorwheel.png  -dither Riemersma  -colors 64  colors_64_rm.gif
  magick colorwheel.png  -dither FloydSteinberg \
                                             -colors 64  colors_64_fs.gif

Par défaut, IM utilise un « tramage » pour nuancer les couleurs sur l'image. Cela évite les changements brusques de couleur dans les dégradés progressifs. Si le tramage est désactivé (avec « None » ou un réglage « [+dither](https://imagemagick.org/command-line-options/#dither) »), on voit clairement quelles couleurs ont été fusionnées pour produire ce qu'IM a considéré comme le meilleur jeu de couleurs pour cette image précise. On voit aussi les changements de couleur brusques que produiraient les dégradés si le tramage n'était pas effectué. Bien entendu, cette image utilise beaucoup plus de couleurs que la plupart des images. Ainsi, si une limite de 64 couleurs est souvent acceptable pour beaucoup d'images, elle est totalement inacceptable pour celle-ci. Autrement dit, la quantification des couleurs cherche à trouver le meilleur jeu de couleurs pour une image donnée. Voici un exemple de quantification des couleurs pour une partie du logo IM, en utilisant un nombre de couleurs extrêmement réduit.

  magick logo: -resize 40% -crop 100x100+105+50\! -normalize  logo.png
  magick logo.png  +dither             -colors 8  colors_8_no.gif
  magick logo.png  -dither Riemersma   -colors 8  colors_8_rm.gif
  magick logo.png  -dither FloydSteinberg \
                                        -colors 8  colors_8_fs.gif

Comparez cela avec quelques résultats obtenus pour l'image photo intégrée « rose: ».

  magick rose: +dither             -colors 16 colors_16_no.gif
  magick rose: -dither Riemersma   -colors 16 colors_16_rm.gif
  magick rose: -dither FloydSteinberg \
                                     -colors 16 colors_16_fs.gif

Comme on peut le voir, les images de type dessin animé nécessitent bien moins de couleurs qu'une véritable photographie pour produire un résultat correct. | _Un seul algorithme de quantification des couleurs, la « subdivision spatiale adaptative », est actuellement implémenté dans IM, et comme il fonctionne très bien, il y a eu peu de besoin d'en ajouter d'autres. Toutefois, grâce aux retours, cet algorithme est progressivement amélioré.

INCISE : à titre de référence, le programme « [Gifsicle](http://www.lcdf.org/gifsicle/) » liste un certain nombre d'autres méthodes de quantification des couleurs (via son option « --color-method »). Je n'ai aucune idée de la façon dont ces méthodes de quantification se comparent à IM. Si vous trouvez une bonne référence sur les différentes méthodes de quantification des couleurs, merci de me l'envoyer par courriel._
---|---

Rouages internes de la quantification des couleurs

Le processus de sélection du nombre limité de couleurs à utiliser dans une image s'appelle la quantification des couleurs (Color Quantization), et c'est un processus très complexe faisant intervenir de nombreux facteurs. Une description technique complète en est donnée sur le site web d'ImageMagick, Color Reduction Algorithm. J'essaierai toutefois d'illustrer ici certains des aspects les plus importants. Le plus grand facteur est probablement les couleurs réellement utilisées dans une image. Il ne sert à rien de choisir une couleur particulière pour une image s'il y a très peu de pixels « proches » de cette couleur. Ainsi, le choix des couleurs dépend non seulement des couleurs utilisées dans une image, mais aussi du nombre de pixels « proches » de la couleur. Je peux le démontrer assez facilement en tentant de réduire deux images bicolores différentes à une seule couleur commune.

  magick -size 4x1 xc:blue -draw 'fill red   point 0,0' \
                                                -scale 20 colors_rb.gif
  magick -size 4x1 xc:red   -draw 'fill blue point 3,0' \
                                                -scale 20 colors_br.gif
  magick colors_rb.gif  -colors 1  colors_rb2.gif
  magick colors_br.gif  -colors 1  colors_br2.gif

Comme on peut le voir, l'unique couleur finale dépend non seulement des couleurs présentes, mais aussi de la quantité de chaque couleur dans l'image.

  magick -size 20x640  gradient: -rotate 90  gradient.png
  magick gradient.png   +dither  -colors 5   colors_gradient.gif

Notez que la quantification des couleurs est uniforme, au sein de l'espace colorimétrique courant.

FUTURE: Just what are the effects of the "[-treedepth](https://imagemagick.org/command-line-options/#treedepth)"  setting?
Mail me if you know

Quantification des couleurs et espace colorimétrique

L'autre grande influence sur les couleurs sélectionnées est la définition exacte de ce qu'on entend par des couleurs « proches » ou « voisines ». Cela est défini par l'espace colorimétrique utilisé pour la quantification (sélection des couleurs), et est (depuis IM v6.2.8-6) contrôlé par le réglage d'espace colorimétrique « [-quantize](https://imagemagick.org/command-line-options/#quantize) ». Le réglage « [-quantize](https://imagemagick.org/command-line-options/#quantize) » devient particulièrement important lorsqu'un très petit nombre de couleurs est choisi. Pour le démontrer, réduisons une image standard de « colorwheel » en utilisant différents espaces colorimétriques et en définissant différentes « distances de couleur ».

  for S in    RGB CMY sRGB GRAY \
              XYZ LAB LUV  \
              HSL HSB HWB  \
              YIQ YUV OHTA ; do \
     magick colorwheel.png   -quantize $S   +dither -colors 16 \
             -fill black -gravity SouthWest -annotate +2+2 $S \
             colors_space_$S.gif; \
  done

Comme on peut le voir, les couleurs choisies dépendent fortement de l'organisation de l'espace colorimétrique. Le cube colorimétrique sRGB (Rouge, Vert, Bleu) aboutira généralement à ce qu'au moins les couleurs proches des couleurs primaires soient retenues. L'espace colorimétrique sRGB est particulièrement bon pour choisir des couleurs d'images de type dessin animé et d'icônes, mais est en réalité un mauvais espace colorimétrique pour les photos réalistes en général. L'espace colorimétrique CMY est exactement identique à l'espace colorimétrique sRGB, car les canaux de couleur sont simplement inversés pour passer entre les espaces colorimétriques sRGB et CMY. Ainsi, les couleurs de quantification aboutissent à peu près à la même solution. | _L'espace colorimétrique CMYK (non illustré) produit également le même résultat, mais pour des raisons différentes. Comme, en interne, le canal « K » et la « palette de couleurs » (colormap) d'une image utilisent le même pointeur de données (voirPalette Channel), IM le reconvertit en CMY avant la quantification.

---|---
L'espace colorimétrique sRGB produit, comme attendu, un résultat similaire au RGB, mais est déformé de façon à réduire le nombre de couleurs proches du noir dans l'espace colorimétrique. Il y a donc moins de couleurs disponibles pour le centre de la roue chromatique, produisant une tache « pas tout à fait aussi noire » plus grande. L'espace colorimétrique XYZ est lui aussi très très similaire à l'espace colorimétrique RGB linéaire. La grande différence ici est que les axes de couleur ont été décalés afin de mieux contenir TOUTES les couleurs possibles que nous pouvons (et même des couleurs que nous ne pouvons normalement pas) voir ; ainsi, les données de couleur de la roue chromatique sont un peu plus comprimées, et par conséquent les quantifications semblent s'étaler davantage. Les espaces colorimétriques LAB et LUV reposent sur des axes de couleur différents mais similaires entre eux. Cela aboutit à un arrangement différent des quantifications de couleurs. Les espaces colorimétriques particuliers faisant intervenir un canal de « teinte » (Hue), tels que HSL (Teinte, Saturation, Luminosité), HSL (Teinte, Saturation, Brillance) et HWB (Teinte, Blanc, Noir), possèdent tous une représentation cyclique en roue chromatique de la couleur dans leur espace colorimétrique. C'est d'ailleurs un espace colorimétrique HSL qui a été utilisé pour générer cette roue chromatique. Voir Generating a Colorwheel. | _Au moment de la rédaction, l'algorithme de distance de couleur qu'utilise IM ne tient pas compte de la nature cyclique de la « teinte » de l'espace colorimétrique. L'algorithme pour cela est très différent. À cause de cela, une forte discontinuité se produit le long du chemin « rouge », là où la « teinte » boucle, ce qui fait que très peu de couleurs rouges sont sélectionnées lors du processus de quantification des couleurs.
---|---
Les espaces YIQ et YUV sont conçus pour produire des nuances de couleurs « pastel » et « demi-teinte » plus naturelles, bien mieux adaptées aux photographies et aux images du monde réel faisant intervenir des nuances subtiles de couleurs, et en particulier les teintes de peau. Helmut Dersch note sur son site web qu'il faut envisager d'utiliser un espace colorimétrique LAB pour les distorsions. | _Dans les anciennes versions d'IM (précisément IM version 5), l'espace colorimétrique utilisé pour la quantification était défini avec l'option « [-colorspace](https://imagemagick.org/command-line-options/#colorspace) ». Toutefois, dans IM version 6, cet opérateur sert à modifier la manière dont les images sont stockées en mémoire, et n'est donc pas un réglage pour la quantification des couleurs.

C'est pourquoi, dans IM v6.2.8-6, le réglage « [-quantize](https://imagemagick.org/command-line-options/#quantize) » a été fourni pour accomplir cette tâche. Il ne s'agit toutefois que d'un réglage pour le processus de quantification des couleurs de « [-colors](https://imagemagick.org/command-line-options/#colors) ». Il ne fera rien pour le remplacement et le tramage des couleurs à l'aide d'opérateurs tels que « [-remap](https://imagemagick.org/command-line-options/#remap) » et « [-posterize](https://imagemagick.org/command-line-options/#posterize) », ni pour les diverses techniques de tramage._
---|---
Pour une liste complète des espaces colorimétriques disponibles, voir l'opérateur « [-colorspace](https://imagemagick.org/command-line-options/#colorspace) ». On peut voir davantage d'effets de l'espace colorimétrique sur la sélection des couleurs en consultant les exemples sur Random Spots of Solid Color. Là, la quantification des couleurs est utilisée pour réduire le nombre de couleurs dans une image aléatoire en utilisant divers espaces colorimétriques. La quantification ne préserve PAS les couleursNotez que dans toutes les images ci-dessus, une couleur noir pur n'est jamais réellement choisie par la quantification des couleurs. Cela dit, il n'y a qu'un seul pixel noir pur, et de toute façon peu de couleurs proches du noir dans l'image. Par conséquent, le seul noir qui apparaît dans l'image finale a été ajouté plus tard dans le cadre de l'étiquetage de l'image. Même l'image de l'espace colorimétrique « GRAY » n'a pas produit de couleur noir pur. En fait, aucune des images ne contient de couleurs primaires ou secondaires, telles que : rouge, bleu, vert, cyan, magenta ! La seule exception est le blanc, car les images contenaient une bonne quantité de blanc pur, ce qui en fait une « couleur préférée » (voir ci-dessous). Cette situation n'est cependant pas un bogue ! Premièrement, une couleur « black » n'a généralement pas été sélectionnée dans les exemples ci-dessus, habituellement parce qu'il y a très peu de noir dans l'image d'origine, si bien que la quantification des couleurs ne s'est généralement pas trop souciée des couleurs sombres. En fait, elle a généré davantage de couleurs claires, car celles-ci sont plus courantes dans l'image. Voir la section précédente pour un exemple précis. Deuxièmement, comme la quantification tente de choisir des couleurs proches du nombre maximal de pixels de couleur existants dans une image, cela est mieux réalisé en NE faisant PAS correspondre une couleur primaire ou secondaire « pure », car celles-ci se situent toujours aux extrémités mêmes de l'espace colorimétrique utilisé. Une couleur « décalée » aura tendance à correspondre à plus de couleurs qu'une couleur « primaire », c'est pourquoi ces dernières sont plus souvent sélectionnées. Soyons donc clairs... **La quantification des couleurs (« ** -colors ») évitera généralement de choisir des couleurs primaires !

Depuis IM version 6.3, la fonction de quantification des couleurs a été modifiée pour tenter d'inclure les couleurs très fréquentes dans l'image d'origine. Ainsi, si une image contient une zone d'une seule couleur (comme le « white » ci-dessus), cette couleur sera généralement incluse dans la palette de couleurs finale. Cela améliore quelque peu la situation, en particulier pour les images de type « dessin animé » ou les images sur fond de couleur unie. La couleur « unie » sera généralement choisie afin d'aider à éviter les mouchetures de tramage que nous examinerons ci-dessous. Solutions pour une couleur précise dans la palette Pour l'instant, il n'existe que quelques façons de garantir qu'une « couleur précise » soit incluse dans les couleurs sélectionnées en vue d'un tramage ultérieur. Une façon consiste à quantifier l'image normalement, puis à extraire la palette de couleurs générée (avec « [-unique-colors](https://imagemagick.org/command-line-options/#unique-colors) »). Vous pouvez ensuite ajuster cette palette pour que votre couleur précise soit réellement cette couleur-là. Enfin, vous pouvez utiliser l'opérateur Remap Colors pour tramer l'image à l'aide de la palette fournie. La palette peut ne plus être la MEILLEURE pour l'image, et quelques autres couleurs devraient probablement aussi être ajustées, mais elle sera proche de la palette que vous vouliez. Autre solution : ajouter par juxtaposition (en agrandissant l'image) de grandes plages des couleurs précises que vous souhaitez préserver dans l'image, avant d'utiliser « [-colors](https://imagemagick.org/command-line-options/#colors) ». L'ajout d'un grand « échantillon » (swatch) d'une couleur précise rendra cette couleur plus susceptible d'être choisie dans la palette de couleurs finale. De plus, toutes les autres couleurs seront alors automatiquement ajustées pour mieux correspondre à cette palette. Si cela fonctionne, les échantillons de couleurs que vous avez ajoutés devraient rester inchangés (non tramés). Ensuite, vous pouvez recadrer l'image pour retirer les échantillons ajoutés. Si cela ne fonctionne pas, IM devrait au moins avoir ajouté une couleur proche de la « couleur précise » voulue, de sorte que seul un léger ajustement de la palette générée soit nécessaire avant d'appliquer Remap Colors à l'image d'origine. Si vous essayez cela, que ce soit un succès ou un échec, merci de me faire savoir comment cela s'est passé pour vous. Idéalement, ce que j'aimerais voir, c'est un moyen de spécifier un petit nombre de couleurs précises qui doivent faire partie de la palette de couleurs finale, puis de demander d'une manière ou d'une autre à IM de choisir les meilleures couleurs pour le reste de la palette, pour une image donnée.

Quantification des couleurs et transparence

Par défaut, ImageMagick ne génère pas seulement des couleurs totalement opaques, il tente aussi de générer des couleurs semi-transparentes. Ainsi, les images contenant des ombres transparentes ou d'autres effets de superposition ne perdront pas ces effets. Toutefois, depuis IM v6.2.6, la quantification des couleurs faisant intervenir la transparence a été modifiée de façon à traiter toutes les couleurs totalement transparentes comme étant la même couleur. Il s'agit d'une modification linéaire, si bien que les couleurs seulement à moitié transparentes sont également considérées comme plus proches les unes des autres que si elles étaient totalement opaques. À cause de cette modification, la quantification des couleurs d'IM générera toujours des couleurs semi-transparentes, mais se concentrera davantage sur les couleurs opaques et moins sur les couleurs totalement transparentes de l'image. Par exemple, je génère ici un dégradé arc-en-ciel de couleurs, l'image étant totalement opaque en haut et totalement transparente en haut. J'ai affiché les images sur un motif de fond afin que vous puissiez voir à quel point l'image est transparente.

  magick xc:red xc:yellow xc:green1 xc:cyan xc:blue \
          +append -filter Cubic -resize 100x100\!  -size 100x100 \
          gradient: -alpha off -compose CopyOpacity -composite alpha_gradient.png
  magick alpha_gradient.png  +dither  -colors 256  alpha_colors_256.png
  magick alpha_gradient.png  +dither  -colors 64   alpha_colors_64.png
  magick alpha_gradient.png  +dither  -colors 15   alpha_colors_15.png

Comme on peut le voir, lorsque nous demandons à IM de réduire le nombre de couleurs nécessaires à cette image, il a créé beaucoup plus de couleurs opaques et utilisé moins de couleurs très transparentes pour les parties les plus translucides. Le résultat est une très bonne répartition des couleurs sélectionnées, en particulier lorsque le nombre de couleurs est très faible. Toutefois, comme je l'ai souligné plus haut, non seulement les couleurs primaires ne sont pas choisies, mais la couleur totalement transparente ne sera pas non plus choisie, exactement pour les mêmes raisons. En réalité, même les couleurs totalement opaques ne seront pas choisies ! Autrement dit, chaque couleur des images à couleurs quantifiées de l'exemple précédent est semi-transparente. Soyons clairs sur ce point.

Lorsque la transparence est en jeu, la quantification des couleurs d'IM
peut ne sélectionner aucune couleur totalement opaque ni même totalement transparente !

Bien entendu, depuis IM v6.3 et la correction du bogue de la « couleur fréquente » (voir La quantification ne préserve PAS les couleurs ci-dessus), cela est moins susceptible de se produire si l'image contient beaucoup de couleurs opaques et totalement transparentes, ce qui est souvent le cas. Comme certaines images peuvent contenir beaucoup de couleurs semi-transparentes, telles que des images faisant intervenir des effets de fumée ou d'ombres, vous pouvez faire un essai préalable afin de vous assurer qu'une couleur totalement transparente est sélectionnée pour être incluse dans l'image résultante. Vous pouvez ensuite mapper la couleur la plus transparente vers une couleur totalement transparente, et effectuer vous-même le remappage des couleurs. Si vous voulez vraiment être sûr d'obtenir à la fois des couleurs totalement opaques et totalement transparentes dans l'image résultante, vous pouvez normaliser OU étirer le contraste du canal alpha. Par exemple, je m'assure ici que les principales sélections de couleurs sont rendues opaques en utilisant « [-contrast-stretch](https://imagemagick.org/command-line-options/#contrast-stretch) ». Bien que cela soit probablement un peu excessif pour une situation plus normale.

  magick alpha_gradient.png  +dither  -colors 15 \
          -channel A -contrast-stretch 10%  alpha_colors_15n.png

Ce n'est PAS un problème pour les images GIF qui n'autorisent pas les couleurs semi-transparentes, ni pour le JPG qui n'autorise pas la transparence, ni même pour le PNG qui n'a pas besoin de quantification pour être enregistré correctement. Cela ne devient un problème que dans des cas particuliers où vous pourriez forcer une réduction de couleurs dans une image faisant intervenir beaucoup de couleurs semi-transparentes. Rappelez-vous que, pour le format GIF, enregistrer des couleurs semi-transparentes est une entreprise inutile. Ainsi, si vous prévoyez d'effectuer vous-même la quantification des couleurs pour un tel format d'image, vous devez indiquer à IM d'ignorer la transparence de l'image lors de la génération de son jeu de couleurs réduit. Vous pouvez faire cela en utilisant le réglage d'espace colorimétrique spécial « [-quantize](https://imagemagick.org/command-line-options/#quantize) » avec la valeur « transparent ».

  magick alpha_gradient.png -quantize transparent \
                            +dither  -colors 15   alpha_colors_15qt.png

Remarquez que la quantification des couleurs a complètement ignoré la transparence des couleurs et n'a pas du tout touché au canal alpha de l'image. Cela signifie que vous pouvez traiter le canal alpha d'une manière plus appropriée à votre image, de façon complètement distincte des autres couleurs. En fait, vous pouvez le faire soit avant, soit après l'utilisation de « [-colors](https://imagemagick.org/command-line-options/#colors) » sans problème. Cela ne fera aucune différence dans le résultat. Cet espace colorimétrique de quantification est donc recommandé pour réduire le nombre de couleurs d'une image que vous prévoyez d'enregistrer dans un format à transparence booléenne ou sans transparence, tel que les formats d'image GIF ou XPM. Si vous comptez le nombre de couleurs générées, vous verrez aussi qu'il a généré exactement le nombre de couleurs demandé. Ainsi, si vous avez également besoin d'une couleur totalement transparente (ce qui est probable), vous devez réduire l'argument de « [-colors](https://imagemagick.org/command-line-options/#colors) » d'au moins un, afin de laisser de la place pour elle dans la table de couleurs finale de l'image. Ainsi, pour gérer la limite de 256 couleurs de la table de couleurs du format de fichier GIF, vous devrez réduire les couleurs à 255, et non 256, laissant l'espace supplémentaire pour l'index de couleur totalement transparente, tel que défini par le réglage « [-transparent-color](https://imagemagick.org/command-line-options/#tranparent-color) ». Ajustez cela pour des tailles de table de couleurs plus petites. Ce comportement de quantification est automatique lorsqu'IM enregistre au format de fichier GIF, mais il est important lorsque vous avez besoin de faire vous-même la quantification tout en générant des tables de couleurs globales ou partagées. Bien entendu, vous devez tout de même gérer les pixels semi-transparents, afin qu'ils soient corrects par rapport à l'aspect voulu pour votre image.

FUTURE: This last part will probably move to a new section on 'Dithering
Alpha Channel' to be created in the near future. And a reference to this
section added here.

Voici quelques exemples de tramage du seul canal alpha vers un réglage booléen (activé/désactivé), sans affecter le reste des canaux de couleur de l'image.

  magick alpha_gradient.png \
          -channel A   -threshold 50%       alpha_dither_threshold.gif
  magick alpha_gradient.png \
          -channel A -ordered-dither checks alpha_dither_checks.gif
  magick alpha_gradient.png \
          -channel A -ordered-dither o8x8   alpha_dither_ordered.gif
  magick alpha_gradient.png \
          -channel A -ordered-dither h8x8a  alpha_dither_halftone.gif

  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -monochrome \) \
          +swap +delete -combine alpha_dither_monochrome.gif
  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -dither FloydSteinberg -monochrome \) \
          +swap +delete -combine alpha_dither_monochrome_fs.gif
  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -remap pattern:gray50 \) \
          +swap +delete -combine  alpha_dither_map.gif
  magick alpha_gradient.png -channel RGBA -separate \
          \( +clone -dither FloydSteinberg -remap pattern:gray50 \) \
          +swap +delete -combine  alpha_dither_map_fs.gif

| _Lorsque vous tramez une copie du canal alpha, afin de pouvoir la tramer à l'aide de « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) » ou de « [-remap](https://imagemagick.org/command-line-options/#remap) », assurez-vous que l'image est une image en niveaux de gris pure, et non un masque de forme contenant de la transparence. Sinon, vous vous retrouverez probablement avec des effets non linéaires dus au canal alpha encore présent.

Il existe plusieurs façons d'extraire et de restaurer le canal alpha d'une image, sous forme de masque en niveaux de gris, afin de pouvoir le tramer. L'exemple ci-dessus utilise la séparation de canaux et la combinaison pour ce faire. D'autres méthodes utilisent l'extraction alpha avec la composition CopyOpacity._
---|---

Tramage par correction d'erreur

Comme évoqué dans l'introduction, un tramage par correction d'erreur est généralement considéré comme le meilleur choix pour produire la représentation la plus fidèle de l'image d'origine avec un jeu de couleurs réduit. Il se limite en outre à toute palette de couleurs prédéfinie, qu'elle ait été fournie par l'utilisateur ou déterminée par les routines de quantification des couleurs d'IM. Pour cette raison, c'est le choix par défaut logique pour la réduction générale des couleurs telle que fournie par les opérateurs IM « [-colors](https://imagemagick.org/command-line-options/#colors) », « [-remap](https://imagemagick.org/command-line-options/#remap) », « [-posterize](https://imagemagick.org/command-line-options/#posterize) » et « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) ».

Méthodes de tramage E-Dither

Depuis la version 6.4.2-9, IM fournit désormais plus d'un type de style ou de méthode de tramage, qui peut être sélectionné à l'aide du réglage « [-dither](https://imagemagick.org/command-line-options/#dither) ». Auparavant, IM était limité à une variante du tramage Riemersma, ou tramage par courbe de Hilbert, que vous pouvez définir avec « -dither Riemersma ». Vous pouvez maintenant aussi sélectionner un tramage Floyd-Steinberg avec « -dither FloydSteinberg ». Vous pouvez voir quels types de méthodes de tramage ont été implémentés dans votre version d'IM en utilisant...

  magick -list dither

Par exemple, voici la roue chromatique tramée à l'aide de différentes méthodes de tramage.

  magick colorwheel.png -dither Riemersma      -colors 16 dither_riemersma.gif
  magick colorwheel.png -dither FloydSteinberg -colors 16 dither_floyd.gif

Comme on peut le voir, le tramage Floyd-Steinberg produit un motif de tramage bien plus uniforme que le tramage Riemersma par défaut. La plus grande différence entre eux réside dans la façon dont chacun distribue l'« erreur de couleur » entre les pixels voisins. Voyons donc comment fonctionne un tramage E-Dither.

Comment fonctionne un E-Dither

Réécriture en cours

La méthode précise utilisée par IM pour le tramage général est une variante du « tramage par correction d'erreur par courbe de Hilbert ». C'est en réalité une très bonne technique de tramage, très bien définie et raisonnablement rapide. Pour une description complète (et une variante très similaire), voir... tramage Riemersma. Fondamentalement, chaque pixel de l'image est examiné selon un chemin très complexe appelé « courbe de Hilbert ». Le pixel se voit attribuer la couleur la plus proche de sa valeur, et toute différence entre la couleur d'origine du pixel et la couleur sélectionnée est conservée et ajoutée aux valeurs de couleur du pixel suivant (qui est toujours un pixel voisin) avant qu'une nouvelle couleur ne soit à nouveau sélectionnée. De cette façon, toute variation de couleur entre les couleurs sélectionnées et la couleur d'origine de l'image est répartie sur les autres pixels de la même zone. Le résultat est que, bien que seules des couleurs précises soient attribuées à l'image finale, la même couleur d'ensemble de base pour cette zone correspondra étroitement à l'image d'origine. Par exemple, voici une petite image grise que j'ai demandé à IM de tramer en utilisant un jeu de couleurs ne comprenant pas la couleur d'origine. L'image résultante est agrandie afin que vous puissiez voir chaque pixel coloré attribué.

  magick -size 10x10 xc:'#999999' -scale 80x80  dither_not.gif
  magick -size 10x10 xc:'#999999' \
          -remap colortable.gif   -scale 80x80  dither.gif

Comme on peut le voir, la couleur de l'image d'origine ne figurant pas dans la palette de couleurs spécifiée, cette couleur d'origine est approchée à l'aide d'un motif des trois couleurs les plus proches présentes dans la table de couleurs fournie. Si nous devions faire la moyenne de la couleur générée par le motif de tramage ci-dessus, nous obtiendrions la couleur , qui est très proche de la couleur moyenne d'origine de l'image , et c'est là tout l'intérêt du motif de tramage produit. Toutefois, comme le « chemin » utilisé pour attribuer les couleurs est complexe (bien qu'il reste généralement dans la zone locale), les attributions de couleur produisent un motif essentiellement aléatoire. Ce n'est techniquement pas aléatoire, cependant, car la même image produira le même motif, mais les résultats peuvent tout aussi bien être aléatoires, ou du moins pseudo-aléatoires. Le tramage « F-S » n'est en fait que l'un (le premier) de plusieurs « E-Dithers rastérisés » qui ont été développés depuis sa création au début des années 1970. C'est aussi probablement le plus largement implémenté, même s'il n'est pas considéré comme le meilleur. Voir l'article Dithering Algorithms pour un résumé plus complet de ces algorithmes. Depuis IM v6.4.3, il est également directement disponible dans IM, et est implémenté de façon à suivre un chemin « serpentin » ligne par ligne, du haut de l'image vers le bas.

  magick -size 10x10 xc:'#999999'  -dither FloydSteinberg \
          -remap colortable.gif   -scale 80x80  dither_fs.gif

Le « tramage Floyd-Steinberg » en particulier produit, à mon avis, un motif de pixels plus « hachuré » que le « tramage par courbe de Hilbert », et a d'ailleurs été conçu pour cela. Un tel motif régulier peut faciliter grandement un nettoyage manuel de bas niveau des petites images d'icônes en couleur. C'est quelque chose que j'ai beaucoup fait par le passé pour la bibliothèque d'icônes d'Anthony, mais ce genre de chose n'est plus souvent nécessaire, sauf peut-être pour de petites images monochromes.

Problème du E-Dither — sensible aux changements

L'un des plus gros problèmes auxquels vous êtes confronté lorsque vous utilisez un tramage par correction d'erreur est que vous obtenez un motif de pixels essentiellement aléatoire, qui est aussi très sensible aux changements. Prenons par exemple l'image grise d'origine et remplaçons un pixel par une couleur différente avant de la tramer à nouveau. Le résultat est un décalage complet du motif de tramage sur chaque pixel qui se trouve plus loin le long du chemin suivi par le tramage par courbe de Hilbert.

  magick -size 10x10 xc:'#999999' -draw 'fill #C28 point 2,2' \
          -remap colortable.gif   -scale 80x80   dither_modified.gif
  magick compare dither.gif dither_modified.gif dither_difference.gif

tramage d'origine |
changement d'un pixel |
|
comparaison des changements
---|---|---|---

Comme on peut le voir, le simple ajout d'un seul pixel à l'image a fait changer radicalement le motif de tramage ! Il suffit d'un changement d'un seul bit pour que l'image résultante devienne différente, même si l'aspect global de l'image (lorsqu'elle n'est pas agrandie) reste fondamentalement le même (ce qui est après tout le but d'un bon algorithme de tramage). L'image « magick compare » montre également l'ampleur du changement dans le motif de tramage. Dans ce cas, environ 80 % des pixels se sont vu attribuer une couleur complètement différente. Dans un tramage par courbe de Hilbert, un changement d'un seul pixel entraînera en réalité que chaque pixel venant ensuite pourra être différent, ce qui signifie que de 0 à 100 % du motif de tramage pourrait être différent. Cela dépend simplement de l'endroit où le changement s'est produit dans la courbe de Hilbert complexe. Le tramage Floyd-Steinberg, en revanche, ne progresse à travers l'image que dans une seule direction, si bien qu'un changement d'un seul pixel ne modifiera le motif que d'un seul côté du changement.

  magick -size 10x10 xc:'#999999' -draw 'fill #C28 point 2,2' \
          -dither FloydSteinberg -remap colortable.gif \
          -scale 80x80   dither_fs_modified.gif
  magick compare dither_fs.gif dither_fs_modified.gif dither_fs_difference.gif

tramage FS |
changement d'un pixel |
|
comparaison des changements
---|---|---|---

Comme on peut le voir, il présente exactement le même problème. Un changement d'un seul pixel provoque un changement presque complet du motif de tramage pour les zones de l'image traitées après ce pixel. C'est-à-dire, à partir de cette ligne vers le bas. Pour une image unique, le motif résultant des couleurs tramées n'a pas d'importance. La couleur moyenne du motif devrait donner à l'image la couleur appropriée pour cette zone de l'image. Mais lorsque vous avez une animation dans laquelle une image est suivie d'autres images très similaires, avec de grandes zones de couleur constante, le motif de tramage changeant devient très perceptible et irritant, comme un « bruit » de fond de bas niveau. Par exemple, je génère ici une animation de 3 images de la même couleur tramée, mais avec un changement d'un seul pixel dans chaque trame. J'agrandis également une région centrale afin que vous puissiez voir ce motif changeant plus clairement.

  magick -size 80x80 xc:'#999999' \
          \( +clone -draw 'fill #C28 point 2,2' \) \
          \( +clone -draw 'fill #28C point 2,2' \) \
          -remap colortable.gif  -set delay 50 -loop 0   dither_anim.gif
  magick dither_anim.gif -crop 10x10+40+40 +repage \
                              -scale 80x80     dither_anim_magnify.gif

Mouchetage de pixels par l'E-Dither

Un autre problème des E-Dithers est qu'ils peuvent produire occasionnellement des pixels de couleur étrange dans des zones qui seraient sinon assez uniformes en couleur. Par exemple, un pixel vert occasionnel dans une image en niveaux de gris. Ou, comme dans les exemples ci-dessous, un pixel blanc dans une zone par ailleurs d'un bleu plat et uni. C'est particulièrement le cas dans les grandes images contenant des objets avec de grands nombres de couleurs, et d'autres zones de couleurs unies et constantes. C'est particulièrement typique des objets colorés superposés sur des fonds de couleur plate, comme on en trouve souvent dans les diagrammes et les dessins. On peut voir un tel pixel de couleur étrange dans l'agrandissement des exemples de test ci-dessus, où un pixel violet clair supplémentaire a été ajouté à une bonne distance du petit changement d'un seul pixel. Les pixels de couleur étrange ajoutés ci-dessus ne sont toutefois pas facilement visibles et la palette de couleurs couvre plutôt bien l'image, de sorte que les pixels étranges sont raisonnablement proches des trois couleurs normales utilisées pour tramer l'image. Pour un exemple plus extrême, j'ai ici un fond en dégradé flouté, que j'ai fortement réduit en couleurs à 64 couleurs pour vraiment mettre à l'épreuve le tramage par correction d'erreur. |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' \
          -blur 0x5  -colors 64     speckle_gradient.gif

Comme on peut le voir avec cette palette de couleurs fortement réduite, le tramage par correction d'erreur a fait un travail raisonnablement bon pour représenter le dégradé d'origine. Mais si l'on ajoute une plage de blanc pur à ce qui précède... |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' -blur 0x5 \
          -fill white -draw 'rectangle 40,40 60,55' \
          -colors 64   speckle_problem.gif

On peut voir que l'E-dither a soudainement commencé à produire un saupoudrage de pixels blancs dans la partie supérieure de l'image, là où l'on n'en avait aucun auparavant. Voici l'agrandissement d'une petite section pour voir ces pixels plus clairement... |

  magick speckle_problem.gif -crop 15x15+75+0 +repage \
          -scale 90x90    speckle_prob_mag.gif

Le pixel de couleur étrange est causé par deux facteurs. Premièrement, la quantification des couleurs a été forcée d'inclure une unique couleur blanc pur (mais aucune autre couleur d'anticrénelage blanc-bleu) dans la palette de couleurs finale de l'image, autorisant ainsi le processus de tramage à utiliser cette couleur supplémentaire. Mais comme les E-Dithers accumulent lentement les erreurs, particulièrement dans les zones de couleurs extrêmes, comme dans la section supérieure de l'image ci-dessus. Finalement, les erreurs s'additionneront jusqu'à une valeur suffisamment grande pour faire de cette unique couleur supplémentaire la correspondance la plus proche. Ainsi, de temps à autre, un pixel blanc fortement contrasté est produit pour « corriger l'erreur », à un emplacement pseudo-aléatoire. Le résultat est un très léger mouchetage de pixels blancs. Plus l'accumulation d'erreur est lente, plus ces pixels blancs sont dispersés et plus ils paraissent déplacés. La meilleure solution est de passer à un autre format d'image qui n'a pas de table de couleurs limitée. Par exemple, convertir avec magick votre image au format GIF en PNG. Cela évitera le besoin de quantification (réduction) des couleurs et donc le besoin de tramer les couleurs réduites. La solution suivante consiste à remplacer l'usage de l'E-dither par une autre méthode de tramage qui « localise » toute erreur, comme le Tramage ordonné. Cependant, ce n'est actuellement pas chose facile à appliquer dans IM à l'heure actuelle. Voir De meilleurs résultats de tramage ordonné pour une telle méthode en attendant qu'une plus générale soit trouvée. Si passer à un autre format d'image, ou utiliser une méthode de tramage différente, n'est pas praticable (et ça ne l'est souvent pas), il ne reste qu'à tenter de corriger la situation pour cette image spécifique. Le meilleur correctif à cela est de s'assurer d'une manière ou d'une autre d'avoir d'autres couleurs juste à l'extérieur du grand groupe de couleurs qui cause l'accumulation d'erreur de l'E-Dither. Cependant, la quantification des couleurs normale ne fait pas cela. Elle a tendance à choisir un ensemble de couleurs moyennes représentant des groupes de couleurs. Ce qu'il faut, ce sont des couleurs supplémentaires qui « clôturent » les bords d'un grand groupe de couleurs, plutôt qu'une simple couleur moyenne. Ici par exemple, j'ai utilisé un cercle plutôt qu'un carré, de sorte que non seulement une couleur blanc pur est ajoutée, mais aussi un certain nombre de couleurs blanc-bleu. Celles-ci ont été ajoutées automatiquement en raison de l'anticrénelage des bords du cercle, pour en adoucir l'aspect. |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' -blur 0x5 \
          -fill white -draw 'circle 50,45 40,40' \
          -colors 64  speckle_fixed.gif

Et un agrandissement de la même zone qu'auparavant. |

  magick speckle_fixed.gif -crop 15x15+85+0 +repage \
          -scale 90x90    speckle_fix_mag.gif

Comme on peut le voir, les couleurs additionnelles fournissent les couleurs supplémentaires, juste à l'extérieur du dégradé bleu-cyan. Or, si ces couleurs supplémentaires signifient qu'il y a moins de couleurs disponibles pour le dégradé lui-même, elles fournissent d'autres couleurs bleu-blanc qui permettront à l'E-dither de se corriger plus tôt et plus souvent, avant que l'erreur accumulée ne puisse devenir trop grande. C'est-à-dire, non pas que nous ayons empêché le mouchetage de l'E-dither, mais simplement fourni de meilleures couleurs avec lesquelles l'algorithme de tramage peut travailler. Si l'on étudie la portion agrandie de l'image, on verra toujours un motif de mouchetage, mais les couleurs sont plus proches de la couleur de fond, et il y en a beaucoup plus, produisant une répartition plus uniforme des mouchetures. Une autre façon est de générer notre propre table de couleurs, peut-être fondée sur celle qu'IM a générée, et d'ajouter les couleurs appropriées pour empêcher l'accumulation d'erreur. Ce n'est cependant pas chose facile à faire, surtout avec un espace colorimétrique tridimensionnel. Pour cet exemple d'image spécifique, une façon d'empêcher le « mouchetage » est de générer et tramer le fond séparément, avec un peu moins de couleurs que nécessaire, puis de superposer la boîte blanche et sa couleur supplémentaire. |

  magick -size 100x60 xc:SkyBlue \
          -fill DodgerBlue -draw 'circle 50,70 15,35' \
          -fill RoyalBlue  -draw 'circle 50,70 30,45' -blur 0x5 \
          -colors 63 \
          -fill white -draw 'rectangle 40,40 60,55'  speckle_perfect.gif

Cela ajoutera une couleur « blanche » à l'image, mais le fond n'aura aucun effet de mouchetage, car le blanc n'était pas disponible lorsque le tramage par correction d'erreur a été utilisé. Le résultat est une image comptant exactement 64 couleurs, et aucun mouchetage du tout. Cependant, cela dépend beaucoup de l'image et de ce que l'on cherche à réaliser, ce n'est donc pas une solution générale au problème de mouchetage. Une alternative plus générale à l'ajout de couleurs supplémentaires est d'essayer de retirer les mouchetures de l'image finale tramée. Autrement dit, nettoyer l'image d'une manière ou d'une autre. Cependant, c'est en soi un problème délicat, car on ne veut pas retirer les pixels qui font partie du motif de tramage normal. Ce qu'il nous faut, c'est trouver les pixels de couleur qui sont d'une manière ou d'une autre très différents de toutes les couleurs qui les entourent, mais qui sont aussi bien isolés de toutes les autres couleurs semblables, par une certaine distance. Avez-vous une meilleure solution de filtre d'image ? Résumé Pour moi, le mouchetage est un problème très agaçant, en particulier pour les images d'icônes de bureau utilisant une table de couleurs très limitée. J'édite moi-même souvent de plus petites images « d'icône » pour retirer les mouchetures ou corriger certains des autres effets de tramage, comme les bandes verticales. Si vous connaissez une autre meilleure solution, faites-le-moi savoir.

Images bitmap monochromes tramées

L'opérateur « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) » est une forme spécialisée de l'opérateur « [-colors](https://imagemagick.org/command-line-options/#colors) » servant à générer une image bitmap. C'est de ce fait un opérateur idéal pour démontrer non seulement le « tramage par courbe de Hilbert », mais aussi pour regarder de plus près la sélection des couleurs. Voici un exemple typique. |

  magick logo.png  -monochrome     monochrome.gif

L'opérateur a tramé l'image uniquement d'après leur « intensité » ou « niveau » de luminosité en niveaux de gris, cependant il ne trame pas directement toute la plage des niveaux de gris mais applique un seuil aux valeurs les plus extrêmes vers leurs valeurs maximales. On peut le constater en demandant à IM de tramer une image en dégradé.

  magick -size 15x640 gradient: -rotate 90 \
                   -monochrome     monochrome_gradient.gif

Comme on peut le voir, le dégradé n'a qu'environ les 50 % centraux de ses couleurs tramés par l'opérateur « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) ». Un remerciement spécial va à Ivanova flamingivanova@punkass.com pour avoir signalé ce fait intéressant sur le fonctionnement d'IM. Si vous souhaitez tramer en utilisant toute la plage des niveaux de gris, vous pouvez utiliser l'opérateur « [-remap](https://imagemagick.org/command-line-options/#remap) » avec une palette de couleurs purement noir et blanc (fournie par une image de motif intégrée). |

  magick logo.png  -remap pattern:gray50  mono_remap.gif
  magick -size 15x640 gradient: -rotate 90 \
                   -remap pattern:gray50     mono_remap_gradient.gif

Par une sélection plus soignée des couleurs à l'aide de « [-remap](https://imagemagick.org/command-line-options/#remap) », vous pouvez effectivement produire la même plage de « seuil » que celle utilisée par l'opérateur « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) », ou toute autre plage de seuil que vous voulez. |

  magick xc:gray20  xc:white  +append   ctrl_colors.gif
  magick logo.png -colorspace Gray \
          -remap ctrl_colors.gif  -normalize  mono_remap_ctrl.gif
  magick -size 15x640 gradient: -rotate 90 \
          -remap ctrl_colors.gif  -normalize  mono_remap_grad_ctrl.gif

Quantification en deux couleurs

Plutôt que de choisir vous-même les deux couleurs de contrôle, vous pouvez utiliser la quantification des couleurs pour choisir les deux meilleures couleurs de l'image à l'aide de l'opérateur « [-colors](https://imagemagick.org/command-line-options/#colors) ». |

  magick logo.png   -colors 2 -colorspace gray  -normalize \
                                                 colors_monochrome.gif

Cependant, le résultat ne sera pas le même qu'avec « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) », car nous n'avons pas d'abord converti l'image en niveaux de gris avec magick. Au lieu de cela, l'image a été tramée directement entre les deux valeurs de couleur non grises choisies. C'est-à-dire que les deux meilleures couleurs sont sélectionnées pour tramer l'image, plutôt que deux niveaux de luminosité en niveaux de gris. Par conséquent, cela produira un meilleur résultat pour, disons, une image qui n'utilise que des couleurs d'à peu près le même « niveau » de gris. Ici par exemple, nous utilisons « [-colors](https://imagemagick.org/command-line-options/#colors) », ainsi que l'opérateur de tramage bitmap « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) », sur un dégradé rouge-bleu. Comme on peut le voir, les résultats ne sont pas les mêmes.

  magick -size 20x640 gradient:red-blue -rotate 90    gradient_rb.png
  magick gradient_rb.png   -colors 2 -colorspace gray \
                                -normalize        colors_threshold.gif
  magick gradient_rb.png       -monochrome       mono_threshold.gif

L'opérateur « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) » dans ce qui précède n'a pas réussi à trouver de différences pour le tramage bitmap, car le bleu et le rouge sont d'une intensité très proche. La méthode de quantification « [-colors](https://imagemagick.org/command-line-options/#colors) » n'a toutefois eu aucun mal à trouver des couleurs acceptables entre lesquelles tramer. On peut aussi voir que seule la portion centrale des couleurs a été tramée. Cela est dû au fait que la quantification des couleurs choisit des couleurs au milieu des deux « grappes » de couleurs qu'elle a sélectionnées. Les couleurs à l'« extérieur » des couleurs sélectionnées sont ainsi effectivement mises au seuil directement vers cette couleur sans tramage. Cela démontre que les couleurs à l'extérieur de l'espace colorimétrique de quantification ne sont pas tramées, bien que ce fait soit difficile à exploiter de façon pratique. En réglant l'« [-colorspace](https://imagemagick.org/command-line-options/#colorspace) » sur niveaux de gris avant la quantification, vous reproduirez l'opération interne de l'opérateur « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) ». |

  magick logo.png -colorspace gray   -colors 2  -normalize \
                                                 monochrome_equivelent.gif

Et enfin, en désactivant le tramage, vous pouvez produire une séparation plus automatique des couleurs de l'image que celle produite par l'usage d'un réglage « [-threshold](https://imagemagick.org/command-line-options/#threshold) » fixe. |

  magick logo.png  -colorspace gray  +dither  -colors 2  -normalize \
           threshold_two_grays.gif

| Rappelez-vous que « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) » ignore actuellement le réglage « [+dither](https://imagemagick.org/command-line-options/#dither) », donc vous ne pouvez pas simplement utiliser cet opérateur pour faire un « seuil intelligent ».
---|---
Si vous retirez le « [-colorspace](https://imagemagick.org/command-line-options/#colorspace) » pour l'étape de quantification des couleurs du traitement de l'image, vous pouvez appliquer un seuil à une image d'après la meilleure séparation de couleurs (plutôt que la séparation de couleurs en niveaux de gris) possible pour cette image. |

  magick logo.png  +dither  -colors 2  -colorspace gray -normalize \
           threshold_two_color.gif

Tramage à l'aide de palettes de couleurs prédéfinies

Comme montré ci-dessus, « [-colors](https://imagemagick.org/command-line-options/#colors) » tente de choisir un ensemble limité optimal de couleurs avec lequel représenter une image. Avec « [-remap](https://imagemagick.org/command-line-options/#remap) », vous fournissez à IM l'ensemble final de couleurs que vous voulez utiliser pour l'image, que vous prévoyiez de tramer ces couleurs ou simplement de remplacer les couleurs par leurs plus proches voisines. L'argument est donné sous forme d'une image contenant toutes les couleurs que vous souhaitez utiliser. Si vous souhaitez réduire une grande image de couleurs à seulement sa liste de couleurs, vous pouvez utiliser « [-unique-colors](https://imagemagick.org/command-line-options/#unique-colors) », avant de l'enregistrer, pour un usage ultérieur par « [-remap](https://imagemagick.org/command-line-options/#remap) ». | _Notez que si l'opérateur « [-remap](https://imagemagick.org/command-line-options/#remap) » accepte n'importe quelle image à utiliser, n'utilisez pas d'image JPEG pour cette image, sinon vous obtiendrez beaucoup de couleurs supplémentaires en raison de sa « compression avec perte » qui génère des couleurs supplémentaires.

D'un autre côté, utiliser le JPEG pour générer des couleurs supplémentaires peut aider à résoudre le problème de « mouchetage » vu précédemment !_
---|---
Par exemple, ici je limite les couleurs utilisées dans le logo IM à une palette prédéfinie de couleurs X window nommées. Le défaut est le tramage « Riemersma », mais à partir d'IM v6.4.4 « [-dither](https://imagemagick.org/command-line-options/#dither) » a été étendu pour permettre la sélection d'autres méthodes de tramage telles que « FloydSteinberg ». Vous pouvez bien sûr toujours désactiver le tramage à l'aide de l'option « [+dither](https://imagemagick.org/command-line-options/#dither) ».

  magick logo.png  -dither None       -remap colortable.gif  remap_logo_no.gif
  magick logo.png  -dither Riemersma  -remap colortable.gif  remap_logo_rm.gif
  magick logo.png  -dither FloydSteinberg \
                                       -remap colortable.gif  remap_logo_fs.gif

Comme on peut le voir, IM a tenté de faire un travail raisonnable pour représenter l'image en n'utilisant que les couleurs données, bien que les résultats soient loin d'être aussi bons que l'image que l'on obtient si l'on laisse IM sélectionner l'ensemble de couleurs à utiliser. Notez que cette image « [colortable.gif](../static/img/images/colortable.gif) » n'a jamais été conçue pour tramer des images, mais comme ensemble de couleurs pour concevoir des icônes de couleurs de type dessin animé pour les affichages couleur X window plus anciens et plus primitifs (voir Anthony's X Window Icon Library et AIcons Color Selection pour les détails). Notez également que l'image finale n'a pas utilisé la totalité des 32 couleurs fournies par cette palette, bien que plus de couleurs de la palette soient utilisées lorsqu'une forme de tramage est activée ( et respectivement), que lorsqu'il était désactivé (). Ce dernier exemple montre à quel point il est important de sélectionner une bonne palette de couleurs. C'est pourquoi je recommande de laisser IM optimiser la sélection des couleurs utilisées dans une image à l'aide de l'opérateur « [-colors](https://imagemagick.org/command-line-options/#colors) », et de la modifier pour l'adapter à vos besoins, à moins d'avoir des raisons plus pressantes de ne pas le faire. Un dernier point : bien que vous puissiez spécifier un espace colorimétrique dans lequel « [-colors](https://imagemagick.org/command-line-options/#colors) » trouvera le meilleur ensemble de couleurs, vous ne pouvez actuellement PAS définir d'espace colorimétrique pour la phase de mise en correspondance des couleurs ou de tramage. Toutes mes expériences semblent montrer que l'ensemble de couleurs est appliqué (tant le tramage par correction d'erreur que le remplacement par la couleur la plus proche) d'après l'espace RGB. Le réglage d'espace colorimétrique « [-quantize](https://imagemagick.org/command-line-options/#quantize) » n'est utilisé que pour la sélection des couleurs, pas pour leur mise en correspondance. Donc si utiliser une palette de couleurs est une si mauvaise idée, pourquoi voudrait-on l'utiliser ? Il y a un certain nombre de raisons courantes, généralement parce que vous avez besoin de plus de contrôle sur la palette spécifique de couleurs utilisée dans une image. Un autre utilisateur a aussi extrait la palette de couleurs pour pouvoir l'utiliser sur un Risographe (un système d'impression numérique). Si vous connaissez une autre raison d'utiliser l'opérateur « [-remap](https://imagemagick.org/command-line-options/#remap) » que je n'ai pas présentée ci-dessous — écrivez-moi.

Palette de couleurs commune ou « optimale »

L'autre technique, lorsqu'on manipule plusieurs images, est de générer une table de couleurs commune à toutes les images concernées. Fondamentalement, vous accolez toutes les images ensemble en une grande image, puis vous utilisez l'opérateur « [-colors](https://imagemagick.org/command-line-options/#colors) » pour déterminer une bonne palette de couleurs à utiliser qui soit commune à toutes les images. Une fois que vous avez cette image de palette de couleurs, vous pouvez l'utiliser pour recolorer chacune des images d'origine à l'aide de cette palette de couleurs prédéfinie tout juste générée. Alternativement, vous pouvez utiliser l'opérateur spécial « [+remap](https://imagemagick.org/command-line-options/#remap) », qui fait la même chose avec une palette de couleurs de 255 couleurs. Il compte les couleurs, effectue la quantification des couleurs pour former une bonne palette de couleurs commune, puis trame les images pour qu'elles utilisent cette palette, si nécessaire. Les deux formes « [-remap](https://imagemagick.org/command-line-options/#remap) » et « [+remap](https://imagemagick.org/command-line-options/#remap) » ont toutefois une caractéristique très importante pour les animations GIF. Elles convertissent toutes les images en un « [-type](https://imagemagick.org/command-line-options/#type) » d'image « Palette » avec toutes les images utilisant la même palette de couleurs. La raison en est que lors de l'écriture d'une image GIF, la palette de couleurs de la première image sera utilisée comme « palette de couleurs globale » du format de fichier. Puis, à mesure que chaque image est écrite, il note que ces images utilisent le même ensemble de couleurs, donc il ne crée PAS de « palette de couleurs locale ». Cela peut économiser jusqu'à 256 × 3, soit 768 octets d'espace de palette de couleurs pour chacune des images du fichier GIF final. Seuls les opérateurs « [-remap](https://imagemagick.org/command-line-options/#remap) » peuvent faire cela. Donc lorsqu'on manipule des GIF et en particulier des animations GIF, cela peut être un point important à retenir. Pour plus de détails et un exemple, voir Animations GIF, table de couleurs globale.

Colorisation en couleurs web sûres

Lorsque le WWW a été créé, les affichages informatiques disposaient d'une gamme limitée de couleurs, et les navigateurs web utilisaient généralement un ensemble de couleurs plus simple pour les images. De ce fait, il était courant de recolorer les images vers cet ensemble de couleurs, afin de les rendre à la fois plus petites et de s'assurer qu'elles auront un aspect correct sur les navigateurs des utilisateurs. Pour plus de détails, voir Web Style Guide, Dithering. Pour aider à cela, IM a fourni une image de palette de couleurs intégrée de cette table spéciale de 216 couleurs, appelée « netscape: ». Voyons donc à quoi ressemblerait notre image de test sur un affichage de vieux navigateur web utilisant ces couleurs.

  magick logo.png         -remap netscape:  remap_netscape.gif
  magick logo.png +dither -remap netscape:  remap_netscape_nd.gif

Cet ensemble de couleurs était une palette déterminée mathématiquement, conçue par des ingénieurs d'affichages et d'ordinateurs, non par des graphistes, et bien qu'elle soit assez générale pour fonctionner raisonnablement bien pour de vraies images comme les photos, elle est très mauvaise pour les images contenant de grandes zones plates de couleur, telles que les logos, les fonds, les images générées par ordinateur comme les graphiques, et les images de type dessin animé. Fondamentalement, cela fonctionne dans les zones de couleurs très variables, mais pour les plus grandes zones plates de couleurs constantes, un tramage de trois couleurs (en général) est appliqué, comme la chemise d'un bleu terne du logo IM des images de test (ci-dessus). En d'autres termes, si vous conceviez une image ou un logo pour un usage sur le web, vous essaieriez généralement d'utiliser les couleurs de cette palette pour les grandes zones plates, et de n'avoir des couleurs tramées que dans les zones où vous avez des nuances de couleur variables. Les commandes ci-dessus vous permettent de tester vos images pour voir à quoi elles ressembleraient sur des affichages informatiques plus primitifs, et d'éditer une image pour utiliser ces couleurs, afin qu'elles fonctionnent bien. Ceci est particulièrement important pour les symboles et les images de navigation. Bien sûr, aujourd'hui, grâce aux exigences des utilisateurs de jeux et du web, vous pouvez être à peu près assuré que la plupart des utilisateurs disposent d'un affichage informatique moderne qui n'a pas ces anciennes limitations de couleurs, cependant l'usage de cette « palette de couleurs web sûres » est toujours d'actualité, car elle a d'autres avantages, tels que la compression d'image. Pour une discussion sur l'usage des couleurs web sûres dans le monde moderne, voir Death of the Web-safe Color Palette?, et probablement un point de vue plus important d'une graphiste qui a la première identifié cette palette de couleurs, Lynda Weinman.

Génération de palettes de couleurs

Déterminer une bonne palette de couleurs pour une image, ou un ensemble spécifique d'images, peut être très important. Cela devient particulièrement important lorsque vous avez affaire à une séquence d'images qui sera utilisée pour une animation GIF. Fondamentalement, vous voulez faire en sorte qu'elles n'aient besoin que d'une seule table de couleurs, à utiliser pour toutes les trames de l'animation, plutôt qu'une table de couleurs distincte pour chaque trame. En d'autres termes, vous voulez une unique palette de couleurs pour toutes les images. Vous n'avez réellement que deux choix dans ce cas. Vous pouvez tenter de créer une palette de couleurs qui fonctionnera bien pour n'importe quelle image, ou vous pouvez essayer d'optimiser une palette de couleurs pour l'ensemble spécifique d'images auquel vous l'appliquez.

Palette de couleurs web sûres

La première méthode est typiquement une palette de couleurs générée mathématiquement, telle que la palette de couleurs « netscape: » intégrée à IM. Elle fournit un ensemble de 216 couleurs, qui tiendra bien dans la limite de 256 couleurs du format GIF, et laissera encore de la place pour gérer la transparence de l'image, voire ajouter quelques couleurs supplémentaires à des fins spéciales, comme les ombres ou les superpositions de texte. Cette palette de couleurs a été générée en créant 6 niveaux de couleurs pour chacun des trois canaux de couleur, produisant 6×6×6 couleurs, soit 216 couleurs. Le nombre de la bête. Comme seulement 219 couleurs sont utilisées, elle a encore de la place (pour les images GIF) pour ajouter plus de couleurs à la palette de couleurs à des fins spécifiques. Par exemple, une couleur transparente, ainsi que davantage de nuances de niveaux de gris. Une ancienne version Macintosh de la palette web sûres faisait exactement cela pour tenter d'améliorer son résultat global, mais elle n'était utilisée que sur les clients web Macintosh. C'est probablement la palette de couleurs « uniforme » (ou dérivée mathématiquement) la plus courante d'usage général, grâce à sa simplicité et à son usage général sur le World Wide Web.

Palette de couleurs uniforme 332

Une autre mise en correspondance de couleurs uniforme couramment utilisée est la « palette de couleurs RGB 332 ». Le nombre fait référence au nombre de bits utilisés pour représenter chaque couleur au sein d'un index de couleur de 8 bits. C'est-à-dire, 3 bits (ou 8 niveaux) de rouge, 3 pour le vert, et 2 bits (ou 4 niveaux de couleur) pour le bleu, étant donné que nos yeux ne réagissent pas bien au bleu. Cela donne 3+3+2 bits, soit un index de couleur de 8 bits, soit 256 couleurs. Parfait pour la table de couleurs GIF limitée. Cependant, cela ne laissera aucune place pour une couleur de transparence GIF, ni pour d'autres couleurs à usage spécial. Voici une façon d'amener IM à générer cette palette de couleurs... |

  magick -size 16x16 xc: -channel R -fx '(i%8)/7' \
                          -channel G -fx '(j%8)/7' \
                          -channel B -fx '((i>>3&1)|(j>>2&2))/3' \
          -scale 600% colormap_332.png

| Les opérateurs de décalage de bits « >> » et « << » manquaient à l'opérateur « [-fx](https://imagemagick.org/command-line-options/#fx) » jusqu'à la version 6.2.9-2 d'IM.
---|---
Une façon plus simple de faire la même chose est d'utiliser le Tramage ordonné à l'aide de niveaux de couleur uniformes en utilisant l'opération « -ordered-dither threshold,8,8,4 » (voir cette zone d'exemples). Une technique bien plus facile et rapide que la méthode DIY FX ci-dessus, et qui permet même d'utiliser d'autres cartes de tramage intégrées pour une meilleure gestion des dégradés. Le seul inconvénient de cette palette est qu'elle ne fournit en fait aucune couleur « grise » du tout. Cependant, cet inconvénient peut être un plus lorsque le tramage est utilisé, car les légères différences de couleur réduisent l'effet des changements de frontière de couleur dans un dégradé en niveaux de gris, le rendant juste un peu plus lisse à l'œil.

Palette de couleurs TrueColor 16 bits

Une palette de couleurs uniforme semblable à la « palette 332 » ci-dessus est utilisée par X windows dans une classe visuelle 16 bits rarement utilisée. Dans ce cas, 16 bits sont utilisés pour l'index de couleur, qui est divisé en 5 bits pour le rouge, 5 pour le vert et 6 pour le bleu. En d'autres termes, cette palette de couleurs ressemble davantage à une « palette 556 », et se réalise au mieux à l'aide d'un Tramage ordonné à l'aide de niveaux de couleur uniformes utilisant une carte de tramage « threshold ». Plus précisément, l'opération « -ordered-dither threshold,32,32,64 ». Les palettes de couleurs 16 bits sont toutefois rarement rencontrées, car les images utilisant des palettes de couleurs ont typiquement besoin d'une table de couleurs de 8 bits. De ce fait, je n'en dirai pas plus.

Palettes de couleurs uniformes corrigées gamma

À l'heure actuelle, IM ne réalise pas directement de palettes de couleurs corrigées gamma. Au lieu de cela, ce que vous devriez faire est de convertir avec magick votre image (en supposant que vous ayez une version d'IM compilée en qualité Q16 ou mieux), depuis le sRGB ou quel que soit le niveau gamma de l'image vers un modèle RGB linéaire, avant de faire votre tramage. Cela vaut aussi pour de nombreuses autres opérations de traitement d'image, telles que le redimensionnement, le flou, etc. Voir Redimensionnement avec correction gamma pour un exemple.

Postériser, recolorer à l'aide d'une palette de couleurs uniforme

Le but originel de cet opérateur (en utilisant un argument de « 2 ») est de recolorer les images en n'utilisant que 8 couleurs de base, comme si l'image avait été générée à l'aide d'une méthode d'impression d'affiches simple et bon marché n'utilisant que les couleurs de base. C'est ainsi que l'opérateur tire son nom. L'opérateur « [-posterize](https://imagemagick.org/command-line-options/#posterize) » est en réalité un opérateur spécial de réduction de couleurs qui génère une palette de couleurs d'après le nombre de « niveaux » de couleur donnés, pour chacun des canaux de couleur de l'image, tramant l'image à l'aide d'un tramage par correction d'erreur.

  magick netscape: -scale 50%  +dither  -posterize 2   posterize_2_ns.gif
  magick netscape: -scale 50%  +dither  -posterize 3   posterize_3_ns.gif
  magick netscape: -scale 50%  +dither  -posterize 6   posterize_6_ns.gif

Comme on peut le voir, un argument « [-posterize](https://imagemagick.org/command-line-options/#posterize) » de « 2 » signifie ne fournir que 2 couleurs par canal de couleur, produisant une palette de seulement 8 couleurs pour une image RGB à 3 canaux, comme celle ci-dessus. Fondamentalement, il recolorera les images à l'aide de l'ensemble de seuil de 8 couleurs. Un argument de « 3 » mettra en correspondance les couleurs de l'image d'après une palette de couleurs de 27 couleurs, incluant des couleurs de demi-teinte. Tandis qu'un argument de « 4 » générera une table de couleurs de 64 couleurs, et « 5 » génère une palette de couleurs de 125 couleurs. Bien sûr, comme mentionné ci-dessus, un argument de « 6 » reproduira le même ensemble de 216 couleurs, tel que fourni par l'image « netscape: » intégrée. Veuillez noter qu'un argument « [-posterize](https://imagemagick.org/command-line-options/#posterize) » de « 0 » ou « 1 » n'a pas de sens, et avec les dernières versions d'IM convertit simplement les images en noir pur (ce qui, bien que logique, est tout à fait inutile). Le résultat est que l'image a été recolorée à l'aide d'une palette de couleurs dérivée mathématiquement ou « uniforme ». Vous pouvez le voir plus clairement sur une image en dégradé, produisant une distribution uniforme de niveaux de gris postérisés.

  #magick -size 20x640  gradient: -rotate 90  gradient.png
  magick gradient.png  +dither  -posterize 5   posterize_gradient.gif

Par exemple, postérisons l'image du logo IM à divers niveaux...

  magick logo.png  +dither -posterize 2  posterize_logo.gif
  magick logo.png          -posterize 2  posterize_logo_dither.gif
  magick logo.png          -posterize 6  posterize_6_logo.gif

Comme meilleur test, postérisons l'image ombrée « colorwheel ».

  magick colorwheel.png  +dither  -posterize 2   posterize_2_cw.gif
  magick colorwheel.png  +dither  -posterize 3   posterize_3_cw.gif
  magick colorwheel.png  +dither  -posterize 6   posterize_6_cw.gif

Et voici la même chose avec le tramage activé...

Bien sûr, beaucoup des tramages bitmap que nous examinons dans la section suivante peuvent aussi générer des tramages ordonnés de niveau 2, utilisant divers types de styles de tramage. Cependant, peu peuvent utiliser un plus grand nombre de niveaux de gris. Le Tramage ordonné, à partir d'IM v6.2.9, est aussi une méthode de postérisation, en raison de sa limitation actuelle de tramage à l'aide de palettes de couleurs uniformes. Cependant, le motif de tramage est plus uniforme, avec une plus large sélection de styles, que le tramage pseudo-aléatoire produit par « [-posterize](https://imagemagick.org/command-line-options/#posterize) ». Comparez ceux-ci avec les versions « [-posterize](https://imagemagick.org/command-line-options/#posterize) » tramées ci-dessus.

  magick colorwheel.png  -ordered-dither o8x8,2   posterize_2_od.gif
  magick colorwheel.png  -ordered-dither o8x8,3   posterize_3_od.gif
  magick colorwheel.png  -ordered-dither o8x8,6   posterize_6_od.gif

La carte de tramage « threshold » (au lieu de « o8x8 » utilisée ci-dessus) convertit effectivement « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » en une méthode de postérisation non tramée. Enfin, le Tramage ordonné vous permet de spécifier un nombre différent de niveaux de couleur, pour chaque canal de couleur individuel. Quelque chose que l'opérateur « [-posterize](https://imagemagick.org/command-line-options/#posterize) » ne permet pas actuellement.

Méthodes de tramage par seuil

Images seuillées

La méthode la plus simple pour convertir une image en une image bitmap noir et blanc (à partir de la couleur) consiste à utiliser « [-threshold](https://imagemagick.org/command-line-options/#threshold) ». Il s'agit en réalité d'un simple opérateur mathématique qui ne fait que fournir une valeur de coupure. Tout ce qui est inférieur ou égal à cette valeur devient noir, tandis que tout ce qui est supérieur devient blanc.

  magick logo.png     -threshold   -1   threshold_0.gif
  magick logo.png     -threshold  25%   threshold_25.gif
  magick logo.png     -threshold  50%   threshold_50.gif
  magick logo.png     -threshold  75%   threshold_75.gif
  magick logo.png     -threshold 100%   threshold_100.gif

Comme on peut le voir, une valeur de « -1 » rendra toutes les couleurs blanches, tandis que « 100% » convertit toutes les couleurs en noir. « 50% » est bien sûr la valeur la plus couramment utilisée. Une valeur de « 0 » est un cas particulier qui rend blanches toutes les couleurs qui ne sont pas d'un noir pur. Bien sûr, si l'image ne contient pas de couleurs noir pur, on n'obtiendra qu'une image entièrement blanche ! |

  magick logo.png  -threshold   0    threshold_black.gif

Si l'on souhaite réellement rendre noires toutes les couleurs qui ne sont pas d'un blanc pur, il est recommandé de seuiller l'image négativée plutôt que d'essayer de calculer la bonne valeur de seuil à utiliser (une de moins que le « MaxRGB » actuel d'IM), une valeur qui dépend du réglage de Qualité, ou « Q » fixé à la compilation de votre IM spécifique. |

  magick logo.png  -negate -threshold 0 -negate threshold_white.gif

L'opérateur « [-threshold](https://imagemagick.org/command-line-options/#threshold) » peut être considéré comme l'opérateur de « contraste » ultime, maximisant les différences entre couleurs par le niveau de seuil. Il s'agit toutefois d'un opérateur en niveaux de gris, ce qui signifie que le réglage « [-channel](https://imagemagick.org/command-line-options/#channel) » peut être utilisé pour ajuster à quel canal de couleur l'opérateur sera appliqué. Par exemple, on peut seuiller chacun des canaux individuels de l'image pour produire le même effet qu'une opération « [-posterize](https://imagemagick.org/command-line-options/#posterize) » de niveau 2 non tramée. |

  magick logo.png  -channel R -threshold 50% \
                     -channel G -threshold 50% \
                     -channel B -threshold 50%   threshold_posterize.gif

| Notez que « [-threshold](https://imagemagick.org/command-line-options/#threshold) » traite toute transparence d'une image comme un canal matte, et non comme un canal alpha (tout comme elle est stockée en interne dans IM). Il faut donc être prudent si l'on prévoit d'appliquer cet opérateur au canal alpha. Voir Canal Matte pour plus de détails.
---|---
Pour une technique de seuillage plus automatique, on peut utiliser la technique de Quantification à Deux Couleurs présentée précédemment. Par exemple, ceci va seuiller l'image en fonction des deux meilleures couleurs trouvées dans l'image. Ces couleurs ne sont pas nécessairement en niveaux de gris ni même opposées, ce sont simplement les deux couleurs qui représentent le mieux l'ensemble de l'image. Les deux couleurs sont ensuite mappées (à l'aide de « [-normalize](https://imagemagick.org/command-line-options/#normalize) ») sur du noir et du blanc purs. |

  magick logo.png  +dither  -colors 2  -colorspace gray -normalize \
             threshold_two_color.gif

Tramage et seuillage aléatoires

L'opérateur « [-random-threshold](https://imagemagick.org/command-line-options/#random-threshold) » est une forme particulière de convertisseur d'image bitmap. Dans ce cas, il utilise un « tramage aléatoire » très simple pour déterminer si un pixel donné doit devenir un pixel blanc ou un pixel noir. Contrairement aux opérateurs « [-threshold](https://imagemagick.org/command-line-options/#threshold) » ou « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) », ou même aux variantes de la section précédente, les canaux sélectionnés (fixés avec « [-channels](https://imagemagick.org/command-line-options/#channels) ») ne sont pas fusionnés en un seul canal en niveaux de gris et tramés comme une seule unité. Au lieu de cela, « [-random-threshold](https://imagemagick.org/command-line-options/#random-threshold) » travaille sur chaque canal sélectionné de manière totalement indépendante des autres. Bien sûr, utiliser l'opérateur directement produira une postérisation à 2 niveaux de l'image au moyen d'un tramage aléatoire. |

  magick logo.png  -random-threshold  0x100%  random_posterize.gif

La conversion en niveaux de gris égalisera tous les canaux de l'image avant qu'ils ne soient tramés. Mais comme chaque canal est tramé indépendamment des autres et de manière aléatoire, le résultat n'est pas une image bitmap comme on pourrait s'y attendre. On obtiendra plutôt une éclaboussure de pixels colorés, en particulier pour les couleurs de tons moyens. |

  magick logo.png  -colorspace Gray -random-threshold  0x100% \
                                                   random_greyscale.gif

Voici la manière correcte de générer une véritable image bitmap tramée aléatoirement. |

  magick logo.png  -colorspace Gray -channel B \
          -random-threshold 0x100%    -separate   random_monochome.gif

En substance, ce qui a été fait ici est de ne tramer qu'un seul canal de l'image en niveaux de gris, puis d'utiliser l'opérateur de canal « [-separate](https://imagemagick.org/command-line-options/#separate) » pour extraire ce canal comme image bitmap finale. Astucieux mais efficace. Comme fonctionnalité spéciale de cet opérateur, IM garantira la génération d'une image bitmap si l'option spéciale « [-channels](https://imagemagick.org/command-line-options/#channels) » avec la valeur « All » est utilisée. |

  magick logo.png  -channel All -random-threshold 0x100% random_all.gif

Notez toutefois que tout canal alpha sera ignoré et perdu avec cette méthode, c'est pourquoi elle n'est normalement pas recommandée. J'ai moi-même découvert cette ancienne fonctionnalité par accident dans le code source. Maintenant que vous savez comment utiliser l'opérateur pour générer correctement des bitmaps à partir d'une image en couleur, voyons comment l'argument affecte la plage du tramage. Cela montre aussi clairement le « regroupement » des pixels que ce tramage produit.

  #magick -size 20x640  gradient: -rotate 90  gradient.png
  magick gradient.png  -channel All \
                        -random-threshold 0x100%  random_grad_0x100.gif
  magick gradient.png  -channel All \
                        -random-threshold 10x90%  random_grad_10x90.gif
  magick gradient.png  -channel All \
                        -random-threshold 25x75%  random_grad_25x75.gif
  magick gradient.png  -channel All \
                        -random-threshold 50x50%  random_grad_50x50.gif

Un réglage de « [-random-threshold](https://imagemagick.org/command-line-options/#random-threshold) » à « 0x100% » produira un « tramage aléatoire » pur de l'image. Si les deux bornes sont fixées à la même valeur (ou même se croisent), cela produira simplement une image « [-threshold](https://imagemagick.org/command-line-options/#threshold) » pure. L'utilisation de tout autre ensemble de bornes (généralement spécifiées en pourcentage) seuillera le bitmap en dehors de la plage donnée, tout en produisant un motif de tramage aléatoire pour les valeurs situées à l'intérieur de la plage donnée. Les meilleurs résultats s'obtiennent en utilisant une plage légèrement plus réduite, tout comme avec l'opérateur « [-monochrome](https://imagemagick.org/command-line-options/#monochrome) ». Une valeur d'environ « 30x80% » donne probablement le meilleur résultat dans la plupart des cas. |

  magick logo.png  -channel All -random-threshold 30x80%  random_30x80.gif

Bien sûr, le résultat n'est toujours pas très bon. Mais il s'agit là de la forme de tramage la plus simple et la plus médiocre que l'on puisse obtenir. Ce qui se produit en réalité, c'est que le motif de tramage aléatoire tend à produire des « amas » de pixels plutôt qu'un motif de tramage régulier. Cela est dû au « bruit » de haute fréquence du générateur de nombres aléatoires. Cependant, à de très hautes résolutions, il a été démontré qu'un tramage aléatoire produit un résultat extrêmement bon, s'il est suffisamment aléatoire. IM utilise un niveau de hasard de qualité cryptographique, il sera donc probablement très aléatoire, bien que les images soient rarement utilisées à une résolution suffisamment élevée pour rendre cela utile de cette manière. Une « correction » proposée pour ce tramage consiste à utiliser un générateur de « bruit bleu » aléatoire (un filtre de haute fréquence, par opposition au filtre de « bruit rose » de basse fréquence utilisé en production sonore). Cela devrait éliminer le regroupement des pixels, mais est très difficile à implémenter numériquement. Aucune implémentation connue de « tramage aléatoire à bruit bleu » n'a été trouvée, et il est peu probable qu'une telle implémentation soit un jour créée.

Tramage ordonné

Alors qu'un tramage aléatoire produit des amas aléatoires de pixels, et que les divers tramages à correction d'erreur produisent un motif de points essentiellement aléatoire, le tramage ordonné est fondamentalement l'opposé. Il est conçu pour être aussi déterministe mathématiquement que possible. Si déterministe, en fait, qu'il faut réellement spécifier le motif qu'il doit utiliser pour tramer l'image. L'opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » tramera chacun des « [-channels](https://imagemagick.org/command-line-options/#channels) » sélectionnés de l'image selon un motif prédéfini donné. L'argument définit le motif (appelé carte de seuils) à utiliser. Ces cartes de seuils se répartissent en trois styles de base. Les Tramages à Pixels Diffusés, où les pixels sont placés aussi loin les uns des autres que possible, afin d'éviter le « regroupement » et les artefacts de pavage. Ou bien on les regroupe en points serrés qui les rendent plus faciles à imprimer mécaniquement, selon une technique connue sous le nom de Similigravure Numérique. Il existe aussi certaines cartes de seuils artistiques spécialisées que nous examinerons également, et nous concevrons même notre propre motif de tramage ou carte de seuils. Dans chaque cas, le nombre de pixels allumés ou éteints dans la carte de seuils dépend de l'intensité de niveau de gris de l'image (ou du canal de couleur individuel) qui est tramée en bitmap. La carte ajoute des niveaux de seuil de pixels de manière cohérente, de sorte qu'une fois qu'un pixel s'allume à un « seuil » particulier, il reste allumé pour toute couleur grise plus claire. Cette cohérence est très importante, sinon des artefacts se produisent le long des frontières où le motif de tramage change. Le point important est que le résultat pour chaque pixel d'une image est purement déterminé mathématiquement, indépendamment de tout autre pixel de l'image. Ainsi, tout petit changement dans l'image d'origine n'aura absolument aucun effet sur l'image dans une autre zone, un problème que les Tramages à Correction d'Erreur présentent, comme nous l'avons vu ci-dessus. Ce point est essentiel pour un tramage cohérent des images vidéo et des animations optimisées.

Tramage à pixels diffusés

L'objectif initial du tramage ordonné, et ce que la plupart des programmeurs graphiques s'attendent à obtenir lorsqu'ils utilisent un tramage ordonné, est parfois désigné plus correctement par « Tramage Ordonné à Pixels Diffusés ». Cela signifie que les pixels sont ajoutés à la carte pavée à mesure que l'intensité du seuil augmente, de sorte qu'ils soient aussi éloignés les uns des autres et répartis aussi uniformément que possible. Cela produit un motif très cohérent qui paraît assez régulier et presque invisible sur la plupart des écrans modernes. De tels motifs ont été mis au point pour des tailles de pavage qui sont des puissances de 2, à savoir des tailles de tuile de 2, 4 et 8. IM fournit toutefois aussi un motif de seuils raisonnable pour une tuile de carte de seuils de 3 sur 3. Voici l'ensemble actuel des tramages ordonnés intégrés que IM fournit actuellement. Rappelez-vous que l'argument reflète la taille de tuile du tramage ordonné.

  magick logo.png    -ordered-dither o2x2    logo_o2x2.gif
  magick logo.png    -ordered-dither o3x3    logo_o3x3.gif
  magick logo.png    -ordered-dither o4x4    logo_o4x4.gif
  magick logo.png    -ordered-dither o8x8    logo_o8x8.gif

Notez comment une taille de tuile plus grande permet de simuler davantage de « niveaux de couleur », mais génère aussi des défauts plus visibles ou des rangées rectangulaires de pixels à certains niveaux. | _Le tramage ordonné « o8x8 » a fait partie du code principal d'IM pendant longtemps, mais n'était pas utilisé. Il n'a été ajouté comme option de l'opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » que dans IM v6.2.9, lorsque IM Examples a commencé à détailler l'utilisation de cet opérateur.

À cette époque, les cartes ont reçu des noms plus définitifs pour permettre une extension ultérieure de l'opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) », bien que les anciens noms de « taille de tuile » rétrocompatibles aient été conservés comme alias des nouveaux noms.

De plus, les « cartes » qui produisaient les « o3x3 » et « o4x4 » ont été entièrement révisées pour produire un meilleur motif de tramage à « pixels diffusés ». Avant cela, les cartes produisaient des « amas » de pixels distincts.

Voir la page de notes Mise à Niveau du Tramage Ordonné pour des exemples des anciens motifs avant leur correction, ainsi que d'autres changements apportés lors du développement pour la publication officielle des mises à niveau dans IM v6.3.0._
---|---
Bien sûr, il faut d'abord convertir l'image en niveaux de gris pour produire un bitmap correct de tous les canaux de l'image ; cependant, comme le processus n'est pas aléatoire, il n'est pas nécessaire de post-traiter l'image comme il le faut pour l'opérateur -random-threshold », ce qui simplifie énormément les choses.

  magick logo.png -colorspace Gray  -ordered-dither o2x2  logo_bw_o2x2.gif
  magick logo.png -colorspace Gray  -ordered-dither o3x3  logo_bw_o3x3.gif
  magick logo.png -colorspace Gray  -ordered-dither o4x4  logo_bw_o4x4.gif
  magick logo.png -colorspace Gray  -ordered-dither o8x8  logo_bw_o8x8.gif

À titre de référence, voici chacun des motifs à « pixels diffusés » de « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » appliqués à un dégradé en niveaux de gris, afin de voir clairement à quoi ils ressemblent.

  # Non-tramage par seuil / Tramage en damier minimal
  magick gradient.png   -ordered-dither threshold  od_threshold.gif
  magick gradient.png   -ordered-dither checks     od_checks.gif
  # Tramage à pixels diffusés
  magick gradient.png   -ordered-dither o2x2       od_o2x2.gif
  magick gradient.png   -ordered-dither o3x3       od_o3x3.gif
  magick gradient.png   -ordered-dither o4x4       od_o4x4.gif
  magick gradient.png   -ordered-dither o8x8       od_o8x8.gif

Le nombre de motifs de niveaux effectifs ou pseudo-niveaux produits par un tramage ordonné donné est généralement (mais pas toujours) égal au nombre de pixels du motif plus un. Ainsi, un tramage ordonné « o3x3 » produira 3×3+1, soit 10 niveaux de gris effectifs par canal (noir, blanc et 8 motifs de gris artificiels) dans l'image résultante. Sont également montrées ci-dessus deux cartes de seuils de tramage minimales spéciales :

1. un non-tramage à « seuil de 50 % » direct, qui ne produit aucun niveau de gris supplémentaire et
2. un motif de tramage « checks » ou en damier, qui n'insère qu'un seul motif afin d'ajouter un « pseudo-niveau » supplémentaire au dégradé résultant.

Tramages en similigravure numérique

  # Trame de similigravure (angle de 45 degrés)
  magick logo.png   -ordered-dither h4x4a    logo_h4x4a.gif
  magick logo.png   -ordered-dither h6x6a    logo_h6x6a.gif
  magick logo.png   -ordered-dither h8x8a    logo_h8x8a.gif
  # Trame de similigravure (orthogonale)
  magick logo.png   -ordered-dither h4x4o    logo_h4x4o.gif
  magick logo.png   -ordered-dither h6x6o    logo_h6x6o.gif
  magick logo.png   -ordered-dither h8x8o    logo_h8x8o.gif

À nouveau, utiliser l'opérateur « [-colorspace](https://imagemagick.org/command-line-options/#colorspace) » pour générer un véritable tramage bitmap d'une image.

  # Trame de similigravure (angle de 45 degrés)
  magick logo.png -colorspace Gray  -ordered-dither h4x4a logo_bw_h4x4a.gif
  magick logo.png -colorspace Gray  -ordered-dither h6x6a logo_bw_h6x6a.gif
  magick logo.png -colorspace Gray  -ordered-dither h8x8a logo_bw_h8x8a.gif
  # Trame de similigravure (orthogonale)
  magick logo.png -colorspace Gray  -ordered-dither h4x4o logo_bw_h4x4o.gif
  magick logo.png -colorspace Gray  -ordered-dither h6x6o logo_bw_h6x6o.gif
  magick logo.png -colorspace Gray  -ordered-dither h8x8o logo_bw_h8x8o.gif

Et enfin, une autre image de référence en dégradé pour montrer clairement le motif de tramage en similigravure, et comment les amas de pixels au sein du motif de tramage grandissent pour se rejoindre à mesure que le niveau de gris change.

  # Trame de similigravure (angle de 45 degrés)
  magick gradient.png   -ordered-dither h4x4a      od_h4x4a.gif
  magick gradient.png   -ordered-dither h6x6a      od_h6x6a.gif
  magick gradient.png   -ordered-dither h8x8a      od_h8x8a.gif
  # Trame de similigravure (orthogonale)
  magick gradient.png   -ordered-dither h4x4o      od_h4x4o.gif
  magick gradient.png   -ordered-dither h6x6o      od_h6x6o.gif
  magick gradient.png   -ordered-dither h8x8o      od_h8x8o.gif
  magick gradient.png   -ordered-dither h16x16o    od_h16x16o.gif
  # Similigravures circulaires (noir et blanc)
  magick gradient.png   -ordered-dither c7x7b      od_c7x7b.gif
  magick gradient.png   -ordered-dither c7x7w      od_c7x7w.gif

Jusqu'à la version 6.2.9 d'ImageMagick, toutes les cartes de tramage ordonné par seuil ci-dessus étaient tout ce qui était possible avec IM. Cela a désormais changé, permettant aux utilisateurs d'ajouter leurs propres motifs, voire de les contribuer à la communauté IM. Les seuils de similigravure « Circle » ont été ajoutés par Glenn Randers-Pehrson, IM v6.6.5-6.

Tramage par similigravure décalée

Le seul problème du tramage par similigravure ci-dessus est que la carte de seuils (tuile) exactement identique est appliquée à tous les canaux de couleur de la même manière. Cela signifie que le même ensemble de couleurs primaires est disposé en points ayant le même « centre ». Pour obtenir ce que l'on appelle l'« impression décalée » (offset), le motif de seuils est pivoté selon un schéma particulier de sorte que les couleurs forment de petites « rosettes » qui détruisent les motifs d'interférence (moiré) bien plus disgracieux que l'on pourrait sinon obtenir. Ce diagramme explique en gros le procédé, détaillé de façon approfondie sur la page Wikipédia Halftone.

Notez cependant que les trames pivotées ne se juxtaposent pas très bien ; c'est pourquoi la meilleure idée est en réalité de générer le motif pivoté directement, plutôt que d'utiliser un motif de seuils en tuiles. Voici une manière de donner à une image un aspect d'impression offset en similigravure, à l'aide d'un petit motif en damier pivoté de 2x2 pixels, ce qui correspond à peu près à la plus petite « trame » utilisable. |

  magick colorwheel.png  -set option:distort:viewport '%wx%h+0+0' \
          -colorspace CMYK -separate null: \
          \( -size 2x2 xc: \( +clone -negate \) \
                +append \( +clone -negate \) -append \) \
          -virtual-pixel tile -filter gaussian \
          \( +clone -distort SRT 60 \) +swap \
          \( +clone -distort SRT 30 \) +swap \
          \( +clone -distort SRT 45 \) +swap \
          \( +clone -distort SRT 0 \)  +swap +delete \
          -compose Overlay -layers composite \
          -set colorspace CMYK -combine -colorspace RGB \
          offset_colorwheel.png

Notez que les quatre « trames » pivotées sont appliquées à l'image dans son ensemble ; c'est seulement l'étape « -combine » dans l'espace colorimétrique CMYK qui extrait réellement les 4 canaux de couleur distincts des images tramées. De plus, la distorsion « sans effet » (no-op) pour le dernier canal « noir » est importante car elle floute le damier d'entrée selon le filtre gaussien utilisé sur les autres canaux lors de leurs rotations, même si cette trame elle-même n'est pas pivotée. Et ici j'utilise la fonction de mise à l'échelle de la distorsion SRT employée pour générer les tuiles pivotées, afin de créer un « motif de trame » légèrement plus grand et plus flou.

  magick parrots_med.png  -set option:distort:viewport '%wx%h+0+0' \
          -colorspace CMYK -separate null: \
          \( -size 2x2 xc: \( +clone -negate \) \
                +append \( +clone -negate \) -append \) \
          -virtual-pixel tile -filter gaussian \
          \( +clone -distort SRT 2,60 \) +swap \
          \( +clone -distort SRT 2,30 \) +swap \
          \( +clone -distort SRT 2,45 \) +swap \
          \( +clone -distort SRT 2,0  -blur 0x0.7 \) +swap +delete \
          -compose Overlay -layers composite \
          -set colorspace CMYK -combine -colorspace RGB \
          offset_parrots.png

Notez que le motif reste très « carré », en particulier la trame noire dont toutes les autres sont dérivées. POSSIBILITÉ FUTURE : remplacer le damier de 2 pixels ci-dessus par le motif en damier au niveau du pixel « pattern:gray50 ». Les options du filtre gaussien peuvent servir à ajuster le flou du motif mis à l'échelle. On peut aussi mettre le motif à l'échelle avec du flou, puis le seuiller, pour obtenir des points plus arrondis. Il peut ensuite être pivoté comme précédemment pour créer les 4 trames de couleur. Il vaudrait aussi mieux pouvoir utiliser une trame plus grande à motif de points hexagonaux, plutôt que le motif en damier que j'ai utilisé ci-dessus.
Il est important de noter que cela ne génère pas réellement des points de couleur comme la vraie impression offset, mais l'imite simplement en multipliant les trames de couleur contre l'image d'origine. On voit que c'est bien le cas au changement brusque de couleur le long des bords du perroquet rouge sur le fond vert. La vraie impression offset, n'utilisant que des points de couleur pure, n'aura aucun changement de couleur au milieu d'un point. C'est la taille du point de couleur pure qui doit changer, selon la moyenne des couleurs de la zone représentée par ce point dans l'image source. Générer réellement une image d'impression offset ne contenant que des points ronds de taille appropriée dans chaque canal de couleur demanderait bien plus de travail. La couleur moyenne de chaque point dans chaque canal de couleur devrait être déterminée, et à partir de là, le point de couleur de taille appropriée (cercle anticrénelé) généré. Quelqu'un veut-il s'y essayer ? Ce qui précède est issu d'une discussion sur le forum IM, CMYK Halftone Effect, qui examine comment photoshop « fait semblant » et comment ImageMagick pourrait obtenir le même effet. Cette discussion est aussi liée à B/W Halftone Dither, qui étudie de plus près la génération de vraies trames de similigravure à l'aide de points réels de taille appropriée. Cette discussion n'est cependant pas allée jusqu'à l'étape suivante de l'utilisation de trames décalées (pivotées). De telles trames nécessiteraient probablement de pivoter l'image pour générer les points, puis de repivoter le motif de points pour ce canal de couleur spécifique.

Cartes de seuils XML

Depuis la version 6.3.0 d'IM, plutôt que d'utiliser un ensemble fixe de cartes intégrées au code source d'IM (montrées précédemment), les cartes sont désormais lues depuis un ensemble de fichiers de données XML externes au programme lui-même. Dans le cadre de ce changement, vous pouvez maintenant lister les « cartes de seuils » disponibles que l'opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » peut utiliser.

  magick identify -list threshold

La liste ci-dessus montre non seulement les cartes de seuils disponibles, mais aussi les alias fournis pour la rétrocompatibilité ou pour des noms alternatifs, ainsi que ceux définis dans mon propre fichier de données XML « thresholds.xml » (enregistré dans le sous-répertoire « .magick » de mon répertoire personnel). Lorsque « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » recherche une carte, la première carte qu'il trouve dans la liste ci-dessus sera utilisée. Vous ne pouvez donc pas remplacer un motif de seuils défini par le système. Le fichier système « thresholds.xml » (dont le chemin est donné par l'option « [-list](https://imagemagick.org/command-line-options/#list) » ci-dessus) contient un résumé complet du format du fichier XML. Un format suffisamment simple (avec vérifications d'erreurs par IM) pour permettre aux utilisateurs de définir et de créer leurs propres cartes de seuils de tramage ordonné. Par exemple, voici une copie de la carte de seuils « diag5x5 » que j'ai définie dans mon fichier personnel « threshold.xml ».

Si vous l'examinez, elle crée une simple carte 5x5 d'une seule ligne diagonale qui s'épaissit à mesure que le niveau de seuil augmente. Les numéros de niveau dans la carte vont de 0 à 5, soit un de moins que le diviseur, qui déclare en combien de « gris » il doit diviser le dégradé de couleur. Voici un dégradé tramé à l'aide de cette carte de seuils personnelle.

  magick gradient.png   -ordered-dither diag      od_diag.gif

Et voici un exemple d'utilisation de ce seuil pour tramer le canal alpha d'une simple image ombrée, un usage pour lequel je l'ai conçu.

  magick -size 70x60 xc:none -font Candice -pointsize 50 \
          -fill black -annotate +10+45 'A' -channel RGBA  -blur 0x5 \
          -fill white -stroke black -draw "text 5,40 'A'"   shadow.png

  magick shadow.png  -channel A  -ordered-dither diag   shadow_diag.gif

Plutôt cool, hein ! Plus loin, davantage sur le tramage des canaux alpha. Il me faut d'abord montrer comment utiliser les capacités de coloration de l'opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » étendu.

Tramage ordonné utilisant des niveaux de couleur uniformes

Avec la sortie d'IM v6.3.0, non seulement les cartes de seuils utilisées par « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » ont été modifiées pour être lues depuis des fichiers externes, mais les opérations internes ont été améliorées pour lui permettre d'utiliser des palettes de couleurs « postérisées » définies mathématiquement. Cela signifie que vous pouvez générer un tramage d'images plus déterministe que ce que permet le « tramage par correction d'erreur ». C'est particulièrement important pour les réductions de couleurs impliquant des animations, car vous n'aurez pas de problèmes dus aux différences de couleur entre les images. Les niveaux de postérisation sont passés à l'argument « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » à l'aide d'une liste supplémentaire de nombres séparés par des virgules, ajoutée au nom de la carte de seuils à utiliser. Si aucun nombre n'est fourni, l'opérateur revient à la palette normale à 2 couleurs (ou niveau de postérisation 1). Par exemple, un argument « checks,6 » utilisera une classique palette de couleurs Web Safe (niveau de postérisation 6) (également définie par l'image de palette intégrée « netscape: »). Cependant, comme la carte de tramage minimale « checks » est utilisée, un seul niveau de tramage supplémentaire est ajouté entre chacun des 6 niveaux de couleur, créant 11 pseudo-niveaux de couleurs dans chaque canal de l'image. Autrement dit, même si seuls 6 niveaux de couleur par canal sont utilisés (produisant 6^3 soit 216 couleurs), le motif de tramage unique entre les niveaux porte le tramage à 11 niveaux effectifs (produisant 11^3 soit 1331 couleurs effectives). Par exemple, voici un dégradé en niveaux de gris tramé à l'aide de 6 niveaux de gris et de diverses cartes de seuils. La première carte « threshold » est une carte de seuils de tramage ordonné spéciale non tramante, montrant simplement les couleurs utilisées.

  magick gradient.png   -ordered-dither threshold,6  od_threshold_6.gif
  magick gradient.png   -ordered-dither checks,6     od_checks_6.gif
  magick gradient.png   -ordered-dither o2x2,6       od_o2x2_6.gif
  magick gradient.png   -ordered-dither o4x4,6       od_o4x4_6.gif
  magick gradient.png   -ordered-dither o8x8,6       od_o8x8_6.gif

Comme vous pouvez le voir, même si seulement 6 couleurs sont utilisées, le tramage ordonné augmente le nombre effectif de couleurs employées pour définir le dégradé, au point qu'il devient difficile de remarquer combien peu de couleurs ont réellement été utilisées ! Non seulement vous pouvez définir le nombre de niveaux de postérisation pour tous les canaux, mais contrairement à l'option de tramage par correction d'erreur « [-posterize](https://imagemagick.org/command-line-options/#posterize) », vous pouvez spécifier les niveaux pour chaque canal. Les nombres sont attribués aux canaux selon le réglage « [-channels](https://imagemagick.org/command-line-options/#channels) ». Par exemple, ici nous avons tramé le dégradé à l'aide d'une palette de couleurs 332 spéciale (8 niveaux de rouge et de vert, 4 de bleu) qui définit un total de 256 couleurs.

  magick gradient.png   -ordered-dither o8x8,8,8,4   od_o8x8_884.gif

En raison du nombre différent de niveaux de couleur par canal, l'image ci-dessus ne contient pas uniquement des gris purs, mais inclut quelques pixels bleutés et jaunâtres qui s'annulent mutuellement pour produire des niveaux de gris supplémentaires. Comparez maintenant la version tramée par O-Dither à la version tramée par correction d'erreur, en utilisant des niveaux de postérisation de 2 et 6, ainsi qu'une « palette 332 » (8 niveaux de rouge et de vert, 4 de bleu).

  magick logo.png  -ordered-dither o8x8        logo_o8x8_2.gif
  magick logo.png  -posterize 2                logo_posterize_2.gif
  magick logo.png  -ordered-dither o8x8,6      logo_o8x8_6.gif
  magick logo.png  -posterize 6                logo_posterize_6.gif
  magick logo.png  -ordered-dither o8x8,8,8,4  logo_o8x8_332.gif
  magick logo.png  -remap colormap_332.png     logo_remap_332.gif

La première image de chaque paire ci-dessus est tramée par tramage ordonné mathématique, tandis que la seconde est tramée par « correction d'erreur » pseudo-aléatoire. La dernière paire utilise la « palette 332 » spéciale (voir Génération de palettes de couleurs), considérée comme probablement la meilleure palette de postérisation pour des images générales avec une limite de 256 couleurs. La différence impaire des niveaux par canal produit un ombrage des couleurs légèrement meilleur pour cette image de type dessin animé. C'est pour permettre la production de la « palette 332 » que l'opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » a inclus la possibilité de spécifier des niveaux distincts pour chaque canal de couleur.

De meilleurs résultats de tramage ordonné

Examinons de plus près le O-Dither de niveau 6 que nous venons de générer.

  magick logo.png -ordered-dither o8x8,6 -format %k info:

Comme vous pouvez le voir, pour cette image, nous ne nous sommes même pas approchés du remplissage de la table de couleurs GIF (limite de 256). En gros, comme l'image est composée principalement de couleurs bleues, très peu de nuances de rouge, voire de vert, d'une palette uniforme de niveau 6 ont été utilisées. Cependant, en augmentant le nombre de niveaux de postérisation, nous pouvons mieux remplir la table de couleurs GIF, afin de produire une meilleure image tramée par O-Dither.

  magick logo.png -ordered-dither o8x8,13 -format %k info:

Cela produit assez de couleurs pour n'être que légèrement en dessous des limites de la table de couleurs GIF. Avec l'augmentation du nombre de couleurs, le résultat est bien meilleur que celui d'une simple palette uniforme standard. |

  magick logo.png -ordered-dither o8x8,13    logo_o8x8_13.gif

Comme vous pouvez le voir avec une valeur « levels » élevée, « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » peut produire des images comparables à celles quantifiées en couleur, au choix précis de couleurs généré par la quantification de couleur et un tramage par correction d'erreur. Le point majeur à propos de ces images n'est pas qu'elles sont de haute qualité. Après tout, une quantification de couleur complète peut plus facilement produire une meilleure palette pour l'image. Mais c'est que le motif de tramage de bas niveau à l'intérieur de l'image est fixe, indépendamment de tout petit changement pouvant survenir. Seuls les changements de zone seront modifiés dans l'image tramée par tramage ordonné. Autrement dit, elles n'ont pas la sensibilité au tramage E-Dither au changement, qui pose problème pour l'optimisation des images dans les animations GIF. (voir Problème d'optimisation) Bien sûr, pour une animation, vous devrez « [-append](https://imagemagick.org/command-line-options/#append) » toutes les images ensemble avant de vérifier combien de couleurs sont réellement utilisées. Et vous devrez utiliser l'option spéciale « [+remap](https://imagemagick.org/command-line-options/#remap) » après avoir utilisé « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » pour forcer IM à générer une « palette de couleurs globale commune » pour TOUTES les images, même si vous avez déjà effectué la réduction de couleurs et le tramage. Cette méthode de détermination du nombre de niveaux de couleur n'est pas simple à déterminer, mais elle fonctionne. J'espère élaborer un moyen pour qu'IM détermine automatiquement le meilleur niveau, en particulier pour les animations GIF.

Motifs de tramage et cartes de seuils faits maison

Précédemment, j'ai montré que le nouvel opérateur « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » peut accepter un motif de tramage défini par l'utilisateur. Ici, je vais montrer comment créer son propre motif de tramage. Plus précisément, un motif particulier que j'ai trouvé utile pour générer des ombres constituées de lignes horizontales.

Motifs de tramage multi-images

La première chose à faire est de créer un jeu d'images définissant le motif que l'on souhaite créer. Le motif doit commencer par une image entièrement noire de la bonne taille comme première image (tous les pixels éteints) et une image entièrement blanche à l'autre extrémité (tous les pixels allumés). L'image suivante doit être le motif de gris à 50 % du milieu, définissant le style de base du tramage que l'on cherche à obtenir. Par exemple, voici mon motif de tramage fait maison initial. Que j'enregistre dans un fichier GIF multi-images (pas une animation GIF)...

  magick -size 2x2 xc:black \
          \( +clone -draw 'fill white line 0,0 1,0' \) \
          xc:white     dpat_hlines2x2.gif
  montage dpat_hlines2x2.gif    -tile x1 -background none -frame 2 \
          -filter box  -geometry 32x32+5+0    dpat_hlines2x2_imgs.gif

C'est à peu près le jeu d'images de motif de tramage le plus simple que l'on puisse obtenir, et il est très semblable au « tramage en damier » ou « Checkerboard Dither », mais avec des lignes horizontales plutôt qu'un motif en damier. Pour voir à quoi ressemblerait ce motif de tramage, voici un tramage ordonné fait maison assez simple, qui utilise directement le jeu d'images de tramage par seuil.

  magick gradient.png   dpat_hlines2x2.gif \
          -virtual-pixel tile  -fx 'u[(floor((n-1)*u)+1) % n]' dgrad_hlines2x2.gif

  magick shadow.png dpat_hlines2x2.gif  -channel A \
          -virtual-pixel tile  -fx 'u[floor((n-1)*u)+1].g' \
          shadow_dpat_hlines2x2.gif

Cartes de seuils de tramage ordonné faites maison

Le motif de tramage fait maison ci-dessus est à peu près le motif de tramage le plus simple que l'on puisse obtenir, et à ce titre nous pouvons le transformer directement en une carte de seuils XML, afin que l'opérateur intégré et rapide « [-ordered-dither](https://imagemagick.org/command-line-options/#ordered-dither) » puisse l'utiliser. Voici la définition XML finale, que j'ai enregistrée dans mon propre fichier de cartes de seuils personnel « ~/.magick/thresholds.xml » de mon répertoire « $HOME ».

Le format XML est très simple et définit une carte de 2x2 pixels. La première image noire reçoit la valeur zéro, et n'a aucun pixel, donc aucune valeur zéro n'est présente. Les pixels allumés (rendus blancs) dans l'image du milieu sont réglés à « 1 » et les pixels restants ou de la seconde image reçoivent la valeur « 2 ». Le « divisor= » définit le nombre d'images, ou de niveaux de pseudo-couleur (faux niveaux de couleur) que représente ce motif de tramage, il a donc la valeur « 3 ». Il divise les valeurs des pixels afin de définir le niveau de couleur auquel ce pixel doit être allumé. Ainsi, les deux pixels du haut sont allumés pour les couleurs supérieures à 1/3, tandis que les deux du bas sont allumés pour les valeurs de couleur supérieures à 2/3. Autrement dit, chaque valeur de pixel représente un niveau de « seuil », et c'est pourquoi les motifs de tramage sont aussi appelés cartes de seuils. Le reste de la définition définit les noms (et l'alias facultatif) par lesquels on peut faire référence à la carte de seuils pour l'opérateur de tramage ordonné. Alors essayons-la...

  magick gradient.png  -ordered-dither hlines2x2  od_hlines2x2.gif
  magick shadow.png  -channel A \
          -ordered-dither hlines2x2   shadow_hlines2x2.gif

Comme on peut le voir, le résultat est raisonnablement bon, mais nous pouvons faire d'autres choses pour l'améliorer. En ajustant les valeurs de seuil dans la carte, nous pouvons modifier les frontières, de sorte qu'elle ne divise pas l'espace colorimétrique en 3 zones égales...

Notez comment j'ai augmenté le diviseur à « 10 », afin de diviser les niveaux de couleur en dix sections égales. J'ai ensuite modifié les réglages de seuil pour que le motif commence à un seuil de 30 % à l'extrémité transparente (noir), jusqu'à 90 % pour un état entièrement opaque (blanc). Et voici les résultats de la modification de la carte de seuils.

  magick gradient.png  -ordered-dither hlines2x2a  od_hlines2x2a.gif
  magick shadow.png -channel A \
          -ordered-dither hlines2x2a  shadow_hlines2x2a.gif

Comme on peut le voir, cela a élargi la plage des pixels semi-transparents qui utilisent des lignes purement horizontales comme motif de tramage. Cela donne un meilleur effet d'ombre, bien qu'il ne devrait probablement être utilisé qu'avec une ombre moins floue que celle de l'exemple employé ici. Notez cependant que ce type de modification d'un seuil est très inhabituel. Bien que justifié pour l'usage prévu dans ce cas. En gros, cela ne définit pas correctement un dégradé et ne permet pas des teintes plus claires ou plus foncées des motifs. Pour cela, il nous faut créer une carte de seuils bien plus complexe, avec davantage de pixels et davantage de motifs.

Tramage à lignes horizontales fait maison

Ici, j'ai étendu le simple motif de tramage à lignes horizontales que j'ai créé ci-dessus en un jeu de motifs, afin de produire un dégradé plus doux de « éteint » à « allumé ». Voici le résultat.

  montage dpat_hlines.gif   -filter box   -geometry 60x20+2+0 \
          -tile x1 -background none  -frame 2   dpat_hlines_images.gif
  magick gradient.png  dpat_hlines.gif  \
          -virtual-pixel tile  -fx 'u[(floor((n-1)*u)+1) % n]' \
          dgrad_dpat_hlines.gif
  magick shadow.png dpat_hlines.gif  -channel A \
          -virtual-pixel tile  -fx 'u[floor((n-1)*u)+1].g' \
          shadow_dpat_hlines.gif

Comme on peut le voir, il se compose désormais de 9 images de 12x4 pixels. Il ne représente pas tous les motifs de pixels que l'on pourrait avoir, mais cela renforce l'effet des lignes. J'ai aussi doublé sa hauteur afin de décaler correctement les intervalles entre les lignes. Voici un autre exemple d'utilisation de ce motif de tramage...

  magick -size 120x55 xc:white  -draw 'fill #777 ellipse 50,43 30,5 0,360' \
          -motion-blur 0x15+180   -blur 0x2      sphere_shadow.png
  magick sphere_shadow.png dpat_hlines.gif \
          -virtual-pixel tile  -fx 'u[(floor((n-1)*u)+1) % n]' \
          sphere_shadow_dither.gif
  magick sphere_shadow_dither.gif   -fill red  -stroke firebrick \
          -draw 'circle 35,25 35,5'     sphere_shadow_hlines.gif

L'étape suivante consiste à transformer ce jeu de motifs de tramage en une seule image de carte de seuils, plutôt qu'en un jeu d'images multiples. On y parvient en utilisant quelques manipulations d'images astucieuses pour fusionner toutes les images ensemble.

|

  magick -size 1x10 gradient: -flip -crop 1x1 +repage -delete 0,-1 \
          -scale 12x4\! null: \( dpat_hlines.gif -delete 0 \) \
          -alpha off -compose CopyOpacity -layers Composite \
          -reverse -compose Over -flatten -alpha off dmap_hlines.png

La valeur « 10 » est un de plus que le nombre d'images du motif de tramage, tandis que « -scale 12x4\! » est la taille des motifs de tramage convertis en carte de seuils. Le résultat est une carte en niveaux de gris, sans couleurs noires ni blanches pures. Le niveau de gris utilisé pour un pixel signifie que si le niveau de couleur est égal ou supérieur à cette valeur de gris, alors ce pixel doit être allumé. Autrement dit, chaque niveau de gris est le niveau de « seuil » auquel la valeur de couleur passe du noir au blanc. Si l'on préfère considérer l'image d'une autre manière, les pixels sombres font généralement que ces pixels sont allumés pour davantage de niveaux de couleur. Tandis que les pixels clairs ne sont allumés que lorsque la couleur de l'image devient très vive. C'est presque une négation de ce à quoi ressemble réellement l'image, mais si l'on y réfléchit, cela a du sens. J'ai également utilisé une image PNG plutôt qu'une image GIF pour la carte, car une seule image a besoin d'être enregistrée, et surtout, pour tenter de préserver la qualité des niveaux sur 16 bits pour les valeurs de seuil. Le GIF ne peut gérer que des niveaux de couleur sur 8 bits. Nous pouvons maintenant tramer nos images en utilisant une seule image, et une comparaison de seuil bien plus simple de chaque pixel directement par rapport à l'image (ou carte) de seuil de tramage.

  magick gradient.png dmap_hlines.png \
          -virtual-pixel tile  -fx 'u>=v'   dgrad_dmap_hlines.gif

  magick dmap_hlines.png pgm:- | pnmdepth 9 | pnmnoraw > dmap_hlines.pgm

Tous les nombres (autres que l'identifiant magique d'image « P2 ») dans ce qui précède sont les nombres nécessaires pour générer la « carte de seuils » appropriée, que vous pouvez ajouter à votre fichier « thresholds.xml » personnel. Par exemple, voici l'entrée de carte de seuils résultante créée à partir de ce qui précède.

Et voici un exemple d'utilisation de cette carte de seuils.

  magick shadow.png  -channel A  -ordered-dither hlines   shadow_hlines.gif

Et voilà comment générer une carte de seuils complexe à partir d'une progression d'images.

Tramage avec des motifs de symboles

Bien que l'on puisse utiliser une seule carte de seuils ou image de seuil, au lieu d'un jeu de motifs multi-images pour la plupart des opérations de tramage, cela ne signifie pas que les cartes multi-images n'ont pas leurs propres usages. On peut utiliser un jeu d'images de correspondance pour carreler plusieurs zones toutes en même temps, plutôt qu'une à la fois. Par exemple, en mettant à l'échelle une image simple, puis en remplaçant chaque pixel d'une image par un symbole particulier. Par exemple, ici je prends la toute petite image « eyes » et je remplace les pixels individuels par divers symboles, pour produire un tel motif pour chaque pixel de l'image d'origine.

  montage dpat_symbols.gif   -geometry +5+0 \
          -tile x1 -background none -mattecolor blue  -frame 3 \
          dpat_syms_images.gif
  magick eyes.gif -alpha off -colorspace sRGB -grayscale Average \
          -alpha off -scale 1600% -negate  \
          dpat_symbols.gif -virtual-pixel tile -fx 'u[floor(15.9999*u)+1]' \
          eyes_syms.gif

Le montage est utilisé pour agrandir l'image GIF multi-images afin de pouvoir en voir le contenu, sans qu'elle soit « animée ». Vous pouvez ajuster la méthode d'intensité « [-grayscale](https://imagemagick.org/command-line-options/#grayscale) » que vous souhaitez utiliser, du « Rec709Luminance » normal à un « Rec709Luma » plus sombre, ou utiliser une « average » soit d'un espace colorimétrique non linéaire « sRGB », soit d'un espace colorimétrique linéaire « RGB ». Vous pouvez même ajuster la mise à l'échelle « [-gamma](https://imagemagick.org/command-line-options/#gamma) » des valeurs pour obtenir la meilleure répartition des couleurs. Il y a de nombreuses possibilités, et ce qui est bon dépend davantage de l'agencement de vos symboles que de la méthode réellement choisie. La clé de ce qui précède est de garantir d'une manière ou d'une autre que chaque couleur de l'image d'entrée produise un symbole unique, et cela peut être très délicat à réaliser. Cet exemple peut servir à créer des guides de point de croix ou de tricot que les amateurs peuvent suivre, générant une œuvre à plus grande échelle à partir d'images informatiques plus petites. Vous pouvez utiliser cette technique pour carreler des images en niveaux de gris avec un jeu d'images de couleur carrelables. Le résultat ressemble un peu aux cartes de paysage vues dans de nombreux anciens jeux de guerre informatiques.

  montage dpat_map.gif   -geometry +5+0 -tile x1  -background none  \
          dpat_map_images.gif
  magick -seed 100 \
          -size 200x200 plasma:'gray(50%)-gray(50%)' -blur 0x15 \
          -channel G -auto-level +channel -set colorspace sRGB \
          dpat_map.gif -virtual-pixel tile  -fx 'u[floor(5.999*u.g)+1]' \
          map.gif

Notez que j'ai dû m'assurer qu'IM considère l'image en niveaux de gris comme étant déjà dans l'espace colorimétrique sRGB final (comme le sont les images de carreaux), même s'il s'agit en réalité de données RGB linéaires utilisées pour les recherches d'indices FX. Sans cela, la « carte » résultante est biaisée vers des paysages boisés, avec peu de chances d'avoir des zones d'eau. Comme on peut le voir, n'importe quel jeu d'images peut servir de carreaux, les images n'ont même pas besoin de s'aligner entre elles, ni même d'avoir la même taille de carreau. Bien entendu, si les carreaux ont la même taille et sont étroitement liés les uns aux autres, comme dans le cas des 3 carreaux bleus de « mer », le motif carrelé peut « s'écouler » d'une zone carrelée à une autre. En remplaçant les carreaux par des images de nombres, vous pouvez aussi générer une sorte de guide de peinture par numéros. Cependant, un traitement supplémentaire peut être nécessaire pour border les différentes zones. Ceci est laissé en exercice, envoyez-moi vos solutions par courriel, et vous pourrez voir votre nom dans les exemples IM comme auteur de cette technique.

Notes diverses sur le tramage ordonné et possibilités futures

En cours de construction

Tramage ordonné avec un petit nombre de couleurs.

Lorsqu'on utilise un petit nombre de couleurs pour une petite image, un tramage pseudo-aléatoire comme le tramage à correction d'erreur par courbe de Hilbert d'IM, ou même un tramage à correction d'erreur Floyd-Steinberg plus simple (voir Tramage à correction d'erreur ci-dessus) produit un résultat d'aspect horrible. Idéalement, un tramage ordonné devrait être utilisé avec des images à faible nombre de couleurs et de type petite icône pour produire un résultat d'aspect bien meilleur. Cependant, pour l'instant, le tramage ordonné dans IM ne peut utiliser que des tables de couleurs « fixes » générées mathématiquement, et non simplement une collection de « meilleures » couleurs.

Tramage ordonné avec une carte de couleurs quelconques

Il existe un algorithme qui permettrait d'utiliser un jeu de couleurs spécifiques pour le tramage ordonné. En gros, en ajoutant les « pseudo-couleurs » qu'un algorithme de tramage ordonné peut générer (ce qui pourrait impliquer un tramage à trois couleurs), à la palette de couleurs donnée, pour la « compléter ». Vous pouvez ensuite « mapper » les pixels individuels d'une image sur cette « palette de couleurs étendue ». À partir de ce mappage initial vers une pseudo-couleur spécifique, la couleur réelle peut être choisie depuis la carte de seuils qui génère cette pseudo-couleur, et ainsi tramer par ordre les zones de cette couleur, et donc l'image entière vers un jeu de couleurs donné. En raison de mon expérience avec les icônes, et maintenant les animations GIF, j'aimerais assurément voir un tramage ordonné à couleurs quelconques implémenté, mais je n'ai pas encore trouvé de référence pratique sur la façon de réaliser des tramages ordonnés avec un jeu fixe de couleurs.