Embed Size (px)
Citation preview
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é - NilPost - 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é - NilPost - 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é - NilPost - 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 avecle 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 lescalaire non nul S.
Pré - Le scalaire S est non nul et le vecteur courant est créé etinitialisé.
Post - Retourne le vecteur obtenu en divisant les composantes duvecteur 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 <cmath>
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 <iostream.h>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 d’un 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 composantesdu point P par le scalaire S.
Point_3D operator / (float S);Retourner le point obtenu en divisant les coordonnéesdu point courant par S.
Point_3D operator * (float S);Retourner le point obtenu en multipliant les coordonnéesdu 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 à l’aide d’un point P et d’un
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 pasi.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 d’intersection des droites P et Q.
Pré - Les droites P et Q sont non || et font partie du même plan.Post - Retourne le point d’intersection 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 d’intersection des plans P et Q.
Pré - Les plans P et Q sont non parallèles et ne coïncident pas.Post - Retourne la droite d’intersection des plans P et Q. */
friend Point_3D Intersection(Droite_3D & P, Plan & Q);/* Permet de calculer le point d’intersection de P avec le plan Q.
Pré - P n’est pas parallèle au plan Q.P ne fait pas partie du plan Q.
Post - Retourne le point d’intersection de P avec Q. */};
