Theorie und Praxis geometrischer Algorithmen Sweep Line Algorithmus Roman Adam

Einführung Gegeben: Liniensegmente si, dargestellt durch ihre linken und rechten Endpunkte li und ri mit 0  i  n.

Man betrachtet die Endpunkte und Schnittpunkte als Knoten eines Graphen und die Segmentabschnitte zwischen diesen Punkten als Kanten. Gesucht ist ein Algorithmus, der die Schnittpunkte berechnet und aus den Punkten und Segmenten einen Graphen aufbaut.

Konstruktion eines planaren Graphen: v L a R v` k` Man speichert die Kante a in einer speziellen Form ab: previous from to left right next k k` v v` L R

Einfach-Lösung: Alle Segmente paarweise auf Schnittpunkte testen, gefundene Schnittpunkte speichern und dann Graph berechnen. Problem: schlechte Laufzeit: O(n2) nicht besonders effizient, falls wenige Schnittpunkte man möchte den Graphen während der Schnittpunkt-Berechnung konstruieren

gesucht: Algorithmus, der nicht nur von der Anzahl der Segmente, sondern auch von der Anzahl der Schnittpunkte abhängt  Output - sensitiv Idee: Man braucht nur Segmente zu testen, die ‚nah‘ beieinander liegen. Aber was ist ‚nah‘?

Wir projezieren die Segmente auf die x-Achse y x Man sieht: Durch Projektion der Segmente auf die x-Achse erhält man einen Hinweis, ob zwei Segmente ‚nah‘ beieinander sind.

Idee: Man bewegt eine (imaginäre) Linie parallel zur y-Achse von links nach rechts.  Sweep Line („Fegelinie“) Man betrachtet nur die Segmente, die an einer bestimmten Stelle x diese Linie schneiden und testet die Segmente auf Schnitt, die nebeneinander liegen.  Aus einem statischen zweidimensionalen wird ein dynamisches eindimensionales Problem. Frage: Wie findet man heraus, welche Segmente die Sweep Line schneiden?

y x Die Sweep Line muss nur an diskreten Punkten, den Endpunkten der Segmente ‚anhalten‘. Man betrachtet die x-Achse als Zeitachse und bezeichnet einen solchen diskreten Punkt als Ereignis.

Diese Ereignisse werden in einer besonderen Datenstruktur gespeichert, der Ereignis- oder X-Struktur. Diese Datenstuktur wird also zu Beginn mit den Endpunkten der Segmente initialisert, die in aufsteigender Reihenfolge nach ihren x-Koordinaten geordnet sind. Wie werden die Segmente behandelt, die die Sweep Line schneiden? Die Segmente, die zu einem bestimmten Zeitpunkt die Sweep Line schneiden, werden in der Status- oder Y-Struktur gespeichert und zwar in aufsteigender Reihenfolge ihrer y-Koordinaten. Die Y-Struktur ist zu Beginn leer.

x1: s3, s1, s4, s2 x4: s3, s2,s5 x2: s3, s4, s2 x5: s2, s3,s5 y s5 s2 s4 s1 s3 x x1 x2 x3 x4 x5 x6

Sweep Line Algorithmus Voraussetzung: x-Koordinaten der Schnitt- und Endpunkte sind paarweise verschieden Länge der Segmente > 0 nur echte Schnittpunkte keine Linien parallel zur y-Achse keine Mehrfachschnittpunkte keine überlappenden Segmente

Beim Sweep können folgende Ereignisse eintreten, die die Ordnung der Segmente in der Y-Struktur verändern und eine Aktualisierung der X-Struktur erfordern: Die Sweep Line stösst auf den linken Endpunkt eines Liniensegments Die Sweep Line stösst auf den rechten Endpunkt eines Liniensegments Die Sweep Line stösst auf den Schnittpunkt zweier Liniensegmente

Wie soll man die Schnittpunkte kennen, wenn man sie doch suchen soll? Frage: Wie soll man die Schnittpunkte kennen, wenn man sie doch suchen soll? y s5 s2 s4 s1 p s3 x x2- x2 x1

kurz vor einem Schnittpunkt sind die beiden Segmente benachbart durch die Ordnung in der Y-Struktur kann man dies leicht erkennen Man muss zwei Liniensegmente sofort auf Schnitt testen, wenn sie in der Y-Struktur Nachbarn werden. Durch diesen Test, kann man alle Schnittpunkte spätestens kurz vor ihrem Auftreten erkennen. Lemma 1: Wenn zwei Liniensegmente einen echten Schnittpunkt haben, wo werden sie unmittelbar vorher direkte Nachbarn in der Ordnung längs der Sweep Line.

