3.6 Structures des données géométriques
Les éléments d'une figure ont une description abstraite et une apparence typographique. Cette section décrit la première propriété. ePiX fournit les classes P, segment, circle, plane et sphere que l'on peut utiliser dans les constructions de géométrie euclidienne. Chaque classe est définie par une petite quantité de données (p. ex. un centre, un rayon et un vecteur unitaire normal pour un circle) et fournit des constructeurs, des opérateurs d'intersection, de transformations affines et une fonction draw.
ePiX fournit également des outils pour les géométries sphérique et hyperbolique, spécialement ce qu'il faut pour tracer des droites dans les modèles dits du demi-plan et du disque de Poincarré du plan hyperbolique et aussi ce qu'il faut pour tracer les latitudes, longitudes, arcs de grands cercles, triangles sphériques, polyhèdres réguliers et courbes paramétrées sur la sphère.
Triplets et repères
Les points et les déplacements dans l'espace sont représentés par des triplets. Le nom du type est « P» bien que on eut pu utiliser «triple» pour des raisons de rétrocompatibilité. On fournit des constructeurs sphérique, cylindriquepolaire. On peut effectuer sur ces triplets les opérations canoniques – et d'autres moins canoniques – de l'algèbre linéaire : additionsoustraction, multiplication par un scalaire, produits vectoriel, scalaire, composante par composante et orthogonalisation. Lorsque l'on forme une expression symbolique utilisant des triplets les scalaires doivent être rassemblés à gauche et les triplets à droite. Si nécessaire l'utilisation de parenthèse forcera une association particulière.
P pt(x,y,z); // definit pt = (x,y,z) double u=pt.x1(); // première coordonée de pt, etc. P(x,y); // même chose que P(x, y, 0); polar(r, theta); cis(t); // polaire (1, t), alias Cos(t) + i*Sin(t) sph(r, theta, phi); // theta=longitude, phi=latitude P(a,b,c)|P(x,y,z); // produit scalaire, ax+by+cz P(a,b,c)&P(x,y,z); // produit par composante, P(ax,by,cz) p*q; // produit vectoriel, p x q J(p); // quart de tour autour de l'axe Oz p%q; // orthogonalisation, p (mod q)
De manière explicite, p%q est l'unique vecteur p+l*q perpendiculaire à q.
Un frame (repère) est un ensemble de trois vecteurs unitaires orthogonaux deux à deux. Le repère normal est l'ensemble E_1, E_2, E_3. Le constructeur transforme un ensemble de trois vecteurs non-coplanaire en repère :
frame(); // le repère normal frame(P v1, P v2, P v3); // orthonormalise (v1, v2, v3)
Le troisième vecteur d'un nouveau repère est positivement proportionnel à v3, le deuxième positivement proportionnel à v2%v3 et le premier est le produit vectoriel de deux derniers. De cette façon, un repère (frame) est orienté positivement et ne dépend pas de v1.
Intersection
Le concept de généricité est au c½ur de la compréhension de l'intersection des structures de données géométriques d'ePiX. Pour que la définition fonctionne, deux objets disjoints, tangents ou confondus se coupent de manière « non-générique». (Les géomètres noteront que cela change considérablement de la définition habituelle.) Les opérateurs d'intersection d'ePiX lance une exception lorsque les opérandes sont non-génériques. Si epix se termine avec un message d'erreur, vérifiez que vous ne cherchez pas à intersecter deux objets malformés ou mal positionnés.
Dans ePiX, un segment s'allonge en une droite pour les besoins d'une intersection. La table 3.1 présente les types d'intersections (génériques !) dans ePiX. L'intersection est commutative aussi on n'a rempli que la partie supérieure de la table. Toutes les intersections ne sont pas définies.
* segment circle plane sphere segment P segment P — circle segment segment — plane line circle sphere circle
Tableau 3.1: Types d'intersections d'ePiX.
Segments
Un segment est une paire (non ordonnée) de points. Un segment peut être translaté par un P et on peut prendre son milieu.
segment L1 = segment(P(0,0), P(2,4)); P mid = L1.midpoint(); // le milieu de L1 segment L2(mid, P(-2,3)); // forme un segment L2 += P(1,0); // translate L2 de (1,0) L1.draw(); L2.draw(); dot(L1*L2); // point d'intersection
Cercles
Une structure de données circle (cercle) est constituée d'un centre, un rayon et un vecteur unitaire perpendiculaire. On fournit trois constructeurs :
circle(P center, double radius, P normal); circle(P center, P point); circle(P p1, P p2, P p3);
Si les derniers arguments du premier constructeur ne sont pas spécifiés ils prennent, par défaut, les valeurs suivantes : si normal n'est pas donné, il prend la valeur E_3, si, de plus, le rayon n'est pas spécifié, il vaut 1, enfin, le centre est à l'origine s'il n'est pas donné explicitement. Comme d'habitude en C++, seuls les derniers arguments peuvent être implicites ; l'appel circle(center, normal) ne crée pas un cercle de rayon unité avec centre et normale données.
Le second crée un circle parallèle au plan (xy), de centre donné, passant par le point donné. Le troisième retourne un circle passant par les points donnés. Une exception est lancée si le centre (center) et le point ne sont pas dans un plan parallèle au plan (xy) ou si les trois points pi sont colinéaires.
Un circle peut être translaté d'un P avec l'opérateur + ou agrandit (ou réduit) d'un facteur double avec l'opérateur * :
circle C1=circle(); // cercle unité (« trigo ») circle C2 = C1+P(1,0.5); // translate vers le haut et la droite C2 *= 1.5; // multiplie le rayon par 1.5 C1.draw(); C2.draw(); // montre le travail (C1*C2).draw(); // trace le segment d'intersection
Sphères
Une sphere (sphère) est déterminée par un point et un rayon qui sont, par défaut, l'origine et l'unité. On fournit des constructeurs pour une sphere de centre donné qui passe par un point donné et pour une sphere donnée par ses poles.
sphere(center, point); poles(north, south);
De même que pour les circles, on fournit les opérateurs de translation et d'homothétie (agrandissement, réduction). Les outils particuliers à la géographie et à la géométrie sphérique sont décrit dans la section 3.8.
La fonction draw() d'une sphere dessine un horizon visible depuis le point de vue courant. Bien que cet horizon soit un cercle dans l'espace objet, son image sur le plan de l'écran est générallement une ellipse. De plus, des points antipodaux ne sont généralement pas représentés par des points symétriques par rapport au centre de l'ellipse. Ces effets sont d'autant plus prononcés que le point de vue est proche de la sphere et que le centre de celle-ci est éloigné de la cible (target).
Droites et plans
ePiX n'a pas de structure de données spéciale pour les droites mais il fournit la fonction Line (droite) qui trace la droite joignant deux points. Naturellement seul un segment est tracé. ePiX cadre (crop) toujours une Line et, de plus, enlève la demi-droite qui se trouve derrière l'observateur. Ainsi, une Line apparait imprimée comme un segment dont les deux extrémités sont sur la boite-cadre soit dont une seule extrémité est à l'intérieur de la boite-cadre, extrémité qui représente le point à l'horizon visible. La Prochaine Génération (alias ePiX3d ou «Version 2.x») fournira une structure de données pour les droites.
Un plane (plan) est déterminé par un point et un vecteur unitaire normal ou par trois points non-colinéaires. La fonction draw() représente les droites d'intersection du plan (plane) avec les faces de la boite de rognage. À moins qu'on ait fixé la boite de rognage à la main, les droites d'intersection éviteront presque surement la boite-cadre et resteront donc invisibles.