Classe de base: tableau de float de taille arbitraire.
/* Classe de stockage d'un vecteur de float */
/* de longueur arbitraire */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Vecteur {
public float [] c;
public Vecteur(int n) {
c = new float[n];
}
public Vecteur(float v) {
c = new float[1];
c[0] = v;
}
public Vecteur(float v1,float v2) {
c = new float[2];
c[0] = v1;
c[1] = v2;
}
public Vecteur(float v1,float v2,float v3) {
c = new float[3];
c[0] = v1;
c[1] = v2;
c[2] = v3;
}
public Vecteur(float v1,float v2,float v3,float v4) {
c = new float[4];
c[0] = v1;
c[1] = v2;
c[2] = v3;
c[3] = v4;
}
public Vecteur(float [] v) {
c = new float[v.length];
for ( int i = 0 ; i < v.length ; i++ )
c[i] = v[i];
}
public Vecteur(Vecteur v) {
c = new float[v.c.length];
for ( int i = 0 ; i < v.c.length ; i++ )
c[i] = v.c[i];
}
public String toString() {
String s = "[";
for ( int i = 0 ; i < c.length ; i++ )
s += (c[i]+",");
s += "]";
return(s);
}
}
Classe tableau de 4 float.
/* Une classe de stockage d'un vecteur de 4 float */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Vecteur4 extends Vecteur {
public Vecteur4() {
super(4);
}
public Vecteur4(float v1,float v2,float v3,float v4) {
super(v1,v2,v3,v4);
}
public Vecteur4(Vecteur4 v4) {
super(v4);
}
}
Classe de base: tableau de float à deux dimensions de taille arbitraire selon les deux dimensions.
/* Classe de stockage d'une matrice rectangulaire */
/* de float de nombre de lignes et de colonnes */
/* arbitraires */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Matrice {
public float [][] c;
public Matrice(int lignes,int colonnes) {
c = new float[lignes][colonnes];
}
public Matrice(float [][] v) {
c = new float[v.length][v[0].length];
for ( int i = 0 ; i < v.length ; i++ )
for ( int j = 0 ; j < v[i].length ; j++ )
c[i][j] = v[i][j];
}
public Matrice(Matrice m) {
c = new float[m.c.length][m.c[0].length];
for ( int i = 0 ; i < m.c.length ; i++ )
for ( int j = 0 ; j < m.c[i].length ; j++ )
c[i][j] = m.c[i][j];
}
public Vecteur multiplication(Vecteur v) {
if ( v.c.length == c[0].length ) {
Vecteur r = new Vecteur(c.length);
for ( int i = 0 ; i < c.length ; i++ )
for ( int j = 0 ; j < c[0].length ; j++ )
r.c[i] += c[i][j]*v.c[j];
return(r); }
return(null);
}
public Matrice multiplication(Matrice m) {
if ( m.c.length == c[0].length ) {
Matrice r = new Matrice(c.length,m.c[0].length);
for ( int i = 0 ; i < c.length ; i++ )
for ( int j = 0 ; j < m.c[0].length ; j++ )
for ( int k = 0 ; k < m.c.length ; k++ )
r.c[i][j] += c[i][k]*m.c[k][j];
return(r); }
return(null);
}
public String toString() {
String s = "[";
for ( int j = 0 ; j < c.length ; j++ ) {
s += "[";
for ( int i = 0 ; i < c[j].length ; i++ )
s += (c[j][i]+",");
s += "]\n"; }
s += "]";
return(s);
}
}
Classe matrice de 4x4 float
/* Une classe de stockage d'une matrice de 4x4 float */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Matrice44 extends Matrice {
public Matrice44() {
super(4,4);
}
public Matrice44(float [][] t) {
super(t);
}
public Matrice44(Matrice44 m) {
super(m.c);
}
}
Une première classe CoodonneesHomogenes est dérivée de la classe Vecteur4 pour représenter des coordonnées homogènes 3D.
/* Une classe coordonnees homogenes en trois dimensions */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class CoordonneesHomogenes3D extends Vecteur4 {
public CoordonneesHomogenes3D() {
super();
}
public CoordonneesHomogenes3D(float x,float y,float z,float t) {
super(x,y,z,t);
}
public CoordonneesHomogenes3D(CoordonneesHomogenes3D ch) {
super(ch.c[0],ch.c[1],ch.c[2],ch.c[3]);
}
public void setX(float x) {
c[0] = x;
}
public float getX() {
return(c[0]);
}
public void setY(float y) {
c[1] = y;
}
public float getY() {
return(c[1]);
}
public void setZ(float z) {
c[2] = z;
}
public float getZ() {
return(c[2]);
}
public void setT(float t) {
c[3] = t;
}
public float getT() {
return(c[3]);
}
}
La classe Position est dérivée de la classe CoordonneesHomogenes pour représenter des positions dans un espace 3D (4ème coordonnée initialisée à 1.0F).
/* Une classe position en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Position3D extends CoordonneesHomogenes3D {
public Position3D() {
super(0.0F,0.0F,0.0F,1.0F);
}
public Position3D(float x,float y,float z) {
super(x,y,z,1.0F);
}
public Position3D(Position3D p) {
super(p);
}
}
La classe Direction est dérivée de la classe CoordonneesHomogenes pour représenter des directions dans un espace 3D (4ème coordonnée initialisée à 0.0F).
/* Une classe direction en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Direction3D extends CoordonneesHomogenes3D {
public Direction3D() {
super(0.0F,0.0F,1.0F,0.0F);
}
public Direction3D(float x,float y,float z) {
super(x,y,z,0.0F);
}
public Direction3D(Direction3D p) {
super(p);
}
public Direction3D(Position3D pi,
Position3D pf) throws ArithmeticException {
float dx = pf.c[0]-pi.c[0];
float dy = pf.c[1]-pi.c[1];
float dz = pf.c[2]-pi.c[2];
float d =(float) Math.sqrt(dx*dx+dy*dy+dz*dz);
if ( d == 0.0F ) {
throw new ArithmeticException(); }
c = new float[4];
c[0] = dx/d;
c[1] = dy/d;
c[2] = dz/d;
c[3] = 0.0F;
}
}
La classe Transformation est dérivée de la classe Matrice44 pour représenter des
transformations géométriques quelconques en coordonnées homogènes dans un espace 3D.
Le constructeur sans paramètre dérive directement de celui de la classe Matrice44 qui
crée une matrice identité.
Trois méthodes sont développées pour:
/* Une classe transformation geometrique 3D */
/* en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class TransformationGeometrique3D extends Matrice44 {
public TransformationGeometrique3D() {
super();
for ( int i = 0 ; i < 4 ; i++ )
c[i][i] = 1.0F;
}
public TransformationGeometrique3D(float [][] t) {
super(t);
}
public TransformationGeometrique3D(TransformationGeometrique3D t) {
super(t);
}
public Position3D multiplication(Position3D p) {
Vecteur v = multiplication((Vecteur) p);
return(new Position3D(v.c[0],v.c[1],v.c[2]));
}
public Direction3D multiplication(Direction3D d) {
Vecteur v = multiplication((Vecteur) d);
return(new Direction3D(v.c[0],v.c[1],v.c[2]));
}
public TransformationGeometrique3D multiplication(TransformationGeometrique3D t) {
Matrice m = multiplication((Matrice) t);
return(new TransformationGeometrique3D(m.c));
}
}
TransformationGeometrique3D.java
La classe Identite est dérivée de la classe Transformation.
/* Une classe transformation geometrique identite */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Identite extends TransformationGeometrique3D {
public Identite() {
super();
}
}
La classe Translation est dérivée de la classe Transformation.
/* Une classe transformation geometrique translation */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Translation extends TransformationGeometrique3D {
public Translation() {
super();
}
public Translation(float x,float y,float z) {
super();
c[0][3] = x;
c[1][3] = y;
c[2][3] = z;
}
public Translation(Direction3D d) {
super();
c[0][3] = d.getX();
c[1][3] = d.getY();
c[2][3] = d.getZ();
}
public Translation(Translation t) {
super(t);
}
}
La classe Rotation est dérivée de la classe Transformation.
Elle comporte un constructeur pour la création d'une rotation autour d'un axe défini par
une direction arbitraire passant par l'origine.
/* Une classe transformation geometrique rotation */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Rotation extends TransformationGeometrique3D {
public Rotation() {
super();
}
public Rotation(float a,
float dx,float dy,float dz) throws ArithmeticException {
super();
remplissage(a,dx,dy,dz);
}
public Rotation(float a,
Direction3D d) throws ArithmeticException {
super();
remplissage(a,d.getX(),d.getY(),d.getZ());
}
public Rotation(Rotation rt) {
super(rt);
}
private void remplissage(float a,
float x,float y,float z) throws ArithmeticException {
a = a/180.0F*(float) Math.PI;
float c =(float) Math.cos(a);
float s =(float) Math.sin(a);
float d =(float) Math.sqrt(x*x+y*y+z*z);
if ( d == 0 ) {
throw new ArithmeticException(); }
x /= d;
y /= d;
z /= d;
float x2 = x*x;
float y2 = y*y;
float z2 = z*z;
float xs = x*s;
float ys = y*s;
float zs = z*s;
float mc = 1.0F - c;
float xymc = x*y*mc;
float xzmc = x*z*mc;
float yzmc = y*z*mc;
this.c[0][0] = x2+c*(1.0F-x2);
this.c[0][1] = xymc-zs;
this.c[0][2] = xzmc+ys;
this.c[1][0] = xymc+zs;
this.c[1][1] = y2+c*(1.0F-y2);
this.c[1][2] = yzmc-xs;
this.c[2][0] = xzmc-ys;
this.c[2][1] = yzmc+xs;
this.c[2][2] = z2+c*(1.0F-z2);
}
}
La classe Scale est dérivée de la classe Transformation.
/* Une classe transformation geometrique scale */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Novembre 2009 */
public class Scale extends TransformationGeometrique3D {
public Scale() {
super();
}
public Scale(float rx,float ry,float rz) {
super();
c[0][0] = rx;
c[1][1] = ry;
c[2][2] = rz;
}
public Scale(Scale sc) {
super(sc);
}
}
Aide de cette hiérarchie de classes au format Javadoc
RETOUR