L'exécutable

Une B-Spline sur 4 sommets de contrôle

Une B-Spline par morceaux

Fichier sources :
 - B-Spline.cpp
 - Vecteur4.h
 - Vecteur4.cpp
 - CoordonneesHomogenes3D.h
 - CoordonneesHomogenes3D.cpp
 - Position3D.h
 - Position3D.cpp
 - Matrice4x4.h
 - Matrice4x4.cpp
 - MatriceDeBase.h
 - MatriceDeBase.cpp

Fichier source : LignePolygonale3D.h

/* Mathematiques de l'informatique graphique    */
/* Ligne polygonale 3D                          */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Mars 2014                                    */

#ifndef ____LIGNEPOLYGONALE3D____
#define ____LIGNEPOLYGONALE3D____

#include "Position3D.h"
#include "MatriceDeBase.h"

class LignePolygonale3D {

  public :
    /* Nombre de sommets                        */
    int n;
    /* Tableau des sommets                      */
    Position3D *t;

  public :

    /* Constructeur "vide" (n=0, t = NULL)      */
    LignePolygonale3D(void);
    /* Constructeur pour une ligne polygonale   */
    /* de n sommets                             */
    LignePolygonale3D(int n);
    /* Constructeur de clonage                  */
    LignePolygonale3D(LignePolygonale3D *lp);
    /* Constructeur pour une ligne polygonale   */
    /* de n sommets lissee a partir des sommets */
    /* p1, p2, p3 et p4 en utilisant la matrice */
    /* m comme matrice de base                  */
    LignePolygonale3D(int n,Position3D *p1,Position3D *p2,Position3D *p3,Position3D *p4,MatriceDeBase *m);
    /* Constructeur pour une ligne polygonale   */
    /* de n sommets lissee a partir de la ligne */
    /* polygonale lp en utilisant la matrice    */
    /* m comme matrice de base                  */
    LignePolygonale3D(int n,LignePolygonale3D *lp,MatriceDeBase *m);

    /* Destructeur                              */
    ~LignePolygonale3D(void);

    void set(int pos,Position3D *p);
    void print(void);
    void drawOpenGL(int mode);
};

#endif

Fichier source : LignePolygonale3D.cpp

/* Mathematiques de l'informatique graphique    */
/* Ligne polygonale 3D                          */
/*                                              */
/* Auteur: Nicolas JANEY                        */
/* nicolas.janey@univ-fcomte.fr                 */
/* Mars 2014                                    */

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

#include <GL/glut.h>
#include <GL/gl.h>
#include <GL/glu.h>

#include "Position3D.h"
#include "Vecteur4.h"
#include "LignePolygonale3D.h"

/* Constructeurs                            */

LignePolygonale3D::LignePolygonale3D(void) {
  n = 0;
  t = NULL;
}

LignePolygonale3D::LignePolygonale3D(int n) {
  this->n = n;
  t = new Position3D[n]();
}

LignePolygonale3D::LignePolygonale3D(LignePolygonale3D *lp) {
  n = lp->n;
  t = new Position3D[n]();
  for ( int i = 0 ; i < n ; i++ ) {
    t[i].c[0] = lp->t[i].c[0];
    t[i].c[1] = lp->t[i].c[1];
    t[i].c[2] = lp->t[i].c[2];
    t[i].c[3] = lp->t[i].c[3]; }
}

/* Destructeur                              */

LignePolygonale3D::~LignePolygonale3D(void) {
  if ( n != 0 ) {
    delete [] t; }
}

LignePolygonale3D::LignePolygonale3D(int n,
                                     Position3D *p1,Position3D *p2,
                                     Position3D *p3,Position3D *p4,
                                     MatriceDeBase *m) {
  this->n = n;
  this->t = new Position3D[n]();
  Vecteur4 vx(p1->c[0],p2->c[0],p3->c[0],p4->c[0]);
  Vecteur4 vy(p1->c[1],p2->c[1],p3->c[1],p4->c[1]);
  Vecteur4 vz(p1->c[2],p2->c[2],p3->c[2],p4->c[2]);
  m->produit(&vx);
  m->produit(&vy);
  m->produit(&vz);
  for ( int i = 0 ; i < n ; i++ ) {
    double t =(double) i/(n-1);
    double tt = t*t;
    double ttt = tt*t;
    this->t[i].c[0] = ttt*vx.c[0]+tt*vx.c[1]+t*vx.c[2]+vx.c[3];
    this->t[i].c[1] = ttt*vy.c[0]+tt*vy.c[1]+t*vy.c[2]+vy.c[3];
    this->t[i].c[2] = ttt*vz.c[0]+tt*vz.c[1]+t*vz.c[2]+vz.c[3]; }
}

LignePolygonale3D::LignePolygonale3D(int n,
                                     LignePolygonale3D *lp,
                                     MatriceDeBase *m) {
  this->n = n;
  this->t = new Position3D[n]();
  for ( int i = 0 ; i < n ; i++ ) {
    double pos =(double) ((lp->n-3)*i)/(n-1);
    int p =(int) pos;
    if ( p == lp->n-3 )               // Dernier sommet de lissage
      p--;
    Vecteur4 vx(lp->t[p].c[0],lp->t[p+1].c[0],lp->t[p+2].c[0],lp->t[p+3].c[0]);
    Vecteur4 vy(lp->t[p].c[1],lp->t[p+1].c[1],lp->t[p+2].c[1],lp->t[p+3].c[1]);
    Vecteur4 vz(lp->t[p].c[2],lp->t[p+1].c[2],lp->t[p+2].c[2],lp->t[p+3].c[2]);
    m->produit(&vx);
    m->produit(&vy);
    m->produit(&vz);
    double t = pos-p;
    double tt = t*t;
    double ttt = tt*t;
    this->t[i].c[0] = ttt*vx.c[0]+tt*vx.c[1]+t*vx.c[2]+vx.c[3];
    this->t[i].c[1] = ttt*vy.c[0]+tt*vy.c[1]+t*vy.c[2]+vy.c[3];
    this->t[i].c[2] = ttt*vz.c[0]+tt*vz.c[1]+t*vz.c[2]+vz.c[3]; }
}

void LignePolygonale3D::set(int pos,Position3D *p) {
  t[pos].c[0] = p->c[0];
  t[pos].c[1] = p->c[1];
  t[pos].c[2] = p->c[2];
  t[pos].c[3] = p->c[3];
}

void LignePolygonale3D::print(void) {
  printf("%d\n",n);
  for ( int i = 0 ; i < n ; i++ ) {
    t[i].print();
    printf("\n"); }
}

void LignePolygonale3D::drawOpenGL(int mode) {
  switch (mode) {
    case 0 :
      glBegin(GL_POINTS);
      for ( int i = 0 ; i < n ; i++ ) {
        glVertex3f(t[i].c[0],t[i].c[1],t[i].c[2]); }
      glEnd();
      break;
    case 1 :
      glBegin(GL_LINE_STRIP);
      for ( int i = 0 ; i < n ; i++ ) {
        glVertex3f(t[i].c[0],t[i].c[1],t[i].c[2]); }
      glEnd();
      break; }
}

RETOUR