y s5 s2 s4 U(p) s1 p s3 x x1 x2- x2 Beweis: Sei p = (x2, y2) echter Schnittpunkt von s2 und s3. Weil nach Voraussetzung kein anderes Liniensegment den Punkt p enthält, gibt es ein  > 0, s.d. die Umgebung U(p) nur von s2 und s3 geschnitten wird => zu jedem Zeitpunkt x  (x2 - , x2) sind s2, s3 direkte Nachbarn in der Y-Struktur, spätestens nach dem letzten Ereignis vor Erreichen von p. 

Wie sind die Ereignisse zu behandeln? Linker Endpunkt: neues Segment s richtig in die Y-Struktur einfügen s mit Vorgänger si und Nachfolger sk auf Schnitt testen gefundenen Schnittpunkt als zukünftiges Ereignis an der richtigen Stelle in die X-Struktur einfügen sk s si

Segment s aus Y-Struktur entfernen Rechter Endpunkt: Segment s aus Y-Struktur entfernen Vorgänger si und Nachfolger sk sind jetzt selbst Nachbarn und werden sofort auf Schnitt getestet. sk s si

der alte Vorgänger von si (sh) ist jetzt Vorgänger von sk Schnittpunkt: die beiden Linien si und sk, die sich schneiden, vertauschen ihre Position in der Y-Struktur der alte Vorgänger von si (sh) ist jetzt Vorgänger von sk der alte Nachfolger von sk (sm) ist jetzt Nachfolger von si somit müssen sk mit sh und si mit sm auf einen gemeinsamen Schnittpunkt getestet werden sm sk si sh

Sweep-Line-Algorithmus initialisiere die Ereignis-Struktur mit den schon bekannten Ereignissen, den Endpunkten der Segmente, geordnet nach aufsteigender x-Koordinate initialisiere die (leere) Y-Struktur nimm das erste Ereignis aus der X-Struktur und behandele es wie angegeben lies solange Ereignisse und behandle sie wie angegeben, bis die X-Struktur leer ist

