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(); /*Permet de créer un vecteur dans l'espace à 3 dimensions et de l'initialiser au vecteur nul. Pré - Nil Post - Un vecteur est créé et initialisé au vecteur nul.*/ Vecteur_3D(float x, float y, float z); /*Permet de créer un vecteur dans l'espace à 3 dimensions et de l'initialiser à (x, y, z). Pré - Nil Post - Un vecteur est créé et initialisé à (x, y, z).*/

3 Vecteur_3D(Vecteur_3D & Q); /*Permet de créer un vecteur dans l'espace à 3 dimensions et de l'initialiser à Q. Pré - Nil Post - Un vecteur est créé et initialisé à Q.*/ Vecteur_3D & operator = (Vecteur_3D & Q); /*Permet d'affecter Q au vecteur courant. Pré - Q est créé et initialisé. Le vecteur courant est créé et initialisé. Post -Retourne le contenu de Q dans le vecteur courant.*/ float & operator[](int i); /*Permet d'accéder ou de modifier la i ième composante (= 1, 2, 3 ou 4) du vecteur courant. Pré -Le vecteur courant est créé et initialisé. Post -Accède ou modifie la i ième composante (= 1, 2, 3 ou 4) du vecteur courant.*/

4 float operator * (Vecteur_3D V); /*Permet de calculer le produit scalaire du vecteur courant avec le vecteur V. Pré -Le vecteur V est créé et initialisé. Post -Retourne le produit scalaire du vecteur courant avec le vecteur V.*/ Vecteur_3D operator + (Vecteur_3D V); /*Permet de calculer la somme du vecteur courant avec le vecteur V. Pré - Le vecteur V et le vecteur courant sont créés et initialisés. Post - Retourne la somme du vecteur courant avec le vecteur V.*/ Vecteur_3D operator - (Vecteur_3D V); /*Permet de calculer la différence du vecteur courant avec le vecteur V. Pré - Le vecteur V et le vecteur courant sont créés et initialisés. Post - Retourne la différence du vecteur courant avec le vecteur V. */ += et -=

Vecteur_3D operator / (float S); /*Permet de diviser chaque composante du vecteur courant par le scalaire non nul S. Pré -Le scalaire S est non nul et le vecteur courant est créé et initialisé. Post - Retourne le vecteur obtenu en divisant les composantes du vecteur courant par le scalaire S.*/ bool operator == (Vecteur_3D V); /*Permet de vérifier si le vecteur courant est identique au vecteur V. Pré – Les vecteurs V et courant sont créés et initialisés. Post - Retourne TRUE si les vecteurs sont égaux. FALSE sinon.*/ bool operator | | (Vecteur_3D V); /*Permet de vérifier si le vecteur courant est parallèle au vecteur V. Pré – Les vecteurs V et courant sont créés et initialisés. Post - Retourne TRUE si les vecteurs sont | |. FALSE sinon.*/

friend Vecteur_3D Produit_vectoriel (Vecteur_3D & P, Vecteur_3D & Q); /*Permet de calculer le produit vectoriel P X Q. Pré - P et Q ont été créés et initialisés. Post - Retourne le produit vectoriel P X Q.*/ friend float Norme(Vecteur_3D & P); /*Permet de calculer la norme du vecteur P i.e., sa longueur. Pré - P est créé et initialisé. Post - Retourne la norme du vecteur P.*/ friend Vecteur_3D & Normaliser(Vecteur_3D & P); /*Permet de normaliser le vecteur P. Pré - P est créé et initialisé. P est un vecteur non nul. Post - Retourne le vecteur P normalisé.*/ }; Vecteur_3D operator * (float S, Vecteur_3D & V); /*Permet de multiplier chaque composante de V par le scalaire S. Pré -Le vecteur V est créé et initialisé. Post - Retourne le vecteur obtenu en multipliant les composantes de V par S.*/

7 PROTOTYPE PGC++ Vecteur_3D IMPLANTATION

