1 PROTOTYPE PGC++ Courbe_parametrique DÉFINITION.

Slides:



Advertisements
Présentations similaires
CINEMATIQUE.
Advertisements

1 Quelques précisions sur l'héritage. 2 Signification de super.f() appel à la méthode f() masquée super : désigne l'objet appelant comme s'il était de.
Introduction à l’étude des variations
Langages objet Définitions Traduction des méthodes en C++
Courbes & Surfaces de subdivision
Constante de temps d ’une évolution exponentielle
Modélisation 3D Réalisation d'une image de synthèse
Modélisation Géométrique
Connaissances Logiciel de géométrie dynamique Epreuve Expérimentale Série S 2007/08.
Leçon 3 : Héritage IUP 2 Génie Informatique
Conception assistée par ordinateur GPA445
Physique mécanique (NYA)
Dérivation et Intégration numérique
Algorithmique et Programmation
Nicolas Holzschuch Cours d’Option Majeure 2
2ème secondaire.
Des révisions et des constructions.
Modélisation géométrique à l’aide d’un maillage
ANIMATION PAR TRAJECTOIRES
COURBES B-SPLINE B-Spline Bézier
Programme de baccalauréat en informatique Programmation Orientée Objets IFT Thierry EUDE Module 5 : La surcharge des opérateurs Département dinformatique.
IFT3355: Infographie Courbes et surfaces
1 PROTOTYPE PGC++ Vecteur_3D DÉFINITION. 2 class Vecteur_3D { private : float vx, vy, vz, vw; // Représentation en coordonnées homogènes. public : Vecteur_3D();
Courbes de Hermite Michael E. Mortenson, Geometric Modeling. Wiley, 1997, 523p.
Courbes de Bézier.
Surfaces bicubiques de Hermite
OBJETS ÉLÉMENTAIRES DANS L’ESPACE À TROIS DIMENSIONS
Constante de temps d ’un dipôle RC
Accélération.
1 Fonction : surcharge de sélection La surcharge de sélection consiste à implanter plusieurs méthodes de même nom dans une même classe à condition que.
Héritage Lhéritage permet de spécialiser une classe en définissant une relation de type « est une sorte de ». #include comptebancaire.h class CompteEpargne.
Réalisation d'une image de synthèse
Texture 2D en PGC++.
Techniques de points de contrôle en OpenGL : formes de Bézier
IFT3355: Infographie Courbes et surfaces
1 Spline de Catmull-Rom Rick Parent, Animatique Algorithmes et techniques. Vuibert, Paris, 2003, 530p. (Voir section B.4.6) Tomas Akenine-Möller, Eric.
Modélisation géométrique de base
Héritage Licence Informatique Besançon Méthode et Outils pour la Programmation Françoise Greffier.
Héritage et composition
1 Exemples Construction et implantation de types de données abstraits.
(Vient du grec et signifie « Peut prendre plusieurs formes »)
Elaboré par M. NUTH Sothan
LES FONCTIONS DERIVEES
Cinématique des changements de référentiel
Journées Scientifiques / Paris février 2005 IEEA Modélisation de l’interaction onde-structure par l’UTD Application au positionnement d’une antenne.
Compléments mathématiques. COMPLEMENTS MATHEMATIQUES
Cours C++ Fonctions Surcharge d’opérateurs Passage d’arguments
1 Interpolation Buts L’interpolation consiste à calculer des valeurs pour différents points sur la base d’observations faites sur des points particuliers.
Un peu de Design Pattern Quelques modèles pour développer vite et bien.
Déterminer les vecteurs vitesse et accélération sur un enregistrement
Chapitre 4 Dérivée directionnelle et gradient
Les classes Introduction aux Langages Orientés Objets
Surfaces de Bézier.
OBJETS ÉLÉMENTAIRES DANS L’ESPACE À TROIS DIMENSIONS
Courbe 3D Créer un fichier pièce dans l’environnement part design Créer les 4 points suivants :
1 Courbes Bsplines non uniformes Bsplines uniformes 1.Nombre de points de définition 2.Position des points de définition 3.Degré m des polynômes Paramètres.
Géométrie et communication graphique
1 Modèles rationnels - NURBS Courbe de Bézier invariante par une transformation affine (par exemple projection sur un plan parallèlement à une projection.
Courbes Bsplines uniformes
Courbes d'Interpolation Interpolation de Lagrange, et Interpolation B-spline.
Algorithmique Langage C
1 COURBES B-SPLINE Bézier B-Spline Hearn & Baker, Computer Graphics with OpenGL. Prentice-Hall, 2004, chapitre 8.
C1 – Interpolation et approximation
Dérivation : calculs.
IFT3355: Infographie Courbes et surfaces © Pierre Poulin Dép. I.R.O. Université de Montréal.
IFT3355: Infographie Courbes et surfaces © Pierre Poulin Dép. I.R.O. Université de Montréal.
Transcription de la présentation:

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 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 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 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 PROTOTYPE PGC++ Segment_3D 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.*/

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 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 PROTOTYPE PGC++ Courbe_composite DÉFINITION

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 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 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 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 //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 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 PROTOTYPE PGC++ Surface_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 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 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 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 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 PROTOTYPE PGC++ Surface guidée Interface

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 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 PROTOTYPE PGC++ Maillage_triangulaire DEFINITION

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 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 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 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 PROTOTYPE PGC++ Maillage_triangulaire IMPLANTATION

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