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é.

L'exécutable

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);
}

Fichier source : CH3D.h

/* 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

Fichier source : CH3D.cpp

/* 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);
}

Fichier source : Pos3D.h

/* 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

Fichier source : Pos3D.cpp

/* 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) {
}

Fichier source : Dir3D.h

/* 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

Fichier source : Dir3D.cpp

/* 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;
}

RETOUR