Programmation Java Swing/Dessin d'un composant

La création d'un composant directement à partir de la classe javax.swing.JComponent nécessite de définir une méthode pour redessiner le composant quand il est visible. Ce chapitre décrit comment le faire en détails.

Le dessin d'un composant Swing est effectué par la méthode publique void paint(Graphics g). Cette méthode délègue le travail à trois autres méthodes protégées appelées dans l'ordre suivant :

void paintComponent(Graphics g): Affiche le contenu du composant lui-même.
void paintBorder(Graphics g): Affiche les bords du composant dans la zone définie par les marges de type Insets.
void paintChildren(Graphics g): Affiche les composants contenus dans celui-ci, par appel à leur méthode paint.

Cet ordre assure que les composants contenus soit affichés au-dessus du composant. Pour définir l'apparence du composant, une sous-classe ne doit redéfinir que la méthode void paintComponent(Graphics g). Celle-ci doit éviter de dessiner dans la zone définie par les marges de type Insets qui est réservée aux bords (Border).

Contexte graphique

Un objet de classe java.awt.Graphics est passé aux méthodes d'affichage du composant. Il s'agit du contexte graphique, gérant les attributs courants de dessin (couleur, style des lignes, police de caractères, transformations...) et possédant des méthodes de tracé de formes, de texte, d'images...

La classe réelle du contexte graphique passé aux méthode d'affichage est java.awt.Graphics2D possédant des méthodes supplémentaires améliorant l'affichage en 2D. Il est donc nécessaire de convertir l'objet fourni pour pouvoir appeler ces méthodes avancées.

Attributs courants de dessin

Le contexte graphique possède des accesseurs de lecture et écriture pour les attributs de dessin à utiliser par les prochaines méthodes appelées :

Couleur courante pour dessiner : setColor(Color)
Police de caractère courante : setFont(Font)

Attributs supplémentaires ajoutés par la classe java.awt.Graphics2D :

