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