FAQ Java GUIConsultez toutes les FAQ

Nombre d'auteurs : 51, nombre de questions : 152, dernière mise à jour : 29 juin 2013 

 
OuvrirSommaireLe dessin

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.

 
Sélectionnez

Image img = new BufferedImage(150,52,BufferedImage.TYPE_INT_RGB);
Graphics2D g2d = (Graphics2D)img.getGraphics();

Dessiner dans une image ne pose pas de problèmes majeurs mais la personnalisation de composants graphiques nécessite de bien comprendre comment sont dessinés les composants par Java.

Créé le 10 novembre 2002  par Clément Cunin

Lien : Pourquoi mon composant s'efface quand je redimensionne la fenêtre ?

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.

Créé le 10 novembre 2002  par Clément Cunin

Lien : Comment utiliser le double-buffering software ?

Version simple :La méthode drawString(java.lang.String,int,int) de la classe java.awt.Graphics2D correspond parfaitement à ce que l'on cherche.

 
Sélectionnez
/** 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.

 
Sélectionnez
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. ;-) )

Créé le 10 novembre 2002  par Clément Cunin

Lien : Comment dessiner en Java ?
Lien : Comment connaître la taille de l'image d'un texte ?

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.

 
Sélectionnez
Graphics2D g2d = ...;
FontMetrics fontMetrics = g2d.getFontMetrics();
int longueur = fontMetrics.stringWidth("MonTexte");
int hauteur = fontMetrics.getHeight();
Créé le 10 novembre 2002  par Clément Cunin

Lien : Comment écrire du texte dans une image ?

Pas besoin de grandes phrases, un exemple suffit :

 
Sélectionnez
Graphics2D g2d = ...;
/** Lissage du texte uniquement : */
g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 
/** Lissage du texte et des dessins */
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
Mis à jour le 3 février 2007  par Clément Cunin

Lien : Comment dessiner en Java ?
Lien : Comment écrire du texte dans une image ?

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 :

 
Sélectionnez
Graphics2D g2d = ...;
/** 80 % de transparence */
g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f ));
g2d.drawXXX(...);
Créé le 10 novembre 2002  par Clément Cunin

Lien : Comment dessiner en Java ?
Lien : Comment écrire du texte dans une image ?

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

 
Sélectionnez
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 :

 
Sélectionnez
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
        ));
Créé le 10 novembre 2002  par Clément Cunin

Lien : Comment dessiner en Java ?

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.

 
Sélectionnez
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.

Avec une texture :

 
Sélectionnez
Graphics2D g2d = ...;
g2d.setPaint(new TexturePaint(bufferedImage, new Rectangle(x,y,largeur,hauteur));
g2d.fillXXX(...);
Créé le 10 novembre 2002  par Clément Cunin

Lien : Comment dessiner en Java ?
Lien : Texture personalisée en Java2D

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 :

 
Sélectionnez
/** 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);

Le double buffering :L'utilisation d'un double buffer est particulièrement recommandée pour l'affichage d'animations complexes ou de composants de grande taille. Voir Comment utiliser le double-buffering software ?

Créé le 27 janvier 2003  par Clément Cunin

Lien : Comment utiliser le double-buffering software ?

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.

 
Sélectionnez
public class DoubleBufferingSoftware extends Frame{
   // boucle d'affichage
   RenderingThread renderingThread = new RenderingThread();
   // buffer mémoire (2eme buffer)
   Graphics buffer;
   // image mémoire correspondante au buffer
   Image image; 
   int x = 0; // coordonnée x de l'affichage du texte
 
   public DoubleBufferingSoftware(){
      //affichage
      setSize( 400, 400 );
      setVisible( true );
 
      // on démarre la bouche d'affichage
      renderingThread.start();
 
   }
   public void update(Graphics g){
      paint(g);
   }
   public void paint( Graphics g ){
     //création du buffer si il n'existe pas
     if(buffer==null){
        image = createImage(400,400);
        buffer = image.getGraphics();
      }
     //on dessine sur le buffer mémoire
      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;
      // finalement, le buffer mémoire est dessiné dans le buffer d'affichage
      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();}
}
Créé le 9 mai 2002  par Seigne David

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

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) :

 
Sélectionnez
public class DoubleBufferingHardware extends Frame{
   // boucle d'affichage
   RenderingThread renderingThread = new RenderingThread(); 
   // variable permettant d'utiliser la mémoire VRAM
   BufferStrategy strategy; 
   // buffer mémoire  les images et les textes sont appliqués
   Graphics buffer; 
   int x = 0; // coordonnée x de l'affichage du texte
 
   public DoubleBufferingHardware(){
      setSize( 400, 400 );
      setVisible( true );
 
      // inhibe la méthode courante d'affichage du composant 
      setIgnoreRepaint( true );  
 
      // on créé 2 buffers dans la VRAM donc c'est du double-buffering
      createBufferStrategy( 2 ); 
 
      // récupère les buffers graphiques dans la mémoire VRAM
      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; 
      //on envoie toutes les données du buffer mémoire vers le buffer d'affichage
      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 {
                // on appelle notre propre méthode de rafraichissement
               graphicalRender();
               sleep( 5 );
            } catch ( Exception e ) {} 
         }
      }
   }   
   public static void main(String[] args){new DoubleBufferingHardware();}
}
Créé le 8 septembre 2004  par Seigne David

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

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 :

 
Sélectionnez
createBufferStrategy( 2 );

pour ceci:

 
Sélectionnez
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).
Créé le 8 septembre 2004  par Seigne David

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 ?

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 - 2009 Developpez LLC : Tous droits réservés Developpez LLC. Aucune reproduction ne peut 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.