Interface devant être implantée par une classe d'affichage : Afficheur.java

import java.awt.*;

/**
 * L'interface <code>Afficheur</code> specifie les methodes a implanter pour developper
 * une classe utilisable en tant qu'objet <code>Afficheur</code> gere
 * au sein d'un {@link ApplicationCanvas ApplicationCanvas}.
 * 
 * @author Nicolas Janey
 * @author nicolas.janey@univ-fcomte.fr
 * @version 1.0, 12/11/08
 */


public interface Afficheur {
  
/**
 * Methode d'affichage executee en boucle infinie pour realiser l'affichage d'une image.
 * 
 * @param g l'objet <code>Graphics</code> d'affichage.
 * @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
 * @param tx la largeur (en pixels) de la zone de dessin.
 * @param ty la hauteur (en pixels) de la zone de dessin.
 */

  public void paint(Graphics g,int numeroImage,int tx,int ty);
}

Classe d'affichage en fil de fer en projection parallèle orthographique avec animation de caméra : AfficheurProjectionOrthographique.java

import java.awt.*;

/**
 * La classe <code>AfficheurProjectionOrthographique</code> implante
 * l'interface {@link Afficheur Afficheur} pour developper une methode d'affichage
 * d'un objet en projection parallele orthographique utilisable
 * au sein d'un {@link ApplicationCanvas ApplicationCanvas}.
 * 
 * @author Nicolas Janey
 * @author nicolas.janey@univ-fcomte.fr
 * @version 1.0, 12/11/08
 */


public class AfficheurProjectionOrthographique implements Afficheur {
  
/**
 * Tableau de stockage des {@link Position3D Position3D} des sommets
 * definissant l'objet affiche.
 */

  private static final Position3D [] pts = { new Position3D( 2.0,0.0,3.0),
                                             new Position3D( 2.0,3.0,3.0),
                                             new Position3D( 0.0,5.0,3.0),
                                             new Position3D(-2.0,3.0,3.0),
                                             new Position3D(-2.0,0.0,3.0),
                                             new Position3D( 2.0,0.0,-3.0),
                                             new Position3D( 2.0,3.0,-3.0),
                                             new Position3D( 0.0,5.0,-3.0),
                                             new Position3D(-2.0,3.0,-3.0),
                                             new Position3D(-2.0,0.0,-3.0) };

/**
 * Tableau de stockage des indices au sein du tableau de {@link Position3D Position3D}
 * definissant les segments de droite de dessin en fil de fer de l'objet affiche.
 */

private static final int [][] indexe = { {  0, 1 },
                                           {  1, 2 },
                                           {  2, 3 },
                                           {  3, 4 },
                                           {  4, 0 },
                                           {  5, 6 },
                                           {  6, 7 },
                                           {  7, 8 },
                                           {  8, 9 },
                                           {  9, 5 },
                                           {  0, 5 },
                                           {  1, 6 },
                                           {  2, 7 },
                                           {  3, 8 },
                                           {  4, 9 } };

/**
 * Facteur de zoom a l'affichage.
 */

  private static final double zoom = 40.0;
  
/**
 * Methode d'affichage executee en boucle infinie pour realiser l'affichage
 * d'un objet en projection parallele orthographique.
 * 
 * @param g l'objet <code>Graphics</code> d'affichage.
 * @param numeroImage le nombre de fois ou cette methode a deja ete appelee.
 * @param tx la largeur (en pixels) de la zone de dessin.
 * @param ty la hauteur (en pixels) de la zone de dessin.
 */

  public void paint(Graphics g,int numeroImage,int tx,int ty) {
    g.drawString("Image : "+numeroImage,10,20);
    double angle = numeroImage*Math.PI/45.0;
    double x = Math.round(1000.0*Math.cos(angle))/100.0;
    double y = 4.0;
    double z = Math.round(1000.0*Math.sin(angle))/100.0;
    g.drawString("x : "+x,10,40);
    g.drawString("y : "+y,10,60);
    g.drawString("z : "+z,10,80);
    Ortho ortho = new Ortho(new Position3D(x,y,z),new Position3D(0.0,3.0,0.0));
    Position3D [] np = new Position3D[pts.length];
    for ( int i = 0 ; i < np.length ; i++ )
      np[i] = ortho.transform(pts[i]);
    double cx = tx/2.0;
    double cy = ty/2.0;
    for ( int i = 0 ; i < indexe.length ; i++ ) {
      Position3D pi = np[indexe[i][0]];
      Position3D pf = np[indexe[i][1]];
      g.drawLine((int) (cx+pi.getX()*zoom),
                 (int) (cy-pi.getY()*zoom),
                 (int) (cx+pf.getX()*zoom),
                 (int) (cy-pf.getY()*zoom));
    }
  }
}

Classe de gestion d'une fenêtre : ApplicationFrame.java

import java.lang.*;
import java.awt.*;
import java.awt.event.*;

/**
 * La classe <code>ApplicationFrame</code> implante la <code>Frame</code> principale
 * d'une application d'affichage d'un {@link ApplicationCanvas ApplicationCanvas}
 * munie d'un {@link Afficheur Afficheur}.
 *
 * @author Nicolas Janey
 * @author nicolas.janey@univ-fcomte.fr
 * @version 1.0, 12/01/06
 */