8 #include "Vecteur_3D.h" #include Vecteur_3D::Vecteur_3D() { vx = 0.0;vy = 0.0;vz = 0.0;vw = 0.0; } Vecteur_3D::Vecteur_3D(float x, float y, float z) { vx = x;vy = y;vz = z;vw = 0.0; } float & Vecteur_3D::operator[](int i) { if (i == 1 ) return vx; if (i == 2 ) return vy; if (i == 3 ) return vz; else return vw; }

9 Vecteur_3D & Vecteur_3D::operator = (Vecteur_3D & Q) { vx = Q[1];vy = Q[2];vz = Q[3];vw = 0.0; return *this; } Vecteur_3D::Vecteur_3D(Vecteur_3D & Q) {vx = Q[1];vy = Q[2];vz = Q[3];vw = 0.0; } float Vecteur_3D::operator * (Vecteur_3D V) { return vx * V[1] + vy * V[2] + vz * V[3]; } Vecteur_3D Vecteur_3D::operator + (Vecteur_3D V) { Vecteur_3D P; P[1] = vx + V[1];P[2] = vy + V[2];P[3] = vz + V[3]; return P; }

10 Vecteur_3D Vecteur_3D::operator - (Vecteur_3D V) { Vecteur_3D P; P[1] = vx - V[1];P[2] = vy - V[2];P[3] = vz - V[3]; return P; } Vecteur_3D Vecteur_3D::operator / (float S) { Vecteur_3D P; P[1] = vx / S;P[2] = vy / S;P[3] = vz / S; return P; } Vecteur_3D Produit_vectoriel(Vecteur_3D &P,Vecteur_3D &Q) { Vecteur_3D R; R[1] = P[2] * Q[3] - P[3] * Q[2]; R[2] = P[3] * Q[1] - P[1] * Q[3]; R[3] = P[1] * Q[2] - P[2] * Q[1]; return R; }

11 bool Vecteur_3D::operator == (Vecteur_3D V) { if ((vx == V[1]) && (vy == V[2]) && (vz == V[3])) return true; else return false; } bool Vecteur_3D::operator || (Vecteur_3D V) { if ((vy * V[3] – vz * V[2]) != 0) return false; if ((vz * V[1] – vx * V[3]) != 0) return false; if ((vx * V[2] – vy * V[1]) != 0) return false; return true; } Vecteur_3D operator * (float S, Vecteur_3D & V) { Vecteur_3D R; R[1] = S * V[1];R[2] = S * V[2];R[3] = S * V[3]; return R; }

12 float Norme(Vecteur_3D & P) { float somme; somme = P[1] * P[1] + P[2] * P[2] + P[3] * P[3]; return (float) sqrt(somme); } Vecteur_3D Normaliser(Vecteur_3D &P) { Vecteur_3D R; R = P / Norme(P); return R; }

13 #include "Vecteur_3D.cpp" #include void Afficher(Vecteur_3D v) { cout << "(" << v[1] << ", " << v[2] << ", " << v[3] << ")" << endl; } void main() { Vecteur_3D U;Afficher(U); Vecteur_3D V(1, 2, 3);Afficher(V);Afficher(-V); Vecteur_3D W(V);Afficher(W); Vecteur_3D X = W;Afficher(X); cout << "Produit scalaire : " << W * (U + V) << endl; Afficher(X += (V - 2 * W / 3)); if (W == V) cout << "W et V sont 2 vecteurs egaux." << endl; if (W || V*3) cout << "W et 3V sont paralleles." << endl; Afficher(Normaliser(V)); }

14 Interface de la classe Point_3D

15 Point_3D(); Création dun point 3D initialisé à l'origine. Point_3D(float x, float y, float z); Permet de créer un point 3D et de l'initialiser à (x, y, z). Point_3D(Point_3D & Q); Permet de créer un point 3D et de l'initialiser à Q. Point_3D & operator = (Point_3D & Q); Permet d'affecter Q au point courant. Vecteur_3D operator - (Point_3D P); Retourne la différence entre le point courant et le point P. Point_3D operator + (Vecteur_3D V); Retourne la somme du point courant avec le vecteur V. Point_3D & operator += (Vecteur_3D V); Permet d'ajouter le vecteur V au point courant. float operator * (Vecteur_3D V); Retourne le produit scalaire du point courant avec le vecteur V.

