TransformationGeometrique.h

/* Mathematiques de l'informatique graphique    */
/* Transformation geometrique 3D                */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2011                                 */

#ifndef ____TRANSFORMATIONGEOMETRIQUE____
#define ____TRANSFORMATIONGEOMETRIQUE____

class CoordonneesHomogenes;

class TransformationGeometrique  {

  public :
    double c[4][4];

  public :
    TransformationGeometrique(void);
    TransformationGeometrique(double *t);
    TransformationGeometrique(double **t);
    TransformationGeometrique(TransformationGeometrique *tg);
    ~TransformationGeometrique(void);
    void print(void);
    void produit(TransformationGeometrique *t1,TransformationGeometrique *t2);
    virtual void transforme(CoordonneesHomogenes *ch);
};

#endif

TransformationGeometrique.cpp

/* Mathematiques de l'informatique graphique    */
/* Transformation geometrique en 3D             */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2011                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "TransformationGeometrique.h"
#include "CoordonneesHomogenes.h"

TransformationGeometrique::TransformationGeometrique(void) {
  for ( int i = 0 ; i < 4 ; i++ )
    for ( int j = 0 ; j < 4 ; j++ )
      c[i][j] =( i == j ) ? 1.0 : 0.0;
}

TransformationGeometrique::TransformationGeometrique(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++; }
}

TransformationGeometrique::TransformationGeometrique(double **t) {
  for ( int i = 0 ; i < 4 ; i++ )
    for ( int j = 0 ; j < 4 ; j++ )
      c[i][j] = t[i][j];
}

TransformationGeometrique::TransformationGeometrique(TransformationGeometrique *tg) {
  for ( int i = 0 ; i < 4 ; i++ )
    for ( int j = 0 ; j < 4 ; j++ )
      c[i][j] = tg->c[i][j];
}

TransformationGeometrique::~TransformationGeometrique(void) {
}

void TransformationGeometrique::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 TransformationGeometrique::produit(TransformationGeometrique *t1,TransformationGeometrique *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 TransformationGeometrique::transforme(CoordonneesHomogenes *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]; }
}

Translation.h

/* Mathematiques de l'informatique graphique    */
/* Translation 3D                               */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2011                                 */

#ifndef ____TRANSLATION____
#define ____TRANSLATION____

#include "TransformationGeometrique.h"

class Translation : public TransformationGeometrique {

  public :
    Translation(void);
    Translation(double tx,double ty,double tz);
    ~Translation(void);
};

#endif

Translation.cpp

/* Mathematiques de l'informatique graphique    */
/* Translation 3D                               */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2011                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "TransformationGeometrique.h"
#include "Translation.h"

Translation::Translation(void):TransformationGeometrique() {
}

Translation::Translation(double tx,double ty,double tz):TransformationGeometrique() {
  c[0][3] = tx;
  c[1][3] = ty;
  c[2][3] = tz;
}

Translation::~Translation(void) {
}

Rotation.h

/* Mathematiques de l'informatique graphique    */
/* Rotation 3D                                  */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2011                                 */

#ifndef ____ROTATION____
#define ____ROTATION____

#include "TransformationGeometrique.h"

class Rotation : public TransformationGeometrique {

  public :
    Rotation(void);
    Rotation(double angle,double ax,double ay,double az);
    ~Rotation(void);
};

#endif

Rotation.cpp

/* Mathematiques de l'informatique graphique    */
/* Rotation 3D                                  */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2011                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "TransformationGeometrique.h"
#include "Rotation.h"
#include "Direction3D.h"

#ifndef M_PI
#define M_PI 3.14159
#endif

Rotation::Rotation(void):TransformationGeometrique() {
}

Rotation::Rotation(double angle,double ax,double ay,double az):TransformationGeometrique() {
  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]);
}

Rotation::~Rotation(void) {
}

TD n°6 pour les classes CoordonneesHomogenes, Position3D et Direction3D

RETOUR