/* Initialisierung */ Init(); /* Sweep und Konstruktion des Graphen */ while( X  0 ) { Ereignis := NächstesEreignis( X); switch( Ereignis) { case LinkerEP: FügeEin(Y, Seg); VSeg := Vorg( Y, Seg); TesteSchnittErzeugeEreignis( VSeg, Seg); NSeg := Nachf( Y, Seg); TesteSchnittErzeugeEreignis( Seg, NSeg); case RechterEP: VSeg := Vorg( Y, Seg); Entferne( Y, Seg); TesteSchnittErzeugeEreignis( VSeg, NSeg); case Schnittpunkt: Vertausche( Y, USeg, OSeg); VSeg := Vorg( Y, OSeg); TesteSchnittErzeugeEreignis( VSeg, OSeg); NSeg := Nachf( Y, USeg); TesteSchnittErzeugeEreignis( USeg, NSeg); }

insert, lookup, delete, search: O(Höhe) = O(log n) Die X-Struktur und die Y-Struktur können als balancierter binärer Suchbaum implementiert werden. Aufbau: O(n log n) insert, lookup, delete, search: O(Höhe) = O(log n) Korrektheit: Die Korrektheit des beschriebenen Sweep Line Algorithmus unter den angegebenen Voraussetzungen folgt aus Lemma 1. Laufzeit: Lemma: Mit dem angegebenen Verfahren kann man die k echten Schnittpunkte von n Liniensegmenten in Zeit O((n+k)log n) berechnen.

Beweis: Der Algorithmus beginnt mit der Konstruktion der X-Struktur Beweis: Der Algorithmus beginnt mit der Konstruktion der X-Struktur. Ist diese als balancierter binärer Suchbaum implementiert, benötigt dies O(n log n) Zeit. Dann werden die Ereignisse abgearbeitet. Insgesamt gibt es 2n+k Ereignisse. Weil keines von ihnen mehrfach in der X-Struktur vorkommt (das Einfügen eines schon vorhandenen Ereignisses wird nicht erlaubt), sind niemals mehr als O(n2) Ereignisse in der Ereignis-Struktur gespeichert. Jeder Zugriff auf die Ereignis-Struktur ist also in Zeit O(log n2) = O(log n) ausführbar. Die while-Schleife wird (2n+k)-mal durchlaufen; bei jedem Durchlauf werden konstant viele Operationen auf der X- oder der Y-Struktur durchgeführt. 

(am Beispiel LEDA) Line Sweep für degenerierte Segmente Um gleiche x-Koordinaten für die Ereignis-Punkte zuzulassen, ändern wir den Aufbau der Sweep Line: Wir definieren die Sweep Line durch einen Punkt p_sweep = (x_sweep, y_sweep). Die Sweep Line L ist nun ein vertikal aufsteigender Strahl bis zum Punkt (x_sweep + 2, y_sweep + ), gefolgt von einem horizontalen Teil bis zum Punkt (x_sweep – 2, y_sweep + ), gefolgt von einem vertikal steigenden Strahl.

L e b h s4 s5 s7 i a s9 s3 s2 f g p_sweep Man beachte, dass kein Endpunkt irgendeines Segmentes auf L liegt, dass keine zwei Segmente L im gleichen Punkt schneiden, ausser sie überlappen sich und dass kein nicht-vertikales Segment den horizontalen Teil von L schneidet. s1 s6 c s8 d

Aufbau X-Struktur Die X-Struktur enthält einen Eintrag für jeden Endpunkt rechts der Sweep Line und einen Eintrag für jeden Schnittpunkt zwischen Segmenten, die in der Y-Struktur benachbart sind. Jeder Eintrag enthält zudem einen Link auf einen Eintrag in der Y-Struktur oder nil. Ist das Ereignis ein rechter Endpunkt, so zeigt der Link auf das zugehörige Segment. Ist es ein Schnittpunkt, so zeigt der Link auf eines der Segment, die sich in diesem Schnittpunkt schneiden. Bei einem linken Endpunkt, ist der Link nil.

L e b h s4 s5 s7 i a s9 s3 s2 f g p_sweep s1 s6 c s8 d X-Struktur: <a,sit4>,<b,sit4>,<c,sit1>,<d,nil>,<e,sit9>,<f,sit1>,<g,sit2>,<h,sit3>,<i,sit1>

Aufbau Y-Struktur Die Y-Struktur enthält neben dem Segment, dass die Sweep Line schneidet, einen Verweis auf ein anderes Element, dass an der gleichen Stelle die Sweep Line berührt (überlappende Segmente) oder einen Verweis auf einen Schnittpunkt (also ein Ereignis in der X-Struktur), falls solche vorhanden sind, sonst nil. Die Leda-Funktion hat zudem zwei Elemente + und – als Begrenzer der Struktur nach oben und unten. Ordnung in der Y-Struktur Die Segmente werden in lexikographischer Ordnung sortiert. Überlappende Segmente werden nach ihrer ID-Nummer sortiert.

Y-Struktur <s3,nil> <s4,xita> <s9,nil> e b h Y-Struktur <s3,nil> <s4,xita> <s9,nil> <s2,nil> <s8,xitf> <s1,sit8> s4 s5 s7 i a s9 s3 s2 f g p_sweep s1 s6 c s8 d X-Struktur: <a,sit4>,<b,sit4>,<c,sit1>,<d,nil>,<e,sit9>,<f,sit1>,<g,sit2>,<h,sit3>,<i,sit1>

Die Abarbeitung eines Ereignisses p, also eines Knotens geschieht nun so: Füge einen Knoten v an Position p zum Ausgabe-Graph. Erstelle aus allen Segmenten in der Y-Struktur, die die Sweep Line in p schneiden, eine Substruktur, die möglicherweise leer ist. Füge für jedes Segment in der Substruktur eine Kante zum Graphen hinzu. Lösche alle Segmente, die in p enden, aus der Y-Struktur. Aktualisiere die Ordnung in der Substruktur der Y-Liste, dabei werden überlappende Segmente nach ihrer ID geordnet. Dies kann als bewegen der Sweep Line über den Punkt p hinaus angesehen werden. Füge alle Segmente zur Y-Struktur, die in p beginnen. Erzeuge Ereignisse für alle Segmente in der Y-Struktur, die durch die letzten Aktionen Nachbarn geworden sind, teste also auf Schnitt und aktualisiere die Verkettung von X- und Y-Struktur.

(v,u1),(v,u2),(v,u4),(v,u3),(v,u5) Y-Struktur <+,nil> <s1,nil> <s2,xitv> <s4,xitv> <s5,xitv> <s3,sit5> <-,nil> s1 v s2 s5 s4 s3 (v,u1),(v,u2),(v,u4),(v,u3),(v,u5) Durch die Verbindung von X- und Y-Struktur werden die m eingehenden Knoten vom Leda-Sweep in O(m) abgearbeitet.

Laufzeit: O((n+s)log(n+m)+m) n = Zahl der Segmente s = Zahl der Knoten m = Zahl der Kanten (n+s) Schleife über alle Ereignisse log(n+m) Operationen im Suchbaum m Bearbeitung der Substruktur