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
modifierUn 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
modifierLe 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
modifierDans 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 quandraised=true
ou d'abaissement quandraised=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 quandraised=true
ou d'abaissement quandraised=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 argumentsarc_width
etarc_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 argumentsarc_width
etarc_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 classejava.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 classejava.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
modifierL'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 classeRectangle2D
pour des coordonnées de typeint
.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éthodeadd
), intersection (méthodeintersect
), soustraction (méthodesubtract
), soustraction symétrique (méthodeexclusiveOr
).
Dessin de texte
modifierLes 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înejava.lang.String
, d'un séquence de caractères avec attributsjava.text.AttributedCharacterIterator
. La classejava.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
modifierLa 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é
modifierLes 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
modifierLe 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) etheight
(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 rectangulairedx1
,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 êtrenull
.
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
modifierComposant transparent
modifierPar 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
modifierPar 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é
modifierLes 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. |
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
modifierUne 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
modifierRenderingHints.VALUE_ANTIALIAS_OFF
|
RenderingHints.VALUE_ANTIALIAS_ON
| |
---|---|---|
RenderingHints.
|
||
RenderingHints.
|
Aperçu pour une épaisseur de 1.5
modifierRenderingHints.VALUE_ANTIALIAS_OFF
|
RenderingHints.VALUE_ANTIALIAS_ON
| |
---|---|---|
RenderingHints.
|
||
RenderingHints.
|
Qualité du texte
modifierTrois 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.
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 :
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 :
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
modifierUn 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
modifierDifférentes valeurs d'ajustement du contraste pour VALUE_TEXT_ANTIALIAS_LCD_HRGB
100
|
|
---|---|
140
|
|
180
|
|
250
|
Qualité des images
modifierLes 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- ↑ Grid-fitting and Scan-conversion Procedure Table https://docs.microsoft.com/en-us/typography/opentype/spec/gasp