RETOUR
Fichier source : MathematiquesIG3.cpp
/* Transformations geometriques */
/* en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdio.h>
#include <math.h>
#include "Position3D.h"
#include "Direction3D.h"
#include "Translation3D.h"
#include "Rotation3D.h"
#include "TransformationGeometrique3D.h"
/* Fonction principale */
int main(int argc,char **argv) {
Position3D *p = new Position3D(1.0,2.0,5.0);
Translation3D *t1 = new Translation3D(-p->c[0],-p->c[1],-p->c[2]);
Rotation3D *r = new Rotation3D(10.0,0.0,0.0,1.0);
Translation3D *t2 = new Translation3D(p->c[0],p->c[1],p->c[2]);
TransformationGeometrique3D *tg = new TransformationGeometrique3D();
tg->compose(t1);
tg->compose(r);
tg->compose(t2);
printf("Matrice de transformation:\n");
tg->print();
printf("\n");
{ Position3D *p = new Position3D(1.0,2.0,5.0);
printf("Point de definition de l'axe\n");
printf("P : ");
p->print();
printf("\n");
tg->transforme(p);
printf("P' : ");
p->print();
printf("\n-> Invariant\n");
printf("\n");
delete(p); }
{ Position3D *p = new Position3D(1.0,2.0,3.0);
printf("Point sur l'axe\n");
printf("P : ");
p->print();
printf("\n");
tg->transforme(p);
printf("P' : ");
p->print();
printf("\n-> Invariant\n");
printf("\n");
delete(p); }
{ Position3D *p = new Position3D(0.0,1.0,3.0);
printf("Point quelconque\n");
printf("P : ");
p->print();
printf("\n");
tg->transforme(p);
printf("P' : ");
p->print();
printf("\n-> Modification\n");
printf("\n");
delete(p); }
delete(tg);
delete(t2);
delete(r);
delete(t1);
delete(p);
getchar();
return(0);
}
Fichier source : CoordonneesHomogenes3D.h
/* Mathematiques de l'informatique graphique */
/* Coordonnees homogenes en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____COORDONNEESHOMOGENES3D____
#define ____COORDONNEESHOMOGENES3D____
class CoordonneesHomogenes3D {
public :
double c[4];
public :
/* Constructeurs */
CoordonneesHomogenes3D(void);
CoordonneesHomogenes3D(double x,double y,double z,double t);
CoordonneesHomogenes3D(CoordonneesHomogenes3D *c);
/* Destructeur */
~CoordonneesHomogenes3D(void);
/* Methode d'affichage texte */
void print(void);
};
#endif
Fichier source : CoordonneesHomogenes3D.cpp
/* Mathematiques de l'informatique graphique */
/* Coordonnees homogenes en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "CoordonneesHomogenes3D.h"
/* Constructeurs */
CoordonneesHomogenes3D::CoordonneesHomogenes3D(void) {
c[0] = c[1] = c[2] = 0.0;
c[3] = 1.0;
}
CoordonneesHomogenes3D::CoordonneesHomogenes3D(double x,double y,double z,double t) {
c[0] = x;
c[1] = y;
c[2] = z;
c[3] = t;
}
CoordonneesHomogenes3D::CoordonneesHomogenes3D(CoordonneesHomogenes3D *ch) {
c[0] = ch->c[0];
c[1] = ch->c[1];
c[2] = ch->c[2];
c[3] = ch->c[3];
}
/* Destructeur */
CoordonneesHomogenes3D::~CoordonneesHomogenes3D(void) {
}
/* Methode d'affichage texte */
void CoordonneesHomogenes3D::print(void) {
printf("%10.4lf %10.4lf %10.4lf %10.4lf",c[0],c[1],c[2],c[3]);
}
/* Mathematiques de l'informatique graphique */
/* Position en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____POSITION3D____
#define ____POSITION3D____
#include "CoordonneesHomogenes3D.h"
class Position3D : public CoordonneesHomogenes3D {
public :
/* Constructeurs */
Position3D(void);
Position3D(double x,double y,double z);
Position3D(Position3D *c);
/* Destructeur */
~Position3D(void);
/* Methode de calcul de la distance */
/* entre deux positions */
double distance(Position3D *p);
/* Methode de calcul du carre */
/* de la distance entre deux positions */
double carreDistance(Position3D *p);
};
#endif
Fichier source : Position3D.cpp
/* Mathematiques de l'informatique graphique */
/* Position en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "CoordonneesHomogenes3D.h"
#include "Position3D.h"
/* Constructeurs */
Position3D::Position3D(void):CoordonneesHomogenes3D(0.0,0.0,0.0,1.0) {
}
Position3D::Position3D(double x,double y,double z):CoordonneesHomogenes3D(x,y,z,1.0) {
}
Position3D::Position3D(Position3D *p):CoordonneesHomogenes3D(p) {
}
/* Destructeur */
Position3D::~Position3D(void) {
}
/* Methode de calcul de la distance */
/* entre deux positions */
double Position3D::distance(Position3D *p) {
return(sqrt(carreDistance(p)));
}
/* Methode de calcul du carre de la distance */
/* entre deux positions */
double Position3D::carreDistance(Position3D *p) {
double dx = p->c[0]-c[0];
double dy = p->c[1]-c[1];
double dz = p->c[2]-c[2];
return(dx*dx+dy*dy+dz*dz);
}
Fichier source : Direction3D.h
/* Mathematiques de l'informatique graphique */
/* Direction en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____DIRECTION3D____
#define ____DIRECTION3D____
class Position3D;
#include "CoordonneesHomogenes3D.h"
class Direction3D : public CoordonneesHomogenes3D {
public :
/* Constructeurs */
Direction3D(void);
Direction3D(double x,double y,double z);
Direction3D(Direction3D *c);
Direction3D(Position3D *p1,Position3D *p2);
/* Destructeur */
~Direction3D(void);
/* Methode de calcul de la norme */
double norme(void);
/* Methode de normalisation */
double normalisation(void);
/* Methode de calcul du produit scalaire */
/* de deux directions */
double produitScalaire(Direction3D *d);
/* Methode de calcul du produit vectoriel */
/* de deux directions */
void produitVectoriel(Direction3D *d1,Direction3D *d2);
/* Methode de calcul du produit vectoriel */
/* de this par une direction */
void produitVectoriel(Direction3D *d);
};
#endif
Fichier source : Direction3D.cpp
/* Mathematiques de l'informatique graphique */
/* Direction en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "CoordonneesHomogenes3D.h"
#include "Direction3D.h"
#include "Position3D.h"
/* Constructeurs */
Direction3D::Direction3D(void):CoordonneesHomogenes3D(0.0,0.0,0.0,0.0) {
}
Direction3D::Direction3D(double x,double y,double z):CoordonneesHomogenes3D(x,y,z,0.0) {
}
Direction3D::Direction3D(Direction3D *p):CoordonneesHomogenes3D(p) {
}
Direction3D::Direction3D(Position3D *p1,Position3D *p2):CoordonneesHomogenes3D() {
c[0] = p2->c[0]-p1->c[0];
c[1] = p2->c[1]-p1->c[1];
c[2] = p2->c[2]-p1->c[2];
c[3] = 0.0;
}
/* Destructeur */
Direction3D::~Direction3D(void) {
}
/* Methode de calcul de la norme */
double Direction3D::norme(void) {
return(sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2]));
}
/* Methode de normalisation */
double Direction3D::normalisation(void) {
double d = norme();
if ( d != 0.0 ) {
c[0] /= d;
c[1] /= d;
c[2] /= d; }
return(d);
}
/* Methode de calcul du produit scalaire */
/* de deux directions */
double Direction3D::produitScalaire(Direction3D *d) {
return(c[0]*d->c[0]+c[1]*d->c[1]+c[2]*d->c[2]);
}
/* Methode de calcul du produit vectoriel */
/* de deux directions */
void Direction3D::produitVectoriel(Direction3D *d1,Direction3D *d2) {
double x = d1->c[1]*d2->c[2] - d1->c[2]*d2->c[1];
double y = d1->c[2]*d2->c[0] - d1->c[0]*d2->c[2];
double z = d1->c[0]*d2->c[1] - d1->c[1]*d2->c[0];
c[0] = x;
c[1] = y;
c[2] = z;
c[3] = 0.0;
}
/* Methode de calcul du produit vectoriel */
/* de this par une direction */
void Direction3D::produitVectoriel(Direction3D *d) {
double x = c[1]*d->c[2] - c[2]*d->c[1];
double y = c[2]*d->c[0] - c[0]*d->c[2];
double z = c[0]*d->c[1] - c[1]*d->c[0];
c[0] = x;
c[1] = y;
c[2] = z;
c[3] = 0.0;
}
Fichier source : TransformationGeometrique3D.h
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____TRANSFORMATIONGEOMETRIQUE3D____
#define ____TRANSFORMATIONGEOMETRIQUE3D____
class CoordonneesHomogenes3D;
class TransformationGeometrique3D {
public :
double c[4][4];
public :
/* Constructeurs */
TransformationGeometrique3D(void);
TransformationGeometrique3D(double *t);
TransformationGeometrique3D(double **t);
TransformationGeometrique3D(TransformationGeometrique3D *tg);
/* Destructeur */
~TransformationGeometrique3D(void);
/* Methodes */
void print(void);
void compose(TransformationGeometrique3D *tg);
void compose(TransformationGeometrique3D *t1,TransformationGeometrique3D *t2);
void transforme(CoordonneesHomogenes3D *ch);
};
#endif
Fichier source : TransformationGeometrique3D.cpp
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique3D.h"
#include "CoordonneesHomogenes3D.h"
/* Constructeurs */
TransformationGeometrique3D::TransformationGeometrique3D(void) {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] =( i == j ) ? 1.0 : 0.0;
}
TransformationGeometrique3D::TransformationGeometrique3D(double *t) {
int k = 0;
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ ) {
c[i][j] = t[k];
k++; }
}
TransformationGeometrique3D::TransformationGeometrique3D(double **t) {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] = t[i][j];
}
TransformationGeometrique3D::TransformationGeometrique3D(TransformationGeometrique3D *tg) {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] = tg->c[i][j];
}
/* Destructeur */
TransformationGeometrique3D::~TransformationGeometrique3D(void) {
}
/* Methodes */
void TransformationGeometrique3D::print(void) {
for ( int i = 0 ; i < 4 ; i++ )
printf("%10.4lf %10.4lf %10.4lf %10.4lf\n",c[i][0],c[i][1],c[i][2],c[i][3]);
}
void TransformationGeometrique3D::compose(TransformationGeometrique3D *t1,TransformationGeometrique3D *t2) {
double c[4][4];
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ ) {
c[i][j] = 0.0;
for ( int k = 0 ; k < 4 ; k++ )
c[i][j] += t1->c[i][k]*t2->c[k][j]; }
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
this->c[i][j] = c[i][j];
}
void TransformationGeometrique3D::compose(TransformationGeometrique3D *tg) {
double aux[4][4];
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ ) {
aux[i][j] = 0.0;
for ( int k = 0 ; k < 4 ; k++ )
aux[i][j] += tg->c[i][k]*c[k][j]; }
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] = aux[i][j];
}
void TransformationGeometrique3D::transforme(CoordonneesHomogenes3D *ch) {
double t[4];
for ( int i = 0 ; i < 4 ; i++ ) {
t[i] = 0.0;
for ( int k = 0 ; k < 4 ; k++ )
t[i] += c[i][k]*ch->c[k]; }
for ( int i = 0 ; i < 4 ; i++ ) {
ch->c[i] = t[i]; }
}
Fichier source : Translation3D.h
/* Mathematiques de l'informatique graphique */
/* Translation3D 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____TRANSLATION3D____
#define ____TRANSLATION3D____
#include "TransformationGeometrique3D.h"
class Translation3D : public TransformationGeometrique3D {
public :
/* Constructeurs */
Translation3D(void);
Translation3D(double tx,double ty,double tz);
/* Destructeur */
~Translation3D(void);
};
#endif
Fichier source : Translation3D.cpp
/* Mathematiques de l'informatique graphique */
/* Translation3D 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique3D.h"
#include "Translation3D.h"
/* Constructeurs */
Translation3D::Translation3D(void):TransformationGeometrique3D() {
}
Translation3D::Translation3D(double tx,double ty,double tz):TransformationGeometrique3D() {
c[0][3] = tx;
c[1][3] = ty;
c[2][3] = tz;
}
/* Destructeur */
Translation3D::~Translation3D(void) {
}
/* Mathematiques de l'informatique graphique */
/* Rotation3D 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____ROTATION3D____
#define ____ROTATION3D____
#include "TransformationGeometrique3D.h"
class Rotation3D : public TransformationGeometrique3D {
public :
/* Constructeurs */
Rotation3D(void);
Rotation3D(double angle,double ax,double ay,double az);
/* Destructeur */
~Rotation3D(void);
};
#endif
Fichier source : Rotation3D.cpp
/* Mathematiques de l'informatique graphique */
/* Rotation3D 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique3D.h"
#include "Rotation3D.h"
#include "Direction3D.h"
#ifndef M_PI
#define M_PI 3.14159
#endif
/* Constructeurs */
Rotation3D::Rotation3D(void):TransformationGeometrique3D() {
}
Rotation3D::Rotation3D(double angle,double ax,double ay,double az):TransformationGeometrique3D() {
Direction3D v(ax,ay,az);
v.normalisation();
double aa = angle/180.0*M_PI;
float sn =(float) sin(aa);
float cs =(float) cos(aa);
c[0][0] = v.c[0]*v.c[0]+cs*(1-v.c[0]*v.c[0]);
c[0][1] = v.c[0]*v.c[1]*(1-cs)-sn*v.c[2];
c[0][2] = v.c[0]*v.c[2]*(1-cs)+sn*v.c[1];
c[1][0] = v.c[0]*v.c[1]*(1-cs)+sn*v.c[2];
c[1][1] = v.c[1]*v.c[1]+cs*(1-v.c[1]*v.c[1]);
c[1][2] = v.c[1]*v.c[2]*(1-cs)-sn*v.c[0];
c[2][0] = v.c[0]*v.c[2]*(1-cs)-sn*v.c[1];
c[2][1] = v.c[1]*v.c[2]*(1-cs)+sn*v.c[0];
c[2][2] = v.c[2]*v.c[2]+cs*(1-v.c[2]*v.c[2]);
}
/* Destructeur */
Rotation3D::~Rotation3D(void) {
}