Commentaires
Quelques soucis se posent à nous. Parmi eux, le premier est que
le choix a été fait au TD n°5 de définir 4 attributs de type float pour la classe mère CH3D. Or, notre but est d'implanter le produit
matrice-vecteur dont la formule de calcul fait appel à une notation indicielle assimilable à l'utilisation de tableaux et donc incompatible avec
des attributs indépendants. Nous n'allons pas remettre en cause le choix réalisé et donc nous adapter
en redesignant la formule de calcul. Pour le produit matrice-matrice, rien ne s'oppose à ce que la classe mère TG3D n'ait qu'un seul
attribut de type matrice 4x4 de float. L'utilisation directe de la formule de calcul est donc possible.
Un autre point auquel attention doit être porté est que, contrairement à la hiérarchie de classes CH3D, Pos3D et Dir3D pour laquelle la classe
mère CH3D est ininstanciable car sans constructeur, la hiérarchie TG3D, Tr3D et Rt3D doit être conçue pour que la classe TG3D permettent
l'instanciation. En effet, si aucune situation n'est envisagée qui conduirait à utiliser des objets CH3D, il est parfaitement naturel d'utiliser
des objets TG3D. Exemple : La composition d'une translation et d'une rotation n'étant généralement ni une translation ni une rotation, le
résultat obtenu sera donc une transformation géométrique. Remarques : La composition de deux translations étant une translation, cette situation
pourrait être prévue. La composition de deux rotations étant une rotation, cette situation pourrait être prévue. Il serait possible de développer
des méthodes permettant de tester si une TG3D est une translation ou si une TG3D est une rotation. On pourrait aussi ajouter à la classe Tr3D
(resp. Rt3d) un constructeur prenant en paramètre une TG3D et construisant, si c'est possible (gestion d'une exception), le clone en Tr3D (resp.
Rt3D) de cette TG3D.
Les choix de développement suivants ont été réalisés :
Le programme principal vise à tester les différents constructeurs et méthodes développés puis à tester la réalisation de transformations géométriques d'une position ou d'une direction, et la composition de transformations géométriques.
Détail : La classe Sc3D a aussi été développée pour gérer des zooms.
Fichier source : Mathematiques2.cpp
Tous les fichiers sources : Mathematiques2.zip
static void afficher(char *message,CH3D *ch) {
printf("%s",message);
ch->print();
printf("\n");
}
int main(void) {
#if defined(WIN32) || defined(WIN64)
#if defined(_DEBUG)
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
//_crtBreakAlloc = 120;
#endif
#endif
Tr3D tr1(1.8F,-3.4F,6.7F);
Tr3D *tr2 = new Tr3D(-4.5F,0.1F,3.2F);
Tr3D tr3;
Tr3D tr4(tr2);
printf("Translations\n\n");
tr1.print("tr1 : translation de vecteur (1.8,-3.4,6.7)\n","\n");
tr2->print("tr2 : translation de vecteur (-4.5,0.1,3.2)\n","\n");
tr3.print("tr3 : translation identite\n","\n");
tr4.print("tr4 : translation clone de tr2\n","\n");
Rt3D rt1(45.0F,-1.3F,2.3F,3.7F);
Dir3D axe2(2.1F,-0.7F,1.8F);
Rt3D *rt2 = new Rt3D(30.0F,&axe2);
Rt3D rt3;
Rt3D rt4(rt2);
Dir3D axe5(1.0F,0.0F,0.0F);
Rt3D *rt5 = new Rt3D(30.0,&axe5);
printf("Rotations\n\n");
rt1.print("rt1 : rotation de 45.0 degres autour de l'axe (-1.3,2.3,3.7) passant par O\n","\n");
rt2->print("rt2 : rotation de 30.0 degres autour de l'axe (2.1,-0.7,1.8) passant par O\n","\n");
rt3.print("rt3 : rotation identite\n","\n");
rt4.print("rt4 : rotation clone de rt2\n","\n");
rt5->print("rt5 : rotation de 30.0 degres autour de l'axe Ox\n","\n");
Sc3D sc1(0.3F,1.3F,0.7F);
Sc3D *sc2 = new Sc3D(0.2F,0.9F,1.7F);
Sc3D sc3;
Sc3D sc4(sc2);
printf("Zooms\n\n");
sc1.print("sc1 : zoom de rapports (0.3,1.3,0.7)\n","\n");
sc2->print("sc2 : zoom de rapports (0.2,0.9,1.7)\n","\n");
sc3.print("sc3 : zoom identite\n","\n");
sc4.print("sc4 : zoom de clone de sc2\n","\n");
Pos3D p1(2.0F,3.0F,4.0F);
Pos3D *p2 = new Pos3D(-1.1F,-0.2F,-2.3F);
Dir3D d1(2.0F,3.0F,4.0F);
Dir3D *d2 = new Dir3D(-1.1F,-0.2F,-2.3F);
tr1.print("tr1 : translation de vecteur (1.8,-3.4,6.7)\n","\n");
tr2->print("tr2 : translation de vecteur (-4.5,0.1,3.2)\n","\n");
rt1.print("rt1 : rotation de 45.0 degres autour de l'axe (-1.3,2.3,3.7) passant par O\n","\n");
rt2->print("rt2 : rotation de 30.0 degres autour de l'axe (2.1,-0.7,1.8) passant par O\n","\n");
printf("Transformations de positions 3D\n\n");
{ p1.print("p1 : ","\n");
Pos3D p(&p1,&tr1);
p.print("p cree par translation tr1 de p1 : ","\n");
p.transformation(tr2);
p.print("p modifie par translation tr2 : ","\n");
printf("\n"); }
{ p2->print("p2 : ","\n");
Pos3D p(p2,&rt1);
p.print("p cree par rotation rt1 de p2 : ","\n");
p.transformation(rt2);
p.print("p modifie par rotation rt2 : ","\n");
printf("\n"); }
printf("Transformations de directions 3D\n\n");
{ d1.print("d1 : ","\n");
Dir3D d(&d1,&tr1);
d.print("d cree par translation tr1 de d1 : ","\n");
d.transformation(tr2);
d.print("d modifie par translation tr2 : ","\n");
printf("\n"); }
{ d2->print("d2 : ","\n");
Dir3D d(d2,&rt1);
d.print("d cree par rotation rt1 de d1 : ","\n");
d.transformation(rt2);
d.print("d modifie par rotation rt2 : ","\n");
printf("\n"); }
printf("Compositions de transformations geometriques\n\n");
TG3D tg1(&tr1,&rt1);
tg1.print("Composition de tr1 et rt1\n","\n");
TG3D tg2(&rt1,&tr1);
tg2.print("Composition de rt1 et tr1\n","\n");
printf("\n");
delete(sc2);
delete(rt5);
delete(rt2);
delete(tr2);
delete(p2);
delete(d2);
getchar();
return(0);
}
/* Mathematiques de l'informatique graphique */
/* Coordonnees homogenes en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____CH3D____
#define ____CH3D____
class TG3D;
class CH3D {
public :
public :
/* Coordonnees x, y et z */
float x;
float y;
float z;
private :
/* Coordonnee w */
float w;
protected :
/* Construit le vecteur nul */
CH3D(void);
/* Construit la CH3D (x,y,z,w) */
CH3D(float x,float y,float z,float w);
/* Construit un clone de la CH3D ch */
CH3D(CH3D *ch);
/* Destructeur */
~CH3D(void);
public :
/* Methode d'affichage texte */
void print(void);
/* Methode d'affichage texte */
/* precede d'un message */
/* et suivi d'un message */
void print(const char *messageAvant,const char *messageApres);
/* Methode de transformation de this */
/* par une transformation geometrique */
void transformation(TG3D *tg);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Coordonnees homogenes en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "CH3D.h"
#include "TG3D.h"
/* Construit le vecteur nul */
CH3D::CH3D(void) {
x = y = z = w = 0.0F;
}
/* Construit la CH3D (x,y,z,w) */
CH3D::CH3D(float x,float y,float z,float w) {
this->x = x;
this->y = y;
this->z = z;
this->w = w;
}
/* Construit un clone de la CH3D ch */
CH3D::CH3D(CH3D *ch) {
x = ch->x;
y = ch->y;
z = ch->z;
w = ch->w;
}
/* Destructeur */
CH3D::~CH3D(void) {
}
/* Methode d'affichage texte */
void CH3D::print(void) {
printf("%10.4f %10.4f %10.4f %10.4f",x,y,z,w);
}
/* Methode d'affichage texte */
/* precede d'un message */
/* et suivi d'un message */
void CH3D::print(const char *messageAvant,const char *messageApres) {
printf("%s",messageAvant);
print();
printf("%s",messageApres);
}
/* Methode de transformation de this */
/* par une transformation geometrique */
void CH3D::transformation(TG3D *tg) {
float vx,vy,vz,vw;
vx = tg->c[0][0]*x+tg->c[0][1]*y+tg->c[0][2]*z+tg->c[0][3]*w;
vy = tg->c[1][0]*x+tg->c[1][1]*y+tg->c[1][2]*z+tg->c[1][3]*w;
vz = tg->c[2][0]*x+tg->c[2][1]*y+tg->c[2][2]*z+tg->c[2][3]*w;
vw = tg->c[3][0]*x+tg->c[3][1]*y+tg->c[3][2]*z+tg->c[3][3]*w;
x = vx;
y = vy;
z = vz;
w = vw;
}
/* Mathematiques de l'informatique graphique */
/* Position en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____POS3D____
#define ____POS3D____
#include "CH3D.h"
class TG3D;
class Pos3D : public CH3D {
public :
/* Construit l'origine */
Pos3D(void);
/* Construit le point (x,y,z) */
Pos3D(float x,float y,float z);
/* Construit un clone de la Pos3D p */
Pos3D(Pos3D *p);
/* Construit la Pos3D transformee */
/* de p par tg */
Pos3D(Pos3D *p,TG3D *tg);
/* Destructeur */
~Pos3D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Position en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "CH3D.h"
#include "Pos3D.h"
#include "TG3D.h"
/* Construit l'origine */
Pos3D::Pos3D(void):CH3D(0.0F,0.0F,0.0F,1.0F) {
}
/* Construit le point (x,y,z) */
Pos3D::Pos3D(float x,float y,float z):CH3D(x,y,z,1.0F) {
}
/* Construit un clone de la Pos3D p */
Pos3D::Pos3D(Pos3D *p):CH3D(p) {
}
/* Construit la Pos3D transformee de p par tg */
Pos3D::Pos3D(Pos3D *p,TG3D *tg):CH3D(p) {
transformation(tg);
}
/* Destructeur */
Pos3D::~Pos3D(void) {
}
/* Mathematiques de l'informatique graphique */
/* Direction en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____DIR3D____
#define ____DIR3D____
class Pos3D;
#include "CH3D.h"
class Dir3D : public CH3D {
public :
/* Construit le vecteur nul */
Dir3D(void);
/* Construit la direction (x,y,z) */
Dir3D(float x,float y,float z);
/* Construit un clone de la Dir3D d */
Dir3D(Dir3D *d);
/* Construit la direction pipf */
Dir3D(Pos3D *pi,Pos3D *pf);
/* Construit la Dir3D produit vectoriel */
/* de d1 par d2 */
Dir3D(Dir3D *d1,Dir3D *d2);
/* Construit la Dir3D transformee */
/* de d par tg */
Dir3D(Dir3D *d,TG3D *tg);
/* Destructeur */
~Dir3D(void);
/* Methode de calcul de la norme de this */
float norme(void);
/* Methode de normalisation de this */
/* Retourne la norme de this */
/* avant normalisation */
float normalisation(void);
/* Methode de calcul du produit scalaire */
/* de this et de la direction d */
float produitScalaire(Dir3D *d);
/* Methode statique de calcul */
/* du produit scalaire des deux directions */
/* d1 et d2 */
static float produitScalaire(Dir3D *d1,Dir3D *d2);
/* Methode de calcul du produit vectoriel */
/* de this par la direction d */
/* avec stockage du resultat dans this */
void produitVectoriel(Dir3D *d);
/* Methode de calcul du produit vectoriel */
/* de la direction d1 par la direction d2 */
/* avec stockage du resultat dans this */
void produitVectoriel(Dir3D *d1,Dir3D *d2);
/* Methode statique de calcul */
/* du produit vectoriel de deux directions */
/* d1 et d2 avec stockage du resultat */
/* dans res */
static void produitVectoriel(Dir3D *d1,Dir3D *d2,Dir3D *res);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Direction en 3D */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "CH3D.h"
#include "Dir3D.h"
#include "Pos3D.h"
/* Constructeurs */
/* Construit le vecteur nul */
Dir3D::Dir3D(void):CH3D() {
}
/* Construit la direction (x,y,z) */
Dir3D::Dir3D(float x,float y,float z):CH3D(x,y,z,0.0F) {
}
/* Construit un clone de la Dir3D d */
Dir3D::Dir3D(Dir3D *d):CH3D(d) {
}
/* Construit la direction pipf */
Dir3D::Dir3D(Pos3D *pi,Pos3D *pf):CH3D(pf->x-pi->x,pf->y-pi->y,pf->z-pi->z,0.0F) {
}
/* Construit la Dir3D transformee de d par tg */
Dir3D::Dir3D(Dir3D *d,TG3D *tg) : CH3D(d) {
transformation(tg);
}
/* Construit la direction produit vectoriel */
/* de d1 par d2 */
Dir3D::Dir3D(Dir3D *d1,Dir3D *d2):CH3D() {
produitVectoriel(d1,d2,this);
}
/* Destructeur */
Dir3D::~Dir3D(void) {
}
/* Methode de calcul de la norme de this */
float Dir3D::norme(void) {
return((float) sqrt(x*x+y*y+z*z));
}
/* Methode de normalisation de this */
/* Retourne la norme de this pre-normalisation */
float Dir3D::normalisation(void) {
float d = norme();
if ( d != 0.0 ) {
x /= d;
y /= d;
z /= d; }
return d;
}
/* Methode de calcul du produit scalaire */
/* de this et de la direction d */
float Dir3D::produitScalaire(Dir3D *d) {
return(produitScalaire(this,d));
}
/* Methode statique de calcul */
/* du produit scalaire des deux directions */
/* d1 et d2 */
float Dir3D::produitScalaire(Dir3D *d1,Dir3D *d2) {
return(d1->x*d2->x+d1->y*d2->y+d1->z*d2->z);
}
/* Methode de calcul du produit vectoriel */
/* de this par la direction d */
/* avec stockage du resultat dans this */
void Dir3D::produitVectoriel(Dir3D *d) {
produitVectoriel(this,d,this);
}
/* Methode de calcul du produit vectoriel */
/* de la direction d1 par la direction d2 */
/* avec stockage du resultat dans this */
void Dir3D::produitVectoriel(Dir3D *d1,Dir3D *d2) {
produitVectoriel(d1,d2,this);
}
/* Methode statique de calcul */
/* du produit vectoriel de deux directions */
/* d1 et d2 avec stockage du resultat */
/* dans res */
void Dir3D::produitVectoriel(Dir3D *d1,Dir3D *d2,Dir3D *res) {
float x = d1->y*d2->z - d1->z*d2->y;
float y = d1->z*d2->x - d1->x*d2->z;
float z = d1->x*d2->y - d1->y*d2->x;
res->x = x;
res->y = y;
res->z = z;
}
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique 3D */
/* en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____TG3D____
#define ____TG3D____
class CH3D;
class TG3D {
public :
/* Composantes */
float c[4][4];
public :
/* Construit la TG3D identite */
TG3D(void);
/* Construit la TG3D clone de tg */
TG3D(TG3D *tg);
/* Construit la TG3D composition */
/* de tg1 par tg2 */
TG3D(TG3D *tg1,TG3D *tg2);
/* Destructeur */
virtual ~TG3D(void);
/* Methode d'affichage texte */
void print(void);
/* Methode d'affichage texte */
/* precede d'un message */
/* et suivi d'un message */
void print(const char *messageAvant,const char *messageApres);
private :
/* Methode de composition */
/* de la transformation geometrique tg1 */
/* par la transformation geometrique tg2 */
/* avec stockage du resultat dans this */
/* this = tg1 * tg2 */
void composition(TG3D *tg1,TG3D *tg2);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Transformation geometrique 3D */
/* en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TG3D.h"
#include "CH3D.h"
/* Construit la TG3D identite */
TG3D::TG3D(void) {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] = ( i == j ) ? 1.0F : 0.0F;
}
/* Construit la TG3D clone de tg */
TG3D::TG3D(TG3D *tg) {
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] = tg->c[i][j];
}
/* Construit la TG3D composition de tg1 par tg2 */
TG3D::TG3D(TG3D *tg1,TG3D *tg2) {
composition(tg1,tg2);
}
/* Destructeur */
TG3D::~TG3D(void) {
}
/* Methode d'affichage texte */
void TG3D::print(void) {
for ( int i = 0 ; i < 4 ; i++ )
printf("%10.4f %10.4f %10.4f %10.4f\n",c[i][0],c[i][1],c[i][2],c[i][3]);
}
/* Methode d'affichage texte */
/* precede d'un message */
/* et suivi d'un message */
void TG3D::print(const char *messageAvant,const char *messageApres) {
printf("%s",messageAvant);
print();
printf("%s",messageApres);
}
/* Methode de composition */
/* de la transformation geometrique tg1 */
/* par la transformation geometrique tg2 */
/* avec stockage du resultat dans this */
/* this = tg1 * tg2 */
void TG3D::composition(TG3D *tg1,TG3D *tg2) {
TG3D aux;
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ ) {
aux.c[i][j] = 0.0;
for ( int k = 0 ; k < 4 ; k++ )
aux.c[i][j] += tg1->c[i][k]*tg2->c[k][j]; }
for ( int i = 0 ; i < 4 ; i++ )
for ( int j = 0 ; j < 4 ; j++ )
c[i][j] = aux.c[i][j];
}
/* Mathematiques de l'informatique graphique */
/* Translation 3D en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____TR3D____
#define ____TR3D____
#include "TG3D.h"
class Dir3D;
class Tr3D : public TG3D {
public :
/* Construit la translation identite */
Tr3D(void);
/* Construit la translation (tx,ty,tz) */
Tr3D(float tx,float ty,float tz);
/* Construit la translation de vecteur d */
Tr3D(Dir3D *d);
/* Construit le clone de la translation tr */
Tr3D(Tr3D *tr);
/* Destructeur */
~Tr3D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Translation 3D en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TG3D.h"
#include "Tr3D.h"
#include "Dir3D.h"
/* Construit la translation identite */
Tr3D::Tr3D(void):TG3D() {
}
/* Construit la translation (tx,ty,tz) */
Tr3D::Tr3D(float tx,float ty,float tz):TG3D() {
c[0][3] = tx;
c[1][3] = ty;
c[2][3] = tz;
}
/* Construit la translation de vecteur d */
Tr3D::Tr3D(Dir3D *d):TG3D() {
c[0][3] = d->x;
c[1][3] = d->y;
c[2][3] = d->z;
}
/* Construit le clone de la translation tr */
Tr3D::Tr3D(Tr3D *tr):TG3D(tr) {
}
/* Destructeur */
Tr3D::~Tr3D(void) {
}
/* Mathematiques de l'informatique graphique */
/* Rotation 3D en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____RT3D____
#define ____RT3D____
#include "TG3D.h"
class Dir3D;
class Rt3D : public TG3D {
public :
/* Construit la rotation identite */
Rt3D(void);
/* Construit la rotation d'angle alpha */
/* degres autour de l'axe (ax,ay,az) */
/* passant par l'origine */
Rt3D(float alpha,float ax,float ay,float az);
/* Construit la rotation d'angle alpha */
/* degres autour de l'axe de direction d */
/* passant par l'origine */
Rt3D(float alpha,Dir3D *d);
/* Construit le clone de la rotation rt */
Rt3D(Rt3D *rt);
/* Destructeur */
~Rt3D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Rotation 3D en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TG3D.h"
#include "Rt3D.h"
#include "Dir3D.h"
#ifndef M_PI
#define M_PI 3.14159F
#endif
/* Construit la rotation identite */
Rt3D::Rt3D(void):TG3D() {
}
/* Fonction utilitaire statique */
/* (C'est juste pour essayer) */
static void initialisation(Rt3D *rt,float alpha,Dir3D *d) {
Dir3D axe(d);
axe.normalisation();
float aa = alpha/180.0F*M_PI;
float sn =(float) sin(aa);
float cs =(float) cos(aa);
rt->c[0][0] = axe.x*axe.x+cs*(1-axe.x*axe.x);
rt->c[0][1] = axe.x*axe.y*(1-cs)-sn*axe.z;
rt->c[0][2] = axe.x*axe.z*(1-cs)+sn*axe.y;
rt->c[1][0] = axe.x*axe.y*(1-cs)+sn*axe.z;
rt->c[1][1] = axe.y*axe.y+cs*(1-axe.y*axe.y);
rt->c[1][2] = axe.y*axe.z*(1-cs)-sn*axe.x;
rt->c[2][0] = axe.x*axe.z*(1-cs)-sn*axe.y;
rt->c[2][1] = axe.y*axe.z*(1-cs)+sn*axe.x;
rt->c[2][2] = axe.z*axe.z+cs*(1-axe.z*axe.z);
}
/* Construit la rotation d'angle alpha degres */
/* autour de l'axe (ax,ay,az) passant */
/* par l'origine */
Rt3D::Rt3D(float alpha,float ax,float ay,float az):TG3D() {
Dir3D axe(ax,ay,az);
initialisation(this,alpha,&axe);
}
/* Construit la rotation d'angle alpha degres */
/* autour de l'axe de direction d passant */
/* par l'origine */
Rt3D::Rt3D(float alpha,Dir3D *d):TG3D() {
initialisation(this,alpha,d);
}
/* Construit le clone de la rotation rt */
Rt3D::Rt3D(Rt3D *rt):TG3D(rt) {
}
/* Destructeur */
Rt3D::~Rt3D(void) {
}
/* Mathematiques de l'informatique graphique */
/* Zoom 3D en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#ifndef ____SC3D____
#define ____SC3D____
#include "TG3D.h"
class Sc3D : public TG3D {
public :
/* Construit le zoom identite */
Sc3D(void);
/* Construit le zoom de rapports (rx,ry,rz) */
Sc3D(float rx,float ry,float rz);
/* Construit le clone du zoom sc */
Sc3D(Sc3D *sc);
/* Destructeur */
~Sc3D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Zoom 3D en coordonnees homogenes */
/* */
/* Auteur: Nicolas JANEY */
/* nicolas.janey@univ-fcomte.fr */
/* Mars 2020 */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "TG3D.h"
#include "Sc3D.h"
/* Construit le zoom identite */
Sc3D::Sc3D(void):TG3D() {
}
/* Construit le zoom de rapports (rx,ry,rz) */
Sc3D::Sc3D(float rx,float ry,float rz):TG3D() {
c[0][0] = rx;
c[1][1] = ry;
c[2][2] = rz;
}
/* Construit le clone du zoom sc */
Sc3D::Sc3D(Sc3D *sc):TG3D(sc) {
}
/* Destructeur */
Sc3D::~Sc3D(void) {
}
RETOUR