Fichier source : CoordonneesHomogenes.h

/* Mathematiques de l'informatique graphique    */
/* Coordonnees homogenes generiques             */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____COORDONNEESHOMOGENES____
#define ____COORDONNEESHOMOGENES____

class CoordonneesHomogenes  {

  public :
    double *c;

  private :
    int n;

  public :

    /* Constructeurs                            */
    CoordonneesHomogenes(int n);

    /* Destructeur                              */
    ~CoordonneesHomogenes(void);

    /* Methode d'affichage texte                */
    void print(void);
};

#endif

Fichier source : CoordonneesHomogenes.cpp

/* Mathematiques de l'informatique graphique    */
/* Coordonnees homogenes generiques             */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes.h"

/* Constructeurs                                */

CoordonneesHomogenes::CoordonneesHomogenes(int n) {
  c =(double *) calloc(n,sizeof(double));
  this->n = n;
}

/* Destructeur                                  */

CoordonneesHomogenes::~CoordonneesHomogenes(void) {
  free(c);
}

/* Methode d'affichage texte                    */

void CoordonneesHomogenes::print(void) {
  printf("%8.3lf",c[0]);
  for ( int i = 1 ; i < n ; i++ )
    printf(" %8.3lf",c[i]);
}

Fichier source : CoordonneesHomogenes2D.h

/* Mathematiques de l'informatique graphique    */
/* Coordonnees homogenes en 2D                  */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____COORDONNEESHOMOGENES2D____
#define ____COORDONNEESHOMOGENES2D____

#include "CoordonneesHomogenes.h"

class CoordonneesHomogenes2D : public CoordonneesHomogenes  {

  public :

    /* Constructeurs                            */
    CoordonneesHomogenes2D(void);
    CoordonneesHomogenes2D(double x,double y,double t);
    CoordonneesHomogenes2D(CoordonneesHomogenes2D *c);

    /* Destructeur                              */
    ~CoordonneesHomogenes2D(void);
};

#endif

Fichier source : CoordonneesHomogenes2D.cpp

/* Mathematiques de l'informatique graphique    */
/* Coordonnees homogenes en 2D                  */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes2D.h"

/* Constructeurs                                */

CoordonneesHomogenes2D::CoordonneesHomogenes2D(void):CoordonneesHomogenes(3) {
  c[0] = c[1] = 0.0;
  c[2] = 1.0;
}

CoordonneesHomogenes2D::CoordonneesHomogenes2D(double x,double y,double t):CoordonneesHomogenes(3) {
  c[0] = x;
  c[1] = y;
  c[2] = t;
}

CoordonneesHomogenes2D::CoordonneesHomogenes2D(CoordonneesHomogenes2D *ch):CoordonneesHomogenes(3) {
  c[0] = ch->c[0];
  c[1] = ch->c[1];
  c[2] = ch->c[2];
}

/* Destructeur                                  */

CoordonneesHomogenes2D::~CoordonneesHomogenes2D(void) {
}

Fichier source : CoordonneesHomogenes3D.h

/* Mathematiques de l'informatique graphique    */
/* Coordonnees homogenes en 3D                  */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____COORDONNEESHOMOGENES3D____
#define ____COORDONNEESHOMOGENES3D____

#include "CoordonneesHomogenes.h"

class CoordonneesHomogenes3D : public CoordonneesHomogenes  {

  public :

    /* Constructeurs                            */
    CoordonneesHomogenes3D(void);
    CoordonneesHomogenes3D(double x,double y,double z,double t);
    CoordonneesHomogenes3D(CoordonneesHomogenes3D *c);

    /* Destructeur                              */
    ~CoordonneesHomogenes3D(void);
};

#endif

Fichier source : CoordonneesHomogenes3D.cpp

/* Mathematiques de l'informatique graphique    */
/* Coordonnees homogenes en 3D                  */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes3D.h"

/* Constructeurs                                */

CoordonneesHomogenes3D::CoordonneesHomogenes3D(void):CoordonneesHomogenes(4) {
  c[0] = c[1] = c[2] = 0.0;
  c[3] = 1.0;
}

CoordonneesHomogenes3D::CoordonneesHomogenes3D(double x,double y,double z,double t):CoordonneesHomogenes(4) {
  c[0] = x;
  c[1] = y;
  c[2] = z;
  c[3] = t;
}

CoordonneesHomogenes3D::CoordonneesHomogenes3D(CoordonneesHomogenes3D *ch):CoordonneesHomogenes(4) {
  c[0] = ch->c[0];
  c[1] = ch->c[1];
  c[2] = ch->c[2];
  c[3] = ch->c[3];
}

/* Destructeur                                  */

CoordonneesHomogenes3D::~CoordonneesHomogenes3D(void) {
}

Fichier source : Position2D.h

