
|
auteur :
Clément Cunin | Il y a principalement deux cas où un programmeur est amené à dessiner : la réalisation d'un composant graphique non-standard tel qu'un diagramme, ou la création automatique d'une image à partir de données.
Dans les 2 cas, le dessin sera assuré par la classe java.awt.Graphics2D. Vous ne devez en aucun cas essayer de construire une instance de cette classe. Pour dessiner dans un composant graphique, l'instance vous est donnée en paramètre de la méthode paint(AWT) ou paintComponent(SWING). Pour le dessin dans une image, on crée un objet java.awt.Image, puis on utilise la méthode getGraphics() pour récupérer l'objet Graphics et dessiner dans l'image.
Image img = new BufferedImage(150,52,BufferedImage.TYPE_INT_RGB);
Graphics2D g2d = (Graphics2D)img.getGraphics();
|
lien : Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?
|
|
auteur :
Clément Cunin | Les solutions adoptées par SUN pour le dessin des composants sont assez complexes et un certain nombre d'optimisations sont propices à induire les débutants en erreur.
Quand un composant est-il dessiné ? Le plus important est de bien comprendre quand et pourquoi les méthodes paint(AWT) et paintComponant(SWING) sont exécutées. La première raison est une requête explicite du composant via la méthode repaint(). La deuxième raison est une requête du système, soit suite au redimensionnement de la fenêtre, soit suite au masquage du composant par une autre fenêtre du système.
La règle à toujours respecter : Tout programmeur qui redéfinit la méthode paint(AWT) ou paintComponent(Swing) s'engage à redessiner l'intégralité de la surface du composant. En effet, l'objet Graphics qui est transmis au composant dessine toujours dans le même espace mémoire et cet espace n'est jamais nettoyé (pour des raisons de performance). Le programmeur du composant a donc la charge de nettoyer l'espace et de redessiner son composant. Si le composant est complexe et que son dessin est long, il est recommandé d'utiliser la technique de double-buffering pour optimiser son affichage.
|
lien : Comment utiliser le double-buffering software ?
|
|
auteur :
Clément Cunin | Version simple : La méthode drawString(java.lang.String,int,int) de la classe java.awt.Graphics2D correspond parfaitement à ce que l'on cherche.
/** Ecriture dans une image 'img' */
Graphics2D g2d = (Graphics2D)img.getGraphics();
g2d.drawString("HelloWord",x,y);
Avec quelques raffinements : On peut améliorer un peu le procédé et choisir la police et la couleur de notre texte. En fait, la classe java.awt.Graphics2D garde un certain nombre d'attributs qui sont appliqués à toutes les opérations de dessin ; la couleur principale, la couleur secondaire (de fond), la police, la déformation. Il suffit de changer ces valeurs en utilisant la méthode appropriée.
Graphics2D g2d = (Graphics2D)img.getGraphics();
g2d.setFont(new Font("Serif",Font.PLAIN,12));
g2d.setColor(Color.RED);
g2d.drawString("HelloWord",x,y);
A quoi correspond (x,y) ? : Les coordonnées (x,y) que l'on donne à la méthode drawString correspondent au coin inférieur gauche de la première lettre du texte. Plus précisément, la valeur y correspond à la ligne 'de base' du texte. Pour les langues comme l'Arabe qui s'écrivent de droite à gauche, cette position correspond à la position du dernier caractère de la chaine, donc de celui qui sera affiché le plus a gauche. (Si vous n'avez pas tout compris, faite le test. ;-) )
|
lien : Comment dessiner en Java ?
lien : Comment connaître la taille de l'image d'un texte ?
|
|
auteur :
Clément Cunin | Lorsque l'on dessine du texte il est souvent utile de connaître la taille nécessaire pour l'affichage de ce texte, pour le centrer ou continuer à écrire à la ligne suivante. Il suffit pour cela de récupérer l'instance de la classe java.awt.FontMetrics du graphique dans lequel on souhaite écrire.
Graphics2D g2d = ...;
FontMetrics fontMetrics = g2d.getFontMetrics();
int longueur = fontMetrics.stringWidth("MonTexte");
int hauteur = fontMetrics.getHeight();
|
lien : Comment écrire du texte dans une image ?
|
|
auteur :
Clément Cunin | Pas besoin de grandes phrases, un exemple suffit :
Graphics2D g2d = ...;
/** Lissage du texte uniquement : */
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALOAS_ON);
/** Lissage du texte et des dessins */
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALOAS_ON);
|
lien : Comment dessiner en Java ?
lien : Comment écrire du texte dans une image ?
|
|
auteur :
Clément Cunin | La gestion de la transparence passe par l'utilisation du 'canal alpha', notion bien connue des graphistes. Pour nous, la gestion de la transparence se résume à spécifier à notre graphique le pourcentage d'opacité que l'on souhaite appliquer à ce que l'on va dessiner (graphique ou texte). Une composante alpha de 0 correspond à une complète transparence, alors qu'une valeur de 1 correspond à une complète opacité.
Juste une méthode à appliquer à notre graphique :
Graphics2D g2d = ...;
/** 80 % de transparence */
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f ));
g2d.drawXXX(...);
|
lien : Comment dessiner en Java ?
lien : Comment écrire du texte dans une image ?
|
|
auteur :
Clément Cunin | Définir la taille du pinceau : Comme toujours avec l'objet java.awt.Graphics2D, nous allons définir une nouvelle taille de pinceau qui s'appliquera à tous les traits qui seront tracés par la suite, aussi bien via la méthode drawLine(..) que drawRect(...) ou drawShape(...).
Graphics2D g2d = ...;
/** Défini une épaisseur de 5 pixels */
g2d.setStroke(new BasicStroke( 5.0f ));
g2d.drawXXX(...);
Le fait que la taille du pinceau soit précisée par un nombre réel peut surprendre, difficile en effet d'imaginer une ligne de 2.5 pixels. Pour comprendre, il suffit de s'imaginer le cas d'une ligne oblique, ou le cas d'un tracé avec l'anti-aliasing actif.
Définir le type de la ligne : La classe java.awt.BasicStroke contrairement à ce que laisse penser son nom n'est pas si basique que ca. Outre la taille du pinceau, elle permet la définition de lignes en pointillés avec éventuellement plusieurs longueurs, elle permet aussi de définir comment sont gérées les intersections des lignes d'une multi-ligne (shape), et plein d'autres choses encore. Je ne rentrerai donc pas dans les détails, tout est expliqué dans la documentation. Un petit exemple quand même :
Graphics2D g2d = ...;
float epaisseur=3; /** taille de la ligne */
float[] style = {10,5}; /** les pointillés seront 2 fois plus long que les blancs */
g2d.setStroke( new BasicStroke(
epaisseur,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
10.0f,
style,
0
));
|
lien : Comment dessiner en Java ?
|
|
auteur :
Clément Cunin | Les fonctions de remplissage de zone sont gérées par java.awt.Graphics2D en précisant comment colorier avant d'utilisant les méthodes fillXXX(...).
Avec un dégradé de couleur : Un dégradé de couleur est calculé en fonction de deux points de référence dont on fixe la couleur, la couleur des points situés entre les 2 est un dégradé linéaire.
Graphics2D g2d = ...;
g2d.setPaint(new GradientPaint(xDebut,yDebut,colDebut,xFin,yFin,colFin,cyclique);
g2d.fillXXX(...);
Le booléen 'cyclique' permet de définir comment gérer les points au-delà des bornes.
Graphics2D g2d = ...;
g2d.setPaint(new TexturePaint(bufferedImage, new Rectangle(x,y,largeur,hauteur));
g2d.fillXXX(...);
|
lien : Comment dessiner en Java ?
lien : Texture personalisée en Java2D
|
|
auteur :
Clément Cunin | Quelques paramètres intéressants : Un certain nombre de propriétés peuvent être initialisées pour indiquer vos préférences d'affichage. Voici les valeurs à mettre pour gagner en vitesse :
/** Désactivation de l'anti-aliasing */
g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
g2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
/** Demande de rendu rapide */
g2D.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
g2D.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
g2D.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
g2D.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
|
lien : Comment utiliser le double-buffering software ?
|
|
auteur :
Seigne David | L'affichage par défaut sur un composant awt, swing, ... de Java se fait à l'aide d'un simple buffer (on voit l'image se tracer). Si on commence à faire des animations un peu complexes, il apparait dès lors des problèmes de scintillements de l'image appelés clipping. Pour résoudre ce problème, on peut utiliser la méthode du double-buffering software (c'est une couche de la JVM qui s'en charge). Le double-buffering est le fait d'avoir un buffer où l'on dessine en mémoire et un buffer qui s'occupe de l'affichage. Les problèmes de rafraichissement, saut d'image et autres bugs visuels sont ainsi éliminés.
Voici un programme très simple se servant du double-buffering software.
public class DoubleBufferingSoftware extends Frame{
RenderingThread renderingThread = new RenderingThread();
Graphics buffer;
Image image;
int x = 0;
public DoubleBufferingSoftware(){
setSize( 400, 400 );
setVisible( true );
renderingThread.start();
}
public void update(Graphics g){
paint(g);
}
public void paint( Graphics g ){
if(buffer==null){
image = createImage(400,400);
buffer = image.getGraphics();
}
buffer.setColor( Color.white );
buffer.fillRect( 0, 0, 400, 400 );
buffer.setColor( Color.black );
buffer.drawString( "affichage d'une ligne de texte", x, 200 );
x++;
if(x>400) x = 0;
g.drawImage(image, 0, 0, this);
}
class RenderingThread extends Thread {
/**
* Ce thread appelle le rafraichissement de notre fenêtre
* toutes les 10 milli-secondes
*/
public void run(){
while(true){
try {
repaint();
sleep( 10 );
} catch ( Exception e ) {}
}
}
}
public static void main(String[] args){new DoubleBufferingSoftware();}
}
|
lien : Tutorial de Sun sur l'utilisation d'un double 'buffer'
lien : http://www.dgp.utoronto.ca/~mjmcguff/learn/java/07-backbuffer/
lien : Comment accélérer le rendu graphique de mon dessin ?
lien : Comment utiliser le double-buffering hardware ?
téléchargement : DoubleBufferingSoftware.java
|
|
auteur :
Seigne David | Les développeurs de Sun se sont rapidement rendu compte que le double-buffering software ne suffisait pas parfois, notamment pour faire des jeux et d'autres applications graphiques très lourdes. Ils ont donc décider d'implémenter l'utilisation de la carte graphique (VRAM au lieu de la RAM) afin de diminuer une grande partie des calculs. Le Page-flipping, plus communément appelé double-buffering hardware est le fait d'utiliser un pointeur vidéo pour décider quel buffer sert de mémoire et quel buffer sert d'affichage.
Principe : On créé un buffer qui va servir de buffer mémoire (celui où l'on dessine dessus), puis on créé un buffer qui va servir de buffer graphique (celui qui s'occupe d'afficher ce qu'il contient à l'écran). On dessine sur le buffer mémoire, des images, des textes, des dessins, ... pendant que le buffer graphique affiche ce qu'il contient. Puis, on swap les buffers(en clair, on les inverse), le buffer mémoire devient le buffer graphique et le buffer graphique devient le buffer mémoire.
On les appelle habituellement: BackBuffer (buffer mémoire) et FrontBuffer (buffer graphique).
Voici la méthode qui permet d'utiliser la mémoire vidéo de votre carte graphique (VRAM) :
public class DoubleBufferingHardware extends Frame{
RenderingThread renderingThread = new RenderingThread();
BufferStrategy strategy;
Graphics buffer;
int x = 0;
public DoubleBufferingHardware(){
setSize( 400, 400 );
setVisible( true );
setIgnoreRepaint( true );
createBufferStrategy( 2 );
strategy = getBufferStrategy();
buffer = strategy.getDrawGraphics();
renderingThread.start();
}
public void graphicalRender(){
buffer.setColor( Color.black );
buffer.fillRect( 0, 0, 400, 400 );
buffer.setColor( Color.white );
buffer.drawString( "affichage d'une ligne de texte", x, 200 );
x++;
if ( x > 400 ) x = 0;
strategy.show();
}
class RenderingThread extends Thread{
/**
* Ce thread appelle le rafraichissement de notre fenêtre
* toutes les 10 milli-secondes
*/
public void run(){
while( true ){
try {
graphicalRender();
sleep( 5 );
} catch ( Exception e ) {}
}
}
}
public static void main(String[] args){new DoubleBufferingHardware();}
}
|
lien : Tutorial de Sun sur l'utilisation d'un double 'buffer'
lien : http://www.dgp.utoronto.ca/~mjmcguff/learn/java/07-backbuffer/
lien : Comment accélérer le rendu graphique de mon dessin ?
lien : Comment utiliser le double-buffering software ?
lien : Comment utiliser le double-buffering hardware ?
téléchargement : DoubleBufferingHardware.java
|
|
auteur :
Seigne David | La technique pour faire du triple-buffering hardware est très simple, il suffit de reprendre l'architecture pour le double-buffering hardware et de changer ceci :
createBufferStrategy( 2 );
pour ceci:
createBufferStrategy( 3 );
Peut-on faire mieux que du triple-buffering en mettant plus que le chiffre 3 ?
La reponse est non car les cartes graphiques ne le gèrent pas, si vous le tentez, soit votre carte le supporte et tournera en fait en triple-buffering, soit vous ferez planter votre programme ou aurez de gros bugs à l'affichage.
Inconvénients du triple-buffering ?
Et bien, les cartes actuelles tournent moins bien avec le triple que le double, résultat des courses, vous allez perdre en images par seconde lors de l'affichage. Cette diminution en performance est de l'ordre de 3 ce qui n'est pas négligeable.
Avantages du triple-buffering ?
- Si le double-buffering ne suffisait pas à nettoyer tous les bugs d'affichage, le triple-buffering peut finir de les nettoyer. Cependant, il est vraiment très rare que le double-buffering ne suffise pas à nettoyer les bugs graphiques.
- Dans le cas où vous faites du plein écran avec votre programme et que vous faites du double-buffering, vous avez dû remarquer que le compteur d'images par secondes est de 70-85 (bizarrement comme votre rafraichissement d'écran sur windows), ceci est dû au fait que le double-buffering se synchronise avec le rafraichissement de votre écran. La solution pour passer outre cette synchronisation est le triple-buffering, celui-ci permet de casser la V-sync (synchronisation des FPS avec le rafraichissement vertical de l'écran).
|
lien : Comment accélérer le rendu graphique de mon dessin ?
lien : Comment utiliser le double-buffering software ?
lien : Comment utiliser le double-buffering hardware ?
|
Consultez les autres F.A.Q's
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :
- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".
- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction, ne peux en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.
|
|
|