L'exécutable

 

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]);
}

Fichier source : Position3D.h

/* 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) {
}

Fichier source : Rotation3D.h

/* 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) {
}

RETOUR