16 bool operator == (Point_3D P); Retourne TRUE si le point courant et le point P sont égaux. float & operator[](int i); Accède ou modifie la coordonnée i (=1, 2 ou 3) du point courant. friend float Distance(Point_3D P, Point_3D Q); Retourne la distance entre les points P et Q i.e. ||P-Q||. Point_3D operator * (float S, Point_3D & P); Retourne le point obtenu en multipliant les composantes du point P par le scalaire S. Point_3D operator / (float S); Retourner le point obtenu en divisant les coordonnées du point courant par S. Point_3D operator * (float S); Retourner le point obtenu en multipliant les coordonnées du point courant par S. Point_3D operator - (Point_3D & V); Retourne le point -V.

17 PROTOTYPE PGC++ Droite_3D DÉFINITION

18 #include "Point_3D.h" class Droite_3D { protected : Point_3D P1;Point_3D P2; public : Droite_3D(Point_3D & P, Point_3D & Q); /*Permet de créer une droite 3D. Pré -Nil. Post -Une droite 3D passant par P et Q est créée.*/ Droite_3D(Droite_3D & D); /*Permet de créer une droite 3D. Pré -Nil. Post -Une droite 3D initialisée à D est créée.*/ Droite_3D(Point_3D & P, Vecteur_3D & D); /*Permet de créer une droite 3D à laide dun point P et dun vecteur directeur D. Pré -D est un vecteur non nul. Post -Une droite 3D définie par P et D est créée.*/

19 Droite_3D & operator = (Droite_3D & D); /*Permet d'affecter D à la droite courante. Pré -D est créée. La droite courante est créée. Post -La droite courante renferme la définition de D.*/ Point_3D & operator[](int i); /*Sachant que la droite courante est définie par 2 points, cette fonction permet d'accéder ou de modifier ce ième point(= 1 ou 2). Pré -La droite courante est créée et initialisée. Post -Accède ou modifie le ième point (= 1 ou 2) définissant la droite courante.*/ float Distance_de_l_origine(); /*Permet de calculer la distance de l'origine à la droite courante i.e. || (P1 - origine) x (P2 – P1) || / ||P2 – P1||. Post -Retourne la distance de l'origine à la droite.*/ float Distance_d_un_point(Point_3D Q); /*Permet de calculer la distance de Q à la droite courante i.e. || (P1 - Q) x (P2 – P1) || / ||P2 – P1||. Post -Retourne la distance de Q à la droite courante.*/

20 bool operator || (Droite_3D & Q); /*Permet de déterminer si la droite courante est parallèle à Q i.e. si || (Q[2] – Q[1]) x (P2 – P1) || est égale à 0. Post -Retourne true si la droite courante est parallèle à Q; false autrement.*/ bool Perpendiculaire(Droite_3D & Q); /*Permet de déterminer si la droite courante est perpendiculaire à Q i.e. (P2 – P1) * Vecteur directeur de Q est égale à 0. Pré -Les droites sont créées et initialisées. Post -Retourne TRUE si les droites sont perpendiculaires. FALSE autrement. bool Appartenance_d_un_point(Point_3D Q); /*Permet de vérifier si un point Q appartient ou non à une droite i.e. || (Q - P1) x (P2 – P1) || est égale à 0. Post -Retourne true si Q appartient à la droite; false autrement.*/ bool operator == (Droite_3D & Q); /*Détermine si les 2 droites coïncident ou pas i.e. si P1 appartient à Q et P2 appartient à Q. Post -Retourne true si les 2 droites coïncident; false autrement.*/