/* Mathematiques de l'informatique graphique    */
/* Position en 2D                               */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____POSITION2D____
#define ____POSITION2D____

#include "CoordonneesHomogenes2D.h"

class Position2D : public CoordonneesHomogenes2D {

  public :

    /* Constructeurs                            */
    Position2D(void);
    Position2D(double x,double y);
    Position2D(Position2D *c);

    /* Destructeur                              */
    ~Position2D(void);

    /* Methode de calcul de la distance         */
    /* entre deux positions                     */
    double distance(Position2D *p);

    /* Methode de calcul du carre               */
    /* de la distance entre deux positions      */
    double carreDistance(Position2D *p);
};

#endif

Fichier source : Position2D.cpp

/* Mathematiques de l'informatique graphique    */
/* Position en 2D                               */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes2D.h"
#include "Position2D.h"

/* Constructeurs                                */

Position2D::Position2D(void):CoordonneesHomogenes2D(0.0,0.0,1.0) {
}

Position2D::Position2D(double x,double y):CoordonneesHomogenes2D(x,y,1.0) {
}

Position2D::Position2D(Position2D *p):CoordonneesHomogenes2D(p) {
}

/* Destructeur                                  */

Position2D::~Position2D(void) {
}

/* Methode de calcul de la distance             */
/* entre deux positions                         */

double Position2D::distance(Position2D *p) {
  return(sqrt(carreDistance(p)));
}

/* Methode de calcul du carre de la distance    */
/* entre deux positions                         */

double Position2D::carreDistance(Position2D *p) {
  double dx = p->c[0]-c[0];
  double dy = p->c[1]-c[1];
  return(dx*dx+dy*dy);
}

Fichier source : Position3D.h

/* Mathematiques de l'informatique graphique    */
/* Position en 3D                               */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____POSITION3D____
#define ____POSITION3D____

#include "CoordonneesHomogenes3D.h"

class Position3D : public CoordonneesHomogenes3D {

  public :

    /* Constructeurs                            */
    Position3D(void);
    Position3D(double x,double y,double z);
    Position3D(Position3D *c);

    /* Destructeur                              */
    ~Position3D(void);

    /* Methode de calcul de la distance         */
    /* entre deux positions                     */
    double distance(Position3D *p);

    /* Methode de calcul du carre               */
    /* de la distance entre deux positions      */
    double carreDistance(Position3D *p);
};

#endif

Fichier source : Position3D.cpp

/* Mathematiques de l'informatique graphique    */
/* Position en 3D                               */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes3D.h"
#include "Position3D.h"

/* Constructeurs                                */

Position3D::Position3D(void):CoordonneesHomogenes3D(0.0,0.0,0.0,1.0) {
}

Position3D::Position3D(double x,double y,double z):CoordonneesHomogenes3D(x,y,z,1.0) {
}

Position3D::Position3D(Position3D *p):CoordonneesHomogenes3D(p) {
}

/* Destructeur                                  */

Position3D::~Position3D(void) {
}

/* Methode de calcul de la distance             */
/* entre deux positions                         */

double Position3D::distance(Position3D *p) {
  return(sqrt(carreDistance(p)));
}

/* Methode de calcul du carre de la distance    */
/* entre deux positions                         */

double Position3D::carreDistance(Position3D *p) {
  double dx = p->c[0]-c[0];
  double dy = p->c[1]-c[1];
  double dz = p->c[2]-c[2];
  return(dx*dx+dy*dy+dz*dz);
}

Fichier source : Direction2D.h

/* Mathematiques de l'informatique graphique    */
/* Direction en 2D                              */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____DIRECTION2D____
#define ____DIRECTION2D____

class Position2D;

#include "CoordonneesHomogenes2D.h"

class Direction2D : public CoordonneesHomogenes2D {

  public :

    /* Constructeurs                            */
    Direction2D(void);
    Direction2D(double x,double y);
    Direction2D(Direction2D *c);
    Direction2D(Position2D *p1,Position2D *p2);

    /* Destructeur                              */
    ~Direction2D(void);

    /* Methode de calcul de la norme            */
    double norme(void);

    /* Methode de normalisation                 */
    double normalisation(void);

    /* Methode de calcul du produit scalaire    */
    /* de deux directions                       */
    double produitScalaire(Direction2D *d);
};

#endif

Fichier source : Direction2D.cpp

/* Mathematiques de l'informatique graphique    */
/* Direction en 2D                              */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes2D.h"
#include "Direction2D.h"
#include "Position2D.h"

/* Constructeurs                                */

Direction2D::Direction2D(void):CoordonneesHomogenes2D(0.0,0.0,0.0) {
}

Direction2D::Direction2D(double x,double y):CoordonneesHomogenes2D(x,y,0.0) {
}

