Plan du cours Introduction Triangulation de polygones Recherche/localisation Diagrammes de Voronoï Triangulation de Delaunay Arbres de partition binaire 1
Intersection de segments de droite Intersection de zones polygonales Balayage du plan / DCEL. 2
Problème classique en GIS/géomatique Exemple : On dispose de : Une carte avec les zones forestières Une carte avec les zones d'occupation par les animaux sauvages etc... On veut connaître toutes les zones «homogènes» pour chacune des caractéristiques eg. zone de feuillus et population de chevreuils zone d'épineux et population de chevreuils zone d'épineux et population d'ours etc... 3
Types d'information portée par une carte : Villes (points ou polygones) Rivières, routes (réseaux, graphes) Zones boisées, de précipitations (polygones) On doit combiner 2 ou plus de ces «cartes» et calculer les intersections Deux cartes de réseaux points (ponts?) Deux cartes de zones nouveaux polygones Toute combinaison... Une opération élémentaire est l'intersection entre «paquets» de segments de droites. 4
Calcul des intersections dans un ensemble de segments 5
Intersection de segments Données en entrée : Deux ensembles de segments En sortie : Toutes les intersections entre ces deux ensembles On peut sans perte de généralité rassembler les deux ensembles et calculer les intersections à l'intérieur d'un seul ensemble. Il est possible de trouver des intersection au sein du même ensemble d'origine mais cela peut être filtré par la suite. 6
Algorithme 1 Force brute : prendre chaque paire de segments et vérifier si ils s'intersectent O(n²)!!! En un sens, c'est optimal si un grand nombre de segments s'intersectent (aussi en O(n²) ) Les algorithmes calculant ces intersections prennent nécessairement un temps en n 2 exemple : 2n segments n² intersections 7
En pratique, le nombre d'intersections n'est généralement pas en O(n²). L'algorithme n'est alors plus optimal On doit établir un algorithme plus efficace Idéalement O(f(n,I))) avec f(n,i) meilleur que O(n²) quand I est O(n) Ici, la complexité attendue est fonction des données d'entrée (nombre de segments n) mais aussi des données de sortie (ici le nombre d'intersections I ) On parle d'algorithme sensible aux données de sortie ce n'était pas le cas pour certains algorithmes calculant l'enveloppe convexe. Comment ne pas tester toutes les paires de segments quand ce n'est pas nécessaire? Utilisation de la géométrie... 8
Soit S ={s 1, s 2, s 3,..., s n } l'ensemble des segments. Ne testons les segments que si leur intervalle sur x (projection orthogonale sur l'axe x) est non disjoint y x 9
Pour détecter les paire de segments dont la projection sur x est non disjointe, utilisation d'une ligne imaginaire l balayant de gauche à droite le domaine l Point événement Le statut de la ligne l est l'ensemble des segments qui l'intersectent Il change au fur et à mesure du déplacement de la ligne À chaque événement ; le statut est mis à jour C'est le seul moment ou l'on «fait» quelque chose : ajouter un segment, faire quelques tests d'intersections, retirer un segment. Si un événement correspond à une extrémité à gauche, ajout de segment ; on teste l'intersection avec les segments déjà présents Si un point événement est une extrémité à droite, retirer le segment du statut. 10
On teste donc tous les segments présents dans le statut. Est-ce optimal? Non! Ici on teste un nombre quadratique de paires de segments... 11
Ordonnons les segments dans le statut de bas en haut Cela permet de savoir si deux segments sont proches ou éloignés dans la direction verticale On ne teste que des segments adjacents dans cet ordre. Lorsque l'on ajoute un segment dans le statut, on ne le teste qu'avec celui «au dessous» et celui «au dessus» Si un événement est une intersection simple, il faut intervertir les segments concernés dans le classement... et les tester avec leurs nouveaux voisins Si un événement revient à retirer un segment du statut, on teste les deux segments qui deviennent voisins. Ainsi, chaque nouvelle adjacence dans le statut est testée pour intersection 12
Cet algorithme fonctionne-t-il? Il faut vérifier que chaque point d'intersection p peut être calculé au moment ou l'on traite un événement. Revient à montrer que s i et s j deviennent adjacents avant de traiter p s ij l s k p s i Ici, s i et s j deviennent adjacents losque s k est retiré du statut. C'est la cas, car les deux segments sont adjacents dans le statut au moment ou est p est traité ; mais ne le sont pas au début (avant l'ajout d'un des segment s i ou s j ). Il existe donc un événement pour lequel ils deviennent adjacents. 13
En principe l'algorithme fonctionne, sans tenir compte des cas dégénérés. Intersections de 3 segments ou plus au même point Segments verticaux Segments confondus 14
«Invariant» de l'algorithme : tous les points d'intersection à gauche de la ligne ont été calculés correctement. 15
Structures de données La file des événements F Classée de façon lexicographique en fonction des coordonnées du point considéré règle le cas des points situés sur une même coordonnée x (e.g. Segments verticaux) - structure identique à celle utilisée dans le cas du calcul de l'enveloppe convexe Détermine la nature de l'événement Point «gauche» d'un segment ajout dans le statut Point «droit» d'un segment retrait du statut Point d'intersection échange de deux segments dans le statut Le statut T Classé en permanence selon l'ordre des segments le long de la ligne l Permet de rechercher rapidement les segments contigus à un événement donné (classement selon la coordonnée y par exemple) Difficulté : la clef (coordonnée y) varie lorsque l se déplace 16
Les algorithmes : TrouveIntersections(S) Entrée : un ensemble de segments S dans le plan Sortie : un ensemble contenant les points d'intersection, avec pour chacun des points les segments qui le contiennent { Initialiser une file d'événements F vide. Insérer les points extrémités des segments de S dans F. Si le point est un point situé a gauche du segment, on y attache le segment. Initialiser une stucture Statut T vide. Tant que F est non vide { Trouver le prochain point p de F, et l'effacer de F. TraiteEvenement(p,T) } } 17
TraiteEvenement(p) doit être capable de traiter les cas dégénérés suivants : l s 6 s 1 p s 2 s 2 s 1 s 3 s 4 s 5 T={s 5, s 4, s 3, s 2, s 1 } T={s 5, s 1, s 2, s 6 } 18
TraiteEvenement(p) { Soit G(p) l'ensemble des segments dont le point «à gauche» est p (ils sont connus et stockés avec p) Trouver tous les segments dans T qui contiennent p ; ils sont adjacents dans T. Soit D(p) le sous ensemble de ces segments dont p est le point «droit» C(p) le sous ensemble des segments contenant p dans leur intérieur. Si Union(G(p),D(p),C(p)) contient plus d'un segment { p est une intersection, y attacher G(p),D(p),C(p) } Effacer les segments appartenant a Union(D(p),C(p)) de T Inserer les segments appartenant a Union(G(p),C(p)) dans T : l'ordre nouveau doit correspondre à l'ordre obtenu si l est juste à droite de p. Si il y a un segment vertical, il vient en dernier. Note : l'ordre parmi les segments de C(p) est renversé... Si Union(G(p),C(p)) est vide { Soit s u et s d les voisins du dessus et du dessous de p dans T l s 6 TrouverEvenement(s u, s d, p) G(p) } Sinon { Soit s' le segment le plus haut dans Union(G(p),C(p)) Soit s u le segment voisin (vers le haut) de s' dans T Si s u existe TrouverEvenement(s u, s', p) Soit s'' le segment le plus bas dans Union(G(p),C(p)) Soit s d le segment voisin (vers le bas) de s'' dans T Si s d existe TrouverEvenement(s'', s d, p) } } s 2 s 3 s 1 s 5 D(p) s 4 p C(p) s 2 s 1 19
TrouveEvenement(s 1, s 2, p) { Si s 1 et s 2 s'intersectent à droite de la ligne l, ou sur la ligne l mais au dessus de p Et que l'intersection n'est pas présente dans F Inserer l'intersection comme nouvel événement dans F. } 20
Analyse de l'algorithme L'algorithme trouve-t-il toutes les intersections? Preuve par induction sur la priorité des événements On suppose que toutes les événements de plus haute priorité (avant p dans la file) sont correctement traitées. Soit p est une extrémité d'un des segments Il a été inséré dans F au début de l'algorithme et y figure donc, avec G(p), et les segments D(p) et C(p) sont dans T au moment ou cet événement est traité. Soit p est une intersection, il faut prouver que p a été introduit dans F à un moment ou à un autre. Ici, tous les segments impliqués ont p dans leur intérieur. Soit s i et s j deux segments voisins dans T. La preuve précédente (slide 13) permet d'affirmer que ces segments deviennent voisins (et sont donc testés et p calculé) pour un certain événement q antérieur à p. (Cf page 27 du livre) 21
e 1 degré=4 e 2 Performance en temps de l'algorithme On peut prouver que T=O((n+k) log n) avec k = taille de la sortie File d'événements : O(n log n) Le traitement de chaque événement Insertions / délétions dans F : log n chaque Insertions / délétions dans T : log n chaque (au pire), mais il y en a m(p)=card(union(g( p ), D( p ), C( p ) ) ) Soit m la somme des m(p), globalement on a O(m log n) Or m=o(n+k), k étant la taille de la sortie (segments + intersections) Au final, on a donc une complexité de de O((n+k) log n) On peut prouver un résultat plus fort : T=O((n+I) log n) avec I = nombre d'intersections considérations sur les graphes plans m est borné par la somme des degrés de chaque sommet Chaque arête contribue au degré de au plus deux sommets, donc m est borné par 2n e (nombre d'arêtes du graphe). n v (nombre de sommets) est au plus égal à 2n+I, Or, sur un graphe plan, n e = O(n v ), CQFD. 22
Relation d'euler pour les graphes plans Chaque face du graphe plan est bornée par au moins 3 arêtes Une arête limite au plus deux faces distinctes Donc n f 2n e /3 Formule d'euler : n v n e +n f = r avec r 2 r dépend du genre topologique (nb de trous etc) On a donc n e =O(n v ). 23
Performance en mémoire de l'algorithme T stocke au plus n segments, dans un arbre binaire O(n) La file F stocke au pire n +I événements O(n + I) Au final, M=O(n+I) Si I = O(n²), c'est trop peu efficace. Si l'on veut traiter les intersection les unes après les autres (sans stockage), c'est catastrophique. Faire mieux est possible : Ne faire figurer dans F que les événements (intersections) dont les segments sont adjacents dans T. Donc, dès que deux segments ne sont plus adjacents, il faut supprimer l'événement correspondant dans F. Un événement est susceptible d'être supprimé/réinséré plusieurs fois avant d'être effectivement traité. Toutefois, cela n'arrive jamais plus de n fois en tout... donc globalement T=O((n+I) log n) La file F ne contient donc plus que O(n) élements. 24
En bref, Il est possible de calculer les intersections en un temps T=O((n+I) log n) et une place mémoire M=O(n) Cet algorithme date de 1979 (avec une modification ultérieure pour garder la mémoire en O(n)) J. L. Bentley and T. A. Ottmann, Algorithms for reporting and counting geometric intersections, IEEE Trans. Comput., C-28:643 647, 1979 Est-ce optimal? Non... cas ou I=O(n²) : T=O(n² log n), or on peut y arriver en O(n²)!!! La borne inférieure théorique est T=Ω(n log n +k) et il existe un algorithme déterministe qui réalise cela (seulement) depuis 1995 I. J. Balaban. An optimal algorithm for finding segment intersections. In Proc. 11th Annu. ACM Sympos. Comput. Geom., pages 211 219, 1995. 25
Robustesse? Tel quel ; algorithme non robuste à cause du calcul des intersections fait en précision finie... Il est possible que le calcul (imprécis) d'une intersection donne un point légèrement à gauche de l, mais que ce point n'ait pas été traité auparavant (n'a jamais figuré dans F.) Conséquence, l'intersection n'est pas reportée... l ε 2 k ε 26
Solutions pour la robustesse Travailler avec des données en entrée sous forme d'entiers, et calculer les intersection exactes sous forme de nombres rationnels Lent / réducteur! Augmenter la précision des calculs Une implémentation naïve (i.e. telle quelle) de l'algorithme de Bentley et Ottmann impose des calculs sur 5n bits pour un résultat exact sur n bits Boissonat & Preparata ont montré que l'on peut parvenir à faire les calculs sur 2n bits pour la même précision finale de n bits. Cf. Boissonat, J.-D.; Preparata, F. P. (2000), Robust plane sweep for intersecting segments, SIAM Journal on Computing 29 (5): 1401 1421 27
Erreur numérique Calcul de Erreur faite avec l'expression ( x+ y)( x y) x y x y = x y1 1 x y1 2 1 3 = x y x y1 1 2 3 1 2 2 3 1 3 1 2 3 5 Pas d'augmentation catastrophique de l'erreur x 2 y 2 =( x+ y)( x y) Erreur faite avec l'expression x 2 y 2 ( x x) ( y y) = [ x 2 (1+ δ 1 ) y 2 (1+ δ 2 )](1+ δ 3 ) = (( x 2 y 2 )(1+ δ 1 )+ (δ 1 δ 2 ) y 2 )(1+ δ 3 ) = (( x 2 y 2 )(1+ δ 1 + δ 3 + (δ 1 δ 2 ) y 2 + δ 1 δ 3 + (δ 1 δ 2 ) y 2 δ 3 )) Quand x est proche de y, l'erreur peut être de l'ordre de grandeur dur résultat calculé... 28
Erreur numérique Quelques règles utiles Préférer x y x y à Forme de Lagrange plus précise que le schéma de Horner E. g. somme d'un grand nombre de termes L'algorithme naïf : x 2 y 2 S=0; for (j=1;j<=n;j++){ S=S+X[j] ; } return S ; implique une erreur N L'algorithme de sommation compensée de Kahan S=X[1];C=0 for (j=2;j<=n;j++) { Y=X[j]-C; T=S+Y; C=(T-S)-Y; S=T } return S ; implique une erreur 2 N S = j=1 X [ j ] 29
Erreur numérique Exemple d'arrondi catastrophique nx*ny échatillons Calcul d'une intégrale y max S= Ω nx 1 ny 1 S i=0 j=0 f ( x, y)dxdy avec f ( x, y)=x 2 + y 2 f xi, y j det J y min dx=x max x min / nx dy= y max y min /ny xi =x min i dxdx/2 y j = y min j dydy/2 det J =dx dy y x x min x max 30
Erreur numérique Calculs fais avec les paramètres suivants : x min = y min = 0.0 ; x max = y max = 1.0 ; nx = ny = 10, S exact =2/3 1) Flottants simple précision (32 bits) 2) Flottants double précision (64/80 bits) 3) Flottants quadruple précision (128 bits) 4) Flottants simple précision avec la sommation compensée de Kahan bechet@yakusa:floating_error$./test 10 1) sum (float )=0.66500002145767211914 2) sum (double )=0.66500000000000025757 3) sum (ldouble)=0.66499999999999999997 4) sum (kahan )=0.66499999999999999997 Note : Le programme doit être compilé sans optimisation 31
Erreur numérique bechet@yakusa:floating_error$./test 10000 1) somme (float )=0.36836874 2) somme (double )=0.666666664999852 3) somme (ldouble)=0.66666666499999997715 4) somme (kahan )=0.66666657 bechet@yakusa:floating_error$./test 100000 1) somme (float )=0.00390625 2) somme (double )=0.666666666655411 3) somme (ldouble)=0.66666666665000055191 4) somme (kahan )=0.66666657 Algorithme de sommation compensée tiré de : William Kahan. Further remarks on reducing truncation errors. Comm. ACM, 8(1):40,1965. 32
Erreur numérique y=p(x)=(1-x) n pour x=1.333 et 2<n<41 S. Graillat, Ph. Langlois, N. Louvet Compensated Horner Scheme Research Report RR2005-04, LP2A, University of Perpignan, France, july 2005 33
Erreur numérique Définition du conditionnement d'une expression numérique Ratio entre l'erreur directe et l'erreur inverse K P, x=lim 0 y sup x D Pour un polynôme x sous forme monomiale: K P, x= i=0 n n i=0 a i x i a i x i x erreur δ x inverse x+δ x p p p y= p(x) δ y erreur directe y= p(x)= y+δ y = p(x+δ x) 34
Algorithme de balayage Paradigme utile dans un certain nombre de problèmes en CG Intersections de segments Diagrammes de Voronoï Triangulation de polygones M. I. Shamos and D. Hoey. Geometric intersection problems. In Proc. 17th Annu. IEEE Sympos. Found. Comput. Sci., pages 208 215, 1976. D. T. Lee and F. P. Preparata. Location of a point in a planar subdivision and its applications. SIAM J. Comput., 6:594 606, 1977. et référence précédente (J. L. Bentley and T. A. Ottmann) 35
Exercice : Tenter de trouver un algorithme incrémental pour l'intersection de segments? 36
Algorithmes par balayage Deux autres exercices Déterminer en T=O(nlogn) les segments (tous disjoints) visibles à partir d'un point. Non visible 37
Algorithmes par balayage Relier un ensemble de n triangles disjoints Chaque segment relie deux triangles Les segments sont disjoints (pas d'intersection excepté aux extrémités) et ils sont disjoints des bords des triangles (connectés en exactement un point) Donner les événements, les cas qui apparaissent et les actions à mener, les structures de données, et l'invariant de l'algorithme. 38