RETOURCommentaires
Vous constaterez quelques différences entre ce que nous avons conçu en TD et l'implantation réalisée ici :
- Dans la classe CH3D, tous les constructeurs et le destructeur ont été définis en protected de façon rendre l'utilisation de CH3D impossible
pour une instanciation. En effet, aucune utilisation directe d'un objet CH3D n'est envisagée car on ne souhaite manipuler que des Pos3D
et
des Dir3D.
- La fonction de test de planarité teste l'égalité du produit scalaire à 0.0 à EPSILON près. La constante EPSILON est définie dans la fonction
mais pourrait l'être sous forme de paramètre de fonction ou de constante globale.
- Une méthode d'impression texte a été ajoutée à la classe CH3.
Remarque : L'encapsulation des attributs de la classe CH3D n'a pas été entièrement réalisée par souci d'optimisation de la vitesse d'exécution.
Remarque : Le choix de faire des passages de paramètres par adresse ou par référence n'a pas de logique particulière dans les diverses méthodes développées. Le but est de tester différentes possibilités de développement.
Le programme principal vise à tester les différents constructeurs et méthodes développés puis à tester la méthode de test de planarité.
Tous les fichiers sources : Mathematiques1.zip
Fichier source : Mathematiques1.cpp
#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 v1(p1,p2);
Dir3D v2(p1,p3);
Dir3D v3(p1,p4);
float res = (v1^v2)*v3;
res = (res > 0 ? res: -res);
return res <= 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 = d1.normalize();
*d2 = d2->normalize();
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**d2);
printf("%f\n",*d2*d1);
delete(d2);
delete(p2); }
printf("\n");
{ Dir3D *pv1 = new Dir3D(1.1F,2.3F,-2.1F);
Dir3D *pv2 = new Dir3D(-1.1F,-0.2F,-2.3F);
Dir3D pv3 = *pv1^*pv2;
pv3.print();
printf("\n");
*pv1 = *pv1^*pv2;
pv1->print();
printf("\n");
delete(pv1);
pv1 = new Dir3D(1.1F,2.3F,-2.1F);
*pv2 = *pv1^*pv2;
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 */
/* */
/* Mars 2021 */
#ifndef ____CH3D____
#define ____CH3D____
class TG3D;
class Pos3D;
class Dir3D;
class CH3D {
public :
/* Coordonnees x, y et z */
float x;
float y;
float z;
private :
/* Coordonnee w */
float w;
protected :
/* Construit la position origine */
CH3D(void);
/* Construit la CH3D (xp,yp,zp,wp) */
CH3D(float xp,float yp,float zp,float wp);
/* Construit un clone de la CH3D ch */
CH3D(CH3D *ch);
/* Destructeur */
virtual ~CH3D(void);
public :
/* Methode d'affichage texte */
void print(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Coordonnees homogenes en 3D */
/* */
/* Mars 2021 */
#include <stdio.h>
#include "CH3D.h"
#include "Pos3D.h"
#include "Dir3D.h"
/* Construit la position origine */
CH3D::CH3D(void) : x(0.0F),y(0.0F),z(0.0F),w(1.0F) {
}
/* Construit la CH3D (xp,yp,zp,wp) */
CH3D::CH3D(float xp, float yp, float zp, float wp) : x(xp),y(yp),z(zp),w(wp) {
}
/* 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 */
/* */
/* Mars 2021 */
#ifndef ____POS3D____
#define ____POS3D____
#include "CH3D.h"
class Pos3D : public CH3D {
public :
/* Construit l'origine */
Pos3D(void);
/* Construit la position xp,yp,zp) */
Pos3D(float xp,float yp,float zp);
/* Construit un clone de la Pos3D p */
Pos3D(Pos3D *p);
/* Destructeur */
~Pos3D(void);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Position en 3D */
/* */
/* Mars 2021 */
#include "CH3D.h"
#include "Pos3D.h"
/* Construit l'origine */
Pos3D::Pos3D(void):CH3D() {
}
/* Construit la position (xp,yp,zp) */
Pos3D::Pos3D(float xp,float yp,float zp):CH3D(xp,yp,zp,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 */
/* */
/* Mars 2021 */
#ifndef ____DIR3D____
#define ____DIR3D____
class Pos3D;
#include "CH3D.h"
class Dir3D : public CH3D {
public :
/* Construit le vecteur z */
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 p1 p2 */
Dir3D(const Pos3D &p1,const Pos3D &p2);
/* Destructeur */
~Dir3D(void);
/* Methode de calcul de la norme de this */
float norme(void);
/* Calcul de la direction normalisée */
/* de this */
Dir3D normalize(void);
/* Calcul du produit scalaire */
/* de this et de la direction dir */
float operator*(const Dir3D& dir);
/* Calcul du produit vectoriel */
/* de this et de la direction dir */
Dir3D operator^(const Dir3D& dir);
};
#endif
/* Mathematiques de l'informatique graphique */
/* Direction en 3D */
/* */
/* Mars 2021 */
#include <math.h>
#include "CH3D.h"
#include "Dir3D.h"
#include "Pos3D.h"
/* Constructeurs */
/* Construit le vecteur z */
Dir3D::Dir3D(void):CH3D(0.0F,0.0F,1.0F,0.0F) {
}
/* Construit la direction (xp,yp,zp) */
Dir3D::Dir3D(float xp,float yp,float zp):CH3D(xp,yp,zp,0.0F) {
}
/* Construit un clone de la Dir3D d */
Dir3D::Dir3D(Dir3D *d):CH3D(d) {
}
/* Construit la direction p1 p2 */
Dir3D::Dir3D(const Pos3D &p1,const Pos3D &p2) : CH3D(p2.x-p1.x,p2.y-p1.y,p2.z-p1.z,0.0f) {
}
/* 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));
}
/* Calcul de la direction normalisée de this */
Dir3D Dir3D::normalize(void) {
float norm = norme();
Dir3D res;
if (norm != 0.0F) {
res.x = x / norm;
res.y = y / norm;
res.z = z / norm; }
return res;
}
/* Calcul du produit scalaire */
/* de this et de la direction dir */
float Dir3D::operator*(const Dir3D& dir) {
return this->x*dir.x + this->y*dir.y + this->z * dir.z;
}
/* Calcul du produit vectoriel */
/* de this et de la direction dir */
Dir3D Dir3D::operator^(const Dir3D& dir) {
Dir3D res;
res.x = this->y * dir.z - dir.y * this->z;
res.y = this->z * dir.x - dir.z * this->x;
res.z = this->x * dir.y - dir.x * this->y;
return res;
}