Computational Geometry - cadxfem.org tuple of characteristics : ... Relation d'Euler … pour les graphes plans

1

Computational Geometry

Course outline

Introduction

Line intersections

Polygon triangulation

Geometric search

Voronoï diagrams

Delaunay Triangulations

Binary Space Partition Trees

2


Line intersections

Line segments intersectionsPolygonal zones intersections

Plane sweeping / DCEL

3


Line intersections

Classical problem in GIS

Example :

One has access to several independent maps : Forestry Wildlife etc...

One wishes to know every homogeneous zones for every tuple of characteristics :

e.g. deciduous forest & deerspine forest & deerspne forest & bears … and so forth.

4


Line intersections

Types of data that are contained in maps : Towns (as points or polygons) Rivers, highways (networks, graphs) Wooden areas, or of a given climate (polygones)

One needs to combine 2 or more of these maps, therefore compute intersections

Two maps with networks → points (bridges ?) Two maps with areas (zones) → new polygons Any combination...

One common task (elementary task) is the intersection between two sets of line segments.

5


Line intersections

Line segments intersections

6


Line intersections

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.

7


Line intersections

Algorithme 1 Force brute : prendre chaque paire de segments et

vérifier si ils s'intersectentO(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

exemple :

2n segmentsn² intersections

n2

8


Line intersections

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...

9


Line intersections

Soit 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

S={s1, s2, s3, ... , sn}

10


Line intersections

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 à jourC'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.

11


Line intersections

On teste donc tous les segments présents dans le statut. Est-ce optimal ?

Non !

Ici on teste un nombre quadratiquede paires de segments ...

12


Line intersections

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

13


Line intersections

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 si et s

j deviennent adjacents avant de traiter p

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.

sk

si

l

p

sj

si

Ici, si et s

j deviennent adjacents

losque sk est retiré du statut.

14


Line intersections

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

15


Line intersections

« Invariant » de l'algorithme : tous les points d'intersection à gauche de la ligne ont été calculés correctement.

16


Line intersections

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 …

17


Line intersections

Les algorithmes :TrouveIntersections(S)Entrée : un ensemble de segments S dans le planSortie : 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) }}

18


Line intersections

TraiteEvenement(p) doit être capable de traiter les cas dégénérés suivants :

ls

1

s2

s3

s5

s4

s6

s2

s1

T={s5, s

4, s

3, s

2, s

1} → T={s

5, s

1, s

2, s

6}

p

19


