Programmation Java Swing/Dessin d'un composant

Un livre de Wikilivres.
Aller à la navigation Aller à la recherche


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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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.
Tracer 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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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.

Gras, italique, soulignement et barré[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

Transformations[modifier | modifier le wikicode]

Composant transparent[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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 change 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é[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

RenderingHints.VALUE_ANTIALIAS_OFF RenderingHints.VALUE_ANTIALIAS_ON
RenderingHints.

VALUE_STROKE_NORMALIZE

Java Swing render S1 aa0.png Java Swing render S1 aa1 strk norm.png
RenderingHints.

VALUE_STROKE_PURE

Java Swing render S1 aa0.png Java Swing render S1 aa1 strk pure.png

Aperçu pour une épaisseur de 1.5[modifier | modifier le wikicode]

RenderingHints.VALUE_ANTIALIAS_OFF RenderingHints.VALUE_ANTIALIAS_ON
RenderingHints.

VALUE_STROKE_NORMALIZE

Java Swing render S1p5 aa0 strk norm.png Java Swing render S1p5 aa1 strk norm.png
RenderingHints.

VALUE_STROKE_PURE

Java Swing render S1p5 aa0 strk pure.png Java Swing render S1p5 aa1 strk pure.png

Qualité du texte[modifier | modifier le wikicode]

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 RGB (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 RGB (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.

Java Swing render fm0 ta hrgb.png

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 bordant le côté gauche des lettres en noir pour se mélangé 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.

Aperçu de l'antialiasing et des mesures fractionnaires[modifier | modifier le wikicode]

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 Java Swing render fm0 ta0.png Java Swing render fm1 ta0.png
ON Java Swing render fm0 ta1.png Java Swing render fm1 ta1.png
LCD_HRGB Java Swing render fm0 ta hrgb.png Java Swing render fm1 ta hrgb.png
LCD_HBGR Java Swing render fm0 ta hbgr.png Java Swing render fm1 ta hbgr.png
LCD_VRGB Java Swing render fm0 vrgb.png Java Swing render fm1 vrgb.png
LCD_VBGR Java Swing render fm0 vbgr.png Java Swing render fm1 vbgr.png

Aperçu de l'ajustement du contraste[modifier | modifier le wikicode]

Différentes valeurs d'ajustement du contraste pour VALUE_TEXT_ANTIALIAS_LCD_HRGB

100 Java Swing render fm0 ta hrgb 100.png
140 Java Swing render fm0 ta hrgb.png
180 Java Swing render fm0 ta hrgb 180.png
250 Java Swing render fm0 ta hrgb 250.png

Qualité des images[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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