1 prototype pgc++ courbe_parametrique dÉfinition

34
1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

Upload: stuart-barthelemy

Post on 04-Apr-2015

110 views

Category:

Documents


4 download

TRANSCRIPT

Page 1: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

1

PROTOTYPE PGC++

Courbe_parametrique

DÉFINITION

Page 2: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

2

#include "Point_3D.h"  

enum type_de_courbe_parametrique{constante_3D, segment_3D, conique, courbe_de_Bezier, courbe_de_Hermite, B_Spline_quadratique_uniforme_elementaire, B_Spline_cubique_uniforme_elementaire, courbe_parabolique, courbe_parametrique_quelconque};

/* Une classe abstraite permettant de définir et de manipuler des courbes 3Ddans l'espace paramétrique [0,1] est créée.

Cette classe renferme des fonctions virtuelles pures lesquelles devront êtreredéfinies obligatoirement dans les classes dérivées. */

class Courbe_parametrique {

protected :type_de_courbe_parametrique Courbe;

Page 3: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

3

public :Courbe_parametrique(type_de_courbe_parametrique T)

{ Courbe = T;}/* Permet de créer une courbe paramétrique d'un certain type.

Pré - Nil.Post - Une courbe de type T est créée. */

virtual type_de_courbe_parametriqueAcces_type_de_courbe_parametrique()=0;

/* Permet d'identifier le type de courbe paramétrique qui a été définie.Pré - La courbe doit avoir été définie.Post - Retourne le type de courbe paramétrique créée. */

virtual Point_3D operator ()(float u) = 0;/* Permet d'évaluer la courbe courante à u dans l'intervalle [0, 1].

Pré - La courbe courante est créée.Post - Retourne le point sur la courbe à u. */

virtual Vecteur_3D Tangente(float u) = 0;/* Permet de calculer la tangente unitaire à la courbe à u.

Pré - La courbe courante est créée.Post - Retourne la tangente unitaire à la courbe à u. */

Page 4: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

4

virtual float Longueur(float u1, float u2) = 0;

/* Permet de calculer la longueur de la courbe dans [u1, u2].Pré - La courbe courante est créée. 0 <= u1, u2 <= 1.Post - Retourne la longueur de la courbe dans [u1, u2]. */

virtual bool Courbe_plane() = 0;

/* Permet de déterminer si une courbe 3D est plane ou non.Pré - La courbe courante est créée.Post - Retourne true si la courbe est plane.

False autrement.

La courbe n’est pas considérée plane lorsqu’il s’agitd’un point ou d’un segment de droite. */

};

F NI

Page 5: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

5

PROTOTYPE PGC++

Segment_3D

DÉFINITION

Page 6: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

6

#include "Courbe_parametrique.h "  

class Segment_3D : public Courbe_parametrique{

protected :Point_3D S1;Point_3D S2;

public :Segment_3D(Point_3D & P1, Point_3D & P2);/* Permet de créer un segment de droite 3D.

Pré - Nil.Post - Un segment de droite 3D d'extrémités P1 et P2 est

créée. */

type_de_courbe_parametrique Acces_type_de_courbe_parametrique();

/* Permet d'identifier le type de courbe qui a été définie.Pré - La courbe doit avoir été définie.Post - Retourne le type de courbe paramétrique créée,

soit un segment de droite. */

Page 7: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

7

void Acces_definition_segment_3D(Point_3D & P1, Point_3D & P2);/* Donne accès à la définition du segment 3D courant.

Pré - La courbe doit avoir été définie.Post - Retourne les extrémités du segment 3D courant. */

Segment_3D & operator = (Segment_3D & S);/* Permet d'affecter S à la courbe courante.

Pré - S est créée. Le segment courant est créé.Post - La courbe courante renferme maintenant la définition de S.

*/Point_3D & operator[](int i);/* Permet d'accéder ou de modifier l'extrémité i (= 1 ou 2) du segment

de droite courant.Pré - Le segment de droite courant est créé et initialisé.Post - Accède ou modifie l'extrémité i (= 1 ou 2) du segment de

droite courant. */

Point_3D operator ()(float u);/* Permet d'évaluer la courbe courante à u dans l'intervalle [0, 1].

Pré - La courbe courante est créée.Post - Retourne le point sur la courbe à u. */

Page 8: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

8

Vecteur_3D Tangente(float u);/* Permet de calculer la tangente au segment de droite à u.

Pré - La courbe courante est créée.Post - Retourne le vecteur S2 - S1. */

float Longueur(float u1, float u2);/* Permet de calculer la longueur du segment de droite dans [u1, u2].

Pré - Le segment de droite est créé. 0 <= u1, u2 <= 1.Post - Retourne la longueur du segment de droite dans cet

intervalle. */

bool Courbe_plane();/* Pré - La courbe courante est créée.

Post - Retourne false car la courbe n’est pas considérée plane.*/

};