Line intersectionsTraiteEvenement(p) { Soit L(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 R(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(L(p),R(p),C(p)) contient plus d'un segment { p est une intersection, y attacher L(p),R(p),C(p) } Effacer les segments appartenant a Union(R(p),C(p)) de T Inserer les segments appartenant a Union(L(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(L(p),C(p)) est vide { Soit s

u et s

d les voisins du dessus et du dessous de p dans T

TrouverEvenement(su , s

d , p)

} Sinon { Soit s' le segment le plus haut dans Union(L(p),C(p)) Soit s

u le segment voisin (vers le haut) de s' dans T

Si su existe TrouverEvenement(s

u , s', p)

Soit s'' le segment le plus bas dans Union(L(p),C(p)) Soit s

d le segment voisin (vers le bas) de s'' dans T

Si sd existe TrouverEvenement(s'' , s

d , p)

} }

ls

1

s2

s3

s5

s4

s6

s2

s1

p

C(p)

L(p)

R(p)

20


Line intersections

TrouveEvenement(s1 , 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.}

21


Line intersections

Analyse de l'algorithmeL'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 L(p), et les segments R(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)

22


Line intersections

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(L( p ) , R( 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 2ne (nombre d'arêtes du graphe). n

v (nombre de sommets) est

au plus égal à 2n+I, Or, sur un graphe plan, ne= O(n

v), CQFD.

e2

e1

degré=4

23


Line intersections

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 nf ≤ 2n

e /3

Formule d'euler : nv – n

e+n

f = r avec r≥2

r dépend du genre topologique (nb de trous etc)

On a donc ne=O(n

v).

24


Line intersections

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.

25


Line intersections

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.

26


Line intersections

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...

ε

2kε

l

27


Line intersections

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

28


Numerical errors

Numerical errors Floating point calculations are (most of the time)

inaccurate Analysis of the rounding done during operations in

floating point :

Mathematically equivalent calculations but expressed differently give distinct results

An example with

x⊖ y=x− y 11 , ∣1∣≤2 x⊕ y= x y 12 , ∣2∣≤2

x2− y2=x yx− y

x⊗ y= xy13 , ∣3∣≤

29


Numerical errors

Error made with the expression

No catastrophic increase of the relative error Error made with the expression

When x is close to y, the error can be of the order of magnitude of the calculated result...

x2− y2

( x⊗ x)⊖( y⊗ y) = [ x2(1+ δ1)− y2(1+ δ2)](1+ δ3)= (( x2− y2)(1+ δ1)+ (δ1−δ2) y2)(1+ δ3)

x yx− y x⊕ y⊗x⊖ y = x− y 11x y1213= x y x− y 1123122313123≈ 5

= ((x2− y2)(1+ δ1+ δ3+ (δ1−δ2) y2+ δ1δ3+ (δ1−δ2) y2δ3))

30


Numerical errors

Some useful rules (not a comprehensive list !) Prefer to

Lagrange form more accurate than horner's scheme …

E. g. sum of many terms Naive algorithm :

involves an error Kahan's summation algorithm

involves an error

x2− y2x yx− y

S=0;for (j=1;j<=N;j++){ S=S+X[j] ; }return S ;

≈ N

S=X[1];C=0for (j=2;j<=N;j++) { Y=X[j]-C; T=S+Y; C=(T-S)-Y; S=T }return S ;

≈2

S=∑j=1

N

X [ j ]

31


Numerical errors

Example of catastrophic rounding Computation of an integral :

S=∫Ω

f (x , y)dxdy with f (x , y)=x2+ y2

xy

S≈∑i=0

nx−1

∑j=0

ny−1

f x i , y j det J

dx=xmax−xmin/nxdy= ymax− ymin/ny

x i =xmini dxdx /2y j = ymin j dydy /2

det J =dx dy

nx*ny samples

xmin

xmax

ymin

ymax

32


Numerical errors

Computations made with the following parameters:x

min= y

min= 0.0 ; x

max= y

max= 1.0 ; nx = ny = 10, S

exact=2/3

1) Single precision floating point numbers2) Double precision floating point numbers3) Quad precision floating point numbers4) Single precision floating points numbers with Kahan's summation algorithm

bechet@yakusa:floating_error$ ./test 101) sum (float )=0.665000021457672119142) sum (double )=0.665000000000000257573) sum (ldouble)=0.664999999999999999974) sum (kahan )=0.66499999999999999997

Note : Program should be compiled without optimization !

33


Numerical errors



34


Numerical errors



William Kahan. Further remarks on reducing truncation errors. Comm. ACM, 8(1):40,1965.

Compensated summation algorithm coming from :

35


Numerical errors

y=p(x)=(1-x)n for x=1.333 and 2<n<41

S. Graillat, Ph. Langlois, N. LouvetCompensated Horner SchemeResearch Report RR2005-04, LP2A, University of Perpignan, France, july 2005

36


Numerical errors

Definition of the condition number of a numerical expression

Ratio of the direct error to the inverse error

For a polynomial

under monomial form:

K P , x=lim 0

sup x∈D ∣ y∣

∣ x∣

K P , x=∑i=0

n

∣ai∣∣x∣i

∣∑i=0

nai x i∣

x y= p(x)

y= p(x)= y+δ y= p(x+δ x)

x+δ x

p

p

p

δ x

δ ydirecterror

inverseerror

37


Numerical errors

There are various compensated algorithms to carry out calculations on floating point numbers.

Ex. Kahan summation, Compensated Horner scheme ...

In general, they allow to have similar results as when using internal floating point with a precision twice that of the input data, following by a final rounding.

See references available on the course's website for the compensated Horner scheme.

38


Line intersections

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)

39


Line intersections

Exercice :

Tenter de trouver un algorithme incrémental pour l'intersection de segments ?

40


Sweeping line paradigm

Deux autres exercices Déterminer en T=O(nlogn) les segments (tous

disjoints) visibles à partir d'un point.

Non visible

41


Sweeping line paradigm

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.

Documents

Computational Geometry - cadxfem.org tuple of characteristics : ... Relation d'Euler … pour les graphes plans