Fichier source : TransformationGeometrique.h
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique generique */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____TRANSFORMATIONGEOMETRIQUE____
#define ____TRANSFORMATIONGEOMETRIQUE____
class CoordonneesHomogenes;
class TransformationGeometrique {
public :
double **c;
private :
int n;
public :
/* Constructeurs */
TransformationGeometrique(int n);
TransformationGeometrique(int n,double *t);
TransformationGeometrique(int n,double **t);
TransformationGeometrique(TransformationGeometrique *tg);
/* Destructeur */
~TransformationGeometrique(void);
/* Methodes */
void print(void);
void compose(TransformationGeometrique *tg);
void compose(TransformationGeometrique *t1,TransformationGeometrique *t2);
void transforme(CoordonneesHomogenes *ch);
};
#endif
Fichier source : TransformationGeometrique.cpp
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique generique */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique.h"
#include "CoordonneesHomogenes.h"
/* Constructeurs */
static double **allocation(int n) {
double **c =(double **) calloc(n,sizeof(double *));
for ( int i = 0 ; i < n ; i++ )
c[i] =(double *) calloc(n,sizeof(double));
return(c);
}
static void liberation(int n,double **c) {
for ( int i = 0 ; i < n ; i++ )
free(c[i]);
free(c);
}
TransformationGeometrique::TransformationGeometrique(int n) {
this->n = n;
c = allocation(n);
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ )
c[i][j] =( i == j ) ? 1.0 : 0.0;
}
TransformationGeometrique::TransformationGeometrique(int n,double *t) {
this->n = n;
c = allocation(n);
int k = 0;
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ ) {
c[i][j] = t[k];
k++; }
}
TransformationGeometrique::TransformationGeometrique(int n,double **t) {
this->n = n;
c = allocation(n);
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ )
c[i][j] = t[i][j];
}
TransformationGeometrique::TransformationGeometrique(TransformationGeometrique *tg) {
n = tg->n;
c = allocation(n);
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ )
c[i][j] = tg->c[i][j];
}
/* Destructeur */
TransformationGeometrique::~TransformationGeometrique(void) {
liberation(n,c);
}
/* Methodes */
void TransformationGeometrique::print(void) {
for ( int i = 0 ; i < n ; i++ ) {
printf("%8.3lf",c[i][0]);
for ( int j = 1 ; j < n ; j++ )
printf(" %8.3lf",c[i][j]);
printf("\n"); }
}
void TransformationGeometrique::compose(TransformationGeometrique *t1,TransformationGeometrique *t2) {
double **c = allocation(n);
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ ) {
for ( int k = 0 ; k < n ; k++ )
c[i][j] += t1->c[i][k]*t2->c[k][j]; }
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ )
this->c[i][j] = c[i][j];
liberation(n,c);
}
void TransformationGeometrique::compose(TransformationGeometrique *tg) {
double **aux = allocation(n);
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ ) {
for ( int k = 0 ; k < n ; k++ )
aux[i][j] += tg->c[i][k]*c[k][j]; }
for ( int i = 0 ; i < n ; i++ )
for ( int j = 0 ; j < n ; j++ )
c[i][j] = aux[i][j];
liberation(n,aux);
}
void TransformationGeometrique::transforme(CoordonneesHomogenes *ch) {
double *t =(double *) calloc(n,sizeof(double));
for ( int i = 0 ; i < n ; i++ ) {
for ( int k = 0 ; k < n ; k++ )
t[i] += c[i][k]*ch->c[k]; }
for ( int i = 0 ; i < n ; i++ ) {
ch->c[i] = t[i]; }
free(t);
}
Fichier source : TransformationGeometrique2D.h
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique 2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____TRANSFORMATIONGEOMETRIQUE2D____
#define ____TRANSFORMATIONGEOMETRIQUE2D____
#include "TransformationGeometrique.h"
class TransformationGeometrique2D:public TransformationGeometrique {
public :
/* Constructeurs */
TransformationGeometrique2D(void);
TransformationGeometrique2D(double *t);
TransformationGeometrique2D(double **t);
TransformationGeometrique2D(TransformationGeometrique2D *tg);
/* Destructeur */
~TransformationGeometrique2D(void);
};
#endif
Fichier source : TransformationGeometrique2D.cpp
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique en 2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique.h"
#include "TransformationGeometrique2D.h"
/* Constructeurs */
TransformationGeometrique2D::TransformationGeometrique2D(void):TransformationGeometrique(3) {
}
TransformationGeometrique2D::TransformationGeometrique2D(double *t):TransformationGeometrique(3,t) {
}
TransformationGeometrique2D::TransformationGeometrique2D(double **t):TransformationGeometrique(3,t) {
}
TransformationGeometrique2D::TransformationGeometrique2D(TransformationGeometrique2D *tg):TransformationGeometrique(tg) {
}
/* Destructeur */
TransformationGeometrique2D::~TransformationGeometrique2D(void) {
}
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____
#include "TransformationGeometrique.h"
class TransformationGeometrique3D:public TransformationGeometrique {
public :
/* Constructeurs */
TransformationGeometrique3D(void);
TransformationGeometrique3D(double *t);
TransformationGeometrique3D(double **t);
TransformationGeometrique3D(TransformationGeometrique3D *tg);
/* Destructeur */
~TransformationGeometrique3D(void);
};
#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 "TransformationGeometrique.h"
#include "TransformationGeometrique3D.h"
/* Constructeurs */
TransformationGeometrique3D::TransformationGeometrique3D(void):TransformationGeometrique(4) {
}
TransformationGeometrique3D::TransformationGeometrique3D(double *t):TransformationGeometrique(4,t) {
}
TransformationGeometrique3D::TransformationGeometrique3D(double **t):TransformationGeometrique(4,t) {
}
TransformationGeometrique3D::TransformationGeometrique3D(TransformationGeometrique3D *tg):TransformationGeometrique(tg) {
}
/* Destructeur */
TransformationGeometrique3D::~TransformationGeometrique3D(void) {
}
Fichier source : Translation2D.h
/* Mathematiques de l'informatique graphique */
/* Translation2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____TRANSLATION2D____
#define ____TRANSLATION2D____
#include "TransformationGeometrique2D.h"
class Translation2D : public TransformationGeometrique2D {
public :
/* Constructeurs */
Translation2D(void);
Translation2D(double tx,double ty);
/* Destructeur */
~Translation2D(void);
};
#endif
Fichier source : Translation2D.cpp
/* Mathematiques de l'informatique graphique */
/* Translation2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique2D.h"
#include "Translation2D.h"
/* Constructeurs */
Translation2D::Translation2D(void):TransformationGeometrique2D() {
}
Translation2D::Translation2D(double tx,double ty):TransformationGeometrique2D() {
c[0][2] = tx;
c[1][2] = ty;
}
/* Destructeur */
Translation2D::~Translation2D(void) {
}
Fichier source : Translation3D.h
/* Mathematiques de l'informatique graphique */
/* Translation3D */
/* */
/* 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 */
/* */
/* 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 */
/* Rotation 2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____ROTATION2D____
#define ____ROTATION2D____
#include "TransformationGeometrique2D.h"
class Rotation2D : public TransformationGeometrique2D {
public :
/* Constructeurs */
Rotation2D(void);
Rotation2D(double angle);
/* Destructeur */
~Rotation2D(void);
};
#endif
Fichier source : Rotation2D.cpp
/* Mathematiques de l'informatique graphique */
/* Rotation 2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique2D.h"
#include "Rotation2D.h"
#include "Direction2D.h"
#ifndef M_PI
#define M_PI 3.14159
#endif
/* Constructeurs */
Rotation2D::Rotation2D(void):TransformationGeometrique2D() {
}
Rotation2D::Rotation2D(double angle):TransformationGeometrique2D() {
double aa = angle/180.0*M_PI;
float sn =(float) sin(aa);
float cs =(float) cos(aa);
c[0][0] = cs;
c[0][1] = -sn;
c[1][0] = sn;
c[1][1] = cs;
}
/* Destructeur */
Rotation2D::~Rotation2D(void) {
}
/* Mathematiques de l'informatique graphique */
/* Rotation 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 */
/* Rotation 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) {
}
/* Mathematiques de l'informatique graphique */
/* Scale 2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____SCALE2D____
#define ____SCALE2D____
#include "TransformationGeometrique2D.h"
class Scale2D : public TransformationGeometrique2D {
public :
/* Constructeurs */
Scale2D(void);
Scale2D(double rx,double ry);
/* Destructeur */
~Scale2D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Scale 2D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique2D.h"
#include "Scale2D.h"
/* Constructeurs */
Scale2D::Scale2D(void):TransformationGeometrique2D() {
}
Scale2D::Scale2D(double rx,double ry):TransformationGeometrique2D() {
c[0][0] = rx;
c[1][1] = ry;
}
/* Destructeur */
Scale2D::~Scale2D(void) {
}
/* Mathematiques de l'informatique graphique */
/* Scale 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#ifndef ____SCALE3D____
#define ____SCALE3D____
#include "TransformationGeometrique3D.h"
class Scale3D : public TransformationGeometrique3D {
public :
/* Constructeurs */
Scale3D(void);
Scale3D(double rx,double ry,double rz);
/* Destructeur */
~Scale3D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Scale 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Octobre 2012 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TransformationGeometrique3D.h"
#include "Scale3D.h"
/* Constructeurs */
Scale3D::Scale3D(void):TransformationGeometrique3D() {
}
Scale3D::Scale3D(double rx,double ry,double rz):TransformationGeometrique3D() {
c[0][0] = rx;
c[1][1] = ry;
c[2][2] = rz;
}
/* Destructeur */
Scale3D::~Scale3D(void) {
}