Couleur courante pour effacer : setBackgroundColor(Color)
Composition avec les pixels existant : setComposite(Composite)
Style des lignes (épaisseur, continu/tirets/..., extrémités, jointure de lignes d'un polygone) : setStroke(Stroke)
Motif de remplissage : setPaint(Paint)
Déformation des coordonnées (translation, rotation...) : setTransform(AffineTransform)

Exemple :

@Override
protected void paintComponent(Graphics graphics)
{
	Graphics2D g = (Graphics2D)graphics;
	g.setColor(Color.BLUE);
// ... dessiner en bleu
	g.setColor(Color.WHITE);
// ... dessiner en blanc
	g.setStroke(new BasicStoke(1.5f));
// ... dessiner des lignes d'un pixel et demi d'épaisseur
}

Dessin de formes

Dans les exemples suivants, g représente le contexte graphique de classe java.awt.Graphics.

Méthode de tracé de contour de formes: Les méthodes dont le nom commence par draw dessine le contour de formes et utilise la couleur et le style de tracé courants du contexte graphique.
Méthode de tracé de formes remplies: Les méthodes dont le nom commence par fill dessine la surface remplie de formes et utilise la couleur et le motif courants du contexte graphique.

Les formes fermées possèdent à la fois une méthode de tracé du contour et une méthode de tracé de la forme remplie.

Tracer une ligne entre deux points: g.drawLine(x1,y1, x2,y2); La méthode drawLine trace une ligne entre les deux points dont les coordonnées sont spécifiées en arguments, en utilisant le style courant de la ligne qui par défaut est une ligne continue d'un pixel d'épaisseur.

Tracer un rectangle: g.drawRect(x,y, width,height); La méthode drawRect trace un rectangle de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Cette méthode trace un rectangle qui s'étend sur la largeur et la hauteur spécifiées additionnées à l'épaisseur courante de la ligne (1 pixel par défaut). Les largeurs ou hauteurs négatives sont acceptées.
Remplir un rectangle: g.fillRect(x,y, width,height); La méthode fillRect trace un rectangle rempli de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Les largeurs ou hauteurs négatives ne sont pas supportées.

Tracer un rectangle 3D: g.drawRect3D(x,y, width,height, boolean raised); La méthode drawRect trace un rectangle de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Cette méthode trace un rectangle avec un bord donnant un effet 3D d'élévation quand raised=true ou d'abaissement quand raised=false. Ce rectangle s'étend sur la largeur et la hauteur spécifiées additionnées à l'épaisseur courante de la ligne (1 pixel par défaut). Les largeurs ou hauteurs négatives sont acceptées.
Remplir un rectangle 3D: g.fillRect3D(x,y, width,height, boolean raised); La méthode fillRect3D remplit un rectangle de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Cette méthode remplit un rectangle avec un bord donnant un effet 3D d'élévation quand raised=true ou d'abaissement quand raised=false. Ce rectangle s'étend sur la largeur et la hauteur spécifiées additionnées à l'épaisseur courante de la ligne (1 pixel par défaut). Les largeurs ou hauteurs négatives ne sont pas supportées.

Tracer un rectangle arrondi: g.drawRect(x,y, width,height, arc_width, arc_height); La méthode drawRect trace un rectangle arrondi de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Les coins du rectangle sont arrondis avec des quarts d'ellipse dont les diamètres horizontaux et verticaux sont spécifiés par les arguments arc_width et arc_height respectivement. Cette méthode trace un rectangle qui s'étend sur la largeur et la hauteur spécifiées additionnées à l'épaisseur courante de la ligne (1 pixel par défaut). Les largeurs ou hauteurs négatives sont acceptées.
Remplir un rectangle arrondi: g.fillRect(x,y, width,height, arc_width, arc_height); La méthode fillRect trace un rectangle arrondi rempli de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Les coins du rectangle sont arrondis avec des quarts d'ellipse dont les diamètres horizontal et vertical sont spécifiés par les arguments arc_width et arc_height respectivement. Les largeurs ou hauteurs négatives ne sont pas supportées.

Tracer un ovale: g.drawOval(x,y, width,height); La méthode drawOval trace un ovale contenu dans un rectangle de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Cette méthode trace un ovale qui s'étend sur la largeur et la hauteur spécifiées additionnées à l'épaisseur courante de la ligne (1 pixel par défaut). Les largeurs ou hauteurs négatives sont acceptées.
Remplir un ovale: g.fillOval(x,y, width,height); La méthode fillOval trace un ovale rempli contenu dans un rectangle de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Les largeurs ou hauteurs négatives ne sont pas supportées.

Tracer un arc: g.drawArc(x,y, width,height, start_angle, ext_angle); La méthode drawArc trace un arc comme une partie d'un ovale contenu dans un rectangle de la taille spécifiée à partir des coordonnées du point supérieur gauche spécifiées. Cette méthode trace l'arc en démarrant à l'angle spécifié en radians, et qui s'étend sur le nombre de radians spécifié. Les largeurs ou hauteurs négatives sont acceptées.

Tracer un polygone: g.drawPolygon(int[] x, int[] y, int point_count); g.drawPolygon(Polygon p); La méthode drawPolygon trace un polygone à partir des deux tableaux de coordonnées spécifiés soit directement, soit indirectement en utilisant un objet de classe java.awt.Polygon. Le dernier point est relié au premier pour fermer le polygone.
Remplir un polygone: g.fillPolygon(int[] x, int[] y, int point_count); g.fillPolygon(Polygon p); La méthode fillPolygon remplit un polygone à partir des deux tableaux de coordonnées spécifiés soit directement, soit indirectement en utilisant un objet de classe java.awt.Polygon. Le dernier point est relié au premier pour fermer le polygone.

Tracer une ligne multipoints: g.drawPolyline(int[] x, int[] y, int point_count); La méthode drawPolyline trace une ligne entre les points à partir des deux tableaux de coordonnées spécifiés directement. Le dernier point n'est pas relié au premier.

Dessin de forme quelconque

L'interface java.awt.Shape définit les méthodes communes des formes pour tester l'appartenance d'un point ou d'un rectangle, tester si la forme intersecte un rectangle, obtenir le rectangle englobant, et obtenir un itérateur de chemin parcourant le contour de la forme. Ce dernier groupe de méthodes est utilisé pour le dessin de la forme.

Tracer une forme quelconque: g.draw(Shape); La méthode draw trace le contour de la forme spécifiée.
Remplir une forme quelconque: g.fill(Shape); La méthode fill remplit la surface de la forme spécifiée.

Différentes classes du package java.awt.geom implémentent cette interface. Celles dont le nom se termine par 2D sont des classes abstraites possédant deux sous-classes concrètes statiques internes appelées Double et Float permettant d'utiliser des coordonnées de type double et float respectivement.

Line2D, Line2D.Double, Line2D.Float
Rectangle2D, Rectangle2D.Double, Rectangle2D.Float
Rectangle dérive de la classe Rectangle2D pour des coordonnées de type int.
RoundRectangle2D, RoundRectangle2D.Double, RoundRectangle2D.Float
Polygon
Path2D, Path2D.Double, Path2D.Float
Arc2D, Arc2D.Double, Arc2D.Float
Ellipse2D, Ellipse2D.Double, Ellipse2D.Float
CubicCurve2D, CubicCurve2D.Double, CubicCurve2D.Float
QuadCurve2D, QuadCurve2D.Double, QuadCurve2D.Float
Area englobe une autre forme et permet des opérations ensemblistes pour composer une aire complexe : union (méthode add), intersection (méthode intersect), soustraction (méthode subtract), soustraction symétrique (méthode exclusiveOr).

Dessin de texte

Les méthodes de tracé de texte utilisent la couleur et la police de caractères courantes du contexte graphique. Les coordonnées spécifiées sont celles du point du début de ligne (à gauche pour le sens d'écriture de gauche à droite, ou à droite pour l'autre sens) situé au niveau de la ligne de base des caractères.

Tracer une chaîne de caractères: g.drawString(String, int x, int y); g.drawString(String, float x, float y); g.drawString(AttributedCharacterIterator, int x, int y); g.drawString(AttributedCharacterIterator, float x, float y); La méthode drawString dessine la chaîne de caractère qu'elle soit spécifiée sous la forme d'une chaîne java.lang.String, d'un séquence de caractères avec attributs java.text.AttributedCharacterIterator. La classe java.awt.Graphics2D surcharge les méthodes pour autoriser des coordonnées sous forme de nombres à virgule flottante.
Tracer un tableau de caractères: g.drawChars(char[], int offset, int length, int x, int y); La méthode drawChars dessine la chaîne de caractère représenté par le tableau de caractères spécifié.
Tracer un tableau d'octets: g.drawBytes(byte[], int offset, int length, int x, int y); La méthode drawChars dessine la chaîne de caractère représenté par le tableau de caractères spécifié.

Police de caractères

La police de caractères utilisée est celle définie par la méthode void setFont(Font f) du contexte graphique. Elle est initialisée avec celle assignée au composant.

Voir police de caractères

Gras, italique, soulignement et barré

Les styles gras et italiques sont gérés par la classe java.awt.Font (constantes PLAIN, BOLD, ITALIC, BOLD_ITALIC).

Le soulignement doit être géré par le code de dessin après ou avant avoir tracé le texte. La classe java.awt.Font fournit des informations pour le soulignement (distance et épaisseur de trait) via une instance de la classe java.awt.font.LineMetrics. Le code ci-dessous affiche un texte souligné, en exploitant ces informations et en utilisant l'objet java.awt.FontMetrics pour mesurer le texte et obtenir la longueur de la ligne de soulignement du texte.

String texte_souligne = "Voici comment souligner le texte."
int tx = 10, ty = 20;

g.drawString(texte_souligne, tx, ty);

FontMetrics fm = g.getFontMetrics();
int tw = fm.stringWidth(texte_souligne);

LineMetrics lm = g.getFont().getLineMetrics(texte_souligne, g.getFontRenderContext());
float line_offset = lm.getUnderlineOffset();
float line_thickness = lm.getUnderlineThickness();

int ly = (int)(ty+line_offset + line_thickness /2); // Position
g.setStroke(new BasicStroke(line_thickness)); // Épaisseur
g.drawLine(tx, ly, tx+tw, ly);

Le style barré utilise le même principe en exploitant les informations retournées par les méthodes getStrikethroughOffset() et getStrikethroughThickness(). Dans le code précédent, il suffit de remplacer les valeurs affectées aux variables line_offset et line_thickness :

float line_offset = lm.getStrikethroughOffset();
float line_thickness = lm.getStrikethroughThickness();

Les styles souligné et barré ne sont pas gérés directement par la classe java.awt.Font car il s'agit d'éléments graphiques (lignes) séparés du texte, pouvant avoir une couleur différente du texte, ou une épaisseur différente de celle indiquée par la classe java.awt.font.LineMetrics.

Afficher une image

Le contexte graphique possède plusieurs variantes de la méthode drawImage permettant d'afficher une image (instance de java.awt.Image) :

drawImage(image, x, y, observateur): Afficher l'image à sa taille normal aux coordonnées indiquées pour le coin supérieur gauche.
drawImage(image, x, y, width, height, observateur): Afficher l'image à la taille spécifiée par width (largeur) et height (hauteur) aux coordonnées indiquées pour le coin supérieur gauche.
drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observateur): Afficher une portion de l'image définie par les coordonnées source des coins de la zone rectangulaire sx1, sy1, sx2, sy2 dans la zone destination définie par les coordonnées source des coins de la zone rectangulaire dx1, dy1, dx2, dy2. Cette méthode permet donc à la fois d'afficher une partie de l'image et de la redimensionner si nécessaire.