Page 9: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

9

PROTOTYPE PGC++

Courbe_composite

DÉFINITION

Page 10: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

10

Cette classe permet de définir et de manipuler des courbes compositesoù chaque segment est une courbe paramétrique dans [0, 1]. Elle permetaussi de définir des courbes composites particulières.

enum type_de_Courbe_composite{ courbe_composite, courbe_de_Catmull_Rom, fusion_de_paraboles, B_Spline_quadratique_uniforme, B_Spline_cubique_uniforme };

Courbe_composite(int Nb_de_segments);Permet de créer une courbe composite de type «courbe_composite»dont le nombre de segments est passé en paramètre.

Courbe_composite(type_de_Courbe_composite T, int Nb_de_points, Point_3D Ensemble_des_points []);Permet de créer une courbe composite particulière à partir d’un ensemblede « Nb_de_Points » points d’interpolation.

Page 11: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

11

type_de_Courbe_composite Acces_type_de_Courbe_composite();Permet d'identifier le type de courbe composite qui a été définie.

int Acces_Nombre_de_segments();Donne accès au nombre de segments de la courbe.

Courbe_composite & operator = (Courbe_composite & C);Permet d'affecter C à la courbe courante.

Courbe_parametrique * operator[](int i);Retourne un pointeur vers le i ième segment de la courbecomposite courante où 1 <= i <= # de segments de la courbe.

void Inserer(int i, Courbe_parametrique & C);Le i ième segment de la courbe composite courante est unecopie de C où 1 <= i <= nombre de segments de la courbe.

Point_3D operator ()(int i, float u);Permet d'évaluer le i ième segment de la courbe composite à udans l'intervalle [0, 1].Le i ième segment de la courbe composite doit être défini où1 i nombre de segments de la courbe.

Page 12: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

12

Vecteur_3D Tangente(int i, float u);Permet de calculer la tangente unitaire au i ième segment de lacourbe à u. Le i ième segment de la courbe composite doit êtredéfini où 1 i nombre de segments de la courbe.

float Longueur(int i, float u1, int j, float u2);Permet de calculer la longueur de la partie de la courbe allantdu i ième segment à u1 au j ième segment à u2 où 0 u1, u2 1et i j. Si i est égale à j alors u1 u2. 1 i, j # de segmentsde la courbe. Les segments concernés de la courbe compositedoivent être définis.

bool Courbe_plane();Retourne true si la courbe est plane. False autrement.Chaque segment de la courbe doit être défini.La courbe est plane si chaque segment est plane etsi tous les plans renfermant les segments de la courbe coïncident.La courbe n'est pas considérée plane lorsqu'un segment de lacourbe correspond à un point ou un segment de droite.

-----------------------------------------------------

Page 13: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

13

Exemple