public class ApplicationFrame extends Frame 
                              implements WindowListener,
                                         ActionListener {

/**
 * {@link ApplicationCanvas ApplicationCanvas} affiche dans la <code>Frame</code>.
 */

  private ApplicationCanvas ac;

/**
 * Barre de menus de la <code>Frame</code>.
 */

  private MenuBar mb = new MenuBar();

/**
 * Menu de la barre de menus de la <code>Frame</code>.
 */

  private Menu m1 = new Menu("Fichier");

/**
 * Item de menu du menu de la barre de menus de la <code>Frame</code>.
 */

  private MenuItem mq = new MenuItem("Quitter");

/**
 * Constructeur pour une <code>ApplicationFrame</code>
 * munie d'un {@link Afficheur Afficheur}.
 *
 * @param afficheur l'objet {@link Afficheur Afficheur} d'initialisation.
 * 
 */

  public ApplicationFrame(String s,Afficheur afficheur) {
    super();
    ac = new ApplicationCanvas(afficheur);
    setTitle(s);
    addWindowListener(this);
    setMenuBar(mb);
    mb.add(m1);
    m1.add(mq);
    mq.addActionListener(this);
    add(ac);
  }
  
/**
 * "Termine" le programme.
 *
 * 
 */

  public void quitter() {
    System.exit(0);
  }
  
/**
 * Retourne le {@link ApplicationCanvas ApplicationCanvas} associe a this.
 *
 * @return le {@link ApplicationCanvas ApplicationCanvas} associe a this.
 * 
 */

  public ApplicationCanvas getCanvas() {
    return(ac);
  }
  
  public void actionPerformed(ActionEvent e) {
    if ( e.getSource() == mq ) {
      quitter(); }
  }
  
  public void windowActivated(WindowEvent e) {
  }
  
  public void windowClosed(WindowEvent e) {
  }
  
  public void windowClosing(WindowEvent e) {
    quitter();
  }
  
  public void windowDeactivated(WindowEvent e) {
  }
  
  public void windowDeiconified(WindowEvent e) {
  }
  
  public void windowIconified(WindowEvent e) {
  }
  
  public void windowOpened(WindowEvent e) {
  }
}

Classe de gestion d'un Canvas d'affichage : ApplicationCanvas.java

import java.lang.*;
import java.awt.*;
import java.awt.event.*;

/**
 * La classe <code>ApplicationCanvas</code> implante un <code>Canvas</code> de dessin
 * faisant appel a la methode paint d'une classe implantant {@link Afficheur Afficheur}.
 *
 * @author Nicolas Janey
 * @author nicolas.janey@univ-fcomte.fr
 * @version 1.0, 16/11/08
 */


public class ApplicationCanvas extends Canvas {

/**
 * {@link Afficheur Afficheur} gere par le <code>Canvas</code>.
 */

  private Afficheur afficheur;

/**
 * Nombre d'images deja affichees.
 */

  private static int image = 0;

/**
 * Constructeur pour un <code>ApplicationCanvas</code>
 * muni de son {@link Afficheur Afficheur}.
 *
 * @param afficheur l'objet {@link Afficheur Afficheur} d'initialisation.
 * 
 */

  public ApplicationCanvas(Afficheur afficheur) {
    super();
    this.afficheur = afficheur;
  }

/**
 * Methode d'affichage.
 *
 * @param g l'objet <code>Graphics</code> d'affichage gere par le canvas.
 * 
 */

  public void paint(Graphics g) {
    image++;
    afficheur.paint(g,image,getWidth(),getHeight());
  }
}

Classe de gestion d'un Thread "tâche de fond" : ThreadTacheDeFond.java

import java.awt.*;

/**
 * La classe <code>ThreadTacheDeFond</code> implante un <code>Thread</code>
 * permettant de gerer le rafraichissement d'un <code>Canvas</code>
 * a interval regulier d'une duree arbitraire.
 *
 * @author Nicolas Janey
 * @author nicolas.janey@univ-fcomte.fr
 * @version 1.0, 16/11/08
 */


public class ThreadTacheDeFond extends Thread {
  
/**
 * Le <code>Canvas</code> a rafraichir regulierement.
 */

  private Canvas c;
  
/**
 * La temporisation entre chaque demande de rafraichissement.
 */

  private int temporisation;
  
/**
 * Le booleen controlant l'exécution du <code>Thread</code>.
 */

  private boolean ok = true ; 

/**
 * Constructeur pour un <code>ThreadTacheDeFond</code> muni d'une certaine temporisation
 * et d'un certain <code>Canvas</code>.
 * 
 */

  public ThreadTacheDeFond(int temporisation,Canvas c) {
    this.c = c;
    this.temporisation = temporisation;
    ok = true;
  }

/**
 * Methode d'execution.
 * 
 */

  public void run() {
    while ( ok ) {
      c.repaint();
      try {
        sleep(temporisation); }
      catch(Exception e) { } }
  }

/**
 * "Termine" le fonctionnement de this.
 * 
 */

  public void arret() {
    ok = false ;
  }
}

Classe programme principal : ProjectionOrthographique.java

/**
 * La classe <code>ProjectionOrthographique</code> implante un programme d'affichage 3D
 * en fil de fer d'une scene dessinee en projection parallele orthographique.
 *
 * @author Nicolas Janey
 * @author nicolas.janey@univ-fcomte.fr
 * @version 1.0, 16/11/08
 */


public class ProjectionOrthographique {
  
  private static int temporisation = 50;
  
  public static void main(String [] args) {
    Afficheur afficheur =(Afficheur) new AfficheurProjectionOrthographique();
    ApplicationFrame f = new ApplicationFrame("Projection parallele orthographique",
                                              afficheur);
    f.setSize(480,360);
    f.setLocation(50,250);
    ThreadTacheDeFond ttdf = new ThreadTacheDeFond(temporisation,f.getCanvas());
    ttdf.start();
    f.setVisible(true);
  }
}

 

RETOUR