Avec ces méthodes, les pixels transparents laissent voir ce qui était dessiné avant.

Paramètres communs :

image: Image à afficher (instance de java.awt.Image).
observateur: Implémentation de l'interface java.awt.image.ImageObserver à notifier de la progression du chargement de l'image. Si l'image est déjà chargée auparavant, ce paramètre peut être null.

Exemple :

// Image chargée auparavant, en dehors de toute méthode paint, par exemple :
URL url_fond = new URL("https://upload.wikimedia.org/wikipedia/commons/a/a6/VST_image_of_the_Hercules_galaxy_cluster.jpg");
Image image_fond = ImageIO.read(url_fond);

// ...
g.drawImage(image_fond, 10, 10, null);

Ces méthodes possèdent une variante acceptant une couleur à afficher comme couleur de fond pour les images transparentes.

Transformations

Composant transparent

Par défaut, un composant est opaque, ce qui signifie qu'il doit dessiner toute la zone rectangulaire correspondant à sa taille.

Si la méthode paint ou la méthode paintComponent ne dessine pas toute la zone, pour laisser paraître le fond du contenant (un composant non rectangulaire, comme un bouton arrondi par exemple), des artifacts peuvent apparaître de manière sporadique ou non car Swing réutilise le même contexte graphique pour peindre plusieurs composants. Dans ce cas, il ne faut pas oublier de déclarer le composant comme transparent pour indiquer qu'il faut un contexte graphique propre pour peindre le composant, dans le constructeur de la classe du composant :

