Theorie und Praxis geometrischer Algorithmen

Roman Adam

Sweep Line Algorithmus

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:

L

R

k

a

v

v`k`

Man speichert die Kante a in einer speziellen Form ab:

previousk`k

L

from

v

leftto

v`

right

R

next

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‘?

y

x

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

Wir projezieren die Segmente auf die x-Achse

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.

y

x

x1

s4

s1

s2

s3

s5

x2 x3 x4 x5 x6

x1: s3, s1, s4, s2

x2: s3, s4, s2

x3: s3, s2

x4: s3, s2,s5

x5: s2, s3,s5

x6: s2, s5,s3

Sweep Line AlgorithmusVoraussetzung:• 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:

(1) Die Sweep Line stösst auf den linken Endpunkt eines Liniensegments

(2) Die Sweep Line stösst auf den rechten Endpunkt eines Liniensegments

(3) Die Sweep Line stösst auf den Schnittpunkt zweier Liniensegmente

y

x

x1

x2- x2

s4

s1

s2

s3

s5

p

Frage:

Wie soll man die Schnittpunkte kennen, wenn man sie doch suchen soll?

• 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

xx1 x2- x2

s4

s1

s2

s3

s5

U(p)p

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

si

sk

s

Rechter Endpunkt:

• Segment s aus Y-Struktur entfernen

• Vorgänger si und Nachfolger sk sind jetzt selbst Nachbarn und werden sofort auf Schnitt getestet.

si

sk

s

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

sh

si

sk

sm

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);NSeg := Nachf( 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);

}}

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

Line Sweep für degenerierte Segmente

(am Beispiel LEDA)

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

a

d

f

e

c

g

b h

i

p_sweep

s2

s3

s1

s7

s4

s6

s5

s9

s8

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.

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

a

d

f

e

c

g

b h

i

p_sweep

s2

s3

s1

s7

s4

s6

s5

s9

s8

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.

L

a

d

f

e

c

g

b h

i

p_sweep

s2

s3

s1

s7

s4

s6

s5

s9

s8

X-Struktur: <a,sit4>,<b,sit4>,<c,sit1>,<d,nil>,<e,sit9>,<f,sit1>,<g,sit2>,<h,sit3>,<i,sit1>

Y-Struktur

<s3,nil>

<s4,xita>

<s9,nil>

<s2,nil>

<s8,xitf>

<s1,sit8>

Die Abarbeitung eines Ereignisses p, also eines Knotens geschieht nun so:

1. Füge einen Knoten v an Position p zum Ausgabe-Graph.2. Erstelle aus allen Segmenten in der Y-Struktur, die die Sweep Line

in p schneiden, eine Substruktur, die möglicherweise leer ist.3. Füge für jedes Segment in der Substruktur eine Kante zum Graphen

hinzu.4. Lösche alle Segmente, die in p enden, aus der Y-Struktur.5. 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.

6. Füge alle Segmente zur Y-Struktur, die in p beginnen.7. 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

s1

s2

s3s4

s5

Y-Struktur

<+,nil>

<s1,nil>

<s2,xitv>

<s4,xitv>

<s5,xitv>

<s3,sit5>

<-,nil>Durch die Verbindung von X- und Y-Struktur werden die m eingehenden Knoten vom Leda-Sweep in O(m) abgearbeitet.

(v,u1),(v,u2),(v,u4),(v,u3),(v,u5)

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