void Affichage(){

// Permet d'effacer l'écran en utilisant la couleur de fond.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Créer une courbe composite renfermant 2 segments.Courbe_composite Comp(2);

// Créer une courbe de Bézier.

Courbe_de_Bezier C(2);C[0] = Point_3D(12, 11, -9);C[1] = Point_3D(28, 12, -8);C[2] = Point_3D(13, 27, 9);

Comp.Inserer(1, C);

Page 14: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

14

// Créer une courbe de Hermite.

Point_3D P1(14, 6, -7);Point_3D P2(20, 28, 17);Vecteur_3D V1(3, -20, 1);Vecteur_3D V2(-1, 22, 3);

Courbe_de_Hermite H(P1, P2, V1, V2);Comp.Inserer(2, H);

Point_3D P;glBegin(GL_LINE_STRIP);

for (int j = 0; j <= Nb_de_points; j++){

P = Comp(1, j / (float)Nb_de_points);glVertex3f(P[1], P[2], P[3]);

}glEnd();

Page 15: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

15

glColor3f(0.0, 0.0, 1.0);glBegin(GL_LINE_STRIP);

for (int k = 0; k <= Nb_de_points; k++){

P = Comp(2, k / (float)Nb_de_points);glVertex3f(P[1], P[2], P[3]);

}glEnd();

/* Permet de s'assurer que l'exécution des primitivesd'affichage est complétée. */

glFlush();}

Page 16: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

16

PROTOTYPE PGC++

Surface_parametrique

DÉFINITION

Page 17: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

17

#include "Point_3D.h"

enum type_de_surface_parametrique{surface_triangulaire, surface_guidee, surface_bilineaire, surface_de_revolution, surface_de_Bezier, surface_parametrique_quelconque};

/* Une classe abstraite permettant de définir et de manipuler des surfaces 3Ddans le carré unité est créée.

Elle permet aussi de définir des surfaces quelconques.

Cette classe renferme des fonctions virtuelles pures lesquelles devront êtreredéfinies obligatoirement dans les classes dérivées. */

Page 18: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

18