21 Point_3D operator ()(float u); /*Permet de déterminer le point sur la droite correspondant à la valeur de u dans les réels. Ce point correspond à P1 + u (P2 – P1). Pré -Nil. Post -Retourne le point sur la droite à u.*/ friend Point_3D Intersection(Droite_3D & P, Droite_3D & Q); /*Permet de calculer le point dintersection des droites P et Q. Pré -Les droites P et Q sont non || et font partie du même plan. Post -Retourne le point dintersection des droites P et Q. friend bool Meme_plan(Droite_3D & P, Droite_3D & Q); /*Détermine si P et Q sont dans le même plan ou non. i.e. ( (P[2] – P[1]) x (Q[1] – P[1]))*(Q[2] – P[1]) = 0. Post -Retourne TRUE si Pet Q sont dans le même plan. FALSE autrement.*/ friend Vecteur_3D & Vecteur_directeur(Droite_3D & Q); /*Détermine le vecteur directeur unitaire de la droite Q i.e. Q[2] – Q[1]. Post -Retourne le vecteur directeur unitaire de la droite Q.*/

22 friend float Distance (Droite_3D & P, Droite_3D & Q); /*Détermine la distance entre les droites P et Q. Post -Retourne la distance entre les droites P et Q.*/ };

23 PROTOTYPE PGC++ Plan DÉFINITION

24 #include "Droite_3D.h" class Plan { private : /*Soit P un point quelconque du plan, l'équation du plan est : normale * P = distance.*/ Vecteur_3D normale; float distance; public : Plan(Vecteur_3D N, float D); /*Permet de créer un plan d'équation N * P = D. Pré -N est un vecteur non nul. Post -Un plan d'équation N * P = D est créé.*/ Plan(Vecteur_3D N, Point_3D Q); /*Permet de créer un plan d'équation N * P = N * Q. Pré -N est un vecteur non nul. Post -Un plan d'équation N * P = N * Q est créé.*/

25 Plan(Point_3D Q, Point_3D R, Point_3D S); /*Permet de créer un plan d'équation N * P = N * Q où N = (R - Q) x (S - Q). Pré -Q, R et S ne sont pas des points colinéaires i.e., ces points ne sont pas alignés. Post -Un plan d'équation N * P = N * Q est créé.*/ Plan(Plan & Q); /*Permet de créer un plan et de l'initialiser à Q. Pré -Le plan Q est créé et initialisé. Post -Un plan est créé et initialisé à Q.*/ Plan & operator = (Plan & Q); /*Permet d'affecter Q au plan courant. Pré -Q et le plan courant sont créés et initialisés. Post -Retourne la définition de Q dans le plan courant.*/ float Distance_de_l_origine(); /*Permet de calculer la distance de l'origine au plan i.e. – distance / ||normale||. Post -Retourne la distance de l'origine au plan.*/

26 float Distance_d_un_point(Point_3D Q); /*Permet de calculer la distance de Q au plan i.e. (distance – Q * normale) / ||normale||. Post -Retourne la distance de Q au plan.*/ bool operator || (Plan & Q); /*Permet de déterminer si le plan courant est parallèle à Q i.e. si ||normale x Q.normale()|| est égale à 0. Post -Retourne true si le plan courant est parallèle à Q; false autrement.*/ bool operator || (Droite_3D & D); /*Permet de déterminer si le plan courant est parallèle à D i.e. si ||normale * vecteur directeur de D|| est égale à 0. Post -Retourne true si le plan courant est parallèle à D; false autrement.*/ Vecteur_3D & Normale(); /*Permet de calculer la normale au plan. Pré -Nil. Post -Retourne la normale au plan.*/

27 void Points_du_plan(Point_3D * Q, Point_3D * R, Point_3D * S); /*Permet de calculer 3 points non alignés du plan. Pré -Nil. Post -Retourne 3 points non alignés du plan.*/ bool Appartenance_d_un_point(Point_3D Q); /*Permet de vérifier si un point Q appartient ou non à un plan i.e. si normale * Q est égale à distance. Post -Retourne true si Q appartient au plan; false autrement.*/ friend Droite_3D Intersection(Plan & P, Plan & Q); /*Permet de calculer la droite dintersection des plans P et Q. Pré -Les plans P et Q sont non parallèles et ne coïncident pas. Post -Retourne la droite dintersection des plans P et Q.*/ friend Point_3D Intersection(Droite_3D & P, Plan & Q); /*Permet de calculer le point dintersection de P avec le plan Q. Pré -P nest pas parallèle au plan Q. P ne fait pas partie du plan Q. Post -Retourne le point dintersection de P avec Q.*/ };