Commentaires
Vous constaterez quelques différences entre ce que nous avons conçu en TD et l'implantation réalisée ici :
Remarque : L'encapsulation des attributs de la classe CH3D n'a pas été entièrement respectée par soucis d'optimisation de la vitesse d'exécution.
Le programme principal vise à tester les différents constructeurs et méthodes développés puis à tester la méthode de test de planarité.
Fichier source : Mathematiques1.cpp
Tous les fichiers sources : Mathematiques1.zip
#include <math.h>
/* Fonction de test de la planarite */
/* d'une facette à quatre sommets */
int testPlanarite(Pos3D *p1,Pos3D *p2,Pos3D *p3,Pos3D *p4) {
const float EPSILON = 0.000001F;
Dir3D d12(p1,p2);
Dir3D d13(p1,p3);
Dir3D d14(p1,p4);
d12.produitVectoriel(&d14);
float ps = d13.produitScalaire(&d12);
return(fabs(ps) < EPSILON);
}
int main(void) {
{ Pos3D *p0 = new Pos3D();
p0->print();
printf("\n");
delete(p0); }
{ Pos3D p1(2.0F,3.0F,4.0F);
p1.print();
printf("\n"); }
{ Pos3D *p2 = new Pos3D(-1.1F,-0.2F,-2.3F);
p2->print();
printf("\n");
delete(p2); }
printf("\n");
{ Dir3D *d0 = new Dir3D();
d0->print();
printf("\n");
delete(d0); }
{ Dir3D d1(1.1F,2.3F,-2.1F);
d1.print();
printf("\n"); }
{ Pos3D p1(2.0F,3.0F,4.0F);
Pos3D *p2 = new Pos3D(-1.1F,-0.2F,-2.3F);
Dir3D *d2 = new Dir3D(&p1,p2);
d2->print();
printf("\n");
delete(p2);
delete(d2); }
printf("\n");
{ Dir3D d1(1.1F,2.3F,-2.1F);
Pos3D p1(2.0F,3.0F,4.0F);
Pos3D *p2 = new Pos3D(-1.1F,-0.2F,-2.3F);
Dir3D *d2 = new Dir3D(&p1,p2);
printf("%f\n",d1.norme());
printf("%f\n",d2->norme());
d1.normalisation();
d2->normalisation();
d1.print();
printf(" %25.20f\n",d1.norme());
d2->print();
printf(" %25.20f\n",d2->norme());
delete(p2);
delete(d2); }
printf("\n");
{ Dir3D d1(1.1F,2.3F,-2.1F);
Pos3D p1(2.0F,3.0F,4.0F);
Pos3D *p2 = new Pos3D(-1.1F,-0.2F,-2.3F);
Dir3D *d2 = new Dir3D(&p1,p2);
printf("%f\n",d1.produitScalaire(d2));
printf("%f\n",d2->produitScalaire(&d1));
printf("%f\n",Dir3D::produitScalaire(&d1,d2));
delete(d2); }
printf("\n");
{ Dir3D *pv1 = new Dir3D(1.1F,2.3F,-2.1F);
Dir3D *pv2 = new Dir3D(-1.1F,-0.2F,-2.3F);
Dir3D pv3;
Dir3D::produitVectoriel(pv1,pv2,&pv3);
pv3.print();
printf("\n");
Dir3D::produitVectoriel(pv1,pv2,pv1);
pv1->print();
printf("\n");
delete(pv1);
pv1 = new Dir3D(1.1F,2.3F,-2.1F);
Dir3D::produitVectoriel(pv1,pv2,pv2);
pv2->print();
printf("\n");
delete(pv1);
delete(pv2); }
printf("\n");
{ Dir3D *pv1 = new Dir3D(1.1F,2.3F,-2.1F);
Dir3D *pv2 = new Dir3D(-1.1F,-0.2F,-2.3F);
Dir3D pv3;
pv3.produitVectoriel(pv1,pv2);
pv3.print();
printf("\n");
pv1->produitVectoriel(pv1,pv2);
pv1->print();
printf("\n");
delete(pv1);
pv1 = new Dir3D(1.1F,2.3F,-2.1F);
pv2->produitVectoriel(pv1,pv2);
pv2->print();
printf("\n");
delete(pv1);
delete(pv2); }
printf("\n");
{ Dir3D *pv1 = new Dir3D(1.1F,2.3F,-2.1F);
Dir3D *pv2 = new Dir3D(-1.1F,-0.2F,-2.3F);
pv1->produitVectoriel(pv2);
pv1->print();
printf("\n");
delete(pv1);
pv1 = new Dir3D(1.1F,2.3F,-2.1F);
pv2->produitVectoriel(pv1);
pv2->print();
printf("\n");
delete(pv1);
delete(pv2); }
printf("\n");
{ Pos3D p1(2.0, 3.0, 4.0);
Pos3D p2(6.0, 1.0, 1.0);
Pos3D p3(3.0, 7.0, 5.0);
Pos3D p4(7.0,-13.0,-5.0);
Pos3D p5(7.0,-13.0,-6.0);
printf("P1 : ");
p1.print();
printf("\n");
printf("P2 : ");
p2.print();
printf("\n");
printf("P3 : ");
p3.print();
printf("\n");
printf("P4 : ");
p4.print();
printf("\n");
printf("P5 : ");
p5.print();
printf("\n");
if ( testPlanarite(&p1,&p2,&p3,&p4) )
printf("Facette (P1,P2,P3,P4) planaire\n");
else
printf("Facette (P1,P2,P3,P4) non planaire\n");
if ( testPlanarite(&p1,&p2,&p3,&p5) )
printf("Facette (P1,P2,P3,P5) planaire\n");
else
printf("Facette (P1,P2,P3,P5) non planaire\n"); }
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 CH3D {
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);
};
#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"
/* 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);
}
/* 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 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);
/* 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"
/* 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) {
}
/* 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 direction produit vectoriel */
/* de d1 par d2 */
Dir3D(Dir3D *d1,Dir3D *d2);
/* 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 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;
}