1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION.

Présentation au sujet: "1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION."— Transcription de la présentation:

1 1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION

2 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 3D dans l'espace paramétrique [0,1] est créée. Cette classe renferme des fonctions virtuelles pures lesquelles devront être redéfinies obligatoirement dans les classes dérivées.*/ class Courbe_parametrique { protected : type_de_courbe_parametrique Courbe;

3 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_parametrique Acces_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.*/

4 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 nest pas considérée plane lorsquil sagit dun point ou dun segment de droite.*/ }; FNI

5 5 PROTOTYPE PGC++ Segment_3D DÉFINITION

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

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

8 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 nest pas considérée plane. */ };

9 9 PROTOTYPE PGC++ Courbe_composite DÉFINITION

10 10 Cette classe permet de définir et de manipuler des courbes composites où chaque segment est une courbe paramétrique dans [0, 1]. Elle permet aussi 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 dun ensemble de « Nb_de_Points » points dinterpolation.

11 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 courbe composite 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 une copie 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 à u dans 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.

12 12 Vecteur_3D Tangente(int i, float u); Permet de calculer la tangente unitaire au i ième segment de la courbe à u. Le i ième segment de la courbe composite doit être dé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 allant du i ième segment à u1 au j ième segment à u2 où 0 u1, u2 1 et i j. Si i est égale à j alors u1 u2. 1 i, j # de segments de la courbe. Les segments concernés de la courbe composite doivent ê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 et si tous les plans renfermant les segments de la courbe coïncident. La courbe n'est pas considérée plane lorsqu'un segment de la courbe correspond à un point ou un segment de droite. -----------------------------------------------------

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

14 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();

15 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 primitives d'affichage est complétée.*/ glFlush(); }

16 16 PROTOTYPE PGC++ Surface_parametrique DÉFINITION

17 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 3D dans le carré unité est créée. Elle permet aussi de définir des surfaces quelconques. Cette classe renferme des fonctions virtuelles pures lesquelles devront être redéfinies obligatoirement dans les classes dérivées.*/

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

19 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 direction v 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).*/

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

21 21 PROTOTYPE PGC++ Surface guidée Interface

22 22 Surface_guidee(Courbe_parametrique & C1, Courbe_parametrique & C2); Permet de créer une surface guidée à partir des 2 courbes frontières C1 et C2. type_de_surface_parametrique Acces_type_de_surface_parametrique(); Permet d'identifier le type de surface paramétrique qui 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ée courante est une copie de C.

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

24 24 PROTOTYPE PGC++ Maillage_triangulaire DEFINITION

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

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

27 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 lancien maillage courant auquel on a ajouté M.*/

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

29 29 PROTOTYPE PGC++ Maillage_triangulaire IMPLANTATION

30 30 #include "Maillage_triangulaire.h" #include 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 dun maillage avec une surface paramétrique.

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

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

33 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(); } ec.t

34 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();