Direction2D::Direction2D(Direction2D *p):CoordonneesHomogenes2D(p) {
}

Direction2D::Direction2D(Position2D *p1,Position2D *p2):CoordonneesHomogenes2D() {
  c[0] = p2->c[0]-p1->c[0];
  c[1] = p2->c[1]-p1->c[1];
  c[2] = 0.0;
}

/* Destructeur                                  */

Direction2D::~Direction2D(void) {
}

/* Methode de calcul de la norme                */

double Direction2D::norme(void) {
  return(sqrt(c[0]*c[0]+c[1]*c[1]));
}

/* Methode de normalisation                     */

double Direction2D::normalisation(void) {
  double d = norme();
  if ( d != 0.0 ) {
    c[0] /= d;
    c[1] /= d; }
  return(d);
}

/* Methode de calcul du produit scalaire        */
/* de deux directions                           */

double Direction2D::produitScalaire(Direction2D *d) {
  return(c[0]*d->c[0]+c[1]*d->c[1]);
}

Fichier source : Direction3D.h

/* Mathematiques de l'informatique graphique    */
/* Direction en 3D                              */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#ifndef ____DIRECTION3D____
#define ____DIRECTION3D____

class Position3D;

#include "CoordonneesHomogenes3D.h"

class Direction3D : public CoordonneesHomogenes3D {

  public :

    /* Constructeurs                            */
    Direction3D(void);
    Direction3D(double x,double y,double z);
    Direction3D(Direction3D *c);
    Direction3D(Position3D *p1,Position3D *p2);

    /* Destructeur                              */
    ~Direction3D(void);

    /* Methode de calcul de la norme            */
    double norme(void);

    /* Methode de normalisation                 */
    double normalisation(void);

    /* Methode de calcul du produit scalaire    */
    /* de deux directions                       */
    double produitScalaire(Direction3D *d);

    /* Methode de calcul du produit vectoriel   */
    /* de deux directions                       */
    void produitVectoriel(Direction3D *d1,Direction3D *d2);

    /* Methode de calcul du produit vectoriel   */
    /* de this par une direction                */
    void produitVectoriel(Direction3D *d);
};

#endif

Fichier source : Direction3D.cpp

/* Mathematiques de l'informatique graphique    */
/* Direction en 3D                              */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Octobre 2012                                 */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "CoordonneesHomogenes3D.h"
#include "Direction3D.h"
#include "Position3D.h"

/* Constructeurs                                */

Direction3D::Direction3D(void):CoordonneesHomogenes3D(0.0,0.0,0.0,0.0) {
}

Direction3D::Direction3D(double x,double y,double z):CoordonneesHomogenes3D(x,y,z,0.0) {
}

Direction3D::Direction3D(Direction3D *p):CoordonneesHomogenes3D(p) {
}

Direction3D::Direction3D(Position3D *p1,Position3D *p2):CoordonneesHomogenes3D() {
  c[0] = p2->c[0]-p1->c[0];
  c[1] = p2->c[1]-p1->c[1];
  c[2] = p2->c[2]-p1->c[2];
  c[3] = 0.0;
}

/* Destructeur                                  */

Direction3D::~Direction3D(void) {
}

/* Methode de calcul de la norme                */

double Direction3D::norme(void) {
  return(sqrt(c[0]*c[0]+c[1]*c[1]+c[2]*c[2]));
}

/* Methode de normalisation                     */

double Direction3D::normalisation(void) {
  double d = norme();
  if ( d != 0.0 ) {
    c[0] /= d;
    c[1] /= d;
    c[2] /= d; }
  return(d);
}

/* Methode de calcul du produit scalaire        */
/* de deux directions                           */

double Direction3D::produitScalaire(Direction3D *d) {
  return(c[0]*d->c[0]+c[1]*d->c[1]+c[2]*d->c[2]);
}

/* Methode de calcul du produit vectoriel       */
/* de deux directions                           */

void Direction3D::produitVectoriel(Direction3D *d1,Direction3D *d2) {
  double x = d1->c[1]*d2->c[2] - d1->c[2]*d2->c[1];
  double y = d1->c[2]*d2->c[0] - d1->c[0]*d2->c[2];
  double z = d1->c[0]*d2->c[1] - d1->c[1]*d2->c[0];
  c[0] = x;
  c[1] = y;
  c[2] = z;
  c[3] = 0.0;
}

/* Methode de calcul du produit vectoriel       */
/* de this par une direction                    */

void Direction3D::produitVectoriel(Direction3D *d) {
  double x = c[1]*d->c[2] - c[2]*d->c[1];
  double y = c[2]*d->c[0] - c[0]*d->c[2];
  double z = c[0]*d->c[1] - c[1]*d->c[0];
  c[0] = x;
  c[1] = y;
  c[2] = z;
  c[3] = 0.0;
}