class Surface_parametrique {

protected :type_de_surface_parametrique Surface;

public :Surface_parametrique(type_de_surface_parametrique T)

{ Surface = T; }

/* Permet de créer une surface paramétrique d'un certain type.Pré - Nil.Post - Une surface de type T est créée. */

virtual type_de_surface_parametrique Acces_type_de_surface_parametrique() = 0;

/* Permet d'identifier le type de surface paramétrique qui a été définie.

Pré - La surface doit avoir été définie.Post - Retourne le type de surface paramétrique créée. */

Page 19: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

19

virtual Point_3D operator ()(float u, float v) = 0;

/* Permet d'évaluer la surface courante à (u, v).

Pré - La surface courante est créée.Post - Retourne le point sur la surface à (u, v). */

virtual Vecteur_3D Tangente_u(float u, float v) = 0;/* Permet de calculer le vecteur tangent à la surface 3D dans la direction

u au point (u, v).Pré - La surface 3D a été créée et initialisée.Post - Retourne le vecteur tangent à la surface 3D dans la direction

u au point (u, v). */

virtual Vecteur_3D Tangente_v(float u, float v) = 0;

/* Permet de calculer le vecteur tangent à la surface 3D dans la directionv au point (u, v).Pré - La surface 3D a été créée et initialisée.Post - Retourne le vecteur tangent à la surface 3D dans la direction

v au point (u, v). */

Page 20: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

20

Vecteur_3D Normale(float u, float v)/* Permet de calculer le vecteur unitaire normal à la surface 3D

au point (u, v).

Pré - La surface 3D a été créée et initialisée.Post - Retourne le vecteur unitaire normal à la surface 3D

au point (u, v). */

{Vecteur_3D P;P = Produit_vectoriel(Tangente_u(u, v), Tangente_v(u, v));return Normaliser(P);

}

F NI

Page 21: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

21

PROTOTYPE PGC++

Surface guidée

Interface

Page 22: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

22

Surface_guidee( Courbe_parametrique & C1,Courbe_parametrique & C2);

Permet de créer une surface guidée à partir des 2 courbesfrontières C1 et C2.

type_de_surface_parametrique Acces_type_de_surface_parametrique();

Permet d'identifier le type de surface paramétriquequi a été définie.

Surface_guidee & operator = (Surface_guidee & S);Permet d'affecter S à la surface guidée courante.

Point_3D operator ()(float u, float v);Permet d'évaluer la surface courante à (u, v).

Courbe_parametrique * operator[](int i);Retourne un pointeur vers la i ième courbe frontière (i = 1, 2)de la surface guidée courante.

void Inserer(int i, Courbe_parametrique & C);La i ième (= 1 ou 2) courbe frontière de la surface guidéecourante est une copie de C.

Page 23: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

23

Vecteur_3D Tangente_u(float u, float v);Permet de calculer le vecteur tangent à la surface guidéedans la direction u au point (u, v).

Vecteur_3D Tangente_v(float u, float v);Permet de calculer le vecteur tangent à la surface guidéedans la direction v au point (u, v).

Page 24: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

24

PROTOTYPE PGC++

Maillage_triangulaire

DEFINITION

Page 25: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

25

#include "Surface_parametrique.h"#include "Surface_explicite.h"#include "Liste_simple.h"

class Maillage_triangulaire {

private :

struct sommet_du_maillage{

Point_3D P;Vecteur_3D Normale;

};struct facette_triangulaire{

sommet_du_maillage S1, S2, S3;};int N; // Nombre de facettes triangulaires.

Liste_simple E; // L'ensemble des facettes triangulaires.

Page 26: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

26

public :Maillage_triangulaire();

/* Permet de créer un maillage triangulaire vide.Pré - Nil.Post - Un maillage est créé avec 0 facette triangulaire. */

Maillage_triangulaire(Surface_explicite * S, int Nb_Pas_x, int Nb_Pas_y, float Borne_inf_x, float Borne_sup_x, float Borne_inf_y, float Borne_sup_y);

/* Permet de créer un maillage triangulaire issu d'une surface explicite.Pré - Une surface explicite z = f(x, y) est créée.

Nb_Pas_x > 0 et Nb_Pas_y > 0,Borne_inf_x <= x <= Borne_sup_x,Borne_inf_y <= y <= Borne_sup_y.

Post - Un maillage triangulaire est créé à partir de S.Le nombre de pas dans la direction x est Nb_Pas_x.Le nombre de pas dans la direction y est Nb_Pas_y. */

Page 27: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

27

Maillage_triangulaire(Surface_parametrique * S, int Nb_Pas_u, int Nb_Pas_v);

/* Permet de créer un maillage triangulaire issu d'une surface paramétrique.Pré - Une surface 3D est créée. Nb_Pas_u > 0 et Nb_Pas_v > 0.Post - Un maillage triangulaire est créé à partir de S.

Le nombre de pas dans la direction u est Nb_Pas_u.Le nombre de pas dans la direction v est Nb_Pas_v. */

Maillage_triangulaire & operator = (Maillage_triangulaire & M);

/* Permet d'affecter M au maillage triangulaire courant.Pré - M est créé.Post - Le maillage triangulaire courant renferme maintenant les

éléments de M. */

void operator &= (Maillage_triangulaire & M);

/* Ajoute le maillage M au maillage triangulaire courant.Pré - M est créé.Post - Le maillage triangulaire courant est l’ancien maillage courant

auquel on a ajouté M. */

Page 28: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

28

int Nombre_de_facettes_triangulaires();

/* Retourne le nombre de facettes triangulaires du maillage.Pré - Nil.Post - Retourne le nombre de facettes triangulaires du maillage.*/

void Acces_Facette_triangulaire( int j,Point_3D & P1, Vecteur_3D & N1,Point_3D & P2, Vecteur_3D & N2,Point_3D & P3, Vecteur_3D & N3);

/* Retourne les caractéristiques de la j ième facette triangulaire.Pré - 1 <= j <= nombre de facettes du maillage.Post - Retourne les sommets P1, P2 et P3 de la j ième facette dans

le sens horaire et les normales respectives N1, N2 et N3.*/

friend void Afficher(Maillage_triangulaire M);/* Permet d'afficher l'ensemble des facettes triangulaires.

Pré - Le maillage triangulaire M a été créée et initialisée.Post - Permet d'afficher le maillage triangulaire M. */

};

Page 29: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

29

PROTOTYPE PGC++

Maillage_triangulaire

IMPLANTATION

Page 30: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

30

#include "Maillage_triangulaire.h"#include <GL/GLUT.h>#include <GL/GL.h>#include <GL/GLAUX.h>#include <GL/GLU.h>

Maillage_triangulaire::Maillage_triangulaire(){

N = 0;}

Maillage_triangulaire::Maillage_triangulaire(Surface_explicite * S,int Nb_Pas_x, int Nb_Pas_y,float Borne_inf_x, float Borne_sup_x,float Borne_inf_y, float Borne_sup_y)

SEMBLABLE à la construction d’un maillage avecune surface paramétrique.

Page 31: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

31

Maillage_triangulaire::Maillage_triangulaire(Surface_parametrique * S,int Nb_Pas_u, int Nb_Pas_v)

{facette_triangulaire * F; facette_triangulaire * G;float pas_u, pas_v;pas_u = (float) 1.0 / (float) Nb_Pas_u;pas_v = (float) 1.0 / (float) Nb_Pas_v;N = 0;

for (int i = 1; i <= Nb_Pas_v; i++){

for (int j = 1; j <= Nb_Pas_u; j++){

F = new facette_triangulaire;G = new facette_triangulaire;

N = N + 2;(*F).S1.Normale = (*S).Normale((j-1)*pas_u, (i-1)*pas_v);(*F).S2.Normale = (*S).Normale((j - 1) * pas_u, i * pas_v);(*F).S3.Normale = (*S).Normale(j * pas_u, (i - 1) * pas_v);

Page 32: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

32

(*F).S1.P = (*S)((j - 1) * pas_u, (i - 1) * pas_v);(*F).S2.P = (*S)((j - 1) * pas_u, i * pas_v);(*F).S3.P = (*S)(j * pas_u, (i - 1) * pas_v);

E.Inserer_fin_liste(F);

(*G).S1.Normale = (*F).S3.Normale;(*G).S2.Normale = (*F).S2.Normale;(*G).S3.Normale = (*S).Normale(j * pas_u, i * pas_v);

(*G).S1.P = (*F).S3.P;(*G).S2.P = (*F).S2.P;(*G).S3.P = (*S)(j * pas_u, i * pas_v);

E.Inserer_fin_liste(G);}

}

}

Page 33: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

33

void Afficher(Maillage_triangulaire M){

Point_3D P1; Vecteur_3D N1;Point_3D P2; Vecteur_3D N2;Point_3D P3; Vecteur_3D N3;for (int i = 1; i <= M.Nombre_de_facettes_triangulaires(); i++){

M.Acces_Facette_triangulaire(i, P1, N1, P2, N2, P3, N3);glBegin(GL_TRIANGLES);

glNormal3f(N1[1], N1[2], N1[3]);glVertex3f(P1[1], P1[2], P1[3]);glNormal3f(N2[1], N2[2], N2[3]);glVertex3f(P2[1], P2[2], P2[3]);glNormal3f(N3[1], N3[2], N3[3]);glVertex3f(P3[1], P3[2], P3[3]);

glEnd();}

}

e c.t

Page 34: 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

34

Exemple en OpenGl

glNewList(Surface_1, GL_COMPILE);Point_3D A(0, 10, 0); Point_3D B(15, 15, -5);Vecteur_3D U(0, 20, -1); Vecteur_3D V(1, -20, 5);Point_3D C(0, 5, 15); Point_3D D(10, 0, 12);Courbe_de_Hermite Hermite(A, B, U, V);Courbe_de_Bezier Bezier(3);Bezier[0] = A;Bezier[1] = B;Bezier[2] = C;Bezier[3] = D;

Surface_guidee * pS = new Surface_guidee(Hermite, Bezier);

Maillage_triangulaire M1(pS, 10, 10);Afficher(M1);

glEndList();