Coordonnées homogènes pour la représentation des positions et des directions

Commentaires

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 le champ t a été renommé avec le nom w. En effet, les noms s et t étant les deux noms utilisés pour désigner usuellement les coordonnées de texturage d'un sommet, leur utilisation peut être une source d'ambiguité.
Dans la classe CH3D, le champ w a été défini en private de façon à en rendre toute modification impossible après initialisation par l'un des constructeurs. Ainsi, une position 3D (w = 1.0) restera toujours une position 3D et une direction 3D (w = 0.0) restera toujours une direction 3D.
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 ou des Dir3D.
La fonction de test de planarité teste l'égalité du produit scalaie à 0.0 à EPSILON près. La constante EPSILON est défini dans la fonction mais pourrait l'être sous forme de paramètre de fonction ou de constante globale.
La classe Dir3D a été munie de 2 méthodes permettant de calculer la norme de this et de normaliser this.

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