setOpaque(false);

Qualité de l'affichage

Par défaut, les algorithmes de dessin des méthodes du contexte graphique privilégient la vitesse de rendu à la qualité. La méthode addRenderingHints(Map<?, ?> hints) de la classe java.awt.Graphics2D permet de changer différentes options pour améliorer la qualité.

Le paramètre hints est un dictionnaire associant des clés définies par les constantes KEY_ de la classe java.awt.RenderingHints à des valeurs définies par les constantes VALUE_.

Quand les paramètres de qualité ne changent pas, il est recommandé de créer le dictionnaire une seule fois, comme dans l'exemple suivant :

protected static final HashMap<Key, Object> QUALITY_HINTS =
	new HashMap<RenderingHints.Key, Object>();
static
{
	QUALITY_HINTS.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
	QUALITY_HINTS.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
	QUALITY_HINTS.put(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_QUALITY);
	QUALITY_HINTS.put(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
	QUALITY_HINTS.put(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_NORMALIZE);
	QUALITY_HINTS.put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
	QUALITY_HINTS.put(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
}

Ce dictionnaire est ensuite utilisable dans la méthode d'affichage du composant :

@Override
protected void paintComponent(Graphics graphics)
{
	Graphics2D g = (Graphics2D)graphics;
	g.addRenderingHints(QUALITY_HINTS);

// ... dessin du composant avec qualité améliorée
}

Propriétés générales de qualité

Les propriétés générales de qualités s'appliquent quand aucune autre propriété équivalente plus spécifique n'est applicable.

RenderingHints.KEY_RENDERING : Qualité générale d'affichage.

Valeur	Description
`RenderingHints.VALUE_RENDER_DEFAULT`	Option par défaut.
`RenderingHints.VALUE_RENDER_SPEED`	Privilégier la vitesse d'affichage.
`RenderingHints.VALUE_RENDER_QUALITY`	Privilégier la qualité d'affichage.

Dithering alternant des pixels noirs et blancs pour afficher les échelles de gris de l'image.
RenderingHints.KEY_DITHERING : Gestion des couleurs sur un écran où leur nombre est limité.

Valeur	Description
`RenderingHints.VALUE_DITHER_DEFAULT`	Option par défaut.
`RenderingHints.VALUE_DITHER_DISABLE`	Pas de dithering, les couleurs sont arrondies à la plus proche sans propagation d'erreur.
`RenderingHints.VALUE_DITHER_ENABLE`	Activer le dithering permettant la propagation d'erreur d'arrondi des couleurs sur les pixels voisins.

RenderingHints.KEY_ALPHA_INTERPOLATION : Qualité de la transparence des couleurs (canal alpha)

Valeur	Description
`RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT`	Option par défaut.
`RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED`	Privilégier la vitesse de calcul de la transparence.
`RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY`	Privilégier la qualité de calcul de la transparence.

Qualité des lignes

Une partie des propriétés de qualité concerne le tracé des lignes par les méthodes dessinant un contour : drawLine, drawRect, drawOval, drawShape... Cela concerne les méthodes dont le nom commence par draw sauf drawImage, drawRenderedImage, drawRenderableImage et drawString, drawBytes, drawChars.

RenderingHints.KEY_ANTIALIASING : option de réduction des effets pixelisés des lignes et des bords des formes géométriques.

Valeur	Description
`RenderingHints.VALUE_ANTIALIAS_DEFAULT`	Utiliser l'option par défaut
`RenderingHints.VALUE_ANTIALIAS_OFF`	Sans antialiasing
`RenderingHints.VALUE_ANTIALIAS_ON`	Avec antialiasing

RenderingHints.KEY_STROKE_CONTROL : Autoriser une correction de la géométrie pour améliorer la qualité du tracé.

Valeur	Description
`RenderingHints.VALUE_STROKE_DEFAULT`	Utiliser l'option par défaut
`RenderingHints.VALUE_STROKE_NORMALIZE`	Normaliser pour améliorer l'uniformité ou l'espacement des lignes et l'esthétique globale.
`RenderingHints.VALUE_STROKE_PURE`	Géométrie non modifiée, affiché tel quel avec une précision en dessous du pixel.

Aperçu pour une épaisseur de 1.0

	`RenderingHints.VALUE_ANTIALIAS_OFF`	`RenderingHints.VALUE_ANTIALIAS_ON`
`RenderingHints.` `VALUE_STROKE_NORMALIZE`
`RenderingHints.` `VALUE_STROKE_PURE`

Aperçu pour une épaisseur de 1.5

	`RenderingHints.VALUE_ANTIALIAS_OFF`	`RenderingHints.VALUE_ANTIALIAS_ON`
`RenderingHints.` `VALUE_STROKE_NORMALIZE`
`RenderingHints.` `VALUE_STROKE_PURE`

Qualité du texte

Trois autres propriétés de qualité concerne le tracé de texte, qu'il soit sous forme de chaîne de caractère (drawString), d'un tableau d'octets (drawBytes) ou d'un tableau de caractères (drawChars).

RenderingHints.KEY_FRACTIONALMETRICS : utiliser une précision en dessous du pixel pour positionner les caractères selon le vecteur d'avance mis à l'échelle de la taille de la police de caractères ou bien arrondir à l'entier le plus proche.

Valeur	Description
`RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT`	Utiliser l'option par défaut
`RenderingHints.VALUE_FRACTIONALMETRICS_OFF`	Utiliser des mesures fractionnaires.
`RenderingHints.VALUE_FRACTIONALMETRICS_ON`	Arrondir à l'entier le plus proche.

RenderingHints.KEY_TEXT_ANTIALIASING : utiliser de l'antialiasing pour le texte ou bien arrondir au pixel le plus proche.

Valeur	Description
`RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT`	Utiliser l'option par défaut
`RenderingHints.VALUE_TEXT_ANTIALIAS_OFF`	Utiliser l'antialias.
`RenderingHints.VALUE_TEXT_ANTIALIAS_ON`	Sans antialias.
`RenderingHints.VALUE_TEXT_ANTIALIAS_GASP`	Utiliser l'antialias (`VALUE_TEXT_ANTIALIAS_ON`) ou non (`VALUE_TEXT_ANTIALIAS_OFF`) selon l'information de la table GASP^[1] présente dans la police de caractères pour la taille utilisée. Cette information est en général présente dans les polices TrueType, cependant, si l'information n'est pas présente, la valeur par défaut de l'algorithme est utilisée (`VALUE_TEXT_ANTIALIAS_DEFAULT`). Cette option peut ne pas avoir un comportement consistant quand une police de caractères logique est utilisée vu qu'elle est composée de plusieurs polices physiques.
`RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB`	Utiliser l'antialias sur écran LCD, dans le sens horizontal, avec l'ordre de couleur des sous-pixels RGB (rouge, vert, bleu).
`RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR`	Utiliser l'antialias sur écran LCD, dans le sens horizontal, avec l'ordre de couleur des sous-pixels BGR (bleu, vert, rouge).
`RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB`	Utiliser l'antialias sur écran LCD, dans le sens vertical, avec l'ordre de couleur des sous-pixels RGB (rouge, vert, bleu).
`RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR`	Utiliser l'antialias sur écran LCD, dans le sens vertical, avec l'ordre de couleur des sous-pixels BGR (bleu, vert, rouge).

RenderingHints.KEY_TEXT_LCD_CONTRAST : ajustement du contraste pour l'antialiasing sur écran LCD.

Valeur	Description
`int`	Valeur entre 100 et 250 pour ajuster le contraste du texte. Typiquement en noir sur fond blanc, la valeur 100 donne un contraste fort, et 250 un contraste faible. L'intervalle typique est entre 140 et 180.

Le réglage de l'antialiasing du texte dont le nom de la valeur contient LCD est réservé aux écrans LCD ou assimilés où les pixels voisins sont tellement proches qu'il est possible que la composante bleue du pixel se mélange à la rouge du pixel voisin. Ce mélange permettant d'augmenter artificiellement la densité de pixels est la technique utilisée pour l'antialiasing LCD du texte, avec différentes variantes selon la disposition des composantes de couleur composant les pixels de l'écran. La valeur à utiliser dépend donc du modèle de l'écran.

Dans l'image ci-dessus, l'antialiasing de texte est RenderingHints.VALUE_TEXT_ANTIALIAS_HRGB : H pour Horizontal, RGB représentant l'ordre des composants des pixels de gauche à droite : rouge, vert, bleu. La couleur rouge borde le côté gauche des lettres en noir pour se mélanger au fond blanc, tandis que du bleu borde le côté opposé des lettres. Les côtés des couleurs rouges et bleues serait inversés pour un texte blanc sur fond noir.

Antialiasing LCD ordre des composants rouge, vert, bleu dans le sens horizontal (`RenderingHints.VALUE_TEXT_ANTIALIAS_HRGB`)
Zoom sur le bord gauche des lettres en noir sur fond blanc			Zoom sur le bord droit des lettres en noir sur fond blanc
blanc	rouge	noir	noir	bleu	blanc

Sur un écran LCD dont l'ordre des composants correspond, la composante bleue se mélange au rouge et vert à proximité, idem pour le rouge à droite avec les composantes bleue et verte.

Sur un écran LCD dont l'ordre des composants serait l'ordre inverse cela donnerait un effet indésirable de tracé parallèle rendant le texte flou :

Antialiasing LCD ordre des composants rouge, vert, bleu dans le sens horizontal (`RenderingHints.VALUE_TEXT_ANTIALIAS_HRGB`) sur un écran dont l'ordre des composants est bleu, vert, rouge
Zoom sur le bord gauche des lettres en noir sur fond blanc			Zoom sur le bord droit des lettres en noir sur fond blanc
blanc	rouge	noir	noir	bleu	blanc

Il faut dans ce cas utiliser l'ordre inverse :

Antialiasing LCD ordre des composants bleu, vert, rouge dans le sens horizontal (`RenderingHints.VALUE_TEXT_ANTIALIAS_HBGR`) sur un écran dont l'ordre des composants est bleu, vert, rouge
Zoom sur le bord gauche des lettres en noir sur fond blanc			Zoom sur le bord droit des lettres en noir sur fond blanc
blanc	bleu	noir	noir	rouge	blanc

Sur un écran non LCD, où les pixels seraient trop éloignés pour que la composante d'un pixel puissent se mélanger au pixel voisin, ou dont les pixels n'ont pas une haute densité, l'effet ne fonctionne pas correctement et un bord rouge ou bleu est visible. Pour ce cas, il est recommandé d'utiliser RenderingHints.VALUE_TEXT_ANTIALIAS_ON.

Aperçu de l'antialiasing et des mesures fractionnaires

Un aperçu de l'effet des différentes valeurs (lignes) pour RenderingHints.KEY_TEXT_ANTIALIASING (sans le préfixe commun RenderingHints.VALUE_TEXT_ANTIALIAS_, et pour le contraste par défaut) est présenté ci-dessous, combiné aux effets de RenderingHints.KEY_FRACTIONALMETRICS (colonnes).

	`RenderingHints.VALUE_FRACTIONALMETRICS_OFF`	`RenderingHints.VALUE_FRACTIONALMETRICS_ON`
`OFF`
`ON`
`LCD_HRGB`
`LCD_HBGR`
`LCD_VRGB`
`LCD_VBGR`

Aperçu de l'ajustement du contraste

Différentes valeurs d'ajustement du contraste pour VALUE_TEXT_ANTIALIAS_LCD_HRGB

`100`
`140`
`180`
`250`

Qualité des images

Les autres propriétés de qualité concerne l'affichage des images par les méthodes drawImage, drawRenderedImage et drawRenderableImage.

RenderingHints.KEY_INTERPOLATION : option d'affichage d'images redimensionnées.

Valeur	Description
`RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR`	Pixel voisin le plus proche.
`RenderingHints.VALUE_INTERPOLATION_BILINEAR`	La couleur d'un pixel est déterminée linéairement par les 4 pixels voisins les plus proches.
`RenderingHints.VALUE_INTERPOLATION_BICUBIC`	La couleur d'un pixel est déterminée par une fonction cubique sur les 9 pixels voisins les plus proches.

RenderingHints.KEY_COLOR_RENDERING : option de qualité d'affichage des couleurs.

Valeur	Description
`RenderingHints.VALUE_COLOR_RENDER_DEFAULT`	Option par défaut.
`RenderingHints.VALUE_COLOR_RENDER_SPEED`	Conversion rapide des couleurs.
`RenderingHints.VALUE_COLOR_RENDER_QUALITY`	Conversion des couleurs privilégiant la qualité.

Références

↑ Grid-fitting and Scan-conversion Procedure Table https://docs.microsoft.com/en-us/typography/opentype/spec/gasp

[1] Grid-fitting and Scan-conversion Procedure Table https://docs.microsoft.com/en-us/typography/opentype/spec/gasp

[1]