Seminar und Proseminar - WS 2007/2008

Seminar und Proseminar
- WS 2007/2008 Perlen der Theoretischen Informatik
Friedhelm Meyer auf der Heide
Kontakt
Friedhelm Meyer auf der Heide
Universität Paderborn
Institut für Informatik und Heinz Nixdorf Institut
Fürstenallee 11
33102 Paderborn
email: [email protected]
Vorwort
In diesem Seminar/Proseminar soll anhand einer Reihe ausgewählter Aufsätze und LehrbuchAbschnitte die Schönheit von Problemlösungen aus dem Bereich der Theoretischen Informatik demonstriert werden und gezeigt werden, dass die Beschäftigung mit raffinierten Beweistechniken, eleganten Argumenten und überraschenden Konstruktionen höchst vergnüglich
ist. Inspiriert wird dieses Seminar durch das Buch "Perlen der Theoretischen Informatik",
BI Wissenschaftsverlag 1995, von Uwe Schöning (Unibibliothek 41TVA2403, 60TVA2411) ,
in dem er eine Sammlung von Ergebnissen vorstellt, die seiner Meinung nach Highlights der
Theoretischen Informatik darstellen. Natürlich wird die Themenauswahl unseres Seminars
durch den Geschmack der Themensteller und ihrer Arbeitsgebiete geprägt sein.
Aufbau des Seminars/Proseminars
Ziel des Seminars ist die Aufbereitung aktueller Forschungsarbeiten. Zur Auswahl stehen
die unten aufgeführten Arbeiten. Die Veranstaltung besteht aus einem Seminar und einem
Proseminar, d.h. entweder erwirbt man einen Seminarschein oder einen Proseminarschein.
Jedes Thema wird als Pärchen vergeben, das aus einem Proseminarvortrag und einem Seminarvortrag besteht. Der Proseminarvortrag stellt die Grundlagen für den dazugehörigen
Seminarvortrag bereit.
Teilnehmerinnen und Teilnehmer des Seminars
Thema: Cell to Cell Visibility in PVS
Systemen
Seminar: Andre Gärtner
Betreuung: Ralf Petring
Seminar: Markus Heberling
Betreuung:
Morteza Monemizahdeh
Thema: Dynamische Hashingverfahren
Seminar: Marco Müller
Betreuung: Mario Mense
Thema: Peer to Peer Netzwerke
Proseminar: Andreas Vogelsang
Seminar: Marc Borowski
Betreuung: Peter Mahlmann
Thema: Wegeberechnung für Roboter in
2D-Umgebungen
Proseminar: Michael Kionka
Seminar: Benjamin Eikel
Betreuung: Matthias Fischer
Thema: Kinetische Datenstrukturen
Proseminar: Peter Kling
Seminar: Sabine Naewe
Betreuung: Bastian Degener
Thema: Geometrische Spanner
Proseminar:
Jasmin Kovac-Engelmeier
Seminar: Philipp Wissneth
Betreuung:
Christiane Lammersen
Thema: Clustering
Proseminar: Holger Bürger
Thema: Dynamische Steinerbäume
Proseminar: Linda Röhrkohl
Seminar: Holger Hagedorn
Betreuung: Jan Mehler
Thema: Globale Sichtbarkeit in 3D Szenen
Proseminar: Michael Kruse
Seminar: David Schmelter
Betreuung: Claudius Jähn
Inhaltsverzeichnis
Teil I Proseminar
Wegberechnung für Punktroboter mittels Trapezierung
Michael Kionka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
Der Einsatz von Bereichsbäumen zur Beantwortung von orthogonalen
Bereichsanfragen
Jasmin Kovač-Engelmeier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
„A Simple Linear Time (1+ε)-Approximation Algorithm for k-Means
Clustering in Any Dimensions“ für k = 2
Holger Bürger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37
Skalierbare Peer-to-Peer-Netzwerke
Andreas Vogelsang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
49
Eine Einführung in kinetische Datenstrukturen
Peter Kling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
Linda Röhrkohl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
87
Aspektgraphen und Verdeckung
Michael Kruse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Teil II Seminar
Cell to Cell Visibility in PVS Systemen
André Gärtner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Hohe Verfügbarkeit in skalierbaren verteilten Hashingdateien mit
Mirroring
Marco Müller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen in
2D-Umgebungen
Benjamin Eikel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
XII
Inhaltsverzeichnis
Konstruktion von geometrischen Spannern mit geringem Durchmesser
Philipp Wissneth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Ein einfacher, linearer (1+) - Approximationsalgorithmus für das
k-Means Clustering Problem
Markus Heberling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Peer-to-Peer Netzwerke: Skip-Graph
Marc Borowski . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
Kinetische Datenstrukturen für zweidimensionale Probleme
Sabine Naewe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Dynamische Steinerbäume
Holger Hagedorn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Approximationen und Alternativen für Aspektgraphen
David Schmelter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Teil I
Proseminar
Wegberechnung für Punktroboter mittels Trapezierung
Michael Kionka
Universität Paderborn [email protected]
Zusammenfassung. Das Wegberechnungsproblem für Roboter ist ein aktuelles Thema in der algorithmischen Geometrie und Robotik und hat über die Jahre bereits viel Beachtung in der Forschung erfahren.
Mit dieser Ausarbeitung soll ein erster Einblick in das insgesamt sehr komplexe Thema gegeben werden.
Untersuchungsgegenstand ist ein Punktroboter, der sich translatorisch in einer statischen, vorher bekannten
2D-Umgebung zwischen polygonen Hindernissen kollisionsfrei bewegen soll. Die vorgestellte Lösung beruht
auf dem Verfahren der Trapezierung. Es wird gezeigt, dass für den Punktroboter Wegberechnungen zwischen
zwei Positionen in O(n) Zeit, wobei n die Gesamtanzahl der Kanten der Hindernisse bezeichnet, möglich
sind. Hierfür sind einmalige Vorberechnungen für den Raum nötig, die erwartete Zeit O(n log n) benötigen.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2
Raumdefinitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
3
Trapezierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
3.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
9
4
Wegberechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.1 initiale Berechnungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4.2 Pfadberechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.1 Bewertung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1 Einleitung
Die Bedeutung von Robotern nimmt in der heutigen Zeit immer mehr zu. Neben den rein
technischen bzw. mechanischen Anforderungen, stellen sich auch Anforderungen an die verwendete Steuerungslogik. Ein wesentlicher Punkt ist hierbei die Bewegungsplanung. Roboter
müssen sich sicher bewegen können ohne durch Kollision mit anderen Objekten Schaden zu
nehmen.
Die Ausarbeitung setzt an diesem Punkt an. Die gestellten Fragen sind hierbei konkret:
• Existiert für den Roboter ein kollisionsfreier Weg zwischen zwei Punkten
4
Michael Kionka
• Falls ja, wie lautet dieser Weg
Das hierfür betrachtete Szenario sieht wie folgt aus:
Gegeben ist ein so genannter Punktroboter. Dies bedeutet, dass der Roboter keine Ausdehnung besitzt, sondern nur als Punkt dargestellt wird. Diese Einschränkung ist zwar nicht
realistisch, dient aber dazu, die Betrachtung nicht unnötig kompliziert zu machen. Auf die
grundlegenden Vorgehensweisen hat sie keinen Einfluss. Dieser Punktroboter kann sich nur
translatorisch bewegen. Dies bedeutet, dass er sich nicht drehen kann bzw. seine Orientierung nicht ändern kann. Bei Punktrobotern ist die Unterscheidung der Bewegungsarten
zunächst unerheblich für die Wegberechnung, sie ist aber von Bedeutung bei einer möglichen
Erweiterung auf konvexe Roboter.
Weiterhin ist ein 2-dimensionaler Raum gegeben. In ihm befinden sich disjunkte, polygone Hindernisse. Diese Hindernisse sind ausschließlich statisch und zu Beginn der Berechnungen bekannt. Die Umgebung des Roboters wird sich also im betrachteten Zeitraum nicht
verändern.
Die Aufgabe besteht nun darin, für den Punktroboter Wege zwischen beliebigen Punkten
zu berechnen und auszugeben, falls diese Wege existieren. Der Fokus liegt hierbei ausschließlich auf dem Finden von existenten Wegen, nicht jedoch auf dem Angeben von kürzesten
Wegen.
In dieser Ausarbeitung wird angenommen, dass es für einen Roboter erlaubt ist, ein Hindernis zu berühren. Es ist aber sicherlich nicht verkehrt, allgemein ein zu nahes Vorbeifahren
an einem Hindernis zu vermeiden, um mögliche Fehler in einer Robotersteuerung abzufangen. Um dieses zu Erreichen, könnte man zu Beginn alle Hindernisse minimal vergrößern.
Die Berechnungen der vorgestellten Lösung lassen sich in zwei Teile aufteilen. Zunächst
werden einige Vorberechnungen für den Raum stattfinden, die die eigentlichen Wegberechnungen vereinfachen sollen. Anschließend können, aufbauend auf den Ergebnissen, beliebig
viele Weganfragen bearbeitet werden. Aus dieser grundsätzlichen Lösungstruktur ergibt sich,
dass sie insbesondere dann sinnvoll ist, wenn die zu Beginn gegebene Raumumgebung für
möglichst viele Anfragen bestehen bleibt. In diesem Fall lohnen sich die initialen Vorberechnungen.
Diese Ausarbeitung orientiert sich dabei inhaltlich an den Kapiteln 6 und 13 in [1]. Die
verwendeten Abbildungen sind ebenfalls an die dort verwendeten Abbildungen angelehnt.
Bei dem Buch handelt es sich um eine Zusammenstellung verschiedener Themen der algorithmischen Geometrie. Die zu Grunde liegenden Arbeiten stammen von Mulmuley [2] und
Seidel[3] im Bereich des Trapezierungs-Verfahrens. Die Ideen zur free space - Berechnung
basieren auf den Arbeiten von Kedem et al.[4][5].
Im nächsten Kapitel werden zunächst einige grundlegende Begriffe geklärt. Hierbei wird
die Einschränkung auf Punktroboter kurz aufgehoben, da einige wichtige Begriffe im Umfeld der Roboter-Wegberechnung nicht unerwähnt bleiben sollen, aber an Punktrobotern
nicht sinnvoll erklärt werden können.
Wegberechnung für Punktroboter mittels Trapezierung
5
2 Raumdefinitionen
Zunächst geht es darum, festzulegen, wie die Position des Roboters im Raum beschrieben
werden kann und wie der Raum an sich dargestellt wird.
Im Folgenden sei R der Roboter, der sich in seiner Umgebung, die wir work space nennen
werden, bewegt. In dieser Umgebung befindet sich weiterhin eine Menge von Hindernissen
H= {P 1 , . . . , P t }.
Um die aktuelle Position des Roboters beschreiben zu können, führen wir den Begriff
des Referenzpunktes eines Roboters ein. Dies ist ein festgelegter Punkt, der sinnvoller-,
aber nicht notwendigerweise, innerhalb des Roboterpolygons liegt. Wir beschreiben ihn mit
R(x,y), wobei x und y die Koordinaten im 2–dimensionalen Raum darstellen. Der Referenzpunkt liegt für R(0,0) per Definition im Ursprung. Um nun die aktuelle Roboterposition
darstellen zu können, geben wir für die momentane Position des Roboters, die derzeitigen
Koordinaten seines Referenzpunktes an.
Allgemein hängt die Anzahl der Parameter, die nötig sind, um die Platzierung eines
Roboters im Raum eindeutig angeben zu können, von der Anzahl seiner Freiheitsgrade ab.
In diesem Fall kann der Roboter sich in zwei Dimensionen translatorisch bewegen, daher
ergibt sich die benötigte Anzahl von zwei Parametern. Würde sich der Roboter zum Beispiel
im 3–dimensionalen Raum translatorisch bewegen können, so wären drei Parameter nötig.
Allgemein wird pro Freiheitsgrad des Roboters ein weiterer Parameter benötigt.
Im work space wird die tatsächliche Form des Roboters dargestellt. Da in dieser Ausarbeitung nur Punktroboter betrachtet werden, stellt dies hier kein Problem dar. Allgemein
ist diese Darstellung für Berechnungen jedoch nicht sinnvoll. Für die Berechnungen definiert
man daher als Repräsentation den sogenannten configuration space, kurz C(R), in dem der
Roboter nur noch als Punkt (sein Referenzpunkt) dargestellt wird. Ein Punkt im configuration space entspricht also einer Platzierung des Roboters im work space und umgekehrt.
Den configuration space müssen wir genauer definieren. Da wir in unserem Raum Hindernisse haben, sind nicht alle Positionierungen des Roboters im configuration space erlaubt.
Genauer formuliert sind die Positionierungen nicht erlaubt, bei denen der Roboter ein Hindernis schneidet. Diese bezeichnen wir als forbidden (configuration) space, kurz, C f orb (R, H).
Den verbleibenden Raum, der gültige Positionierungen beschreibt, nennen wir free (configuration) space, kurz, C f ree (R, H).
Bei Punktrobotern entsprechen sich der work space und der configuration space.1 Weiterhin stellen die Hindernisse im work space genau den forbidden space des configuration
space dar.
Allgemein haben Roboter jedoch eine Ausdehnung, die im configuration space verloren
geht. Um die reale Situation im allgemeinen Fall dennoch korrekt darzustellen, müssen somit die Hindernisse angepasst werden. Sie müssen entsprechend der Form des Roboters
vergrößert werden. Veranschaulicht beschrieben ergeben sich die neuen Formen, indem man
mit dem Referenzpunkt des Roboters die Kanten der Hindernisse entlang fährt und den
dabei überstrichenen Bereich dem jeweiligen Hindernis als zusätzliche Ausdehnung zuordnet. Die so entstandenen vergrößerten Hindernisse bezeichnet man als configuration-space
1
unter der sinnvollen Annahme, dass der Referenzpunkt des Roboters dem Punkt des Roboters entspricht
6
Michael Kionka
obstacle oder kurz C-obstacle. Abbildung 1 zeigt ein Beispiel hierfür. Auf die entsprechende
Berechnung wird in der Ausarbeitung auf Grund des Fokus auf Punktroboter verzichtet.
work space
configuration space
Referenzpunkt
Cobstacle
Abb. 1. work space und configuration space
3 Trapezierung
In diesem Kapitel soll eine Datenstruktur vorgestellt werden, die uns später helfen wird eine
Repräsentation des free space zu erstellen. Bei dieser Datenstruktur handelt es sich um die
sogenannte Trapezierung. Die Trapezierung des free space wird uns folgende Vorteile bieten.
Zum einen werden wir den free space in kleinere, trapezförmige und damit konvexe Flächen
aufgeteilt haben, in denen der Roboter sich sicher von einem beliebigen zu einem anderen
beliebigen Punkt mit einer geradlinigen Bewegung bewegen kann, ohne gegen ein Hindernis
zu stoßen. Zum anderen werden wir durch den Trapezierungs-Algorithmus eine Suchstruktur
erzeugt bekommen, mit der wir leicht die Start- und Zielposition der Roboterbewegungen
in der Repräsentation finden können.
3.1 Grundlagen
Für eine Trapezierung gehen wir als Eingabe von einer Menge S von n sich nicht schneidenden Liniensegmenten aus, die eine Fläche in kleinere, polygone Flächen trennt. Bei uns
wird diese Trennung später zwischen free space und forbidden space bestehen. Mittels der
Trapezierung werden die polygonen Flächen dann in trapezförmige, konvexe Flächen aufgeteilt.
Normallage
In dieser Ausarbeitung werden zwei Vereinfachungen angenommen, die die Behandlung erleichtern. Eine Erweiterung auf den allgemeinen Fall kann in [1] in Kapitel 6.3 nachgelesen
werden.
Wegberechnung für Punktroboter mittels Trapezierung
7
Zunächst wird um die Liniensegmente eine umgebene Hülle konstruiert, um die am Rand
liegenden Flächen zu beschränken. Dies geschieht in Form eines achsen-parallelen Rechtecks,
welches die gesamte betrachtete Fläche einschließt.
Die zweite Einschränkung stellt sich schwerwiegender, weil weniger realistisch, dar. Es
wird angenommen, dass keine zwei verschiedenen Endpunkte von Liniensegmenten die gleiche x-Koordinate haben. Hieraus ergibt sich die wenig realistische Folgerung, dass es keine
vertikalen Liniensegmente geben darf. Weiterhin ist es unwahrscheinlich, dass es allgemein
keine Endpunkte von verschiedenen Segmenten gibt, die auf Grund einer eingeschränkten
Genauigkeit, die gleiche x-Koordinate besitzen.
Zusammengefasst bezeichnen wir eine solche Menge S von n sich nicht schneidenden
Liniensegmenten, die von einer umgebenen Hülle umschlossen sind und für die gilt, dass
keine zwei verschiedenen Endpunkte die gleiche x-Koordinate haben, als Menge von Liniensegmenten in Normallage.
Struktur einer Trapezierung
Die Trapezierung einer entsprechenden Eingabemenge entsteht, indem von den beiden Endpunkten eines jeden Liniensegmentes jeweils eine vertikale Linie nach oben und nach unten
erzeugt wird, die bis zum Berührpunkt mit einem anderen Segment oder dem äußeren Rechteck verläuft. Diese Linien bezeichnen wir als obere bzw. untere vertikale Erweiterung des
entsprechenden Endpunktes. Abbildung 2 zeigt beispielhaft eine solche Trapezierung.
Abb. 2. Beispiel für eine Trapezierung
Nicht-vertikale Seiten von so entstandenen Trapezen können nur aus Segmenten und den
beiden horizontalen Seiten des äußeren Rechtecks bestehen. Wir bezeichnen das Segment
bzw. die Seite des Rechtecks, die ein Trapez ∆ von oben bzw. unten begrenzt als top(∆)
bzw. bottom(∆).
Auf Grund der angenommenen Normallage können vertikale Seiten von Trapezen nur
vertikale Erweiterungen von Segmentendpunkten oder eine der beiden vertikalen Ränder
8
Michael Kionka
des Rechtecks sein. Insgesamt sind für die linke und die rechte Seite eines Trapezes jeweils
fünf verschiedene Fälle möglich.
Für die linke Seite sehen sie wie folgt aus:
(1)Die linke Seite entartet zu einem Punkt, der der gemeinsame Endpunkt von top(∆) und
bottom(∆) ist.
(2)Es ist die untere vertikale Erweiterung des linken Endpunktes von top(∆), die bis zum
Berühren von bottom(∆) verläuft.
(3)Es ist die obere vertikale Erweiterung des linken Endpunktes von bottom(∆), die bis zum
Berühren von top(∆) verläuft.
(4)Es ist die obere und untere vertikale Erweiterung eines rechten Endpunktes eines weiteren
Segmentes, bis sie top(∆) bzw. bottom(∆) berühren.
(5)Es ist die linke Ecke des äußeren Rechtecks. Dieser Fall beschreibt die Situation für das
am weitesten links liegende Trapez der Trapezierung.
Die Fälle gelten entsprechend angepasst für die rechte Seite eines Trapezes.
Die interessanten Fälle ((1)-(4)) sind in Abbildung 3 dargestellt.
top(Δ)
leftp(Δ)
leftp(Δ)
top(Δ)
top(Δ)
top(Δ)
leftp(Δ)
bottom(Δ)
(1)
bottom(Δ)
(2)
bottom(Δ)
leftp(Δ)
(3)
bottom(Δ)
(4)
Abb. 3. Vier mögliche Entstehungen für die linke Seite eines Trapezes
Wie man sieht, gilt für alle Trapeze, abgesehen vom am weitesten links liegenden, dass die
linke Seite des Trapezes durch den linken Endpunkt von top(∆) bzw. bottom(∆) oder durch
den rechten Endpunkt eines weiteren Segmentes definiert wird. Diesen Punkt bezeichnen
wir im Folgenden mit lef tp(∆). Für das am weitesten links liegende Trapez definieren wir,
dass der Punkt lef tp(∆) der unteren linken Ecke des Rechtecks entspricht. Entsprechende
Definitionen gelten auch für die rechte Seite des Trapezes, wo der entsprechende Punkt mit
rightp(∆) bezeichnet wird.
Für die spätere Verwendung soll bereits hier festgehalten werden, dass ein Trapez ∆
durch top(∆), bottom(∆), lef tp(∆) und rightp(∆) eindeutig festgelegt ist.
Lemma 1. Die Anzahl der enthaltenen Trapeze in der Trapezierung T (S) für eine Menge
S von n Liniensegmenten und damit die Komplexität der Trapezierung ist O(n).
Beweis. Es folgt ein direkter Beweis mittels lef tp(∆). Jedes Trapez hat einen solchen Punkt
lef tp(∆), wobei dieser der Endpunkt einer der n Segmente oder die linke, untere Ecke des
umschließenden Rechtecks ist. Betrachtet man die vorgestellten fünf Fälle für die linke Seite eines Trapezes, so ergibt sich folgendes: Die linke untere Ecke des Rechtecks entspricht
Wegberechnung für Punktroboter mittels Trapezierung
9
lef tp(∆) für genau ein Trapez. Ein rechter Endpunkt eines Segmentes entspricht lef tp(∆)
maximal für ein Trapez. Ein linker Endpunkt eines Segmentes entspricht lef tp(∆) für maximal zwei Trapeze. (Ein Punkt in der Fläche kann die Rolle von lef tp(∆) für mehrere
Trapeze spielen, da Endpunkte von Segmenten sich überdecken können. Wenn man Fall a)
aber genauer betrachtet, so kann lef tp(∆), angenommen als Endpunkt eines der Segmente,
die Rolle lef tp(∆) nur für das über und das unter dem Segment liegende Trapez und damit für maximal zwei Trapeze annehmen.) Die Anzahl an Trapezen beträgt also maximal
3n + 1.
t
u
3.2 Algorithmus
Für die Berechnung einer Trapezierung gibt es verschiedene algorithmische Ansätze. Im
Folgenden wird ein randomisierter inkrementeller Algorithmus in seiner grundsätzlichen
Vorgehensweise beschrieben. Genauere Details hierzu finden sich in [1] in Kapitel 6.2.
Für die Eingabe der Liniensegmente wird als Datenstruktur eine doppelt-verkettete Liste
gewählt.
Die Idee des Algorithmus ist es, zunächst von einem einzigen Trapez (dem umschließenden Rechteck) auszugehen und dann schrittweise durch Hinzufügen der einzelnen Segmente
eine Trapezierung aufzubauen. Parallel hierzu wird eine Suchstruktur erzeugt, mit deren
Hilfe für einen beliebigen Punkt q leicht ermittelt werden kann, in welchem Trapez er liegt.
Der Aufbau dieser Datenstrukturen soll nun etwas genauer beschrieben werden:
In der Trapezierungs-Datenstruktur werden Datensätze für alle Segmente und ihre Endpunkte gespeichert. Weiterhin gibt es Datensätze für die Trapeze, wobei diese nicht das
Trapez an sich, sondern Verweise auf top(∆), bottom(∆), lef tp(∆) und rightp(∆) speichern. Wie oben beschrieben, reichen diese aus, um ein Trapez eindeutig zu definieren und
damit, um mit ihnen die genauen Kanten und Ecken des Trapezes zu bestimmen. Dieses
ist in konstanter Zeit möglich. Für die einzelnen Trapeze werden außerdem Verweise auf
die rechten und linken Nachbartrapeze gespeichert, so dass die Trapeze insgesamt netzartig
verbunden sind.
Die Suchstruktur ist als Graph aufgebaut, der aus inneren Knoten und Blattknoten besteht. Für jedes Trapez gibt es genau einen diesem entsprechenden Blattknoten. Die inneren
Knoten bestehen noch einmal aus zwei verschiedenen Knotentypen (x-Knoten, y-Knoten),
die jeweils Entscheidungsknoten darstellen und genau zwei Ausgangskanten besitzen. Die
x-Knoten speichern jeweils Endpunkte von Segmenten, die y-Knoten die Segmente an sich.
Beim Durchlaufen des Graphen auf der Suche nach dem Trapez, in dem sich q befindet,
stellen sich an den Entscheidungsknoten dann folgende Fragen, die über die anschließend
gewählte Ausgangskante entscheiden:
Beim x-Knoten geht es darum, ob der Punkt q auf der rechten oder linken Seite einer durch
den Segmentendpunkt, der im Knoten gespeichert ist, gezeichneten Linie liegt.
Beim y-Knoten entscheidet sich der weitere Weg dadurch, ob der Punkt q oberhalb oder
unterhalb des im Knoten gespeicherten Segmentes liegt.
Schließlich sind die Trapezierung und die Suchstruktur noch miteinander verlinkt. Die
Verlinkung besteht in beidseitigen Verweisen vom Datensatz eines Trapezes in der einen
Datenstruktur zum Datensatz des gleichen Trapezes in der anderen Datenstruktur.
Der Algorithmus sieht formal wie folgt aus:
10
Michael Kionka
Algorithmus 1 Trapezierung
Eingabe: Menge S von n sich nicht schneidenden Liniensegmenten
Ausgabe: Trapezierung T (S) und Suchstruktur D für T (S)
1: Bestimme ein Rechteck, in dem alle Liniensegmente von S liegen
2: Initialisiere Trapezierung T und Suchstruktur D
3: Bestimme eine zufällige Permutation s1 , . . . , sn der Elemente von S
4: for i = 1 . . . n do
5:
Finde ∆0 , ∆1 , . . . , ∆k der Trapeze in T , die von si geschnitten werden
6:
Entferne ∆0 , ∆1 , . . . , ∆k aus T und ersetze sie durch die durch die Einfügung von si entstandenen
Trapeze
7:
Entferne die Blätter für ∆0 , ∆1 , . . . , ∆k aus D, erzeuge neue Blätter für die neuen Trapeze und füge
sie korrekt in D ein
Die Korrektheit des Algorithmus erfolgt auf dieser Abstraktionsebene direkt aus seiner
Schleifeninvariante, die wie folgt lautet:
Sei S i definiert als S i := {s1 , s2 , . . . , si }, wobei i die Schleifenvariable meint. Dann ist T eine
korrekte Trapezierung für S i und D ist eine gültige Suchstruktur für T .
Die Laufzeit werden wir erst später angeben, da sie sich direkt aus den folgenden Untersuchungen ergeben wird.
Die am Ende erhaltene Trapezierung ist immer gleich, unabhängig von der in Schritt 3
erzeugten Permutation der Liniensegmente. Die Komplexität der Suchstruktur und die Laufzeit einer Suche auf dieser sind jedoch abhängig von der erzeugten Permutation der Segmente. Da der Algorithmus intern auch mit der Suchstruktur arbeitet (siehe [1], Seite 130), hängt
auch seine Laufzeit von der Permutation ab. Im worst-case hat die Datenstruktur quadratische Größe und eine lineare Suchzeit2 . Allerdings gibt es auch Permutationen, bei denen
sich deutlich bessere Werte ergeben. Interessant sind somit die erwartete 3 Komplexität, die
erwartete Suchzeit und daraus folgend die erwartete Ausführungszeit des Algorithmus, die
im Folgenden bestimmt werden sollen.
Theorem 1. Berechne Algorithmus Trapezierung eine Trapezierung für eine Menge S von
n Liniensegmenten in Normallage und eine zugehörige Suchstruktur. Die erwartete Laufzeit
für eine Suchanfrage für einen beliebigen Punkt q beträgt dann O(log n).
Beweis. Sei q der Punkt, für den eine Suchanfrage ausgeführt werden soll, beliebig aber fest.
Die Ausführungszeit für eine solche Anfrage ist linear bezogen auf die Länge des zugehörigen
Pfades im Suchgraphen.
Die maximale Länge des Pfades entspricht der Tiefe von D. Da die Tiefe von D in
jedem Iterationsschritt um maximal 3 zunimmt (siehe [1], Seite 131–133), ist 3n eine obere
Schranke für die Suchanfrage für q.
Man betrachte nun aber die erwartete Suchzeit. Untersucht man den Suchpfad von q, so
wurde jeder der Knoten auf diesem Pfad in einem Iterationsschritt des Algorithmus erzeugt.
Bezeichne Xi , 1 ≤ i ≤ n, die Anzahl an Knoten auf dem Pfad, die in Iterationsschritt i hinzugefügt wurden. Da S und q als fest angenommen sind, ist Xi eine Zufallsvariable, welche
2
3
Begründung wird in den folgenden Beweisen gegeben
der Durchschnitt, der sich über alle n! möglichen Permutationen ergibt
Wegberechnung für Punktroboter mittels Trapezierung
11
nur von der zufälligen Einfügereihenfolge der Segmente abhängt. Die erwartete Pfadlänge
kann nun wie folgt angegeben werden:
n
n
X
X
E[
Xi ] =
E[Xi ]
i=1
i=1
Da in einem Iterationsschritt die Tiefe des Suchgraphen um maximal 3 zunimmt, wird auch
der Suchpfad für q maximal um 3 länger, also gilt Xi ≤ 3. Bezeichnet Pi die Wahrscheinlichkeit, dass es einen in Iteration i erzeugten Knoten auf dem Suchpfad von q gibt, so
folgt:
E[Xi ] ≤ 3Pi
Um Pi nach oben zu beschränken, hilft folgende Beobachtung: Ein Knoten wurde genau
dann in Iteration i zum Suchpfad von q hinzugefügt, wenn ∆q (S i−1 ), das Trapez, welches q
in T (S i−1 ) enthält, nicht das gleiche ist, wie ∆q (S i ). Formal geschrieben:
Pi = P r[∆q (Si ) 6= ∆q (Si−1 )]
Wenn ∆q (S i ) und ∆q (S i−1 ) nicht identisch sind, muss ∆q (S i ) in Iteration i entstanden
sein. Alle Trapeze ∆, die in Iteration i entstanden sind, grenzen an das in dieser Iteration
eingefügte Segment si ; entweder top(∆) oder bottom(∆) ist si , oder lef tp(∆) oder rightp(∆)
sind ein Endpunkt von si .
Man betrachte nun eine beliebige, aber feste Menge S i ⊂ S. Die Trapezierung T (S i )
und damit insbesondere ∆q (S i ) ist allein als Funktion von S definiert. ∆q (S i ) hängt also
nicht von der Reihenfolge ab, in der die Segmente von S i eingefügt wurden. Um die Wahrscheinlichkeit, dass sich das q enthaltene Trapez durch Einfügen von si geändert hat, nach
oben zu beschränken, benutzt man die Technik der Rückwärtsanalyse: Betrachte T (S i ) und
untersuche die Wahrscheinlichkeit, dass ∆q (S i ) aus der Trapezierung verschwindet, wenn
Segment si entfernt wird. ∆q (S i ) verschwindet nur genau dann aus der Trapezierung, wenn
top(∆q (S i )), bottom(∆q (S i )), lef tp(∆q (S i )) oder rightp(∆q (S i )) durch das Entfernen von
si verschwinden (siehe oben). Man untersuche jetzt die Wahrscheinlichkeit, dass top(∆q (S i ))
verschwindet. Da alle Segmente von S i in zufälliger Reihenfolge eingefügt wurden, ist für
jedes Element die Wahrscheinlichkeit gleich hoch si zu sein. Also ist die Wahrscheinlichkeit,
dass si = top(∆q (S i )) gilt, 1/i. 4 Entsprechendes gilt für bottom(∆q (S i )).
Es kann mehrere Segmente geben, die als Endpunkt den Punkt lef tp(∆q (S i )) haben. Daher kann die Wahrscheinlichkeit, dass si eines dieser Segmente ist, groß sein. Allerdings verschwindet lef tp(∆q (S i )) nur, wenn si das einzige Segment von S i ist, welches lef tp(∆q (S i ))
als Endpunkt besitzt. Dementsprechend ist auch für lef tp(∆q (S i )) die Wahrscheinlichkeit
maximal 1/i, dass er verschwindet. Gleiches gilt für rightp(∆q (S i )). Zusammenfassend ergibt sich somit:
Pi = P r[∆q (Si ) 6= ∆q (Si−1 )] = P r[∆q (Si ) ∈
/ T (Si−1 )] ≤ 4/i
Für die erwartete Laufzeit der Suchanfrage folgt abschließend:
n
n
n
n
X
X
X
X
1
12
= 12
= 12Hn
E[
Xi ] ≤
3Pi ≤
i
i
i=1
4
i=1
i=1
i=1
Falls top(∆q (S i )) die obere Kante des äußeren Rechtecks ist, ist die Wahrscheinlichkeit 0.
12
Michael Kionka
Hn entspricht hierbei der n-ten Harmonischen Zahl, die wie folgt definiert ist:
Hn :=
1 1 1
1
+ + + ... +
1 2 3
n
Für n > 1 gilt:
ln n < Hn < ln n + 1
Somit ergibt sich für eine Suchanfrage für einen beliebigen Punkt q die erwartete Laufzeit
O(log n).
t
u
Theorem 2. Berechne Algorithmus Trapezierung eine Trapezierung für eine Menge S von
n Liniensegmenten in Normallage und eine zugehörige Suchstruktur. Die erwartete Größe
der Suchstruktur D beträgt dann O(n).
Beweis. Es genügt die Anzahl von Knoten in D anzugeben, um die Größe der Suchstruktur
zu beschränken. Die Blätter von D gehören alle zu genau einem Trapez der Trapezierung
und jedes Trapez besitzt genau ein Blatt in D, so dass die Anzahl der Blätter der Anzahl der
Trapeze entspricht, welche durch O(n) beschränkt ist (siehe Lemma 1). Für die Gesamtzahl
von Knoten ergibt sich somit:
O(n) +
n
X
(Anzahl innerer Knoten, die in Iteration i erzeugt wurden)
i=1
Sei ki die Anzahl an Trapezen, die in Iteration i neu erzeugt wurden. ki entspricht somit der
Anzahl der neuen Blätter in D. Die Anzahl neuer innerer Knoten entspricht genau ki − 1
(siehe [1], Seite 131–133).
Eine einfache obere Schranke für die worst-case Größe der Suchstruktur ergibt sich aus
der Tatsache, dass offensichtlich nicht mehr Trapeze in Iteration i neu erzeugt werden können, als insgesamt in der Trapezierung T (S i ) vorhanden sind. Dies entspricht O(i). Somit
folgt für die obere Schranke:
O(n) +
n
X
O(i) = O(n2 )
i=1
Aber nun zurück zum eigentlichen Beweis. Für die erwartete Größe gilt zunächst
n
n
X
X
O(n) + E[ (ki − 1)] = O(n) +
E[ki ]
i=1
i=1
Es muss also noch E[ki ] beschränkt werden. Man betrachte eine feste Menge S i ⊂ S. Für
ein Trapez ∆ ∈ T (S i ) und ein Segment s ∈S i , sei
1, f alls ∆ aus T (Si ) verschwindet, wenn s aus Si entf ernt wurde
δ(∆, s) :=
0, sonst
Im Beweis zu Theorem 1 zeigte sich, dass es maximal 4 Segmente gibt, die zum Verschwinden
eines Trapezes führen können. Es folgt also
X X
δ(∆, s) ≤ 4|T (Si )| = O(i)
s∈Si ∆∈T (Si )
Wegberechnung für Punktroboter mittels Trapezierung
13
Für ki gilt nun zusätzlich, dass es die Anzahl Trapeze in T (S i ) angibt, die verschwinden,
wenn Segment si entfernt wird. Da si ein zufälliges Element aus S i ist, kann der Durchschnitt
über alle s ∈S i für E[ki ] herangezogen werden:
E[ki ] =
1X
i
X
δ(∆, s) ≤
s∈Si ∆∈T (Si )
O(i)
= O(1)
i
Die erwartete Anzahl von neuen Trapezen in jeder Iteration des Algorithmus ist also O(1).
Insgesamt folgt somit eine erwartete Größe der Suchstruktur von O(n).
t
u
Es fehlt nun noch eine Laufzeitbeschränkung für den eigentlichen Algorithmus.
Theorem 3. Algorithmus Trapezierung berechnet eine Trapezierung T (S) für eine Menge
S von n Liniensegmenten in Normallage und eine Suchstruktur D für T (S) in O(n log n)
erwarteter Zeit.
Beweis. Die Permutation der Elemente von S benötigt O(n) Zeit (siehe [1], Kapitel 4, Seite
78). Für eine Ausführung des Schleifenrumpfes, was dem Einfügen eines Segmentes entspricht, ergibt sich Folgendes: Das Suchen der betroffenen Trapeze in Schritt 5 benötigt
unter Zurhilfenahme der Suchstruktur von T (S i−1 ) O(log i) Zeit (siehe [1], Seite 130f.), wobei i den i-ten Schleifendurchlauf bzw. das i-te eingefügte Segment meint. Das Aktualisieren
der Trapezierung und der Suchstruktur benötigt O(ki ) Zeit (siehe [1], Seite 131–133). Mit
der im Beweis zu Theorem 2 erhaltenen Grenze für ki ergibt sich somit insgesamt
O(n) +
n
X
{O(log i) + O(E[ki ])} = O(n log n)
i=1
für die Laufzeit von Algorithmus Trapezierung.
t
u
4 Wegberechnung
In diesem Kapitel wird beschrieben wie die Wegberechnung im Detail abläuft. Sie lässt sich in
zwei Teilbereiche unterscheiden, die in zwei Unterkapiteln dargestellt werden. Zunächst muss
aus den bekannten Informationen über den Bewegungsraum eine Repräsentation eben dessen
konstruiert werden, deren Datenmenge nicht zu komplex wird, die aber gleichzeitig später
eine schnelle Wegfindung ermöglicht. Dies geschieht vor der eigentlichen Wegberechnung. In
einem zweiten Schritt kann nun jedes mal, wenn ein neuer Weg berechnet werden soll, auf
die bereits erstellte Repräsentation zurückgegriffen werden und auf dieser der WegfindungsAlgorithmus ausgeführt werden.
4.1 initiale Berechnungen
In diesem Unterkapitel sollen Datenstrukturen konstruiert werden, die eine schnelle Wegfindung ermöglichen. Hierfür werden wir zunächst eine Repräsentation für den free space
angeben.
14
Michael Kionka
Berechnung des Free Space
Um die Handhabung angenehmer zu machen, begrenzen wir den Bewegungsraum des Roboters durch ein ausreichend großes Rechteck B, in dessen Innerem die Hindernisse liegen und
in dem sich der Roboter bewegen wird. Den Bereich außerhalb des Rechtecks interpretieren
wir als großes Hindernis. Durch diese Raumbeschränkung begrenzen wir den Bewegungsfreiraum des Roboters jedoch nicht stärker als in realen Situationen, da auch dort irgendwann
natürliche Grenzen gegeben sind, so dass die Ergebnisse unserer Berechnungen nicht verfälscht sind. Der free space besteht
Stnun aus dem Inneren des Rechtecks ohne die Hindernisse.
Formal geschrieben: C f ree = B\ i=1 P i
Unsere Repräsentation berechnen wir unter Verwendung der im letzten Kapitel vorgestellten
Technik der Trapezierung. Die Eingabe besteht aus der Menge der disjunkten, polygonen
Hindernisse, genauer gesagt aus Polygonzügen, die jeweils die Kanten eines dieser Hindernisse beschreiben. Die Segmente im Trapezierungs-Algorithmus stellen dementsprechend die
Kanten der Hindernisse dar. Als Datenstruktur wird eine doppelt-verkettete Liste für die
Kanten verwendet.
Die Berechnung sieht algorithmisch dann wie folgt aus:
Algorithmus 2 BerechneFreeSpace
Eingabe: H= {P 1 , . . . , P t } als Menge von disjunkten Polygonen
Ausgabe: Trapezierung von C f ree (R,H) inklusive Suchstruktur D für Punktroboter R
1: Sei E die Menge von Kanten der Polygone in H
2: Berechne Trapezierung T (E) und Suchstruktur D mittels Trapezierung(E)
3: Entferne die Trapeze, die innerhalb der Polygone liegen, aus T (E) und D
4: Ausgabe der resultierenden Trapezierung und Suchstruktur
Schritt 3, also das Entfernen der Trapeze, die innerhalb der Hindernisse liegen, kann
dabei wie folgt realisiert werden: Nach der Trapezierung ist für jedes Trapez bekannt, durch
welche Kante es von oben begrenzt wird (top(∆)) und zu welchem Polygon/Hindernis diese
Kante gehört. Um nun zu entscheiden, ob das entsprechende Trapez entfernt werden muss,
reicht es aus zu testen, ob die Kante das Hindernis von oben oder von unten begrenzt. Wird
ein Trapez gefunden, das innerhalb eines Hindernisses liegt, so werden seine Daten aus der
Trapezierung entfernt. Weiterhin wird das Trapez in der Suchstruktur als nicht vorhanden markiert, damit bei einer Punktsuche festgestellt werden kann, dass der entsprechende
Punkt im forbidden space liegt.
Abbildung 4 zeigt noch einmal die sich nach Schritt 2 und 3 ergebenden Trapezierungen.
Es folgt eine Analyse der Laufzeit des Algorithmus:
Sei n die Anzahl an Segmenten/Hinderniskanten. Die Trapezierung benötigt dann O(n log n)
erwartete Zeit. Der Test, ob ein Trapez innerhalb eines Hindernisses liegt, benötigt nur konstante Zeit, da die Kanten der Hindernisse in der Reihenfolge ihres Vorkommens entlang
der Hindernisgrenze sortiert sind, so dass bekannt ist, auf welcher Seite der Kanten der
Hindernisinnenraum liegt.
Die erhaltenen Datenstrukturen, also die Trapezierung T (C f ree ) und die Suchstruktur D
haben nach Lemma 1 und Theorem 2 beide eine Komplexität von O(n).
Wegberechnung für Punktroboter mittels Trapezierung
15
Abb. 4. Trapezierungen von BerechneFreeSpace vor und nach Schritt 3
Damit ergibt sich folgendes Lemma:
Lemma 2. Sei R ein Punktroboter. Sei H eine Menge von disjunkten, polygonen Hindernissen, wobei n die Gesamtanzahl ihrer Kanten ist. R bewegt sich zwischen diesen Hindernissen. Die Trapezierung des free space benötigt dann O(n log n) erwartete Zeit. Die erhaltenen
Datenstrukturen haben eine Komplexität von O(n).
Wegkarte
Um die Wegberechnung zu vereinfachen, konstruieren wir uns eine weitere Datenstruktur.
Wenn sich sowohl Start- als auch Zielposition im gleichen Trapez befinden, besteht der Weg
aus einer einfachen direkten Bewegung von der Start- zur Zielposition. Auf Grund unserer
vorherigen Definitionen ist garantiert, dass sich auf diesem Weg kein Hindernis befindet. Viel
häufiger wird es aber vorkommen, dass Start- und Zielposition in unterschiedlichen Trapezen liegen. Um die Wegberechnung in diesem Fall zu vereinfachen, erzeugen wir uns einen
Graph als Wegkarte, die uns Wege beschreibt, auf denen wir uns leicht zwischen verschiedenen Trapezen bewegen können. Hierbei nutzen wir aus, dass zwei benachbarte Trapeze
immer eine gemeinsame vertikale Kante besitzen, die durch eine vertikale Erweiterung eines
Segmentendpunktes entstanden ist. Die Knoten des Graphen wählen wir nun wie folgt. Wir
nehmen zum einen den Mittelpunkt jeden Trapezes und zum anderen jeweils die Mitte jeder
vertikalen Erweiterung als Knoten. Die Kanten legen wir jeweils von jedem Trapezmittelpunkt zu den Mittelpunkten der begrenzenden vertikalen Erweiterungen. Auf diese Weise
entsteht jeweils ein Weg von der Mitte eines Trapezes zu den Mitten der angrenzenden Trapeze über die zwischen ihnen liegende vertikale Begrenzung, der aus zwei translatorischen
Bewegungen besteht. Eine Veranschaulichung der Wegkarte ist in Abbildung 5 gegeben. Die
Konstruktion dieser Wegkarte aus den in der Trapezierung enthaltenen Informationen ist in
Zeit O(n) möglich.
Für die Komplexität der Wegkarte gilt:
Der Graph besitzt einen Knoten pro Trapez und jeweils einen Knoten für jede vertikale
Erweiterung. Sowohl die Anzahl an vertikalen Erweiterungen als auch die Anzahl an Tra-
16
Michael Kionka
pezen ist linear bezogen auf die Gesamtanzahl der Ecken der Hindernisse. Diese wiederum
ist linear bezogen auf die Anzahl der Kanten der Hindernisse.
Die Anzahl an Kanten im Graph ist ebenfalls linear, da er planar ist. Dies folgt aus dem
eulerschen Polyedersatz.
Insgesamt folgt also, dass die Komplexität der Wegkarte durch O(n) beschränkt ist.
ziel
vziel
start
pziel
vstart
pstart
Abb. 5. Wegkarte und Wegkomponenten des vollständigen Weges
4.2 Pfadberechnung
In diesem Unterkapitel wird der eigentliche Wegberechnungs-Algorithmus vorgestellt.
Durch die initialen Berechnungen besitzen wir eine Trapezierung des free space (inklusive Suchstruktur) und eine auf dieser aufsetzende Wegkarte. Ziel ist es nun mit Hilfe dieser
Datenstrukturen einen Weg von einem Startpunkt pstart zu einem Zielpunkt pziel zu finden
und, falls dieser existiert, diesen zu berechnen und auszugeben.
Liegen pstart und pziel im gleichen Trapez, ergibt sich der Weg wie beschrieben als direkte Bewegung zwischen ihnen. Ansonsten lässt sich ein existierender Weg aus drei Teilen
zusammensetzen; dabei bezeichne vstart und vziel die Knoten im Wegkartengraphen, die in
der Mitte von ∆start und ∆ziel liegen:
Wegberechnung für Punktroboter mittels Trapezierung
17
1. Eine direkte Bewegung von pstart zum Wegkartenknoten vstart in der Mitte von ∆start .
2. Eine Bewegung entlang der Wegkarte von vstart zu vziel . (Berechnung über Breitensuche
im Wegkartengraphen möglich)
3. Eine direkte Bewegung vom Wegkartenknoten vziel in der Mitte von ∆ziel zu pziel .
Falls kein Weg zwischen pstart und pziel existiert, so gibt es hierfür zwei mögliche Gründe:
• Einer der Punkte pstart und pziel liegt nicht im free, sondern im forbidden space.
• Beide Punkte liegen zwar im free space, aber zwischen ihnen liegt nicht umgehbarer
forbidden space.
Der vollständige Algorithmus sieht dann wie folgt aus:
Algorithmus 3 BerechnePfad
Eingabe: Trapezierung T (C f ree ) mit Suchstruktur D, Wegkarte G road , Positionen pstart , pziel
Ausgabe: Weg von pstart zu pziel , falls einer existiert, sonst entsprechend negative Meldung
1: Finde ∆start und ∆ziel
2: if ∆start oder ∆ziel nicht existent then
3:
Ausgabe, dass pstart oder pziel in C f orb liegen
4: else
5:
Sei vstart der Wegknoten in der Mitte von ∆start
6:
Sei vziel der Wegknoten in der Mitte von ∆ziel
7:
Berechne den Weg in G road von vstart zu vziel mittels Breitensuche
8:
if es existiert kein Weg then
9:
Ausgabe, dass kein solcher Weg existiert
10:
else
11:
Ausgabe des Weges pstart 7→ vstart
vziel 7→ pziel
Beweis. Um die Korrektheit des Algorithmus zu beweisen, müssen zwei Dinge gezeigt werden.
• Jeder Weg, der ausgegeben wird, ist kollisionsfrei.
• Wenn ein kollisionsfreier Weg existiert, wird er auch gefunden.
zu 1. Ausgegebene Wege befinden sich immer innerhalb von Trapezen. Da aber alle Trapeze
zum C f ree gehören, der nach Definition kollisionsfreie Positionen angibt, muss ein ausgegebener Weg kollisionsfrei sein.
zu 2. Angenommen, es gibt einen kollisionsfreien Weg von pstart nach pziel . Damit müssen
pstart und pziel in Trapezen des free space liegen. Es muss also noch gezeigt werden, dass
es einen Weg von vstart nach vziel in G road gibt. Dieser Weg muss eine Folge von Trapezen
schneiden. Bezeichne die Folge von Trapezen mit ∆1 , ∆2 , . . . , ∆k , wobei nach Definition
∆1 = ∆start und ∆k = ∆ziel gilt. Sei vi der Knoten von G road , der in der Mitte von ∆i
liegt. Wenn der Weg von ∆i nach ∆i+1 geht, dann müssen die beiden Trapeze Nachbarn
sein und sich damit eine vertikale Erweiterung teilen. Aber G road ist so konstruiert, dass
die Knoten solcher Trapeze über den Knoten ihrer gemeinsamen Grenze verbunden sind.
Also gibt es einen Weg in G road von vi nach vi+1 . Daraus folgt, dass es auch einen Weg von
v1 nach vk bzw. vstart nach vziel gibt. Einen solchen Weg findet eine Breitensuche, die auf
G road ausgeführt wird.
t
u
Nachdem die Korrektheit des Algorithmus nachgewiesen ist, folgt nun eine Analyse seiner
Laufzeit:
18
Michael Kionka
Das Suchen der Trapeze in Schritt 1 kann mittels der Suchstruktur erfolgen, die während
der Trapezierung des free space erzeugt wird. Es benötigt somit O(log n) erwartete Zeit und
maximal O(n) Zeit. Das Berechnen eines Weges in Graphen mittels Breitensuche benötigt
lineare Zeit bezogen auf die Größe des Graphen. Wie gezeigt ist die Größe des Graphen
durch O(n) beschränkt. Somit benötigt die Breitensuche O(n) Zeit. Die benötigte Zeit zur
Ausgabe des Weges ist begrenzt durch die maximale Anzahl an Kanten auf dem Weg, welche
O(n) ist.
Insgesamt benötigt der Algorithmus also eine Laufzeit von O(n).
Unsere Untersuchungen lassen sich in einem abschließenden Theorem zusammenfassen.
Theorem 4. Sei R ein Punktroboter. Sei H eine Menge von disjunkten, polygonen Hindernissen, wobei n die Gesamtanzahl ihrer Kanten ist. R bewegt sich zwischen diesen Hindernissen. H lässt sich in erwarteter Zeit von O(n log n) so aufbereiten, dass ein kollisionsfreier
Weg zwischen Start- und Zielposition für R in O(n) berechnet werden kann, falls er existiert.
Die erzeugten Datenstrukturen haben dabei eine Komplexität von O(n).
5 Zusammenfassung
5.1 Bewertung
Die in dieser Ausarbeitung vorgestellte Methode der Wegberechnung für einen Roboter
mittels Trapezierung liefert wie gezeigt zulässige Wege, wenn sie existieren. Sie garantiert
jedoch keine kürzesten Wege. Genauer gesagt wird sie auf Grund ihrer Herangehensweise
fast nie kürzeste Wege liefern. Dies ist bereits in der in Abbildung 5 dargestellten Situation erkennbar. Für ein extremeres Beispiel kann man als Start- und Zielpunkt die beiden
unteren Ecken wählen. Es ergibt sich ein unnötig komplizierter Weg, wie in Abbildung 6
veranschaulicht ist.
Aus diesem Grund muss man die Vorgehensweise als nicht realitäts-tauglich einstufen.
Niemand wird akzeptieren, dass ein Roboter Zick-Zack-Linien fährt, obwohl eine geradlinige Bewegung möglich wäre. Bei den Zick-Zack-Bewegungen handelt es sich um ein ansatzbedingtes Problem, welches sich daher mit diesem Ansatz kaum vermeiden lassen wird. Eine
gewisse Verbesserung ist jedoch auch beim gezeigten Ansatz noch möglich. Die Wegfindung
in der Wegkarte G road beruht auf Breitensuche. Daher wird bei mehreren zulässigen Wegen,
derjenige Weg gewählt, der die wenigsten Knoten besitzt. Dies ist jedoch nicht zwingend
sinnvoll, da nicht von gleichen Entfernungen zwischen den einzelnen Knoten ausgegangen
werden kann. Deutlich besser wäre es daher, für jede Kante im Graphen ein Kantengewicht anzugeben, das die jeweilige Länge beschreibt und dann einen kosten-optimierenden
Algorithmus anzuwenden.
5.2 Ausblick
Soll das Problem von einem Punktroboter, wie hier betrachtet, auf konvexe Roboter erweitert werden, so können die vorgestellten Algorithmen weitgehend beibehalten werden. Da
sich nun aber der work space und der configuration space unterscheiden, gestaltet sich die
Wegberechnung für Punktroboter mittels Trapezierung
19
ziel
start
vziel
vstart
pziel
pstart
Abb. 6. Beispiel für eine schlechte Wegberechnung
Berechnung des free space aufwändiger. Die Berechnung benötigt nun O(n log2 n) erwartete Zeit, wobei die Komplexität des free space weiterhin linear bleibt. Auch die eigentliche
Wegberechnungszeit beträgt weiterhin O(n). Die Berechnung und die Schranken werden in
[1] in Kapitel 13.3 und 13.4 vorgestellt und bewiesen. Mit einem verbesserten Algorithmus
kann die free space-Berechnungszeit jedoch auch wieder auf O(n log n) gesenkt werden.
Sollen auch Rotationsbewegungen erlaubt sein, so gestalten sich die Berechnungen wiederum komplizierter. Eine mögliche Erweiterung hierfür wird in Kapitel 13.5 in [1] beschrieben.
Neben dem hier vorgestellten Verfahren mittels Trapezierung, existieren weitere Verfahren,
die insbesondere auch optimale Lösungen garantieren. Ein Beispiel für ein solches Verfahren
unter Verwendung so genannter gerahmter quadtrees, wird im Seminarbeitrag vorgestellt.
Literaturverzeichnis
1. de Berg M, van Kreveld M, Overmars M, Schwarzkopf O (2000) Computational Geometry, Algorithms
and applications, 2nd Edition Springer, Berlin Heidelberg New York
2. Mulmuley K (1990) A fast planar partition algorithm. In: Journal of Symbolic Computation 10:253–280
3. Seidel R (1991) A simple and fast incremental randomized algorithm for computing trapezoidal decompositions and for triangulating polygons. Comput. Geom. Theory Appl. 1:51–64
20
Michael Kionka
4. Kedem K, Livne R, Pach J, Sharir M (1986) On the union of Jordan regions and collision-free translational motion amidst polygonal obstacles. Discrete Comput. Geom. 1:59–71
5. Kedem K, Sharir M (1985) An efficient algorithm for planning collision-free translational motion of a
convex polygonal object in 2-dimensional space amidst polygonal obstacles. In: Proc. 1st Annu. ACM
Sympos. Comput. Geom. 75–80
Der Einsatz von Bereichsbäumen zur Beantwortung von
orthogonalen Bereichsanfragen
Jasmin Kovač-Engelmeier
Universität Paderborn
Zusammenfassung. Unter einer orthogonalen Bereichsanfrage versteht man die Suche nach den Punkten
einer gegebenen Punktmenge in einem d-dimensionalen Raum, die in einem achsenparallelen definierten
Bereich liegen. Ein mögliches Anwendungsgebiet für orthogonale Bereichsanfragen ist die Realisierung von
Datenbankanfragen. So wird jede Tabellenspalte als eine Dimension interpretiert, und jede Tabellenzeile als
ein Punkt in dem entsprechenden d-dimensionalen Raum. Für die 1-dimensionale Bereichssuche kann auf die
Datenstruktur eines binären balancierten Suchbaums zurückgegriffen werden. Im Fall der 2-dimensionalen
oder auch mehrdimensionalen Bereichssuche bieten sich Bereichsbäume als eine Datenstruktur an. Wie
diese Datenstrukturen genutzt werden können, um orthogonale Bereichsanfragen zu unterstützen, wird in
der vorliegenden Arbeit erörtert.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2
Orthogonale Bereichsanfragen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3
1-dimensionale Bereichssuche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4
Bereichsbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5
Mehrdimensionale Bereichsbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
6
Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1 Einleitung
Das Problem, orthogonale Bereichsanfragen effizient zu beanworten, spielt nicht nur innerhalb der Geometrie eine wichtige Rolle. So kann diese Fragestellung z.B. konkret auf
Datenbankanfragen übertragen werden, wenn jeder Datensatz als ein Punkt in einer Ebene
bzw. in einem mehrdimensionalen Raum interpretiert wird. Aus einer Menge von Datenstrukturen, die das Beantworten von orthogonalen Bereichsanfragen unterstützen können,
fiel im Rahmen der vorliegenden Proseminararbeit die Wahl auf Bereichsbäume1 .
In dem folgenden Kapitel wird zunächst der Begriff einer orthogonalen Bereichsanfrage
anhand eines Anwendungsbeispiels näher erläutert. Es gilt dann in den darauffolgenden
Kapiteln ausführlich zu beschreiben, wie binäre balancierte Suchbäume die 1-dimensionale
1
Die folgenden Ausführungen orientieren sich primär an [1].
22
Jasmin Kovač-Engelmeier
Bereichssuche und schließlich Bereichsbäume die 2- bzw. mehrdimensionale Bereichssuche
unterstützen können.
2 Orthogonale Bereichsanfragen
Auf den ersten Blick scheint es fraglich, ob und wie die Geometrie für Datenbankanfragen
genutzt werden kann. Wenn nun aber jede der n Spalten einer Datenbank als eine Dimension
und jede Zeile als ein Punkt in einem entsprechenden d-dimensionalen Raum interpretiert
wird, so kann die Suche nach einem Datenbankeintrag durch die Suche nach dem korrespondierenden Punkt im d-dimensionalen Raum simuliert werden.
Ein anschauliches Beispiel aus der Praxis ist die Mitarbeiterliste, welche von der Personalabteilung eines Unternehmens erstellt wird. In der Datenbank ist von jedem Mitarbeiter der Name, die Adresse, das Geburtsdatum, das Gehalt usw. gespeichert. Aus welchen
Gründen auch immer kann es nun notwendig sein, dass eine Auswertung über alle Mitarbeiter, die zwischen 1950 und 1955 geboren sind und die zugleich zwischen Euro 3.000,und Euro 4.000,- pro Monat verdienen, erstellt werden soll. Diese Anfrage kann nun auch
geometrisch interpretiert werden. Dies erfolgt, indem jeder Mitarbeiter als ein Punkt in
der Ebene dargestellt wird. Die erste Koordinate spiegelt dann das Geburtsdatum wieder,
und die zweite Koordinate das monatliche Einkommen. Das Geburtsdatum wird in dem
vorliegenden Beispiel nach der folgenden Regel umgewandelt: 10.000 × Geburtsjahr + 100
× Monat + Tag. So erhält man zum Beispiel für das Geburtsdatum 02.01.1954 den Wert
19.540.102. Für die oben genannte Anfrage bedeutet dies, dass alle Punkte gesucht werden,
deren erste Koordinate zwischen den Werten 19.500.000 und 19.559.999 liegt, und deren
zweite Koordinate sich zwischen den Werten 3.000 und 4.000 befindet. Wenn man dies nun
in ein Koordinatensystem überträgt, so wird deutlich, dass die Punkte, die gesucht werden,
in dem achsenparallelen Rechteck liegen, das durch die Eckpunkte (19.500.000, 3.000) und
(19.559.999, 4.000) definiert wird (vgl. Abbildung 12 ).
Eine solche Anfrage kann selbstverständlich noch um weitere Attribute ergänzt werden
wie z.B. die Anzahl der Kinder eines Mitarbeiters. D.h. es werden in dem Beispiel nun alle
Mitarbeiter gesucht, die zwischen 1950 und 1955 geboren worden sind, monatlich zwischen
Euro 3.000,- und Euro 4.000,- verdienen und zusätzlich zwei bis vier Kinder haben. Die
Anzahl der Kinder wird demnach durch die dritte Koordinate eines jeden Punktes repräsentiert. Somit handelt es sich um eine Suche im dreidimensionalen Raum. Im Rahmen
der Anfrage sind alle Punkte zu ermitteln, die in dem achsenparalleln Quader [19.500.000 :
19.559.999] × [2.000 : 4.000] × [2 : 4] liegen (siehe Abbildung 23 ).
Anhand der beiden vorgestellten Beispiele lässt sich zusammenfassen, dass die Datensätze einer Datenbank sich als Punkte in einem d-dimensionalen Raum darstellen lassen. Die
Suche nach den auf eine Anfrage zutreffenden Datenbankeinträge wird durch die Suche nach
der Punktmenge ersetzt, die in dem d-dimensionalen und achsenparallel begrenzten Bereich
2
3
Die Abbildung ist entnommen aus [1].
Die Abbildung ist entnommen aus [1].
Bereichsbäume
Gehalt
Karl Schmidt
Geburtsdatum: 19. August 1954
Gehalt: € 3.678,‐
4.000
3.000
Geburtsdatum
19.500.000
19.559.999
Abb. 1. Geometrische Interpretation einer Datenbankanfrage
Gehalt
4.000
3.000
Kinder
4
2
Geburtsdatum
19.500.000
19.559.999
Abb. 2. Geometrische Interpretation einer Datenbankanfrage in einem 3-dimensionalen Raum
23
24
Jasmin Kovač-Engelmeier
liegt. Das Ermitteln dieser Punktmenge wird als orthogonale4 Bereichsanfrage bezeichnet.
Im Folgenden werden Datenstrukturen vorgestellt, die orthogonale Bereichsanfragen unterstützen. Zunächst wird auf eine Datenstruktur für die 1-dimensionale Bereichssuche eingegangen, um von dieser Datenstruktur die Vorgehensweise für 2- und mehrdimensionale
Bereichsanfragen abzuleiten.
3 1-dimensionale Bereichssuche
Im Fall der Bereichssuche in einem 1-dimensionalen Raum besteht die betrachtete Punktmenge aus reellen Zahlen. Bei einer Anfrage werden dann die Punkte gesucht, die in einem
1-dimensionalen Rechteck liegen, d.h. also in einem Intervall [x : x0 ].
Sei nun P := {p1 , p2 , . . . , pn } die Menge der Punkte auf einer Zahlengeraden. Die Durchführung der 1-dimensionalen Bereichssuche kann nun mithilfe eines balancierten binären
Suchbaums τ erfolgen. In den Blättern von τ werden alle Punkte von P gespeichert. In
den inneren Knoten von τ sind die sogenannten Splittwerte gespeichert. Sie übernehmen im
Suchbaum sozusagen die Rolle von Wegweisern. Der Splittwert eines inneren Knotens v wird
mit xv bezeichnet. Charakteristisch für einen Suchbaum ist, dass alle Werte, die im linken
Teilbaum von v gespeichert sind, kleiner als oder gleich xv sind. Analog sind alle Werte, die
sich im rechten Teilbaum von v befinden, größer als xv .
Zum Ermitteln der Punkte, die in dem Intervall [x : x0 ] liegen, wird in τ eine Suche nach
x und x0 durchgeführt. Mit µ und µ0 werden die Blätter bezeichnet, bei denen jeweils die
Suche nach x und x0 in τ endet. Man kann somit sagen, dass die Punkte, die in dem Intervall
[x : x0 ] liegen, in den Blättern zwischen µ und µ0 gespeichert sind. Zusätzlich ist zu prüfen,
ob auch die Werte von µ und µ0 in diesem Intervall liegen.
Ein gutes Anschauungsbeispiel liefert die Abbildung 35 , in welcher die 1-dimensionale
Bereichsanfrage in einem binären Suchbaum dargestellt ist. Es sollen in dem Beispiel alle
Punkte ermittelt werden, die in dem Intervall [18 : 77] liegen. Mithilfe der Abbildung lässt
sich schnell intuitiv die Lösung ermitteln. So liegen in der Ergebnismenge alle Punkte, die
in den dunkelgrau markierten Blättern gespeichert sind, plus der Punkt, der in dem Blatt µ
gespeichert ist. Wie lässt sich nun diese eher intuitive Vorgehensweise, die zwischen µ und
µ0 liegenden Blätter, welche die gesuchten Punkte beinhalten, zu ermitteln, in einen Algorithmus fassen? Beim Betrachten des abgebildeten Suchbaums fällt auf, dass die gesuchten
Blätter zu Teilbäumen gehören, die sich zwischen µ und µ0 befinden, und deren Wurzeln auf
den Suchpfaden von x und x0 liegen. Um diese Blätter zu finden, ist es zunächst notwendig, den letzten gemeinsamen Knoten vsplit zu ermitteln, bei dem sich die Suchpfade von
x und x0 voneinander trennen. Das Ermitteln von vsplit wird mittels der folgenden Prozedur FindeSplittknoten durchgeführt. Mit LK(v) und RK(v) werden jeweils das linke und
rechte Kind eines Knotens v bezeichnet.
4
5
Der Begriff orthogonal kommt aus dem Griechischen, und bedeutet soviel wie rechtwinklig oder rechteckig
(vgl. [2]).
Die Abbildung ist entnommen aus [1].
Bereichsbäume
25
49
23
80
37
10
3
3
19
10
19
30
23
30
89
62
49
37
μ
70
59
59
62
70
89
80
100
100 105
μ'
Abb. 3. Beispiel einer 1-dimensionalen Bereichssuche in einem binären balancierten Suchbaum
FindeSplittknoten(τ, x, x0 )
Eingabe: Baum τ und die Werte x und x0 mit x ≤ x0 .
Ausgabe: Knoten v, bei dem die Wege zu x und x0 starten, oder das Blatt, wo beide Wege enden.
1. v ← root(τ )
2. while v ist kein Blatt and (x0 ≤ xv or x > xv )
3.
do if x0 ≤ xv
4.
then v ← LK(v)
5.
else v ← RK(v)
6. return v
Die Eingabeparameter für die Prozedur sind τ, x und x0 . Beginnend bei der Wurzel des
Baums τ , wird schrittweise jeder Knoten, der im Rahmen der Prozedur besucht wird, dahingehend geprüft, ob er ein Blatt ist, und ob sein Wert innerhalb des Intervalls [x : x0 ]
liegt. Solange dies nicht eintrifft, wird für den Fall, dass der Wert des betrachteten Knotens
größer als x0 - sozusagen die rechte Grenze des Intervalls - ist, das linke Kind des betrachteten Knotens v als nächstes untersucht. Für den anderen Fall, d.h. dass der Wert des aktuell
betrachteten Knotens v kleiner als x - die linke Grenze des vorgegebenen Intervalls - ist, wird
als nächstes das rechte Kind des Knotens v untersucht. Sobald es sich bei dem betrachteten
Knoten v um ein Blatt handelt, oder der in ihm gespeicherte Wert in dem Intervall [x : x0 ]
liegt, wird v als Splittknoten ausgegeben.
Der somit ermittelte Splittknoten wird nun zum Ausgangspunkt für den Suchpfad von
x. Bei jedem Knoten, der im Rahmen des Suchpfades besucht wird, wird überprüft, ob
der Wert x im linken oder im rechten Teilbaum zu suchen ist. D.h. es wird ein Vergleich
zwischen x und dem Wert, der in v gespeichert ist, durchgeführt. Führt der Suchpfad im
linken Teilbaum weiter, so werden alle Blätter des rechten Teilbaums ausgegeben, da dieser
26
Jasmin Kovač-Engelmeier
Teilbaum zwischen den Suchpfaden von x und x0 liegt. Analog wird der Suchpfad von x0
durchlaufen, jedoch mit dem Unterschied, dass, wenn der Suchpfad im rechten Teilbaum
eines Knotens weiterverläuft, die Blätter des linken Teilbaums auszugeben sind. Wie bereits
eingangs erwähnt, sind zusätzlich noch die beiden Blätter µ und µ0 darauf zu prüfen, ob die
in ihnen gespeicherten Werte ebenfalls in dem Intervall [x : x0 ] liegen. Falls dies der Fall ist,
sind auch sie entsprechend auszugeben.
Es folgt nun noch der entsprechende Algorithmus, welcher wiederum die Prozedur
BerichteTeilbaum enthält. Mittels dieser Prozedur werden die Werte ausgegeben, die in
den Blättern der Teilbäume gespeichert sind, deren Wurzeln auf einem der beiden Suchpfade
liegen. Aufgrund der Tatsache, dass die Anzahl der inneren Knoten eines binären Suchbaumes kleiner als die Anzahl seiner Blätter ist, ist die Zeit, die diese Prozedur benötigt, linear
zur Anzahl der zu berichtenden Punkte.
Algorithmus 1DBereichsanfrage(τ, [x : x0 ])
Eingabe: ein binärer Suchbaum τ und ein Intervall [x : x0 ]
Ausgabe: alle Punkte, die in τ gespeichert sind und in dem Intervall [x : x0 ] liegen.
1. vsplit ← F indeSplittknoten(τ, x, x0 )
2. if vsplit ist ein Blatt
3.
then überprüfe, ob der Punkt, der in vsplit gespeichert ist, auszugeben ist.
4.
else (*Folge dem Weg zu x und gib die Punkte der Teilbäume aus, die rechts
vom Suchpfad liegen.*)
5.
v ← LK(vsplit )
6.
while v ist kein Blatt
7.
do if x ≤ xv
8.
then BerichteTeilbaum(RK(v))
9.
v ← LK(v)
10.
else v ← RK(v)
11.
Überprüfe, ob der Punkt, der in dem Blatt v gespeichert ist, ausgegeben werden muss.
12.
Folge analog dem Suchpfad von x0 . Gib alle Punkte der Teilbäume aus,
die links von dem Suchpfad liegen, und überprüfe, ob der Punkt, der
in dem Blatt gespeichert ist, wo der Suchpfad endet, ausgegeben werden muss.
Der vorgestellte Algorithmus scheint soweit die gesuchte Ergebnismenge zu liefern. Jedoch ist seine Korrektheit noch im Folgenden formal zu zeigen.
Lemma 1. Der Algorithmus 1DBereichsanfrage gibt genau die Punkte aus, die in dem
angegebenen Intervall liegen.
Der folgende Beweis erstreckt sich über zwei Teile. Zunächst ist zu zeigen, dass jeder
Punkt p, der durch den Algorithmus ausgegeben wird, in dem angegebenen Intervall liegt.
Falls p in einem der beiden Blätter gespeichert ist, wo jeweils die Suchpfade von x und
x0 enden, dann wird explizit durch den Algorithmus überprüft, ob p in dem vorgegebenen
Intervall liegt, und ob p dementsprechend auszugeben ist. Andernfalls wird p infolge des
Aufrufs von BerichteTeilbaum ausgegeben. Angenommen dieser Aufruf findet während
Bereichsbäume
27
des Durchlaufens des Suchpfades von x statt. So sei v ein Knoten auf diesem Suchpfad,
so dass p infolge des Aufrufs von BerichteTeilbaum(RK(v)) ausgegeben wird. Da v und
folglich auch RK(v) in dem linken Teilbaum von vsplit liegen, gilt p ≤ xvsplit . Aus der Tatsache, dass der Suchpfad von x0 rechts von xsplit abzweigt, folgt auch, dass p < x0 gilt. Des
Weiteren steht fest, dass der Suchpfad von x links von v weiterverläuft. Da p im rechten
Teilbaum von v liegt, impliziert dies, dass x < p gilt. Daraus lässt sich insgesamt schließen,
dass p ∈ [x : x0 ]. Der Beweis, dass p auch in dem Intervall liegt, wenn der Suchpfad von x0
durchlaufen wird, erfolgt symmetrisch.
In einem weiteren Schritt ist nun noch zu zeigen, dass auch tatsächlich alle Punkte vom
Algorithmus ausgegeben werden, die in dem vorgegebenen Intervall liegen. Zu diesem Zweck
wird angenommen, dass µ das Blatt ist, in welchem p gespeichert ist. Zusätzlich sei v der
kleinste Vorfahr von µ, der im Rahmen des Algorithmus besucht wird. Es wird behauptet,
dass v = µ ist. Dies impliziert, dass p ausgegeben wird. Zur Erzeugung eines Widerspruchs
wird nun angenommen, dass v 6= µ ist. Geht man von dieser Annahme aus, dann kann v kein
Knoten sein, der infolge eines Aufrufs der Prozedur BerichteTeilbaum besucht wird, da alle
Nachfolger dieses Knotens besucht werden. Somit kann v nur auf dem Suchpfad von x, auf
dem Suchpfad von x0 oder auf beiden liegen. Im Folgenden wird lediglich der letztgenannte
Fall näher betrachtet, da sich alle drei Fälle ähnlich gestalten. Es wird angenommen, dass
µ im linken Teilbaum von v angesiedelt ist. Der Suchpfad von x wird jedoch im rechten
Teilbaum von v fortgesetzt. Andernfalls wäre v nicht der kleinste Vorfahr, der im Rahmen
des Algorithmus besucht wird. Dies hat zur Folge, dass p < x ist. Für den analogen Fall,
dass der Suchpfad von x0 im linken Teilbaum von v weiterverläuft, gilt p > x0 , da gemäss
der getroffenen Annahmen µ im rechten Teilbaum von v liegt. In beiden Fällen führt die
Behauptung, dass p in dem angegebenen Intervall liegt, zu einem Widerspruch. Folglich ist
bewiesen, dass der betrachtete Algorithmus alle Punkte ausgibt, die in dem vorgegebenen
Intervall liegen.
Der Speicherplatz, der für einen balancierten binären Suchbaum benötigt wird, beträgt
O(n). Des Weiteren wurde eingangs vorausgesetzt, dass der verwendete binäre Suchbaum
balanciert ist. Und balancierte Suchbäume garantieren eine Höhe von O(log n) (siehe [3]).
Infolgedessen kann der Baum in einer Zeit von O(n log n) erzeugt werden. Die Suchzeit
beträgt im schlimmsten Fall Θ(n). Dies tritt ein, wenn sich alle Punkte des Baums in
dem angefragten Intervall befinden. Um jedoch so eine Suchzeit zu erhalten, würde es auch
ausreichen, einfach die Punkte mit dem Intervall zu vergleichen. Die zuvor beschriebene
Datenstruktur müsste dann erst gar nicht verwendet werden. Diese Suchzeit lässt sich aber
auch nicht vermeiden, wenn alle Punkte, die in dem Baum gespeichert sind, am Ende ausgegeben werden müssen, weil sie allesamt im Intervall liegen. Abgesehen vom schlimmsten
Fall, lässt sich jedoch eine Verbesserung der Suchzeit erreichen, wenn nicht nur die reine Anzahl n der Punkte aus P berücksichtigt wird, sondern auch die Anzahl der auszugebenden
Punkte. Letztgenannte wird im weiteren Verlauf mit k bezeichnet. Aus der Tatsache, dass
die Zeit, die für einen Aufruf von BerichteTeilbaum benötigt wird, linear zur Anzahl der
aus dem Teilbaum auszugebenden Punkte ist, folgt, dass der Zeitaufwand, der insgesamt für
die Aufrufe von BerichteTeilbaum aufgebracht werden muss, O(k) beträgt. Alle restlichen
Knoten, die noch in dem Baum τ besucht werden, liegen entweder auf dem Suchpfad von x
oder auf dem von x0 . Diese Suchpfade haben die Länge O(log n), da - wie eingangs voraus-
28
Jasmin Kovač-Engelmeier
gesetzt - der binäre Suchbaum τ balanciert ist. Dadurch wird eine Baumhöhe von O(log n)
garantiert. Für jeden Knoten, der auf dem Suchpfad besucht wird, fällt ein Zeitaufwand von
O(1) an. Demnach beträgt der Gesamtaufwand für diese Knoten O(log n). So erhält man
einen gesamten Suchaufwand von O(log n + k). Das folgende Theorem fasst noch einmal die
wichtigsten Ergebnisse aus diesem Abschnitt zusammen.
Theorem 1. Sei P eine Menge von n Punkten in einem 1-dimensionalen Raum. Die Menge P kann in einem balancierten binären Suchbaum gespeichert werden. Dafür wird O(n)
Speicherplatz und O(n log n) Konstruktionszeit benötigt. Die in einem angefragten Intervall
liegenden Punkte können dann in O(k + log n) Zeit ausgegeben werden, wobei k für die
Anzahl der auszugebenen Punkte steht.
Eine 1-dimensionale Bereichsanfrage kann also mithilfe eines balancierten binären Suchbaums durchgeführt werden. Es stellt sich nun die Frage, ob dieses Wissen genutzt werden
kann, um Bereichsanfragen in einem 2-dimensionalen Raum bewerkstelligen zu können.
Dementsprechend beschäftigt sich das folgende Kapitel ausführlich mit Bereichsbäumen.
Diese Datenstruktur unterstützt das Durchführen von 2-dimensionalen Bereichsanfragen.
4 Bereichsbäume
Allgemein lassen sich Bereichsbäume als eine Datenstruktur beschreiben, mittels derer n
Punkte einer Menge P gespeichert werden können, um anschließend auf ihnen orthogonale
Bereichsanfragen durchführen zu können. Im Grunde wurden Bereichsbäume bereits im vorherigen Kapitel vorgestellt, denn ein balancierter binärer Suchbaum ist nichts anderes als
ein 1-dimensionaler Bereichsbaum. Jedoch wie sieht dann der Aufbau eines Bereichsbaums
für 2-dimensionale Bereichsanfragen aus? Bevor diese Frage beantwortet wird, gilt es einige
Vorüberlegungen anzustellen.
Zunächst wird angenommen, dass P eine Menge von n Punkten in einem 2-dimensionalen
Raum ist. Die Position jedes Punktes dieser Menge wird durch zwei Werte bestimmt: die xund die y-Koordinate. Im Rahmen der 1-dimensionalen Bereichsanfrage wurden die Punkte
ermittelt, die innerhalb eines vorgegebenen Intervalls [x : x0 ] lagen. Bei der 2-dimensionalen
Bereichsanfrage sind wiederum die Punkte zu ermitteln, die in dem achsenparallelen Rechteck liegen, welches durch [x : x0 ] × [y : y 0 ] bestimmt wird. Im Grunde besteht die 2dimensionale Bereichsanfrage aus zwei 1-dimensionalen Bereichsanfragen. So erfolgt im ersten Schritt die Ermittlung der Punkte aus P , deren x-Koordinate jeweils in dem Intervall
[x : x0 ] liegt. Es liegt somit eine 1-dimensionale Bereichsanfrage vor, die bereits aus dem
vorherigen Kapitel bekannt ist. D.h. es wird zunächst der Splitknoten vsplit ermittelt, bei
dem sich die Suchpfade von x und x0 trennen. Mit dem linken Kind von vsplit beginnend,
wird der restliche Suchpfad von x durchlaufen. Bei jedem Knoten wird überprüft, wo der
Suchpfad weiterverläuft. Falls der Suchpfad im linken Teilbaum eines Knotens fortgesetzt
wird, werden alle Punkte, die im rechten Teilbaum von v gespeichert sind, ausgegeben. Der
gleiche Vorgang wird für den restlichen Suchpfad von x0 wiederholt, wobei die Punkte des
linken Teilbaum eines Knotens ausgegeben werden, falls der Suchpfad im rechten Teilbaum
von v fortgesetzt wird. Die Blätter µ und µ0 - bei denen die Suchpfade von x und x0 jeweils
enden - werden explizit dahingehend geprüft, ob die in ihnen gespeicherten Punkte in dem
Bereichsbäume
29
vorgegebenen Intervall liegen. Infolgedessen werden O(log n) Teilbäume ausgewählt, die genau die Punkte aus P enthalten, deren x-Koordinate in dem x-Intervall des Anfragebereichs
liegt.
In diesem Zusammenhang soll der Begriff der kanonischen Teilmenge eingeführt werden.
Die kanonische Teilmenge eines Knotens v, welche wiederum mit P (v) bezeichnet wird,
ist die Teilmenge der Punkte, die in den Blättern eines Teilbaums gespeichert sind. Die
Wurzel dieses Teilbaums ist der Knoten v. So ist zum Beispiel die kanonische Teilmenge
der Wurzel eines Baums die gesamte Punktmenge P . Wiederum die kanonische Teilmenge
eines Blattes ist einfach der Punkt, der in dem Blatt gespeichert ist. Infolgedessen kann
die Teilmenge der Punkte aus P , deren x-Koordinate in dem angefragten Bereich liegt, als
eine disjunkte Vereinigung von O(log n) kanonischen Teilmengen P (v) der Knoten v - d.h.
den Wurzeln der ausgewählten Teilbäume - bezeichnet werden. Genaugenommen sind von
dieser Teilmenge von P auch nur die Punkte von Interesse, deren y-Koordinate gleichzeitig
in dem Intervall [y : y 0 ] liegt. Wie bereits angedeutet, handelt es sich dabei um die zweite 1-dimensionale Bereichsanfrage. Diese kann ebenfalls mithilfe eines binären Suchbaums
durchgeführt werden, der auf den y-Koordinaten der Punkte aus P beruht. Es gilt nun diese beiden 1-dimensionalen Bereichsanfragen zu vereinen. Es ergibt sich daraus die folgende
Datenstruktur.
Der Hauptbaum ist ein balancierter binärer Suchbaum τ , der die x-Koordinaten der
Punkte aus P beinhaltet. Für jeden inneren Knoten und jedes Blatt v von τ werden die
kanonischen Teilmengen P (v) in einem weiteren balancierten binären Suchbaum τverbund (v)
gespeichert. Dieser beinhaltet wiederum die y-Koordinaten der Punkte aus P . Von einem
Knoten v führt ein Zeiger zur Wurzel des Baums τverbund (v), welcher als verbundene Struktur von v bezeichnet wird (siehe Abbildung 46 ).
Die soeben grob beschriebene Datenstruktur wird Bereichsbaum genannt. Generell heißen solche Datenstrukturen, bei denen Zeiger von den Knoten zu den verbundenen Strukturen führen, auch Multi-Level -Datenstrukturen. Der Hauptbaum τ wird dann als FirstLevel -Baum bezeichnet, und die verbundenen Strukturen als Second-Level -Bäume. So stellt
sich nun die Frage, wie ein solcher Bereichsbaum konstruiert wird. Es sei eine Punktmenge
P := {p1 , . . . , pn } gegeben, die nach der x-Koordinate sortiert ist. Der folgende rekursive
Algorithmus Erzeuge2DBereichsbaum liefert dann die Wurzel eines 2-dimensionalen Bereichsbaums. Bezüglich der vorgegebenen Punktmenge wird an dieser Stelle vereinfachend
angenommen, dass es keine zwei Punkte gibt, welche die gleichen Koordinaten haben.
Es ist zu betonen, dass in den Blättern der verbundenen Struktur nicht lediglich die
y-Koordinaten der Punkte gespeichert werden, sondern es werden die Punkte selbst in den
Blättern gespeichert. Das bedeutet, dass beim Durchsuchen der verbundenen Struktur am
Ende auch tatsächlich die Punkte ausgegeben werden. Es gilt nun den Speicherplatz, den
diese Datenstruktur benötigt, zu ermitteln.
Lemma 2. Ein Bereichsbaum, der n Punkte im Rahmen einer 2-dimensionalen Bereichsanfrage enthält, benötigt O(n log n) Speicherplatz.
6
Die Abbildung ist entnommen aus [1].
30
Jasmin Kovač-Engelmeier
τ
τverbund(v)
P(v)
P(v)
Abb. 4. Der Aufbau eines 2-dimensionalen Bereichsbaumes
Algorithmus Erzeuge2DBereichsbaum(P )
Eingabe: eine Punktmenge P in der 2-dimensionalen Ebene
Ausgabe: die Wurzel eines 2-dimensionalen Bereichsbaums
1. Konstruiere die verbundene Struktur: erzeuge einen binären Suchbaum τverbund mit der Punktmenge
Py , die sich aus den y-Koordinaten der Punkte aus P ergibt. Speichere in den Blättern des Baums
τverbund nicht einfach nur die jeweiligen y-Koordinaten, sondern die Punkte selbst.
2. if P aus nur einem Punkt besteht
3.
then erzeuge ein Blatt v, das diesen Punkt speichert, und mache τverbund
zur verbundenen Struktur von v
4.
else teile P in zwei Teilmengen auf: die Teilmenge Plinks enthält die
Punkte, deren x-Koordinate kleiner gleich xmitte - der mittleren
x-Koordinate - ist, und die Teilmenge Prechts enthält die Punkte
aus P , deren x-Koordinate größer als xmitte ist.
5.
vlinks ← Erzeuge2DBereichsbaum(Plinks )
6.
vrechts ← Erzeuge2DBereichsbaum(Prechts )
7.
Erzeuge einen Knoten v, der xmitte speichert, mache vlinks zum
linken Kind von v, vrechts zum rechten Kind von v und τverbund
zur verbundenen Struktur von v.
8. return v
Bereichsbäume
31
Der Beweis dieses Satzes sieht folgendermaßen aus. Ein Punkt p aus der Menge P wird
ausschließlich in der verbundenen Struktur der Knoten in τ gespeichert, die auf dem Weg zu
dem Blatt liegen, welches letztendlich p enthält. Somit lässt sich sagen, dass für alle Knoten
einer bestimmten Tiefe in τ gilt, dass p in genau einer verbundenen Struktur gespeichert
ist. Aus der Tatsache, dass 1-dimensionale Bereichsbäume linearen Speicherplatz benötigen,
lässt sich schliessen, dass für die verbundenen Strukturen aller Knoten von τ zusammen
O(n) Speicherplatz benötigt wird. Wie bereits gezeigt, ist die Tiefe von τ O(log n). Demnach beträgt der Gesamtspeicherplatz, der benötigt wird, O(n log n).
Der vorgestellte Algorithmus Erzeuge2DBereichsbaum(P ) erreicht nicht unbedingt die
optimale Zeit von O(n log n), um einen Bereichsbaum zu erzeugen. Es wird nun aber angenommen, dass eine unsortierte Menge von n Schlüsseln vorliegt. Um für diese Menge nun
einen binären Suchbaum zu erzeugen, wird eine Konstruktionszeit von O(n log n) benötigt.
Dies bedeutet, dass für das Erzeugen einer verbundenen Struktur - so wie es in der Zeile 1 des genannten Algorithmus der Fall ist - ein Zeitbedarf von O(n log n) anfällt. Dies
kann jedoch verbessert werden, indem die Punkte von Py bezüglich der y-Koordinate vorsortiert werden. Die Folge ist, dass der binäre Suchbaum von unten nach oben in linearer
Zeit aufgebaut werden kann. Aufgrunddessen wird für den Konstruktionsalgorithmus die
Punktmenge in zwei Listen verwaltet: d.h. in einer Liste werden die Punkte nach der xKoordinate sortiert, und in der anderen nach der y-Koordinate. Demzufolge ist die Zeit, die
für einen Knoten im Hauptbaum τ benötigt wird, linear zur Größe seiner kanonischen Teilmengen. Dies führt wiederum zu dem Schluß, dass die Gesamtkonstruktionszeit der Menge
des benötigten Speichplatzes entspricht: O(n log n). Die Tatsache, dass das Vorsortieren in
einer Zeit O(n log n) realisiert werden kann, führt ebenfalls zur Gesamtkonstruktionszeit
von O(n log n).
Im Laufe des folgenden Algorithmus werden zunächst die O(log n) kanonischen Teilmengen ausgewählt, die zusammen die Punkte enthalten, deren x-Koordinate in dem Intervall [x : x0 ] liegt. Dies wird mithilfe des 1-dimensionalen Anfragealgorithmus durchgeführt.
Von diesen Teilmengen ausgehend, werden anschließend die Punkte ausgegeben, deren yKoordinate in dem Intervall [y : y 0 ] liegt. D.h. es wird der 1-dimensionale Anfragealgorithmus auf die verbundenen Strukturen angewendet, welche die jeweiligen kanonischen Teilmengen enthalten. Im Prinzip kann man sagen, dass der Algorithmus 2DBereichsanfrage
dem 1-dimensionalen Anfragealgorithmus 1DBereichsanfrage gleicht. Die beiden Algorithmen unterscheiden sich dadurch, dass bei der 2-dimensionalen Bereichsanfrage nicht
BerichteTeilbaum aufgerufen wird, sondern 1DBereichsanfrage.
Es stellt sich erneut die Frage nach der Laufzeit des Algorithmus.
Lemma 3. Für eine orthogonale Anfrage in einem Bereichsbaum, der n Punkte beinhaltet,
wird O(log2 n+k) Zeit benötigt. In diesem Kontext steht k für die Anzahl der auszugebenden
Punkte.
Lässt sich diese Aussage auch beweisen? Bei jedem Knoten im Hauptbaum τ wird für
die Entscheidung, wo der Suchpfad nun weiterverläuft, eine konstante Zeit benötigt. Möglicherweise ist es notwendig, in diesem Rahmen den Algorithmus 1DBereichsanfrage auszu-
32
Jasmin Kovač-Engelmeier
Algorithmus 2DBereichsanfrage(τ, [x : x0 ], [y : y 0 ])
Eingabe: ein 2-dimensionaler Bereichsbaum τ und ein Bereich [x : x0 ]x[y : y 0 ].
Ausgabe: alle Punkte von τ , die in dem Bereich liegen.
1. vsplit ← F indeSplitknoten(τ, x, x0 )
2. if vsplit ist ein Blatt
3.
then Überprüfe, ob der Punkt, der in vsplit gespeichert ist, ausgegeben werden
muss.
4.
else (*Folge dem Weg zu x und rufe 1DBereichsanfrage für die Teilbäume
auf, die rechts von dem Weg liegen.*)
5.
v ← LK(vsplit )
6.
while v ist kein Blatt
7.
do if x ≤ xv
8.
then 1DBereichsanfrage(τverbund (RK(v)), [y : y 0 ])
9.
v ← LK(v)
10.
else v ← RK(v)
11.
Überprüfe, ob der Punkte, der in v gespeichert ist, ausgegeben werden
muss.
12.
Analog folge dem Weg von RK(vsplit ) bis x0 , rufe 1DBereichsanfrage
mit dem Intervall für die Teilbäume auf, die links des Weges liegen, auf
und überprüfe, ob der Punkt, der in dem Blatt am Ende des Pfades
gespeichert ist, ausgegeben werden muss.
führen. Infolge des Theorems 1 ist bekannt, dass für diesen rekursiven Aufruf O(log n + kv )
Zeit benötigt wird, wobei kv für die Anzahl der Punkte
steht, die im Rahmen dieses Aufrufs
P
ausgegeben werden. Dies führt zur Gesamtzeit
O(log n + kv ). Diese Summe reicht über
v
P
alle Knoten, die innerhalb des Hauptbaums τ besucht werden. Die Summe
kv ist gleich
v
k - der Gesamtanzahl aller Knoten, die ausgegeben werden. Und wie bereis zuvor erwähnt,
weisen die Suchpfade
von xPund x0 in dem Hauptbaum τ jeweils die Länge O(log n) auf.
P
Daraus folgt
O(logn) = O(log 2 n) und wiederum Lemma 3.
v
v
Das folgende Theorem fasst noch einmal die Ergebnisse dieses Kapitels zusammen.
Theorem 2. Sei P die Menge von n Punkten in einer Ebene. Dann benötigt ein Bereichsbaum für P O(n log n) Speicherplatz und eine Konstruktionszeit von O(n log n). Eine orthogonale Anfrage bezüglich einer bestimmten Teilmenge von P kann dann in O(log2 n + k)
Zeit beantwortet werden, wobei mit k die Anzahl der auszugebenden Punkte bezeichnet wird.
Von der Konstruktion 2-dimensionaler Bereichsbäume ausgehend, soll im folgenden Kapitel eine allgemeine Vorgehensweise für den Aufbau von mehrdimensionalen Bereichsbäumen
vorgestellt werden.
5 Mehrdimensionale Bereichsbäume
Im Rahmen mehrdimensionaler Bereichsbäume sei P die Menge von Punkten in einem ddimensionalen Raum. Im ersten Schritt wird ein balancierter binärer Suchbaum konstruiert,
der von den Punkten jeweils die erste Koordinate enthält. In diesem First level -Baum - dem
Hauptbaum - enthält die kanonische Teilmenge P (v) eines Knotens v die Punkte, die in
Bereichsbäume
33
den Blättern des Teilbaums von v gespeichert sind. Für jeden Knoten v wird eine verbundene Struktur τverbund (v) konstruiert. Dieser Second Level -Baum τverbund (v) ist folglich ein
(d − 1)-dimensionaler Suchbaum für die Punkte in P (v). Diese Punkte bestehen dann also
aus den (d − 1)-letzten Koordinaten. Auf die gleiche Weise - wie zuvor beschrieben - wird
dieser (d − 1)-dimensionale Suchbaum rekursiv konstruiert. D.h. es wird ein balancierter binärer Suchbaum auf Basis der ursprünglich zweiten Koordinate der Punkte gebildet. Jeder
Knoten verweist mit einem Zeiger auf einen (d − 2)-dimensionalen Bereichsbaum, welcher
die auf die (d − 2)-letzten Koordinaten beruhenden Punkte aus dem Teilbaum des jeweiligen Knotens beinhaltet. Die Rekursion endet, wenn nur noch die Punkte übrig bleiben,
die ausschließlich die letzte Koordinate repräsentieren. Diese Punkte werden dann in einem
balancierten binären Suchbaum gespeichert (vgl. Abbildung 57 ).
Abb. 5. Der Aufbau eines mehrdimensionalen Bereichsbaumes
Diese Vorgehensweise ähnelt der, die bereits für den 2-dimensionalen Fall vorgestellt worden ist. D.h. der First Level -Baum dient dazu, O(log n) Knoten zu ermitteln, deren kanonische Teilmengen zusammen die Punkte beinhalten, deren erste Koordinate jeweils in dem
vorgegebenen Bereich liegt. Diese kanonischen Teilmengen werden erneut betrachtet, wenn
eine Bereichsanfrage auf den entsprechenden Second Level -Strukturen durchgeführt wird. In
jeder Second Level -Struktur werden nun O(log n) kanonische Teilmengen ausgewählt. Daraus folgt, dass es insgesamt O(log2 n) solcher Teilmengen in den Second Level -Strukturen
gibt. Sie beinhalten demnach alle Punkte, deren erste und zweite Koordinate in dem definierten Bereich liegen. Im darauffolgenden Schritt werden die Third Level -Strukturen betrachtet, welche die kanonischen Teilmengen beinhalten, bei denen die dritte Koordinate in
dem vorgegebenen Bereich liegt. Diese Vorgehensweise wird so lange rekursiv wiederholt, bis
7
Die Abbildung ist entnommen aus [1].
34
Jasmin Kovač-Engelmeier
die 1-dimensionalen Bäume erreicht werden, in welchen die Punkte gespeichert sind, deren
letzte Koordinate in dem definierten Bereich liegt. Diese Punkte werden dann schließlich als
Ergebnismenge ausgegeben. Soweit es den benötigten Speicherplatz und das Laufzeitverhalten betrifft, so kann Folgendes festgehalten werden.
Theorem 3. Sei P eine Menge von n Punkten in einem d-dimensionalen Raum, wobei d ≥ 2 gilt. Ein Bereichsbaum benötigt dann für P O(n log(d−1) n) Speicherplatz und
O(n log(d−1) n) Konstruktionszeit. Somit können die Punkte aus P , die in einem orthogonalen Anfragebereich liegen, in O(logd n + k) Zeit ausgegeben werden. So bezeichnet k die
Anzahl der auszugebenden Punkte.
Für den Beweis dieser Aussagen wird angenommen, dass Td (n) für die Zeit steht, die
für das Konstruieren eines Suchbaums auf Basis einer Menge von n Punkten in einem
d-dimensionalen Raum benötigt wird. Laut Theorem 2 gilt T2 (n) = O(n log n). Das Konstruieren eines d-dimensionalen Bereichsbaums basiert letztendlich auf dem Erzeugen eines
balancierten binären Suchbaums, wofür O(n log n) Zeit benötigt wird, und das Bilden der
verbundenen Strukturen. In dem First Level -Baum wird jeder Punkt in genau einer verbundenen Struktur gespeichert. Um alle verbundenen Strukuren zu erzeugen, wird O(Td−1 (n))
Zeit benötigt. Folglich ergibt sich die Gesamtkonstruktionszeit
Td (n) = O(n log n) + O(log n) · Td−1 (n).
Wie bereits gezeigt, gilt T2 (n) = O(n log n). Somit lässt sich die Rekursionsgleichung lösen
und man erhält O(n logd−1 n). Die Ermittlung des Speicherbedarfs erfolgt analog.
Es stellt sich nun die Frage nach der Zeit - im weiteren Verlauf mit Qd (n) bezeichnet -,
die benötigt wird, um in einem d-dimensionalen Bereichsbaum eine Anfrage auf n Punkten
durchzuführen. Zum einen ist es notwendig, eine Suche in dem First Level -Baum auszuführen, wofür ein Zeitbedarf von O(log n) anfällt. Des Weiteren ist eine logarithmische Anzahl
von (d − 1)-dimensionalen Bereichsbäumen zu durchsuchen. Somit folgt
Qd (n) = O(log n) + O(log n) · Qd−1 (n).
Wie bereits gezeigt, gilt Q2 (n) = O(log2 n). Folglich lässt sich auch diese Rekursionsgleichung lösen und man erhält Qd (n) = O(logd n). An dieser Stelle fehlt nur noch die Zeit, die
benötigt wird, um die ermittelten Punkte auszugeben. Diese ist auf O(k) beschränkt.
6 Fazit
Es wurde gezeigt, dass ein 1-dimensionaler Bereichsbaum im Grunde ein gewöhnlicher binärer balancierter Suchbaum ist, der wiederum O(n) Speicherplatz und O(n log n) Konstruktionszeit für das Speichern von n Punkten einer Punktmenge benötigt. Im „Worst
case“ beträgt die Suchzeit Θ(n). Dieser Fall tritt ein, wenn alle Punkte in dem vorgegebenen Intervall liegen. Generell lässt sich aber die Suchzeit verbessern, indem man die
tatsächlich auszugebene Punktmenge k in Betracht zieht. Dann erhält man eine Suchzeit
von O(k + log n).
Bereichsbäume
35
Soweit es 2-dimensionale Bereichsbäume betrifft, so wurde im Verlauf der Ausführungen festgestellt, dass für diese O(n log n) Speicherplatz und eine Konstruktionszeit von
O(n log n) benötigt wird. Bei der Ermittlung der Suchzeit wurde auch in diesem Fall die tatsächlich auszugebene Punktmenge k berücksichtigt, so dass sich eine orthogonale Bereichsanfrage dann in einer Zeit von O(log2 n + k) beantworten lässt. Auf diesen Fall aufbauend,
wurde zuletzt noch die Arbeitsweise von mehrdimensionalen Bereichsbäumen skizziert, welche eine Konstruktionszeit von O(n logd−1 n) und O(n logd−1 n) Speicherplatz benötigen.
Eine orthogonale Bereichsanfrage kann dann in O(logd n + k) beantwortet werden. Diese Suchzeit in einem mehrdimensionalen Bereichsbaum kann noch mithilfe von Fractional
Cascading auf O(logd−1 n + k) reduziert werden, indem der jeweils höchstdimensionale assoziierte Baum als Array gespeichert wird.
Literaturverzeichnis
1. Mark de Berg and Mark van Kreveld and Mark Overmars and Otfried Schwarzkopf (1997) Computational Geometry: Algorithms and Applications. Springer-Verlag, Berlin Heidelberg, Seite 95-116
2. Der Brockhaus in einem Band (2000). 9. Auflage. Brockhaus, Mannheim, Seite 667
3. Thomas H. Cormen and Charles E. Leiserson and Ronald L. Rivest and Clifford Stein (2001) Introduction to Algorithms. 2. Auflage. MIT Press, Cambridge, Massachusetts u.a., Seite 265-268
4. Rolf Klein (2005) Algorithmische Geometrie, 2. Auflage. Springer-Verlag, Berlin Heidelberg, Seite 107110, 135-140
„A Simple Linear Time (1+ε)-Approximation Algorithm for
k-Means Clustering in Any Dimensions“ für k = 2
Holger Bürger
Universität Paderborn
Zusammenfassung. Diese Arbeit befasst sich mit dem Thema Clustering mit maximal 2 Schwerpunkten.
Zu Grunde liegt das Paper „A Simple Linear Time (1+ε)-Approximation Algorithm for k-Means Clustering
in Any Dimensions“ [14]
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.1 Verwandte Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.2 Die Leistung von Kumar und anderen[14] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2
Hauptteil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.1 Eigenschaften des 1-means Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.2 Ein Linearzeit-Algorithmus für das 2-means Clustering . . . . . . . . . . . . . . . . . . . . . . . 43
3
Schluß . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
1 Einleitung
Im Rahmen meines Proseminars „Perlen der Theoretischen Informatik“ beschäftige ich
mich laut Seminarbeschreibung mit der Schönheit von Problemlösungen aus dem Bereich
der Theoretischen Informatik, mit raffinierten Beweistechniken, eleganten Argumenten und
überraschenden Konstruktionen auf höchst vergnügliche Art und Weise und im Speziellen
mit dem Thema Clustering. Dieses ist im Folgenden verschriftlicht.
Laut Paper[14] ist das Problem des Clustering einer Gruppe von gleichen Datenobjekten eines der am meisten studierten in der Informatik. Clustering findet eine breite
Anwendung, zum Beispiel bei „data mining“, Informationsbeschaffung, Bildverarbeitung,
Internetsuche[5, 8, 10]. Clustering kommt original aus dem Englischen und ist mittlerweile
ein deutsches Wort. Das Synonym „Gruppenbildung“ läßt mehr auf die Bedeutung schließen.
So wird beim „data mining“ unter anderem versucht Gruppen in einem Datenbestand zu
bilden, um Daten in sinnvolle Teilmengen aufzuspalten. Sinnvoll kann hier bedeuten, Kommunikationswege (beim Datenzugriff) zu verkürzen. Ein Beispiel in der Bildbearbeitung
könnte die Vektorisierung eines Pixelbildes sein, dabei muss man unter anderem naheliegende Punkte zusammenfassen.
Es wurde ausgesagt, dass bei dieser Vielfalt von Anwendungsformen es unterschiedliche
Definitionen[9, 4] gibt. Die Meisten von diesen sollen mit der Definition eines Abstandes
38
Holger Bürger
zwischen zwei Punkten beginnen und dann Cluster formen mit der Eigenschaft, dass zwei
nahe gelegene Punkte zu einem Cluster zugeordnet werden.
Eine weitere Aussage ist, dass meistens ein Zusammenhang zwischen Clustering und
geometrischen Sachverhalten existiert, so dass Datenobjekte als Punkte in einem mehrdimensionalen Raum angesehen werden können. Unter diesen Rahmenbedingungen soll es
nahe liegen, die Distanz zwischen diesen Punkten als euklidischen Abstand anzusehen.
Als eine der meistgebrauchten Definitionen des Clustering wird das k-means Clustering
Problem angesehen. Bei einer gegebenen Menge von Punkten P wird versucht eine Menge
K zu finden, bei der k Schwerpunkte so zugeordnet werden, dass
X
d(p, K)2
(1)
p∈P
minimiert ist.
Die Punkte in K können gewöhnliche Punkte im euklidischen Raum sein und mit d(p, K)
ist der Abstand zwischen p und seinem am nächsten gelegenen Schwerpunkt gemeint. Die
Punkte, welche dem gleichen Schwerpunkt zugeordnet werden, bilden einen Cluster. Das
k-means Problem ist NP-hart, auch für k = 2. Des Weiteren soll es noch als gebräuchliche
Defintion des Clusterings das k-median Problem geben. Dieses sei auf die gleiche Art und
Weise definiert, außer dass folgende Formel zugrunde liegt.
X
d(p, K)
p∈P
Zur Erinnerung: Ein Median war der Wert in der Mitte einer Stichprobe („in der Mitte liegend“). Man beachte jedoch, dass hier nicht durch die Anzahl der Elemente geteilt
wird. Der Unterschied der Formeln ist ungefähr der gleiche wie zwischen arithmetischem
Mittel (Durchschnitt) und Varianz. Vorteil der Quadrierung von Elementen ist die stärkere
Sichtbarkeit von Abweichungen.
Zumindest ist es ebenfalls das Ziel die maximale Distanz zu minimieren(siehe [1, 2, 3,
11, 13] und beinhaltete Referenzen). Es ist jedoch zu beachten, dass die Distanzberechnung
zwischen Punkten, welche hierbei gebraucht wird keine Metrik ist. Somit sei das Lösen des
k-means Problems nicht schwerer als das des k-median Problems. Dies wird in dem Paper[14]
bewiesen.
Zur Erinnerung: Laut Taschenbuch der Mathematik [6],von Bronstein und anderen, ist
eine Metrik eine mathematische Funktion, die je zwei Elementen eines Raums einen nicht
negativen reellen Wert zuordnet, der als Abstand der beiden Elemente voneinander aufgefasst werden kann. Sei X eine beliebige Menge.
Eine Abbildung d : X × X → R heißt Metrik, wenn für beliebige Elemente x, y und z von
X die folgenden axiomatischen Bedingungen erfüllt sind:
1.
2.
3.
4.
d (x, x) = 0 (identische Punkte haben Abstand 0),
d (x, y) = 0 ⇒ x = y(nichtidentische Punkte haben nicht Abstand 0),
d (x, y) = d(y, x) (Symmetrie),
d (x, y) ≤ d(x, z) + d(z, y) (Dreiecksungleichung).
(1+ε)-Approximation Algorithm for 2-Means Clustering
39
Die Dreiecksungleichung (4) besagt, dass der Abstand entlang dem direkten Weg, also
entlang der kürzesten Verbindung zwischen zwei Punkten gemessen wird. Ein Umweg über
einen dritten Punkt kann nicht kürzer als der direkte Weg sein. Dies gilt hier nicht.
Die Aussagen des Papers [14] sind weiterhin, dass eine Menge Forschung betrieben wurde, um das k-means Problem exakt zu lösen(siehe [12] und enthaltene Referenzen). Jedoch
selbst die besten Algorithmen brauchen Ω(nd ) Zeit. Bei der Suche nach konstanten (1+ε)
Approximationsalgorithmen wurden neulich auch Fehler gemacht, indem „mapping subjective features“ von Punkten im euklidischen Raum benutzt wurden, wobei ε eine gewöhnliche
kleine Konstante sein kann. Dies führte zu Algorithmen mit einer stark verbesserten Laufzeit, doch das „mapping“ bzw. Abbilden war fehlerhaft. In diesem Paper [14] wurde der erste
echte Linearzeit (1+ε)-Approximationsalgorithmus für das k-means Clustering vorgestellt,
wobei diese Proseminar-Arbeit nur Sachverhalte bis zum 2-means Clustering beschreibt und
ε und k als Konstante betrachtet werden. Weiteres ist in der Seminararbeit von Markus Heberling zu finden, welcher sich weitergehend mit dem k-means Clustering beschäftigt.
Es folgt die Beschäftigung mit bzw. Darstellung von den zugrundeliegenden Sachverhalten, welche sukzessive zum Beweis des „... Simple Linear Time (1+ε)-Approximation
Algorithm for k-Means Clustering in Any Dimensions“ für k = 2 führt.
1.1 Verwandte Themen
Kumar und andere [14] stellten fest, dass der schnellste exakte Algorithmus für das kmeans clustering Problem von Inaba und anderen[12] eingebracht wurde. Diese berücksichtigten, dass die Anzahl der Voronoi Partitionen von k Punkten in Rd O(nkd ) ist und so
das optimale k-means clustering exakt in O(nkd+1 ) Zeit berechnet werden könnte. Inaba und andere haben ebenfalls einen randomisierten (1+ε)-Approximationsalgorithmus
für das 2-means clustering Problem mit Laufzeit von O(n/εd ) entwickelt. Matousek[15]
soll einen deterministischen (1+ε)-Approximationsalgorithmus für das k-means Problem
2
in Laufzeit von O(nε−2k d log k n) entwickelt haben, Bâdoiu und andere [3] einen (1+ε)O(1)
Approximationsalgorithmus für das k-median Problem mit Laufzeit O(2(k/ε) dO(1) nlog O(k) n).
Letzterer soll erweitert werden können zu einem (1+ε)-Approximationsalgorithmus für das
k-means Problem mit gleicher Laufzeit. W. F. de la Vega und andere [7] sollen einen (1+ε)Approximationsalgorithmus für das k-means Problem erarbeitet haben, welcher gut auf
Punkte im hoch dimensionalen Raum anzuwenden sei. Die Laufzeit sei O(g(k, ε)nlog k n)
wobei g(k, ε) = exp[(k 3 /ε8 )(ln(k/ε)lnk)] sein soll. Ebenfalls sollen kürzlich Har-Peled und
andere[11] einen (1+ε)-Approximationsalgorithmus für das k-means Problem veröffentlich
haben, mit einer Laufzeit von O(n + k k+2 ε−(2d+1)k log k+1 nlog k 1ε ). Dieser sei jedoch ziemlich
kompliziert und soll sich auf Ergebnisse der algorithmischen Geometrie stützen. Das Wort
„exponentiell„ wurde dabei mit der Zahl der Dimension in Verbindung gebracht, so dass dies
nur für geringere Dimensionen anwendbar sei.
1.2 Die Leistung von Kumar und anderen[14]
Ein (1+ε)-Approximationsalgorithmus für das k-means Problem wird präsentiert. k und
ε werden als Konstanten betrachtet. Die Laufzeit soll besser im Vergleich zu allen vorher bekannten Algorithmen für dieses Problem sein. Der Algorithmus von Har-Peled und
Mazumdar[11] sei, trotz linear in n, nicht linear bezogen auf die Eingabegröße des Problems,
40
Holger Bürger
es sei dn (für n Punkte und d Dimensionen). Der Algorithmus ist daher nur für kleinere Dimensionen besser geeignet und zwar für d = Ω(logn). Der hier vorgestellte Algorithmus sei
viel schneller. Selbst die Verwendung des Johnson-Lindenstraus Lemmas mache die Laufzeit
nicht vergleichbar, da es seinen eigenen Overhead haben soll. Viele der neueren Algorithmen
verwenden Techniken, wie “exponential grid„ oder “scaling„ , welche ihren eigenen Overhead
haben sollen. Beispielsweise Normalisierung in Verbindung mit minimaler Distanz zwischen
Punkten verursache extra Kosten in Höhe von Ω(n) pro Punkt, abhängig von dem verwendeten Rechenmodell. In [3] sollen die Autoren Techniken für das Runden verwendet haben,
basierend auf Approximation für den optimalen Wert des k-Schwerpunktes ohne die Kosten
für diesen Prozess zu berücksichtigen. Die in dem jetzigen Algorithmus eingebettete Technik
habe keinen solchen Overhead.
Das 2-means clustering Problem hat auch schon in der Vergangenheit Forschungsinteresse geweckt. Der Algorithmus von Amit Kumar und anderen [14] stellt einen (1+ε)Approximationsalgorithmus für das 2-means clustering Problem mit konstanter WahrscheinO(1)
lichkeit in O(2(1/ε) dn) dar. Dies sei, laut Kumar und anderen, der erste (im Exponenten)
dimensionsunabhängige Algorithmus für das Problem, welcher in linearer Zeit zur Eingabegröße abläuft.
Die Basisidee des Algorithmus sei sehr einfach. Begonnen wird, wie bei Inaba und anderen [12], mit der Betrachtung einer Menge von Punkten, wobei ihr Schwerpunkt durch
Stichproben der Größe O(k) sehr gut approximiert werden kann. Es werden alle Teilmengen
mit dieser konstanten Größe ausprobiert und deren Schwerpunkte bestimmt. Das bedeutet,
dass man eine konstante Anzahl von Punkten dem größten Cluster zuordnet, bevor man
kleineren Clustern Punkte zuordnet - dies sei die Vorgehensweise. Das heisst wiederum,
dass der Algorithmus einen hohen konstanten Rechenaufwand produziert, aber im Sinne
des O-Kalküls immernoch “simpel„ wirkt.
Der Algorithmus des Papers soll, in Anlehnung an dem von Bâdoiu und anderen [3], sehr
einfach wirken. Beide beginnen mit der Zufallsauswahl von Punkten, jedoch muss der Algorithmus von Bâdoiu und anderen die Größe des kleineren Clusters raten und den Abstand
zwischen diesen. Dies verursacht einen Faktor für die Laufzeit von O(log k n). Der Algorithmus von Kumar und anderen [14] vermeidet dies komplett - dies macht ihn so wesentlich
einfacher.
2 Hauptteil
Von Kumar und anderen wird definiert, dass P eine Menge von n Punkten im euklidischen
Raum Rd sei. Weiterhin sei eine Menge von k Punkten K gegeben, welche als Schwerpunkte
bezeichnet werden. Definiert werden die k-means Kosten von P in Beziehung zu K, ∆(P, K),
als
∆(P, K) =
X
d(p, K)2 ,
p∈P
wobei d(p, K) die Distanz zwischen p und dem nächsten Punkt zu p in K beschreibt.
Das k-means Problem versucht eine Menge K von Größe k zu finden, so dass ∆(P, K)
minimiert ist. Sei ∆k (P ) die Bezeichnung für die Kosten der optimalen Lösung für das kmeans Problem in Beziehung zu P . Sollte K eine einelementige Menge sein y, wird ∆(P, K)
durch ∆(P, y) ersetzt. Sollte P eine einelementige Menge sein, geschieht dies analog.
(1+ε)-Approximation Algorithm for 2-Means Clustering
41
Definition 1. Wenn ∆k−1 (P ) ≥ (1 + 32ε)∆k (P ), ist die Menge von Punkten P (k, ε)irreduzibel, sonst ist sie (k, ε)-reduzibel.
Reduzierbarkeit impliziert hauptsächlich, dass nicht die optimale k-means Lösung gesucht wird, sondern die (k − 1)-means Lösung. Dies soll nahe an der vorherigen Lösung
liegen. Nun werden die Eigenschaften des 1-means Problems betrachtet.
2.1 Eigenschaften des 1-means Problems
P
Definition 2. Für eine Menge von Punkten P wird der Schwerpunkt c(P ) von P als
definiert.
p∈P
p
|P |
Für jeden Punkt in x ∈ Rd gilt:
∆(P, x) = ∆(P, c(P )) + |P | · ∆(c(P ), x).
(2)
D.h. Abstand zwischen einer Menge P und einem Punkt x ist definiert als die Summe
vom Abstand der Menge P zu seinem Schwerpunkt c(P ) und dem Produkt aus der Anzahl
der Elemente von P und dem Abstand zwischen x und dem Schwerpunkt c(P ) von P .
Im Paper wird nun Folgendes festgestellt: Ein Fakt ist, dass jede optimale Lösung für
das 1-means Problem unter Einbeziehung der Menge von Punkten P als Eingabe, c(P )
als Schwerpunkt wählt. Es soll eine weitere wichtige Eigenschaft für jede optimale Lösung
des k-means Problems gefolgert werden können. Angenommen eine optimale Lösung des
k-means Problems unter Einbeziehung der Eingabe P sei gegeben. Sei K = {x1 , . . . , xk }
eine Menge von Schwerpunkten, welche durch diese Lösung konstruiert wurde. K verursacht
eine Partitionierung der Menge von Punkten P in k Cluster, nämlich P1 , . . . , Pk . Pi ist die
Menge von Punkten für welche der nächste Punkt in K xi ist. In anderen Worten, die
Cluster korrespondieren mit den Punkten in den Voronoi-Regionen in Rd in Beziehung zu
K. Der gerade genannte Fakt impliziert nun, dass für alle i xi der Schwerpunkt von Pi sein
muss. Diese Feststellung scheint trivial.
Kumar und andere sagen aus, dass das Interesse in schnellen Algorithmen der Berechnung guter Approximationen für das k-means Problem gilt. Der Fall k = 1 wird zuerst
berücksichtigt. Inaba und andere [12] zeigten, dass der Schwerpunkt einer kleinen zufälligen
Stichprobe von Punkten aus P eine gute Approximation für c(P ) sein kann.
Lemma 1. [12] Sei T eine Menge von m Punkten, erhalten durch die zufällige, unabhängige,
gleichmäßige Auswahl von m Punkten aus einer Menge von Punkten P . Dann gilt für jedes
δ > 0,
1
∆(T, c(T )) < 1 +
∆1 (P )
δm
mit einer geringsten Wahrscheinlichkeit von 1 − δ.
Den Sachverhalt des Lemmas 1 aus [12] haben Kumar und andere als Voraussetzung benutzt.
Falls m mit der Eigenschaft 2ε gewählt wird, erhält man mit einer minimalen Wahrscheinlichkeit von 1/2 eine gute (1 + ε)-Approximation für ∆1 (P ), aufgrund der Wahl des Zentrums
von T gleichzeitg als Schwerpunkt für T und damit der approximierten 1-means Lösung
für P . Also erhält man durch Auswahl einer konstanten Größe schnell eine, im Sinne von
42
Holger Bürger
Kumar und anderen, gute Approximation für die optimale 1-means Lösung. Würde man
δ sehr viel kleiner wählen, würde zwar die Wahrscheinlichkeit größer werden, aber damit
auch die Ungenauigkeit. Letzterem könnte man wiederum nur durch die Auswahl von mehr
Punkten entgegenwirken.
Daraufhin wird angenommen P 0 sei eine Teilmenge von P und man möchte eine gute
Approximation für das optimale 1-means Problem für die Menge P 0 finden. Lemma 1 folgend, würde man von P 0 Punkte zur Berechnung auswählen. Ein Problem sei aber, dass P 0
nicht explizit gegeben ist. Das folgende, ebenfalls aus dem Paper stammende Lemma 2 sagt
aus, wenn die Größe von P 0 nahe der Größe von P ist, kann man eine leicht größere Anzahl
von Punkten aus P auswählen und hofft, dass diese Zufallsauswahl genug Punkte von P 0
enthält. In dem Paper werden jedoch vorerst folgende Sachverhalte weiter formalisiert.
Sei P eine Menge von Punkten und P 0 eine Teilmenge von P , mit der Eigenschaft, dass
|P 0 | ≥ β|P |, wobei β eine Konstante zwischen 0 und 1 ist. Angenommen man bestimmt eine
4
Auswahl S von P mit der Größe βε
. Nun betrachtet man alle möglichen Teilmengen von S,
2
0
genannt S , mit der Größe ε .
|P 0 | ≥ β · |P | ⇒
|P 0 |
|P |
≥β
Dann stelle man sich folgende Verhältnisgleichung vor:
4
|P | verhält sich zu βε
, wie |P 0 | zu x. Dies ergibt dann:
|P 0 |
|P |
=
x
4
βε
Will man nun x ausrechnen, erhält man:
4
βε
·
|P 0 |
|P |
=
4
βε
·β =
4
ε
0
|
4
Dabei wurde gleich |P
|P | durch β ersetzt und man erhielt letztendlich ε . Ziel war es, die
1-means Lösung für P 0 zu finden. Wir haben aber nur die Menge P gegeben und wissen,
das durch eine zufällige, unabhängige, gleichmäßige Stichprobenauswahl nach Lemma 1 die
Lösung approximiert werden kann. Also haben wir durch eine Stichprobenauswahl von P
4
mit der Größe βε
sogar eine größere Stichprobe für die unbekannte Teilmenge P 0 ( 4ε anstatt
2
ε ) zur Verfügung, um das Problem zu lösen.
Für jede dieser Teilmengen S 0 berechnet man nun den Schwerpunkt c(S 0 ) und betrachtet
es als potenzielles Zentrum für die 1-means Probleminstanz von P 0 . Anders ausgedrückt,
man betrachtet ∆(P 0 , c(S 0 )) für alle Teilmengen S 0 . Das folgende Lemma soll zeigen, dass
eine dieser Teilmengen eine Approximation für eine optimale 1-means Lösung für P 0 ergibt,
welche genau genug ist.
Lemma 2. (Superset Sampling Lemma) Das Folgende gilt mit konstanter Wahrscheinlichkeit:
minS 0 :S 0 ⊂S,|S 0 |= 2 ∆(P 0 , c(S 0 )) ≤ (1 + ε)∆1 (P 0 )
ε
Beweis. Mit konstanter Wahrscheinlichkeit enthält S mindestens
folgt aus Lemma 1. u
t
2
ε
Punkte von P 0 . Der Rest
(1+ε)-Approximation Algorithm for 2-Means Clustering
43
Es wird die Standardnotation B(p, r) benutzt, um die offene Kugel mit Radius r um
einen Punkt p zu beschreiben. Es wird angenommen, dass für den Eingabeparameter ε,
welcher im Faktor der Approximation enthalten ist, gilt: 0 < ε ≤ 1.
2.2 Ein Linearzeit-Algorithmus für das 2-means Clustering
Theorem 1. Gegeben sei eine Menge von n Punkten P im Rd . Es existiert ein Algorithmus,
welcher eine (1 + ε)-Approximation für die optimale 2-means Lösung der Menge P mit
O(1)
konstanter Wahrscheinlichkeit berechnet. Seine Laufzeit beträgt O(21/ε) dn).
Man beachte, dass das ε im Bruch des Exponenten der Laufzeit, wie weiter oben beschrieben, zwischen 0 und 1 liegt. Das bedeutet der Bruch ist gross, die Laufzeit damit lang,
aber sie ist linear zur Eingabe. Kumar und andere beweisen dies wie folgt:
Beweis. Sei α = ε/64. Es kann angenommen werden, das P (2, α)-irreduzibel ist. Aufgrund
eines Widerspruchbeweises nimmt man an, dass P (2, α)-reduzibel ist. Dann ist, aufgrund
von Definition 1, ∆1 (P ) ≤ (1 + ε/2)∆2 (P ). Man kann eine Lösung für das 1-means Problem
für P bekommen, in dem man den Schwerpunkt von P in O(nd ) Zeit ausrechnet, also den
Durchschnitt der Koordinaten pro Dimension. Die Kosten für dieses Problem sind höchstens
(1 + ε/2)∆2 (P ). So hätte man das Theorem gezeigt, wenn P (2, α)-reduzibel wäre.
Angenommen es gäbe eine optimale 2-means Lösung für P . Seien c1 und c2 die beiden
Zentren dieser Lösung. Seien P1 die Punkte, welche näher an c1 als an c2 und P2 die
Punkte, welche näher an c2 als an c1 sind. So ist c1 der Schwerpunkt von P1 und c2 der
Schwerpunkt von P2 . Ohne Beschränkung der Allgemeinheit kann angenommen werden,
dass |P1 | ≥ |P2 |. Da |P1 | ≥ |P |/2, impliziert Lemma 2, dass wenn man eine Stichprobe S
der Größe O( 1ε ) aus der Menge P nimmt und betrachtet die Menge der Schwerpunkte aller
Teilmengen von S der Größe 2ε , dann hat mindestens einer dieser Schwerpunkte, genannt
c01 , die Eigenschaft ∆(P1 , c01 ) ≤ (1 + α)∆(P1 , c1 ). Da dieser Algorithmus [14] alle Teilmengen
von S durchläuft, kann angenommen werden, dass solch ein Punkt c01 gefunden wurde. Sei
t die Distanz zwischen c1 und c2 , also d(c1 , c2 ) = t.
Lemma 3. d(c1 , c01 ) ≤ t/4
Beweis. Aufgrund eines Widerspruchbeweises wird angenommen, dass
d(c1 , c01 ) > t/4
ist. Gleichung 2 impliziert
∆(P1 , c01 ) − ∆(P1 , c1 ) = |P1 |∆(c1 , c01 ) ≥
t2 |P1 |
16 .
Bemerkung: x aus Gleichung 2 ist hier c01 und ∆(P1 , c1 ) wurde von der Gleichung sub2 |P |
1
entsteht aus Gleichung 1, so ist ∆(c1 , c01 ) = d(c1 , c01 )2 und dies ist wiederum
trahiert. t 16
t2
t2
laut Annahme ≥ (t/4)2 = 16
. ∆(c1 , c01 ) wurde also im rechten Teil durch 16
substituiert.
Man weiss ebenfalls, dass die linke Seite höchstens α∆(P1 , c1 ) beträgt. Daraus ergibt
sich t2 |P1 | ≤ 16α∆(P1 , c1 ). Gleichung 2 nochmal angewendet ergibt weiterhin
44
Holger Bürger
∆(P1 , c2 ) = ∆(P1 , c1 ) + t2 |P1 | ≤ (1 + 16α)∆(P1 , c1 ).
Daher ist ∆(P, c2 ) ≤ (1 + 16α)∆(P1 , c1 ) + ∆(P2 , c2 ) ≤ (1 + 16α)∆2 (P ).
Dies widerspricht dem Fakt, das P (2, α)-irreduzibel ist. u
t
Nun wird die Kugel B(c01 , t/4) betrachtet.
Das vorhergehende Lemma impliziert, dass sich diese Kugel in der Kugel B(c1 , t/2) mit
0
t/4
c1
c’1
t/2
3t/4
t
Abb. 1. Verhältnis zwischen B(c01 , t/4) zwischen B(c1 , t/2)
Radius t/2 und Mittelpunkt c1 befindet. So beinhaltet P1 B(c01 , t/4). Da nach dem Punkt
c2 gesucht wird, können die Punkte dieser Kugel gelöscht werden und es wird gehofft, dass
die verbleibende Menge von Punkten eine guten Anteil an Punkten von P2 enthält. In dem
zugrundeliegenden Paper wird dies als nächstes bewiesen. Sei P10 die Menge von Punkten
P1 − B(c01 , t/4). Sei P 0 die Menge P10 ∪ P2 . Wie gerade erwähnt ist P2 Teilmenge von P 0 .
Behauptung. |P2 | ≥ α|P10 |
Beweis. Aufgrund eines Widerspruchbeweises wird angenommen, dass
|P2 | ≤ α|P10 | ist.
Beachte
∆(P1 , c01 ) ≥ ∆(P10 , c01 ) ≥
t2 |P10 |
16
Aus ∆(P1 , c01 ) ≥ (1 + α)∆(P1 , c1 ) folgt
t2 |P10 | ≤ 16(1 + α)∆(P1 , c1 )
(3)
Weiterhin
∆(P, c1 ) = ∆(P1 , c1 ) + ∆(P2 , c1 )
= ∆(P1 , c1 ) + ∆(P2 , c2 ) + t2 |P2 |
≤ ∆(P1 , c1 ) + ∆(P2 , c2 ) + 16α(1 + α)∆(P1 , c1 )
≤ (1 + 32α)∆(P1 , c1 ) + ∆(P2 , c2 )
≤ (1 + 32α)∆2 (P )
folgt die 2. Gleichung aus 2, während die 3. Ungleichung aus 3 und dem Sacherverhalt
(1+ε)-Approximation Algorithm for 2-Means Clustering
45
|P2 | ≥ α|P10 | folgt. Dies widerspricht jedoch dem Fakt das P (2, α)-irreduzibel ist. Dies
beweist die Behauptung. u
t
Kumar und andere kombinieren nun Lemma 1 und die vorhergehende Behauptung und
implizieren damit, dass wenn eine Stichprobe von O( α12 ) Punkten von P 0 genommen wird
und man die Schwerpunkte aller Teilmengen von Größe α2 dieser Stichprobe betrachtet, dann
sollte mit konstanter Wahrscheinlichkeit ein Punkt c02 gefunden werden, für den ∆(P2 , c02 ) ≤
(1 + α)∆(P2 , c2 ) zutrifft. Aufgrund dessen finden sie die Schwerpunkte c01 und c02 , welche die
Vorraussetzungen für das Lemma 3 erfüllen.
Das einzige Problem besteht darin, dass der Parameter t nicht bekannt ist. Dieser muss
“geraten„ werden, wobei die Eigenschaft des Algorithmus, dass er nur lineare Zeit zur Eingabe verbraucht, nicht verletzt werden dürfe.
Sie schrieben, das angenommen werden darf, dass c01 (unabhängig von t) gefunden wurde. Es müsse von P 0 (alle Punkte der Menge P , außer denen, welche innerhalb der Kugel
B(t/4,c01 ) lagen) eine Stichprobe genommen werden. Angenommen man kenne den Paramen
ter i, so dass 2ni ≤ |P 0 | ≤ 2i−1
gilt. Betrachte man nun die Punkte in P in absteigender
n
0
Reihenfolge der Distanz zu c1 . So seien Q0i die ersten 2i−1
Punkte in dieser Sequenz. Man
beachte, dass P 0 eine Teilmenge von Q0i ist und |P 0 | ≥ |Q0i |/2. Ebenfalls kann Q0i in linearer
n
Zeit gefunden werden, da man den Punkt an der Position 2i−1
in linearer Zeit finden kann.
0
0
Aus |P2 | ≥ α|P | ergibt sich |P2 | ≥ α|Qi |/2. Folglich impliziert Lemma 1, dass es ausreichend ist O( α12 ) Punkte von Q0i zu nehmen, um c02 mit konstanter Wahrscheinlichkeit zu
lokalisieren.
Ein Problem sei jedoch, dass nun der Wert von i unbekannt ist. Alles auszuprobieren
kostet O(n log n) Zeit, unter der Bedingung, dass α und d als Konstante betrachtet werden. Approximierende Distanzsuche könne ebenfalls nicht verwendet werden kann, da die
Vorverarbeitung ebenfalls O(n log n) Zeit brauchen würde.
Die Idee der Stichprobennahme und das Raten des Wertes i wurde kombiniert. Der
zugrundeliegende Algorithmus verfährt wie folgt: Er probiert Werte für i in der Reihenfolge
0, 1, 2, . . . . Mit der Iteration von i wird die Menge Q0i gefunden. Man beachte, dass Q0i+1
eine Teilmenge von Q0i ist. Genauer betrachet ist Q0i+1 die Hälfte von Q0i und weiter von c0i
entfernt. So wird in Iteration (i + 1) begonnen durch Stichprobenentnahme aus Menge Q0i ,
anstelle von P 0 um den Punkt c02 zu finden. Folglich wird Q0i+1 in linearer Zeit zu |Q0i+1 |
gefunden.
Die folgende Grafik soll nocheinmal den Sachverhalt für n=8 verdeutlichen. Die Rahmen
sind jeweils mit dem Wert für i beschriftet.
i=3
i=2
i=1
i=0
t
c’1
Abb. 2. Punkte der Menge Q0i für n=8 und verschiedene i
46
Holger Bürger
Die weitere Iteration von i führt außerdem zu der Summe ∆(P − Q0i+1 , c01 ). Weil ∆(P −
Q0i+1 , c01 ) = ∆(P − Q0i , c01 ) + ∆(Q0i − Q0i+1 , c01 ) ist, kann ∆(P − Q0i+1 , c01 ) in Interation i + 1
in linearer Zeit zu Q0i+1 berechnet werden. Dies wird benötigt, da Kumar und andere c02 in
Iteration i + 1 finden. Dann wird die 2-means Lösung berechnet, wenn alle Punkte P − Q0i c01
zugewiesen sind und die Punkte in Q0i dem näheren von c01 und c02 zugewiesen wurden. Dies
wird in linearer Zeit zu |Q0i+1 | getan, wenn die Beträge zu ∆(P − Q0i , c01 ) für alle i bestimmt
wurden.
Kumar und andere merken an, dass daraufhin ersichtlich ist, dass die Iteration i lineare
Zeit zu |Q0i | benötigt. Da sich der Betrag von |Q0i | um Faktor 2 verringert, beträgt die
O(1)
gesamte Laufzeit für einen gegebenen Wert von c01 O(21/α dn). Da es für c01 auch nur
O(1)
O(21/α ) Möglichkeiten gibt, ist die Laufzeit konstant.
Behauptung. Die Kosten ∆ des Algorithmus liegen zwischen ∆2 (P ) ≤ ∆ ≤ (1 + α)∆2 (P ).
Nun folgt der letzte Beweis, wortwörtlich übersetzt.
Beweis. ∆2 (P ) ≤ ∆ ist offensichtlich, da jedem Punkt eines der beiden Zentren zugeordnet
wird, unter damit verbundenen Kosten. Nun wird die Menge von Zentren betrachet, wobei jedes Zentrum ein (1 + α)-approximierter Schwerpunkt seines entsprechenden Clusters
ist. Wenn jeder Punkt einem approximierten Schwerpunkt eines entsprechenden Clusters
zugeordnet wird, folgt daraus, dass ∆ ≤ (1 + α)∆2 (P ) ist. Wenn die minimalen Kosten
C betrachtet werden, können die konkreten Kosten nur besser sein als die Kosten dieses
Algorithmus [14], da nur approximierte Schwerpunkte verwendet werden, aufgrund der in
Beziehung stehenden Voronoi-Partitionen. werden. So ergibt sich ∆(C) ≤ ∆ ≤ (1+α)∆2 (P ).
t
u
t
u
3 Schluß
Zusammenfassend ist zu sagen, dass dieser Algorithmus im Vergleich zu den anderen, in
der Einleitung angesprochenen Algorithmen tatsächlich sehr einfach wirkt. Als erstes wurde
festgestellt, dass die maximalen Abstände von Punkten zu ihren Schwerpunkten zu minimieren sind. Dann wurde der Sachverhalt verwendet, dass es möglich ist, bei einer Menge
von Punkten P , für eine unbekannte Untermenge P 0 eine gute Approximation durch das
Durchprobieren aller möglichen Teilmengen bestimmter Größe von P für das 1-means Problem zu finden. Daraufhin wurde dem ersten größeren Cluster viele Punkte zugeordnet und
einem weiteren Cluster Punkte durch Zufallsauswahl zugeordnet, dies mit einer linearen
Laufzeit zur Eingabegröße im Sinne des O-Kalküls. Jedoch wurde festgestellt, dass dieser
Algorithmus einen starken konstanten Rechenaufwand produziert. Das die “Brauchbarkeit„
dieses Algorithmus für kleinere Dimensionen und Eingabegröße eher gering ist, wird in der
Seminararbeit von Markus Heberling des gleichen Seminars noch näher erläutert.
Literaturverzeichnis
1. S. Arora, P. Raghavan und S. Rao, 1998, Approximation schemes for euclidean k-medians and related
problems. In Proceedings of the thirtieth annual ACM symposium on Theory of computing, Seite 106-113.
ACM Press.
(1+ε)-Approximation Algorithm for 2-Means Clustering
47
2. V. Arya, N. Garg, R. Khandekar, K. Munagala und V. Pandit, 2001, Local search heuristic for k-median
and facility location problems. In Proceedings of the thirty-third annual ACM symposium on Theory of
computing, Seite 21-29. ACM Press.
3. M. Bâdoiu, S. Har-Peled and P. Indyk, 2002, Approximate clustering via core-sets. In Proceedings of
the thirty-fourth annual ACM symposium on Theory of computing, Seite 205-257. ACM Press.
4. M. Bern und D. Eppstein, 1997, Approximation algorithms for geometric problems. Seite 296-345.
5. A. Broder, S. Glassman, M. Manasse und G. Zweig, 1997, Syntactic clustering of the web. In Proceedings
of the 6th International World Wide Web Conference.
6. I. N. Bronstein, K. A. Semendjajew, G. Musiol und H. Mühlig, 2001, Taschenbuch der Mathematik, 5.
überarbeitete und erweiterte Auflage, Seite 624. Verlag Harri Deutsch.
7. W.F. de la Vega, M. Karpinski, C. Kenyon und Y. Rabani, 2003, Approximation schemes for clustering
problems. In Proceedings of the thirty-fifth annual ACM symposium on Theory of computing, Seite 50-58.
ACM Press.
8. S. Deerwester, S. Dumais, G. Furnas, T. Landauer und R. Harshman, 1990, Indexing by latent semantic
analysis.
9. R. O. Duda, P. E. Hart und D. G. Stork, 2000, Pattern Classification. Wiley-Intersience Publication.
10. C. Faloutsos, R. Barbar, M. Flickner, J. Hafner, W. Niblack, D. Petkovic und W. Equitz, 1994, Efficient
and effective querying by image content. J. Intell. Inf. Syst., 3(3-4):231-262.
11. S. Har-Peled and S. Mazumdar, 2004, On coresets for k-means and k-median clustering. In Proceedings
of the thirty-sixth annual ACM symposium on Theory of computing, Seite 291-300. ACM Press.
12. M. Inaba, N. Katoh, und H. Imai, 1994, Applications of weighted voronoi diagrams ans randomization
to variance-based k-clustering: (extended abstract). In Proceedings of the tenth annual symposium on
Computational geometry, Seite 332-339. ACM Press.
13. S. Kolliopoulos and S. Rao, 1999, A nearly linear time approximation scheme for the euclidean k-medians
problem. In Proceedings of the 7th European Symposium on Algorithms, Seite 326-371.
14. Amit Kumar and Yogish Sabharwal and Sandeep Sen, 2004, A Simple Linear Time (1 + ε) - Approximation Algorithm for k-Means Clustering in Any Dimensions. In Proceedings of the 45th Annual IEEE
Symposium on Foundations of Computer Science, Seite 454-462.
15. J. Matousek, 2000, On approximate geometric k-clustering. In Discrete and Computational Geometry,
Seite 61-84.
Skalierbare Peer-to-Peer-Netzwerke
Andreas Vogelsang
Universität Paderborn [email protected]
Zusammenfassung. Peer-to-Peer-Netzwerke (P2P-Netzwerke) verursachen allein in Deutschland inzwischen über 69% des Verkehrsaufkommens im Internet [4]. Besonders die große Anzahl an Teilnehmern und
die hohe Inhomogenität der Teilnehmer untereinander, macht es schwierig ein P2P-Netzwerk zu konzipieren,
das in Bezug auf eine Datumssuche gut skalierbar ist. In dieser Arbeit wird, neben einer Einführung in die
Welt der P2P-Netzwerke, mit dem Content-Adressable Network (CAN) ein P2P-Netzwerk vorgestellt, das
unter Verwendung von Distributed Hash Tables eine effiziente und gut skalierbare Datumssuche bereitstellt.
1
P2P-Netzwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
1.1
1.2
1.3
1.4
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Entstehung, Geschichte, Vorteile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Napster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gnutella . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
DHT – Distributed Hash Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
50
50
51
53
2.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.2 Hash Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.3 Distributed Hash Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3
CAN – Content-Addressable Network . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.1
3.2
3.3
3.4
3.5
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verwendung von DHT in CAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Funktionsweise und Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verbesserungsmöglichkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
59
59
59
66
69
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
1 P2P-Netzwerke
In diesem Kapitel soll eine Einführung in das Thema P2P-Netzwerke gegeben werden. Neben
einer Definition sowie Daten zur Entwicklung und Geschichte werden mit Napster und
Gnutella zwei bekannte und bedeutende Netzwerke vorgestellt. Abbildungen und Inhalt
sind angelehnt an [5].
50
Andreas Vogelsang
1.1 Einleitung
Als Peer-to-Peer Netzwerke (P2P-Netzwerke) werden Netzwerke bezeichnet, in denen alle Teilnehmer gleichbehandelt werden. Das Netzwerk verwaltet und organisiert sich vollständig selbst ohne zentrale Instanz oder höhergestellte Teilnehmer. Die Teilnehmer eines
P2P-Netzwerks werden als Peers (dt.: Gleichrangige, Ebenbürtige) bezeichnet. Diese Idee
steht im Gegensatz zu der vorherrschenden Client-Server-Netzwerk-Struktur, bei der jeder
Teilnehmer entweder die Rolle des Dienstanbieters (Server ) oder die des Dienstkonsumenten (Client) annimmt. Die Verwaltung des Netzwerkes wird dabei meistens ausschließlich
von den Servern übernommen. Diese Rollenverteilung wird in einem P2P-Netzwerk derart
aufgebrochen, dass jeder Teilnehmer gleichzeitig die Rolle des Servers und des Clients annehmen kann. Daraus folgt auch, dass die Verwaltung des Netzwerkes von allen Teilnehmern
gleichermaßen übernommen wird.
Ein P2P-Netzwerk ist gut skalierbar, wenn es bei steigender Teilnehmer-, oder Datenlast
nicht übermäßig an Leistung verliert, oder gar ausfällt. Der Begriff Robustheit beschreibt
das Verhalten des Netzwerks bei ausfallenden Teilnehmern, oder anderen unerwarteten Ereignissen.
P2P-Netzwerke sind in der Regel Overlay Netzwerke, die auf das bestehende Internet aufgesetzt werden. Das heißt, auf die bestehende Netzwerkstruktur des bekannten Internets wird
auf Anwendungsebene eine zusätzliche Netzwerkstruktur aufgesetzt, die das P2P-Netzwerk
darstellt. Dieses kann zu Verwirrungen führen, wenn man über Eigenschaften des P2PNetzwerks spricht, denn das P2P-Netzwerk ist unabhängig von dem darunter liegenden
Internet zu betrachten. So können zum Beispiel zwei unmittelbar benachbarte Teilnehmer
eines P2P-Netzwerks im darunter liegenden Internet viele tausend Kilometer oder Routerhops entfernt sein.
1.2 Entstehung, Geschichte, Vorteile
Das erste Netzwerk, das als P2P-Netzwerk bekannt wurde, war Napster, welches Shawn
„Napster“ Fanning 1999 herausbrachte. Die Software, deren ursprüngliche Aufgabe die Bereitstellung eines File-Sharing-Systems war, erlangte schnell Popularität, da sie von vielen
missbraucht wurde um urheberrechtlich geschützte Musik bereitzustellen oder herunterzuladen. Die immer weiter steigende Beliebtheit führte zusammen mit den sinkenden Zahlen der
CD-Verkäufe dazu, dass die Musikindustrie immer stärkeren juristischen Druck auf die Betreiber von Napster ausübte, was schließlich Ende 2000 zur Schließung dieses P2P-Netzwerks
führte. Ironischerweise hing das abrupte Ende umittelbar mit der Tatsache zusammen, dass
Napster kein P2P-Netzwerk im eigentlichen Sinne war, sondern eine zentrale Instanz zur
Verwaltung der Indexdaten hatte. Mehr dazu in Kapitel 1.3.
Nach dem Scheitern von Napster versuchten viele Entwickler, den Kerngedanken der P2PNetzwerke stärker in eine Implementierung einfließen zu lassen. Ein Ergebnis war das Gnutella Netzwerk, dessen Client-Software im Jahr 2000 von Justin Frankel zum kostenlosen
Download freigegeben wurde. Da dieses Netz völlig ohne zentrale Instanzen auskommt, ist
es praktisch unangreifbar, denn es existiert, sobald nur ein Teilnehmer im Netz ist. Ausführlicher wird Gnutella im Kapitel 1.4 beschrieben.
Im Laufe der Jahre kamen immer mehr Protokolle und Implementierungen auf den Markt,
die immer leistungsfähigere P2P-Netzwerke zur Verfügung stellten.
Skalierbare Peer-to-Peer-Netzwerke
51
Im Jahr 2008 werden P2P-Netzwerke zu verschiedensten Zwecken verwendet. Neben P2PFile-Sharing Netzen wie Bittorrent [1] existieren auch P2P-VoIP-Netze wie Skype [2] oder
P2P-Netzwerke, die als Ziel haben, die Anonymität und somit das Grundrecht auf Meinungsäußerung zu sichern wie z.B. das Freenet [3]. Studien haben ergeben, dass in Deutschland
über 69% des Verkehrsaufkommens im Internet über P2P Protokolle verursacht werden [4].
1.3 Napster
Einleitung
Napster war das erste als P2P-Netzwerk bezeichnete Netzwerk. Im Juni 1999 stellte Shawn
„Napster“ Fanning eine Beta-Version der zum Netz gehörigen Client Software zum kostenlosen Download bereit. Durch das Engagement eines Freundes von Fanning wurde das Netz,
welches ursprünglich ein File-Sharing-System bereitstellen sollte, zu einem Portal zur Verbreitung von Musikdateien. Diese Funktionalität brachte der Software eine hohe Popularität
und machte sie bereits im Herbst 1999 zum Download des Jahres [5].
Die einfache und schnelle Verbreitung von Musikdateien über Napster zog allerdings zahlreiche Verstöße gegen das Urheberrecht nach sich, so dass Napster Ende 2000 unter dem
juristischen Druck der Musiklabels geschlossen werden musste. Im Anschluss ging Fanning
einen Kooperationsvertrag mit Bertelsmann Ecommerce ein und vermarktet seitdem ein
Client-Server-basiertes kommerzielles File-Sharing-System unter dem Namen Napster.
Funktionsweise
Abb. 1. Die Funktionsweise von Napster
52
Andreas Vogelsang
So rasant der Popularitätsanstieg von Napster war, so einfach ist die Funktionsweise.
Wie Abbildung 1 zeigt, melden sich alle Teilnehmer des Netzwerks an einem Server an.
Eine Dateianfrage (Query) wird von einem Client zum Beispiel in Form des zu suchenden
Dateinamens an den Server übermittelt. Auf dem Server sind Informationen zu der entsprechenden Datei gespeichert. Unter anderem besitzt der Server eine Liste von Netzteilnehmern,
die diese Datei lokal bei sich gespeichert haben. Der Server schickt dem anfragenden Client
eine Reply-Nachricht als Antwort, die eine Liste mit allen Clients enthält, die die gesuchte
Datei bereitstellen. Die gesuchte Datei kann nun direkt von den Teilnehmern heruntergeladen werden.
Evaluierung
Napster war zwar das erste Netzwerk, das unter dem Namen P2P-Netzwerk bekannt wurde,
aber nach der in Kapitel 1.1 gegebenen Definition handelt es sich bei Napster nicht um
ein reines P2P-Netzwerk. Genauer gesagt entspricht lediglich der direkte Dateidownload
von einem anderen Teilnehmer des Netzes der Definition. Die Suche nach einer bestimmten
Datei und das Herausgeben der Kontaktdaten zu Besitzern dieser Datei wird über eine
zentrale Instanz, den Server, organisiert. Gerade dieser Umstand machte es möglich, dass
Napster von einem auf den anderen Tag geschlossen werden konnte. Nachdem die Server,
die für die Dateisuche zuständig waren, abgeschaltet wurden, konnte kein Teilnehmer des
Netzes mehr eine erfolgreiche Suchanfrage starten.
Stärken
Napster ist eine vergleichsweise einfache Möglichkeit, ein schnelles und effizientes FileSharing-System zu implementieren. Durch die Client-Server-Struktur ist es für die Betreiber
einfach zu organisieren und zu koordinieren. Wenn eine Datei im Netzwerk vorhanden ist,
dann wird sie durch die Dateisuche auch gefunden und kann direkt heruntergeladen werden.
Schwächen
Die großen Nachteile der in Napster genutzten Client-Server-Struktur liegen in den Bereichen Robustheit und Skalierbarkeit. Bei Ausfall des verwendeten Servers ist das ganze
Netz funktionsunfähig. Es handelt sich also bei dem Server um einen sogenannten „single
point of failure“. Das Netz ist an dieser Stelle von außen besonders angreifbar. Ebenso kann
ein gesteigertes Datei- oder Teilnehmeraufkommen den Server, der diesen verwalten muss,
überlasten und so ebenfalls zu einem Zusammenbruch des Netzes führen.
Erkenntnisse
Die hohe Popularität Napsters ließ erahnen, welche Möglichkeiten P2P-Netzwerke bieten.
Viele Wissenschaftler und Firmen forschten in Folge an weiterentwickelten Netzwerken.
Dabei wurden die bei Napster aufgetauchten Schwächen schnell zu Kernfeldern der Weiterentwicklung. Vor allem die Entwicklung einer verteilten Indexsuche, die es ermöglicht,
Dateien ohne eine zentrale Instanz im Netzwerk effizient zu finden, ist eine der wichtigsten
Problemstellungen beim Entwurf eines P2P-Netzwerks.
Skalierbare Peer-to-Peer-Netzwerke
53
1.4 Gnutella
Einleitung
Im März 2000 stellten Justin Frankel und Tom Pepper von der Firma Nullsoft das GnutellaNetzwerk [6] vor. Bei dem Versuch, die Schwächen des in Kapitel 1.3 vorgestellten Napster
auszumerzen, entstand ein P2P-Netzwerk, das diesen Namen auch in allen Teilen des Netzes
verdient. Wie Napster auch ist Gnutella ein reines File-Sharing-System und bietet daher von
der Funktionsweise wenig Innovatives. Die Netzwerkstruktur und die Indexsuche jedoch setzt
sich deutlich von der in Napster ab.
Funktionsweise
Jeder Teilnehmer des Gnutella Netzwerkes verwaltet eine Menge von Nachbarknoten. Um
eine solche Menge zu erhalten, kontaktiert ein neuer Peer des Netzwerkes eine Reihe von
Peers, deren Adressen er durch eine Initialliste, die mit der Clientsoftware ausgeliefert wird,
erhält. Der Kontakt wird hergestellt, indem der neue Peer eine sogenannte Ping-Nachricht
nacheinander an die Peers der Initialliste schickt. Der erste Peer der Liste, der aktiv ist,
antwortet mit einer Pong-Nachricht und leitet die Ping-Nachricht an alle Peers seiner Nachbarmenge weiter. Diese verfahren in derselben Weise bis zum k -nächsten Nachbarn des
ersten kontaktierten Peers. Pong-Nachrichten werden auf dem selben Weg zurückgesendet,
wie die dazu gehörige Ping-Nachricht. Der neue Peer erhält so durch den Empfang von
Pong-Nachrichten eine Liste von aktiven Peers. Aus diesen Peers sucht sich der neue Peer
zufällig m Peers aus, die dann seine Nachbarschaft definieren. Der Enstehungsprozess der
Gnutella-Netzwerkstruktur ist also völlig zufällig und bedarf keiner zentralen Instanz (wie
etwa bei einem Server) außer dem sogenannten TTL-Feld (time to live), das die Tiefe k der
Rekursion festlegt, indem es bei jeder Ping-Nachrichten-Weiterleitung um eins verringert
wird.
Die Dateisuche ist analog zum Anmeldeprozess. Eine Query-Nachricht wird rekursiv an alle
Nachbarn bis zur Tiefe k geschickt und von einem Peer p mit einer QueryHit-Nachricht
beantwortet, wenn die gesuchte Datei von p bereitgestellt werden kann. Der Initiator der
Suche kann die Datei dann direkt von Peers herunterladen, die ihm mit einem QueryHit
geantwortet haben (siehe auch Abbildung 2). In Algorithmus 4 und 5 ist die Indexsuche von
Gnutella in Pseudo-Code angegeben.
Algorithmus 4 Dateisuche in Gnutella(1): Suche(Datei x, Knoten p)
Vorbedingung: Knoten p sucht Datei x. Sei N die Menge der Nachbarn von p. Download(p0 , x) startet
den direkten Download der Datei x vom Knoten p0 .
for all n ∈ N do
send Query(p, x, T T L) to n
wait until receipt of a QueryHit or timeout
if receipt a QueryHit(p0 , x) then
download(p0 , x)
54
Andreas Vogelsang
Algorithmus 5 Dateisuche in Gnutella(2): Empfang eines Query(Knoten p, Datei x, int
T T L) bei einem Knoten p0
Vorbedingung: Knoten p0 hat Query(p, x, T T L) von Knoten p mit der Anfrage nach Datei x und time-tolive Wert T T L empfangen. Sei DB die lokale Datenbasis des Knotens p0 und N die Menge der Nachbarn
von p0 .
if x ∈ DB then
send QueryHit(p0 , x) to p
if T T L 6= 0 then
for all n ∈ N do
send Query(p0 , x, T T L − 1) to n
while not timeout do
On receipt of a QueryHit(q, x) send QueryHit(q, x) to p
Abb. 2. Die Dateisuche in Gnutella. Eine Query-Nachricht mit TTL-Wert 2 wird rekursiv an alle Nachbarn
weitergeleitet (a). Peers, die die gesuchte Datei bereitstellen können antworten mit einer QueryHit-Nachricht
(b). Anschließend kann die gesuchte Datei direkt heruntergeladen werden (c).
Evaluierung
Wie beschrieben kommt das Gnutella Netzwerk gänzlich ohne strukturierende oder organisierende Instanzen aus, was es zum ersten P2P-Netzwerk im eigentlichen Sinne macht.
Durch die Vermeidung eines dedizierten Servers löst Gnutella eines der großen Probleme
von Napster. Auch die Indexsuche als völlig dezentralisierter Algorithmus wurde in Gnutella zum ersten Mal umgesetzt. Diese Eigenschaften machen das Gnutella Netzwerk von außen
praktisch unangreifbar, da das Netzwerk besteht und funktioniert, sobald ein Teilnehmer
Skalierbare Peer-to-Peer-Netzwerke
55
im Netzwerk ist. Dass es dennoch möglich ist, das Netz so zu stören, dass Funktionen nur
noch eingeschränkt nutzbar sind, wird im Folgenden noch erklärt.
Stärken
Die Stärke von Gnutella liegt eindeutig in seiner verteilten Netzwerkstruktur, die es extrem
robust macht. Außerdem ist sie sehr gut skalierbar, da viele Knoten aufgenommen werden
können, ohne dass die Leistungsfähigkeit des Gesamtsystems darunter leidet.
Schwächen
Die Schwächen von Gnutella liegen in der verteilten Indexsuche, die im Gegensatz zur Netzwerkstruktur nicht gut skalierbar ist. Da die Suche nach einem Datum durch das TTL-Feld
tiefenbeschränkt ist, wird ein Datum, das im Netzwerk faktisch vorhanden ist, nicht sicher
gefunden. Nur, wenn das Datum von einem der k-nächsten Nachbarn bereitgestellt werden
kann, findet die Indexsuche das Datum auch. Eine Erhöhung des TTL-Feldes, um dieses
Problem zu umgehen, verstärkt nur noch die zweite gravierende Schwäche. Da es in keinster
Weise klar ist, in welcher Richtung des Netzwerkes sich ein Datum befindet, verursacht die
Indexsuche ein sehr hohes Nachrichtenaufkommen zwischen Knoten. Das Netzwerk wird mit
Suchanfragen regelrecht geflutet. Böswillige Teilnehmer, die besonders viele Suchanfragen
stellen, können so einzelne Netzwerkteilnehmer überfordern und das Netzwerk beträchtlich
stören.
2 DHT – Distributed Hash Tables
In diesem Kapitel sollen Distributed Hash Tables (DHT) als besonders geeignete verteilte
Datenstruktur für eine effiziente Indexsuche in P2P-Netzwerken vorgestellt werden. Abbildungen und Inhalt sind angelehnt an [5] und [8].
2.1 Motivation
Mitentscheidend für den Erfolg eines P2P-Netzwerks ist eine effiziente Datensuche innerhalb des Netzwerkes. Aus den Erfahrungen von Napster kann gefolgert werden, dass nur
eine verteilte Datenstruktur für P2P-Netzwerke Sinn macht, da sie ohne zentrale Instanzen
auskommt und so extrem robust und angriffssicher ist. Dieses Konzept der verteilten Datenstruktur wird bereits im Gnutella-Netzwerk verwendet, jedoch auf Kosten einer ineffizienten
Suche auf den Daten. Daten werden im Gnutella Netzwerk nicht zwangsläufig gefunden und
die Suche nach ihnen verursacht ein hohes Nachrichtenaufkommen. Eine Datenstruktur, in
der jeder Teilnehmer wüsste, wo er nach einem Datum suchen muss, würde eine gute Grundlage für eine effiziente Suche bilden. Ebenso wäre es wünschenswert, wenn Daten nahezu
auf alle Peers gleichverteilt wären, damit nicht das Problem der Überlastung einzelner Peers
mit sehr vielen Daten entsteht.
56
Andreas Vogelsang
2.2 Hash Tables
Eine Datenstruktur, die die genannten Anforderungen sehr gut erfüllt, sind Hash Tabellen. Sie werden in zahlreichen Software-Systemen verwendet und gehören zu der Grundausstattung moderner Betriebssysteme. In Hash Tabellen erfolgt die Verteilung von Daten
über eine Hash Funktion h : K → V, die jedem Datum unter Verwendung eines bestimmten
Schlüssels (Key) k ∈ K eine scheinbar zufällige Position (Value) v ∈ V zuweist.
Eine der einfachsten Hash Funktionen ist die Modulo-Funktion h(k) = k mod a, die einem
Key k den Wert zuweist, der als Rest bei einer Division von k durch a entsteht. Typischerweise ist a gleich der Größe des Wertebereiches V. Abbildung 3 zeigt, wie Keys mit Hilfe
der Modulo-Funktion auf Werte und somit auf Positionen abgebildet werden. Werden 2 verschiedene Keys auf einen Wert abgebildet, also gilt h(k1 ) = h(k2 ), k1 6= k2 spricht man von
einer Kollision. In der Praxis treten solche Kollisionen jedoch kaum auf, wenn ein ausreichend großer Wertebereich gewählt wird. Die Modulo-Funktion ist im allgemeinen als Hash
Funktion ungeeignet, da erreicht werden soll, dass Daten gleichmäßig auf den Wertebereich
verteilt werden und folglich ähnliche Keys auf sehr unterschiedliche Werte abgebildet werden müssen.
Dieses Konzept lässt sich auf Peer-to-Peer-Netzwerke übertragen, indem der Wertebereich
als Menge der Peers aufgefasst wird und die Hash Funktion Indexdaten von Dateien auf
einen bestimmten Peer abbildet. Benachbarte Elemente des Wertebereichs, also Peers sind
dabei jeweils verbunden (siehe Abbildung 3).
Diese Umsetzung bietet allerdings einige Nachteile. Da jeweils nur benachbarte1 Peers ver-
Abb. 3. Die Hash Funktion h(k) = k mod 5 bildet die Keys k = 23, 15, 7, 3 nacheinander auf den Wertebereich V = {0, 1, 2, 3, 4} ab. Elemente des Wertebereichs können als Peers und Keys als Indexdaten
interpretiert werden.
bunden sind, steigt die Suchzeit mit der Anzahl der teilnehmenden Peers linear. Ebenso
1
im Sinne der Anordung im Wertebereich
Skalierbare Peer-to-Peer-Netzwerke
57
verhält es sich mit dem Hinzufügen und dem Entfernen von Peers, bei dem die Neunummerierung lineare Zeit beansprucht. Der schwerwiegenste Nachteil ist jedoch, dass beim
Hinzufügen oder Entfernen von Peers die Hash Funktion angepasst werden muss, was im
schlechtesten Falle zu einer Umsortierung aller Key-Value-Paare führt.
2.3 Distributed Hash Tables
Distributed Hash Tables (DHT) sind in der Lage, die Umsortierung von Key-Value-Paaren
beim Hinzufügen oder Entfernen von Peers auf einen lokalen Bereich der Hash Table zu
beschränken. Dazu wird der Bildbereich in ein kontinuierliches Intervall geändert. Wird
beispielsweise das Intervall [0,1) gewählt, sieht die geänderte Hash Funktion wie folgt aus:
h : K → [0, 1). Diese Hash Funktion bildet die Keys k ∈ K der Daten auf einen Punkt des
Intervalls ab. Anders als bei den zuvor vorgestellten Hash Tables wird nun den Peers eines
P2P-Netzwerks nicht genau ein Element des Bildbereichs der Hash Funktion zugeordnet
sondern ein ganzer Bereich. Der Peer ist dann zuständig für alle Daten, deren Key von der
Hash Funktion auf den Bereich des Peers abgebildet wird.
Wird nun ein Peer hinzugefügt, wird diesem eine zufällige Position im Bildbereich zugeordnet. Der bisher für diese Position zuständige Peer teilt seinen Zuständigkeitsbereich und
übernimmt nur einen Teil des Bereiches, während der andere Teil vom hinzugefügten Peer
übernommen wird (siehe Abbildung 4). Ebenso verhält es sich beim Entfernen eines Peers.
Der Bereich des entfernten Peers wird einfach durch einen benachbarten Peer mit übernommen.
Somit verursacht das Hinzufügen und Entfernen von Peers in eine DHT nur lokale Änderungen der Key-Value-Paare und ist daher deutlich besser für P2P-Netzwerke geeignet als
Hash Tables. Diese Eigenschaft wird auch Konsistenz genannt.
Abb. 4. Nacheinander werden Peers der DHT hinzugefügt, indem sie eine zufällige Position zugewiesen
bekommen. Der bisher für diese Position zuständige Peer teilt sich nun den Zuständigkeitsbereich mit dem
neu hinzugefügten Peer.
58
Andreas Vogelsang
Lemma 1. In einer DHT der Größe m mit n Teilnehmern hat der Zuständigkeitsbereich
mit hoher Wahrscheinlichkeit (≥ 1 − n−c ) höchstens die Größe O( m
n log n) und mindestens
die Größe Ω( nmc ) (für eine Konstante c ≥ 0).
Beweis. Für die untere Schranke betrachten wir einen Peer pi , der einen solchen minimalen
Bereich der Größe nmc verwaltet. Die Wahrscheinlichkeit, dass ein neuer Peer auf diesen
Bereich abgebildet wird und somit den Bereich von pi verkleinert, ist gegeben durch
P (Peer wird in Bereich von pi abgebildet) =
=
Größe des Bereichs von pi
Größe der DHT
m
nc
m
m
=
mnc
1
= c
n
= n−c
Beim Hinzufügen von n Peers kann dieser Bereich maximal n mal geteilt werden, wodurch
die Wahrscheinlichkeit für eine weitere Verkleinerung beschränkt ist durch n−c+1 .
Für die obere Schranke betrachten wir die Wahrscheinlichkeit, dass kein Peer einem festen
m
Bereich der Größe B = O( m
n log n) = c n log n zugeordnet wird und somit ein Peer zuständig
ist für einen Bereich größer als dieser. Die Wahrscheinlichkeit, dass ein Peer dem Bereich B
zugeordnet wird, ist gegeben durch
Größe von B
Größe der DHT
c m log n
= n
m
c log n
=
n
P (ein Peer wird dem Bereich B zugeordnet) =
Somit ist die Wahrscheinlichkeit, dass ein Knoten nicht dem Bereich B zugeordet wird
n
1 − c log
n . Für die Wahrscheinlichkeit, dass B nach Einfügen von n Knoten immer noch
ungeteilt bleibt, gilt somit
c log n n
P (kein Peer teilt B) = 1 −
n
≤ e−
c log n
n
n
≤ n−c
Also ist die Wahrscheinlichkeit, dass ein Bereich der Größe B von n Peers nicht unterteilt
wird, sehr gering und somit sind die Zuständigkeitsbereiche der Peers in einer DHT mit sehr
t
hoher Wahrscheinlichkeit nicht größer als O( m
n log n). u
Geht man davon aus, dass die Daten gleichverteilt auf die ganze DHT sind, dann ist die
Menge an Daten, die ein Peer verwaltet proportional zur Größe seines Zuständigkeitsbereiches. Da die durchschnittliche Größe eines Bereiches der DHT m
n beträgt, folgt aus Lemma
1, dass ein Peer maximal nur log n mal mehr Daten verwaltet als der Durchschnitt.
Skalierbare Peer-to-Peer-Netzwerke
59
3 CAN – Content-Addressable Network
In diesem Kapitel soll gezeigt werden, wie Distributed Hash Tables in P2P-Netzwerken
verwendet werden können um eine effiziente Indexsuche zu gewährleisten. Dieses soll am
Beispiel des Content-Addressable Network (CAN) erläutert werden. Abbildungen und Inhalt
sind angelehnt an [5] und [7].
3.1 Einleitung
Das Content-Addressable Network (CAN) war das erste P2P-Netzwerk, das mit Hilfe von
Distributed Hash Tables eine effiziente Datensuche ermöglicht. Es wurde im Jahr 2000
von Sylvia Ratnasamy, Paul Francis, Mark Handley, Richard Karp und Scott Shenker in
einem Paper [7] vorgestellt. Die Verwendung von DHT ist mittlerweile zum Standard in
skalierbaren P2P-Netzwerken geworden.
3.2 Verwendung von DHT in CAN
In einem CAN wird eine Hash Funktion h : K → Q, Q = [0, 1) × [0, 1) eingesetzt, die Datenkeys k ∈ K auf eine kontinuierliche quadratische Fläche abbildet. Die Hash Funktion sorgt
dafür, dass Daten gleichmäßig auf die Fläche verteilt werden. Weiterhin wird die quadratische Fläche so partitioniert, dass jeder teilnehmende Peer für genau ein von mindestens n,
idealerweise gleich großen Rechtecken zuständig ist. Ein Peer verwaltet nun alle Daten, dessen Key auf die Fläche des Peers abgebildet wird. Offensichtlich wird hier das Konzept der
in Kapitel 2.3 vorgestellten DHT auf den 2-dimensionalen Raum übertragen. Eine mögliche
Verteilung von Peers und Daten auf eine quadratische Fläche im CAN zeigt Abbildung 5.
3.3 Funktionsweise und Analyse
Um die Funktionsweise eines CAN zu verstehen, sollen hier die grundlegenden Operationen
auf einem CAN beschrieben werden. Dabei soll der Schwerpunkt mehr auf den grundsätzlichen Ideen hinter den Operationen liegen und nicht so sehr auf Implementationsdetails.
Einfügen von Peers
Wird ein Peer pneu in ein CAN eingefügt, wählt er eine zufällige Position auf der Fläche
Q. Durch ein Verfahren, dass später erklärt wird, kontaktiert pneu den Peer palt , der bisher
für diese Position zuständig war. Nun wird der Zuständigkeitsbereich von palt in der Mitte
geteilt. Ist der Bereich ein Quadrat wird entlang der y-Achse geteilt sonst entlang der xAchse. Die beiden entstehenden Flächen werden von jeweils einem Peer übernommen (siehe
auch Abbildung 6).
Durch dieses Einfügeverfahren wird sichergestellt, dass sich die verteilte Datenstruktur nur
in einem kleinen lokalen Bereich ändert, da sich lediglich der Zuständigkeitsbereich eines
Knotens ändert. Diese Eigenschaft wird Konsistenz genannt und gibt der DHT auch den
Beinamen Consistent Hashing.
Im Unterkapitel Netzwerkstruktur und Routing wird gezeigt, dass sich beim Einfügen von
Knoten die Netzwerkstruktur des CAN ebenfalls nur lokal verändert.
60
Andreas Vogelsang
Abb. 5. Ein CAN mit Peers und Daten verteilt auf eine quadratische Fläche Q = [0, 1) × [0, 1).
Einfügen von Daten
Das Einfügen von Daten erfolgt analog zum Einfügen von Peers. Ein neu einzufügendes
Datum d1 bekommt von der Hash Funktion eine zufällige Position (x, y) auf der Fläche Q
des CAN zugewiesen. Der Peer p, in dessen Zuständigkeitsbereich der Punkt (x, y) liegt,
ist dann zuständig für das neue Datum d1 . Zuständig heißt in diesem Fall, er verwaltet
Meta-Daten, die zum Download des Datums d1 nötig sind 2 .
Offensichtlich ist die Menge an Daten, die ein Peer verwalten muss, proportional zur Fläche,
für die er zuständig ist. Zwar ist für den Einstieg eines neuen Peers jeder Punkt der Fläche
gleichwahrscheinlich, eine völlig gleichmäßige Verteilung der Fläche auf alle Peers ist jedoch
sehr unwahrscheinlich. Dennoch lässt sich die Größe des Zuständigkeitsbereiches eines Peers
nach oben hin beschränken.
Lemma 2. Sei PR,n die Wahrscheinlichkeit, dass ein Rechteck R mit Fläche A(R) nach
Einfügen von n Peers nicht unterteilt wird. Dann gilt
PR,n ≤ e−nA(R)
Beweis. Wir betrachten ein Rechteck R mit Fläche q = A(R) Die Wahrscheinlichkeit, dass
ein Peer beim Einfügen eine Position außerhalb von q zugewiesen wird, ist 1 − q, da für
2
z.B. eine Liste mit IP-Adressen aller Netzwerkteilnehmer, die das Datum zur Verfügung stellen
Skalierbare Peer-to-Peer-Netzwerke
61
Abb. 6. Durch mehrfaches Einfügen von Peers wird die Fläche des CAN immer weiter unterteilt.
die Gesamtfläche Q gilt A(Q) = 1. Diese Warscheinlichkeit ist unabhängig von anderen
eingefügten Peers. Daher gilt für die Wahrscheinlichkeit, dass n Peers eine Position außerhalb
von q zugewiesen bekommen (1 − q)n . Es gilt für alle m > 0:
1 m 1
1−
≤
m
e
Es folgt
1 nq
≤ e−nq = e−nA(R)
PR,n = (1 − q)n = (1 − q) q
und somit das Lemma. u
t
62
Andreas Vogelsang
Theorem 1. In einem CAN wird es nach dem Einfügen von n Peers mit hoher Wahrscheinlichkeit, d.h. mit Wahrscheinlichkeit ≥ 1 − n−c für eine Konstante c > 0, kein Rechteck R
mit Fläche A(R) ≥ 2c lnnn geben.
Beweis. Sei Ri ein Rechteck mit Fläche A(Ri ) = 2−i . Für die Wahrscheinlichkeit, dass ein
Rechteck Ri von 2ci ln n nicht geteilt wird, gilt nach Lemma 2:
PRi ,c2i ln n ≤ e−A(Ri )c2
= e−2
i
ln n
−i 2i c ln n
= e−c ln n
= n−c
Es genügen also c2i ln n Peers, um Ri mit Wahrscheinlichkeit 1 − n−c zu teilen. Damit ein
Rechteck Ri+1 überhaupt entsteht, muss das entsprechende Rechteck Ri geteilt werden. Wir
betrachten das Einfügen weiterer neuer Peers nun staffelweise für i = 1, 2, . . . , log 2c nln n . In
Staffel i werden c2i ln n neue Peers eingefügt. Diese teilen das umschließende Rechteck Ri
eines Rechtecks mit hoher Wahrscheinlichkeit.
Es wird also in der Staffel i = log 2c nln n , mit hoher Wahrscheinlichkeit, ein Rechteck
Rlog 2c nln n mit der Größe
n
ln n
A Rlog 2c nln n = 2− log 2c ln n = 2c
n
geteilt.
Werden die Peers, die in den Staffeln hinzugefügt werden, zusammengezählt, ergibt sich:
log
n
2c ln n
X
log
c2i ln n = c(ln n)
i=1
n
2c ln n
X
2i
i=1
≤ c(ln n)2
n
2c ln n
=n
Damit wird ein bestimmtes Rechteck der Größe 2c lnnn mit Wahrscheinlichkeit n−c log n von
n Peers nicht geteilt. Von diesen Rechtecken gibt es höchstens n Stück. Damit ist die Wahrscheinlichkeit, dass eines dieser Rechtecke ungeteilt bleibt, höchstens n · n−c log n ≤ n−c+2 .
Wählt man also c groß genug, so kann jede polynomiell kleine Fehlerwahrscheinlichkeit erreicht werden. u
t
Theorem 1 zeigt, dass ein Rechteck nach Einfügen von n Peers mit hoher Wahrscheinlichkeit
nicht größer ist als 2c nln n . Da die Größe eines Rechtecks im Durchschnitt n1 ist, sagt Theorem
1 aus, dass ein Peer mit hoher Wahrscheinlichkeit nicht mehr als das 2c(ln n)-fache an Daten
verwaltet als der Durchschnitt.
Netzwerkstruktur und Routing
Für den Einfüge- und Suchalgorithmus in P2P-Netzwerken muss eine Graphenstruktur auf
den Peers des Netzes etabliert werden. In CAN geschieht dies, indem Peers orthogonal
Skalierbare Peer-to-Peer-Netzwerke
63
benachbarter Rechtecke miteinander verbunden werden. Zusätzlich werden sogenannte Torus-Kanten eingefügt, die Rechtecke gleicher Höhe am rechten bzw. linken Rand verbinden.
Analog werden Rechtecke des oberen und unteren Rands, die übereinander liegen, miteinander verbunden. Durch diese Torus Kanten wird die durchschnittliche Entfernung von
Peers im Graphen halbiert. In allen Abbildungen dieser Arbeit werden jedoch aus Gründen der Übersichtlichkeit keine Torus Kanten eingezeichnet (siehe Abbildung 7). Bei einer
völlig gleichmäßigen Unterteilung des Quadrats Q ergibt sich ein Netzwerkdurchmesser von
√
O( n) für n Peers.
Für die folgende Betrachtung nehmen wir an, dass die Kanten zwischen Peers immer vom
Abb. 7. Ein CAN mit Netzwerkstruktur
kleineren zum größeren Rechteck ausgerichtet sind und bei gleicher Größe in zufälliger Richtung. Jedes Rechteck hätte dann den maximalen Ausgangsgrad von vier Kanten, da jede
Kante zu einem größeren oder gleichgroßen Rechteck führt. Insgesamt existieren dadurch
maximal 4n Kanten im ganzen Graphen. Da jede Kante zwei Peers miteinander verbindet,
haben die Peers einen durchschnittlichen Grad von höchstens acht Kanten. Insbesondere ist
dieser Grad konstant und nicht abhängig von den Knoten n im Netzwerk. Diese Tatsache
trägt wesentlich dazu bei, dass ein CAN sehr gut skalierbar ist.
Die Suche nach einem Datum in einem CAN läuft dann in zwei Schritten ab. Zunächst wird
mit Hilfe der Hash Funktion die Position des Datums in der Fläche Q bestimmt. Danach
wird die Suchanfrage solange an den Nachbarnpeer weitergeleitet, dessen Rechteck in der
x− oder y−Richtung näher an der Position des Datums liegt, bis der Peer erreicht ist, in
dessen Zuständigkeitsbereich die Position des Datums liegt. Dieses Routing-Verfahren wird
64
Andreas Vogelsang
neben der Datumssuche auch verwendet, um neu einzufügende Peers an die von ihnen zufällig gewählte Position zu routen. Dort treten sie dann in Kontakt mit dem bisher für den
Punkt zuständigen Peer.
Wie bei der Aufteilung der Zuständigkeitsbereiche hat das Einfügen eines Peers in der
Netzwerkstruktur ebenfalls nur lokale Auswirkungen. Lediglich der Knoten, dessen Bereich
geteilt wird, und seine unmittelbaren Nachbarn müssen ihre Nachbarschaftsumgebung anpassen. In Bezug auf die Netzwerkstruktur handelt es sich also ebenfalls um konsistentes
Hashing. Ein Ablauf der Routing-Routine ist in Abbildung 8 abgebildet.
Abb. 8. Routing in CAN. Die Suchanfrage von Peer p1 nach Datum d1 wird über die Peers p2 , p3 , p4 , p5 an
den für das Datum zuständigen Peer p6 weitergeleitet.
Entfernen von Peers, Defragmentierung
Gerade in P2P-Netzwerken spielt Robustheit eine große Rolle, da häufig Peers ohne Vorwarnung das Netz verlassen oder ausfallen. Aus diesem Grund gibt es im CAN einen take-over
Mechanismus. Ein Knoten sendet in regelmäßigen Zeitabständen seine Position und seine
Nachbarschaft an seine Nachbarn. Bleibt eine solche Update-Message aus, wird ein solcher
Knoten als fehlerhaft entdeckt. Jeder Knoten, der einen fehlerhaften Knoten entdeckt hat,
startet einen Countdown-timer, der proportional zur Größe des Zuständigkeitsbereiches ist.
Aus diesem Grund läuft der timer des Nachbarknotens mit der kleinsten Fläche am ehesten
ab. Dieser übernimmt dann zusätzlich den Bereich des ausgefallenen Knotens und benachrichtigt die übrigen Nachbarn über die Veränderung (siehe Abbildung 9).
Durch diesen Mechanismus ist es möglich, dass ein Knoten mehr als ein Rechteck verwal-
Skalierbare Peer-to-Peer-Netzwerke
65
Abb. 9. Der Bereich eines ausgefallenen Peers p0 wird von dem Nachbarpeer p1 mit dem kleinsten Bereich
übernommen.
tet. Als Konsequenz kann eine sehr starke Fragmentierung des Netzes entstehen. Um dieser
Fragmentierung entgegenzuwirken, wird von Zeit zu Zeit ein Defragmentierungsalgorithmus
durchgeführt. Um diesen Algorithmus besser zu veranschaulichen ist es sinnvoll, das CAN
als Binärbaum darzustellen. Die Wurzel des Baumes ist die ursprüngliche Fläche Q. Ein
66
Andreas Vogelsang
Knoten im Baum hat als Kinder die beiden Rechtecke, in die es unterteilt wurde. Ist ein
Rechteck nicht unterteilt, so ist es im Baum ein Blatt und verbunden mit dem Peer, der für
das Rechteck zuständig ist. Der zur Abbildung 9 (b) passende Binärbaum ist in Abbildung
10 dargestellt.
Während der Defragmentierungsroutine versucht ein Peer, der mehr als ein Rechteck ver-
Abb. 10. Der zu Abbildung 9 (b) passende Binärbaum
waltet, das kleinste von ihm verwaltete Rechteck an einen anderen Peer abzugeben. Sei A
dieses kleinste Rechteck eines Peers p0 . Dann ist A in der Binärbaumdarstellung ein Blatt.
Zur Defragmentierung wird der Bruderbaum B des Rechtecks A betrachtet. Im einfachen
Fall ist B ebenfalls nur ein Blatt, das von einem Peer p1 verwaltet wird. Dann werden A und
B miteinander verschmolzen und sie werden zusammen von p1 verwaltet (siehe Abbildung
11).
Ist B kein Blatt, wird im Teilbaum B mit Hilfe einer Tiefensuche nach zwei benachbarten
Blättern gesucht 3 . Diese beiden Blätter werden zu einer Fläche verschmolzen und von einem der beiden zuständigen Peers übernommen. Der übrig gebliebene Peer übernimmt das
Rechteck A von p0 (siehe Abbildung 12).
In beiden Fällen wird der Grad der Fragmentierung verringert.
3.4 Verbesserungsmöglichkeiten
Durch verschiedene Verbesserungen des CAN können einige Metriken verbessert werden. Wir
betrachten bei den folgenden Konzepten nur Veränderungen des Netzwerkdurchmessers, der
Robustheit und des Knotengrades.
3
Dieses existiert, da ein Knoten des Baumes immer genau 0 oder 2 Kinder hat.
Skalierbare Peer-to-Peer-Netzwerke
67
Abb. 11. Einfacher Fall der Defragmentierung. p0 gibt das Rechteck A an p1 ab.
Abb. 12. Schwieriger Fall der Defragmentierung. Per Tiefensuche wird nach zwei benachbarten Blättern
gesucht. Diese werden verschmolzen und von einem der zuständigen Peers übernommen. Der andere Peer
übernimmt das Rechteck A.
Dimensionen
Bisher haben wir das CAN als eine 2-dimensionale Fläche angesehen. Dabei lag der Netz1
werkwerkdurchmesser bei O(n 2 ). Wird das CAN auf einen 3-dimensionalen Würfel erweitert
1
wird der Netzwerkdurchmesser auf O(n 3 ) verringert. Im allgemeinen Fall gilt für den Netz1
werkdurchmesser O(n d ) bei Verwendung von d Dimensionen. Auf der anderen Seite gilt
jedoch für den Knotengrad O(d), da bei Verwendung von höheren Dimensionen (z.B. in
68
Andreas Vogelsang
einem Würfel) jeder Peer mehr Nachbarn hat. Abbildung 13 stellt dar, wie sich die Verwendung von mehreren Dimensionen auf die Routingdistanz auswirkt.
Abb. 13. Verwendung von mehreren Dimensionen und ihr Einfluss auf die Routingdistanz
Realitäten
Eine weitere Möglichkeit der Verbesserung ist das gleichzeitige Betreiben von mehreren
CAN Netzwerken auf gleichen Daten und Peers. Durch die Verwendung von mehreren verschiedenen Hash Funktionen entstehen verschiedene Anordnungen von Peers und Daten in
jeweils einem Netzwerk. Diese Netzwerke werden Realitäten genannt. Die Verwendung von
r Realitäten erhöht die Robustheit, da bei Ausfall eines Netzes immer noch r − 1 weitere
Netzwerke zur Verfügung stehen. Für den Netzwerkdurchmesser kann gezeigt werden, dass
dieser nur noch O(log n) beträgt. Für das Routing ist dies allerdings nur eingeschränkt
nützlich, da der kürzeste Weg nicht mehr unbedingt bekannt ist. Eine gewisse Verkürzung
des Routing-Weges ist jedoch empirisch messbar zu erkennen. Durch die Verwendung von r
Realitäten erhöht sich allerdings der Knotengrad um den Faktor r. Abbildung 14 stellt dar,
wie sich die Verwendung von mehreren Realitäten auf die Routingdistanz auswirkt.
Latenzoptimiertes Routing
Wenn wir bisher von Weglängen beim Routing gesprochen haben, waren immer Wege im
CAN gemeint. Allerdings sagt die Netzwerkstruktur nichts über die darunterliegende Netzwerkstruktur z.B. des Internets aus. Ein benachbarter Peer im CAN kann theoretisch auf der
Skalierbare Peer-to-Peer-Netzwerke
69
Abb. 14. Verwendung von mehreren Realitäten und ihr Einfluss auf die Routingdistanz
anderen Seite der Erde liegen (siehe auch Kapitel 1.1). Dadurch können beim Routing hohe
Latenzzeiten enstehen. Ein Konzept, um dies zu verhindern, ist das sogenannte Überladen
von Rechtecken. Während bisher immer ein Peer für ein Rechteck verantwortlich war, werden nun bis zu MaxPeers Peers einem Rechteck zugeordnet. Die Netzwerkstruktur wird
dahingehend geändert, dass Verbindungen zu allen Peers eines Nachbarrechtecks gehalten
werden. Der Knotengrad erhöht sich dadurch nur um den additiven Term MaxPeers−1.
Beim Routing kann nun immer der Nachbarpeer mit der niedrigsten Latenz gewählt werden4 . Zusätzlich zur Latenzoptimierung wird die Robustheit erhöht, da nun, statt nur einem
Peer, MaxPeers Peers eine Kopie des Datums bereitstellen. Außerdem verringert sich der
Netzwerkdurchmesser, da mehr Peers das Netzwerk betreten müssen, bis
ein Rechteck unn
terteilt wird. So besteht ein CAN mit n Peers nur noch aus M axP
eers Rechtecken.
Eine weitere Möglichkeit, die Latenzzeiten zu reduzieren, ist, die Netzwerkstruktur an die
topologische Struktur des Internets anzupassen. Dies ist allerdings zur Zeit nicht trivial, da
es schwierig ist, Ortsinformationen über z.B. die IP-Adresse herauszufinden.
3.5 Zusammenfassung
Die Entwicklung des Content-Adressable Network war in der Weiterentwicklung der P2PNetzwerke ein großer Schritt nach vorne. Zum ersten Mal wurde das Konzept der Distributed
Hash Tables in einem P2P-Netzwerk verwendet und so konnte garantiert werden, dass ein
Datum, das im Netzwerk vorhanden ist, auch gefunden wird. Zudem ist das CAN sehr gut
skalierbar, da der Knotengrad konstant und unabhängig von der Anzahl der teilnehmenden
4
Die Latenz im Internet kann über ICMP Echo Requests ermittelt werden.
70
Andreas Vogelsang
Peers ist und der Netzwerkdurchmesser bei einem 2-dimensionalen CAN mit n Teilnehmern
√
nur bei O( n) liegt. Mit Hilfe von Verbesserungen kann die durchschnittliche Pfadlänge
sogar auf O(log n) verringert werden. Allerdings ist dann der Knotengrad nicht mehr unabhängig von der Anzahl der Teilnehmer [7].
Trotzdem konnte sich das CAN in der Praxis nicht durchsetzen, da kurze Zeit später mit
Chord [9] und Pastry [10] P2P-Netzwerke vorgestellt wurden, die noch bessere Werte bezüglich Knotengrad und Routing Zeit aufwiesen. Ein weiterer Nachteil, den alle P2P-Netzwerke
haben, in denen Daten mittels einer Hash Funktion zufällig verteilt werden, ist, dass eine
bestehende Ordnung auf den Daten (z.B. eine lexikographische Ordnung nach Dateinamen)
nicht erhalten bleibt. Bereichsanfragen sind dadurch nicht sehr effizient. Auf diese Problemstellung wird im zugehörigen Seminar eingegangen.
Literaturverzeichnis
1. Bittorrent.org (2006) Bittorrent Protocol Specification. http://bittorrent.org/protocol.html
2. Baset SA, Schulzrinne H (2004) An analysis of the skype peer-to-peer internal telephony protocol.
http://arxiv.org/abs/cs/0412017
3. Clarke I, Sandberg O, Wiley B, Hong TW (2000) Freenet: A distributed anonymous information storage
and retrieval system. In: International Workshop on Design Issues in Anonymity and Unobservability.
311–320
4. ipoque GmbH (2007) Internetstudie 2007. Die Auswirkungen von P2P-Filesharing, Voice over IP, Skype,
Joost, Instant Messaging, One-Click Hosting und Mediastreaming wie YouTube auf das Internet. http://
www.ipoque.de/userfiles/file/p2p_study_2007_abstract_de.pdf
5. Mahlmann P, Schindelhauer C (2007) Peer-to-Peer-Netzwerke. Springer, Berlin Heidelberg New York
6. Clip2 (2001) The Gnutella Protocol Specification v0.4. http://www9.limewire.com/developer/gnutella_protocol_0.4.pdf
7. Ratnasamy S, Francis P, Handley M, Karp R, Shenker S (2001) A scalable content-adressable network
In: Computer Communication Review. Volume 31., Dept. of Elec. Eng. and Comp. Sci., University of
California, Berkeley 161–172
8. Mahlmann P, Schindelhauer C (2004) Algorithmen für Peer-to-Peer-Netzwerke, Vorlesungsskript,
Universität Paderborn. http://wwwcs.upb.de/cs/ag-madh/WWW/Teaching/2004SS/AlgoP2P/Skript/skript-04-4.pdf
9. Stoica I, Morris R, Karger D, Kaashoek F, Balakrishnan H. (2001) Chord: A scalable Peer-to-Peer
lookup service for internet applications. In: Guerin R, ed.:Proceedings of the ACM SIGCOMM 2001
Conference (SIGCOMM-01). Volume 31, 4 of Computer Communication Review., New York, ACM
Press 149–160
10. Plaxtron CG, Rajaraman R, Richa A (1997) Accessing nearby copies of replicated objects in a distributed environment. In: 9th Annual Symposium om Parallel Algorithms and Architectures (SPAA ’97),
New York, Association for Computer Machinery 311–320
Eine Einführung in kinetische Datenstrukturen
Peter Kling
Universität Paderborn
Zusammenfassung. Zu vielen Problemen gibt es heutzutage effiziente Algorithmen, die diese lösen und
dem Nutzer bestimmte Attribute — wie z.B das nächste Paar einer Punktemenge im Raum — berechnen. In
modernen Anwendungen müssen solche statischen Probleme im Allgemeinen nicht nur einmal gelöst werden.
Vielmehr werden sie in kontinuierliche Problemstellungen übertragen, indem die gegebene Problematik über
die Zeit animiert wird. Diese kontinuierliche Problemstellung wirft neue Fragen auf, wie z.B. die Häufigkeit
einer notwendigen Neuberechnung solcher Attribute.
Die hier vorgestellte Idee der kinetischen Datenstrukturen versucht ein allgemeines Konzept aufzubauen,
um diesem Übergang von einer statischen in eine kontinuierliche Situation gerecht zu werden.
1
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
1.2 Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
2
Unterschiede zum klassischen Ansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3
Kinetische Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.1 Grundaufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.2 Begriffe und Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4
Anwendung kinetischer Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5
Davenport-Schinzel Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.1 Definitionen und Begriffe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.2 Verbindung zu kinetischen Prioritätswarteschlangen . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6
Fazit und Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
1 Einführung
Dieses Kapitel soll dem Leser eine Idee davon geben, was kinetische Datenstrukturen prinzipiell darstellen und deren Nutzen motivieren. Anschließend wird der Aufbau dieser Arbeit
erläutert.
72
Peter Kling
1.1 Motivation
Die Modellierung realer Probleme erfordert häufig kontinuierliche Modelle. Diese enthalten
ihrer Natur nach eine überabzählbare Menge an Informationen. Als Anwender ist man aber
meist nur an einigen wenigen Attributen interessiert. So möchte man bei der Simulation eines
Autorennens beispielsweise die aktuelle Position der einzelnen Fahrer, deren Geschwindigkeit oder den Erstplatzierten kennen. Wie man an diesem einfachen Beispiel bereits sieht,
können solche Attribute ganz unterschiedlicher Natur sein. Während die Geschwindigkeit
der einzelnen Fahrer kontinuierlich von der Zeit abhängt, ist das Attribut „Erstplatzierter“
während der gesamten Simulation nur endlich vielen Änderungen unterworfen. Es ist also
diskret. Insbesondere bei diskreten Attributen kann man den Effekt der zeitlichen Kohärenz 1
ausnutzen.
Kinetische Datenstrukturen stellen ein Konzept dar, bestimmte Attribute solch kontinuierlicher Modelle zu berechnen und während der betrachteten Zeitspanne aufrecht zu
erhalten. Obwohl sich der Ansatz dabei auf diskrete Attribute konzentriert, ist zu bedenken, dass man kontinuierliche Attribute oft durch eine diskrete Beschreibung ausdrücken
kann. So kann die Bahn eines sich bewegenden Objektes beispielsweise durch Trajektorien2
analytisch beschrieben werden. Diese Trajektorien können diskret angegeben werden (siehe
Abbildung 1). Eine Änderung der Trajektorie kann dann über eine kinetische Datenstruktur
als diskretes Attribut verwaltet werden.
y
x
Abb. 1. Kontinuierliche Objektbahn als diskretes Attribut (Funktionsgleichung): τ : R → R2 ,
(sin(t), cos(t)).
t 7→
1.2 Aufbau
Vor einer formalen Einführung der Begrifflichkeit, werde ich in Abschnitt 2 zunächst eine
kurze Erläuterung eines klassischen Lösungsansatzes geben und diesen mit der Idee kinetischer Datenstrukturen vergleichen. In Abschnitt 3 folgt die formale Einführung, welche
anschließend in Abschnitt 4 anhand eines Beispiels vertieft wird. Abschnitt 5 stellt einige wichtige Begriffe und Ergebnisse zur Verfügung, welche in der Analyse des Beispiels
1
2
Zeitliche Kohärenz im Diskreten beschreibt den Effekt, dass ein Attribut zu einem Großteil der Simulation
seinen Wert nicht ändert.
Bahnkurven
Eine Einführung in kinetische Datenstrukturen
73
gebraucht werden, allerdings nicht spezifisch für kinetische Datenstrukturen sind. Abschließend folgt in Abschnitt 6 eine kurze Zusammenfassung der Ergebnisse sowie ein Ausblick
auf fortgeschrittenere Anwendungen.
2 Unterschiede zum klassischen Ansatz
Ein typisches Einsatzgebiet kinetischer Datenstrukturen stellt die Simulation kontinuierlicher Systeme dar. Jedoch gibt es natürlich auch einen klassischen Ansatz zur Simulation
solcher Systeme. Im Folgenden sollen beide Ansätze verglichen werden. Außerdem wird der
Unterschied zwischen kinetischen und dynamischen Datenstrukturen erläutert werden.
Klassische Simulation
Der klassische Ansatz ein System zu simulieren, welches zeitlichen Veränderungen ausgesetzt ist, basiert auf einer einfachen Diskretisierung der Zeit sowie auf der Annahme, dass
bei kleiner Diskretisierung eine starke zeitliche Kohärenz vorliegt. Wir betrachten als Beispiel ein System sich in der Ebene bewegender Objekte (vgl. Abbildung 2). Die Objekte
bewegen sich mit konstanter Geschwindigkeit in verschiedene Richtungen. Wir können die
Position der Objekte zu einem beliebigen Zeitpunkt anhand dieser Daten und einer gegebenen Ausgangslage bestimmen. Nun wählt man eine globale Zeiteinheit ∆t, welche die
Granularität der Simulation bestimmt. Nach jeder vergangenen Zeiteinheit werden die Positionen der Objekte neu berechnet. Wie in Abbildung 2 zu sehen ist, kann es dabei zu einer
Kollision kommen. In diesem Fall müssen die Bewegungsvektoren neu berechnet werden.
Die Genauigkeit der Simulation hängt hierbei stark von der Wahl der Zeiteinheit ab: je
größer man ∆t wählt, desto geringer wird die zeitliche Kohärenz. Man übersieht bestimmte
Systemänderungen (vgl. Abbildung 3). Eine zu kleine Wahl führt dazu, dass ein Großteil
der Simulationszeit für unwichtige Berechnungen verschwendet wird.
y
y
x
Abb. 2. Bei richtiger Wahl von ∆t kommt es zur Kollision.
x
74
Peter Kling
y
y
x
x
Abb. 3. Wählt man ∆t zu groß, wird die Kollision „übersehen“.
Bedenkt man, dass in vielen Simulationen die Trajektorien von Objekten und deren Zusammenwirkung durch Differentialgleichungen gegeben sind, zeigt sich ein Vorteil dieser Art
der Simulation: Differentialgleichungen müssen im Allgemeinen numerisch gelöst werden,
was durch eine feine Diskretisierung der Zeit geschieht. Die Feinheit dieser Diskretisierung
kann nun natürlich auch als globale Zeiteinheit genutzt werden.
Kinetische Simulation
Eine Simulation mit Hilfe einer kinetischen Datenstruktur verfolgt einen lokaleren Ansatz.
Im klassischen Ansatz wird durch die global gegebene Zeiteinheit jedes Objekt gleich behandelt. Man stelle sich eine Szene mit einer Schildkröte und einer Gewehrkugel vor. Die
Gewehrkugel soll eine Fensterscheibe zerschlagen. Es stellt sich die Frage nach der Wahl von
∆t. Die schnelle Gewehrkugel benötigt offenbar ein sehr kleines ∆t – bei zu großer Wahl
würde sie durch die Fensterscheibe hindurch fliegen, ohne diese zu zerstören. Ein kleines ∆t
bedeutet aber unnötig viel Simulationsaufwand für die langsame Schildkröte.
Im Grunde hat man bei der numerischen Lösung von Differentialgleichungen das selbe
Problem. Deshalb werden hier adaptive Verfahren genutzt, die versuchen die Größe der
Zeiteinheit an die aktuelle Situation anzupassen. Kinetische Datenstrukturen bieten einen
ähnlichen Ansatz, arbeiten allerdings ereignisbasiert. Statt eine globale Zeiteinheit festzulegen und nach jedem Zeitschritt alle betrachteten Attribute auf Änderungen zu überprüfen,
wird eine Ereignis-Warteschlange erstellt. Diese enthält Ereignisse in der Zukunft, die es abzuarbeiten gilt und welche wiederum neue Ereignisse auslösen können. Ein Ereignis tritt ein,
wenn sich ein Attribut ändert. Die Leistung kinetischer Datenstrukturen besteht hierbei in
der effizienten Verwaltung und Aufrechterhaltung der dazu notwendigen Datenstrukturen.
Es ist wichtig zu bemerken, dass an dieser Stelle eine schwerwiegende und weitreichende
Voraussetzung an das Anwendungsgebiet gestellt wird. Die zu berechnenden – also interessanten – Ereignisse liegen in der Zukunft. Die Berechnung der Eintrittspunkte solcher
Ereignisse ist im Allgemeinen nicht trivial, oft sogar nicht möglich. Eine Möglichkeit mit
Eine Einführung in kinetische Datenstrukturen
75
solchen Situationen dennoch umzugehen, besteht darin geeignete Approximationen zu verwenden.
Kinetik vs. Dynamik
Kinetik und Dynamik sind zwei eng zusammenhängende Begriffe. Umso wichtiger ist es,
sich klar zu machen wo der Unterschied zwischen kinetischen und dynamischen Datenstrukturen liegt. Während kinetische Datenstrukturen helfen sollen, bestimmte Attribute eines
Systems über eine zeitliche Veränderung aufrecht zu erhalten, befassen sich dynamische
Datenstrukturen mit der Problematik einen gegebene Datensatz an eine Veränderung des
Systems anzupassen. Typische Beispiele für dynamische Datenstrukturen sind sortierte Folgen, welche die Sortierung beim Einfügen oder Entfernen eines Elementes aufrecht erhalten.
Der Unterschied wird besonders deutlich, wenn man kinetische Datenstrukturen betrachtet, die zusätzlich dynamische Eigenschaften haben. Neben der allgemeinen zeitlichen Veränderung der Attribute eines Systems können hier Objekte das System betreten oder verlassen. In Abschnitt 3.2 wird der Begriff (δ, n, m)-Szenario eingeführt werden, in dem derartige
dynamische Effekte eine Rolle spielen. Auch in der Analyse des Kinetic Tournament in Abschnitt 4 werden dynamische Effekte — anhand solcher (δ, n, m)-Szenarien — berücksichtigt
werden. Für eine genauere Beschreibung sei hier auf die Begriffserklärungen in Abschnitt
3.2 verwiesen.
3 Kinetische Datenstrukturen
Es soll nun eine formalere Definition kinetischer Datenstrukturen gegeben werden. Dazu
wird zunächst der grundlegende Aufbau einer kinetischen Datenstruktur erläutert sowie
ein Überblick über den Ablauf einer Simulation anhand einer kinetischen Datenstruktur
gegeben. Anschließend werden einige Begriffe definiert und teilweise an Beispielen näher
erläutert.
3.1 Grundaufbau
Kinetische Datenstrukturen sollen also ausgewählte diskrete Attribute in einem kontinuierlichen System aufrecht erhalten. Für ein gegebenes Attribut, welches in der kinetischen
Datenstruktur verwaltet werden soll, besteht das grundsätzliche Verfahren der Kinetisierung
im wesentlichen aus folgenden Schritten:
1. Betrachte einen (statischen) Algorithmus zur Berechnung des Attributes.
2. Umwandlung des Algorithmus in einen Gültigkeitsbeweis für das Attribut.
3. „Animieren“ des Beweises.
Der letzte Punkt enthält den Kerngedanken kinetischer Datenstrukturen: es reicht nicht,
einen Beweis dafür zu haben, dass ein aktueller Attributwert korrekt ist. Vielmehr muss
erkannt werden, wann so ein Beweis fehlschlägt (also sich das betrachtete Attribut verändert
hat3 ) und der Beweis muss an die sich veränderten Verhältnisse angepasst werden. Die Kunst
3
Oder besser noch: wann es fehlschlagen wird!
76
Peter Kling
besteht gerade darin, Beweise zu finden, mit denen man diese beiden Kriterien effizient
erfüllen kann4 .
Eine Kinetische Datenstruktur bietet dem Benutzer zwei fundamentale Operationen zum
Zugriff auf die verwalteten Daten:
query Die query-Operation dient der Rückgabe eines bestimmten Attributes.
update Die update-Operation aktualisiert den internen Zustand der kinetischen Datenstruktur.
Die zwei wesentlichen strukturellen Komponenten einer kinetischen Datenstruktur sind
die Gültigkeitsbeweise der Attribute sowie die Ereigniswarteschlange. Nach der Erstellung
des Gültigkeitsbeweises — welcher aus sogenannten Zertifikaten besteht — wird berechnet,
wann und aus welchem Grund er als nächstes Fehlschlagen wird. Diese Ereignisse werden
in der Ereigniswarteschlange verwaltet und nach und nach abgearbeitet. Dabei kann ein
Ereignis wiederum neue Ereignisse auslösen. Der Ablauf ist in Abbildung 4 verdeutlicht.
Gültigkeitsbeweis
Ereignis
Zertifkat
Fehlschlag
Aktualisierung
Beweis
Aktualisierung
update
Attribut
Aktualisierung
Abb. 4. Ablauf der Simulation mit Hilfe einer kinetischen Datenstruktur.
3.2 Begriffe und Definitionen
Gegeben sei ein zu simulierendes System mit einer Objektmenge S. Das System kann zu
einem bestimmten Zeitpunkt t ∈ R≥0 durch eine Funktion π : S → V beschrieben werden,
die jedem Objekt aus S eine Position im betrachteten Vektorraum V zuordnet (z.B. V =
R2 ). Wir bezeichnen π als Konfiguration und Π := {π|π ist Konfiguration} als die Menge
aller Konfigurationen. Wir beginnen mit der Definition von Attributen:
4
In diesem Zusammenhang spricht man auch von einem Beweisschema; es handelt sich eher um einen
„Bauplan“ für einen Beweis als um einen Beweis selbst.
Eine Einführung in kinetische Datenstrukturen
77
Definition 1 (Attribut). Ein Attribut ist eine Funktion, die einer Konfiguration π ∈ Π
eine kombinatorische Beschreibung zuordnet.
Attribute beschreiben also diskrete5 Eigenschaften des Systems zu einem bestimmten
Zeitpunkt. Beispiele für Attribute sind z.B. das nächste Paar oder die konvexe Hülle einer
Punktmenge (siehe Abbildung 5).
a
b
c
d
e
Abb. 5. Attribut „nächstes Paar“: (c, d); Attribut „konvexe Hülle“: (a, e, b)
Um die Gültigkeit von Attributen zu untersuchen, werden sogenannte Zertifikate eingeführt. Sie dienen der Überprüfung bestimmter Eigenschaften für ein k-Tupel s ∈ S k (k ∈ N)
von Objekten.
Definition 2 (Zertifikat). Zertifikate sind Funktionen zs : Π → R und können drei verschiedene Zustände beschreiben. Ein Zertifikat zs : Π → R heißt:
• gültig für eine Konfiguration π ∈ Π, falls zs (π) > 0 gilt
• ungültig für eine Konfiguration π ∈ Π, falls zs (π) < 0 gilt
• degeneriert für eine Konfiguration π ∈ Π, falls zs (π) = 0 gilt
Man beachte, dass ein Zertifikat immer bezüglich bestimmter Objekte definiert ist. Sie
sind die Grundbausteine für die Gültigkeitsbeweise von Attributen.
Definition 3 (Gültigkeitsbeweis). Ein Gültigkeitsbeweis L ist eine endliche Menge von
Zertifikaten6 . Wir bezeichnen L als gültig für eine Konfiguration π, falls alle z ∈ L gültig in π sind. Ist ein z ∈ L ungültig (degeneriert), so bezeichnen wir ganz L als ungültig
(degeneriert).
Gültigkeitsbeweise dienen der Zertifizierung von Attributen. Sie machen also eine Aussage über die Gültigkeit eines Attributwertes. Es gibt zwei verschiedene Arten von Gültigkeitsbeweisen. Zu deren Erläuterung wird allerdings zunächst folgender Begriff benötigt:
Definition 4 (Szenario). Ein Szenario (πt )t∈[0,1] ist ein Weg7 im Konfigurationsraum Π.
5
6
7
Diskret in dem Sinne, dass sich die kombinatorische Beschreibung während der Simulation nur endlich
oft ändert.
Man kann L auch als Funktion Π → Rd auffassen, wobei d die Anzahl der Zertifikate des Gültigkeitsbeweises beschreibt.
Ein Weg ist eine auf einem geschlossenen Intervall (hier [0, 1]) definierte stetige Abbildung.
78
Peter Kling
Ein Szenario beschreibt also stetige Bewegungen der Objekte. Man sagt nun ein Gültigkeitsbeweis L zertifiziert ein Attribut A in einer Konfiguration π:
• stark, falls ∀π 0 ∈ Π : L gültig für π 0 ⇒ A(π) = A(π 0 ).
• schwach, falls für alle Szenarien (πt )t∈[0,1] mit π0 = π und L ist gültig für alle πt gilt:
A(πt ) = A(π) ∀t ∈ [0, 1].
In beiden Fällen muss L auch gültig für die Konfiguration π sein. Anschaulich lassen
sich diese Begriffe anhand von Abbildung 6 erklären. Wir bezeichnen die Menge ML = {π ∈
Π|L ist gültig für π} als die Menge der von L induzierten Konfigurationen.
Abb. 6. Die markierten Bereiche stellen die durch L induzierten Konfigurationen dar.
Starke Zertifizierung bedeutet, dass A in allen von L induzierten Konfigurationen den
selben Wert annimmt, also auf ganz ML konstant ist. Schwache Zertifizierung hingegen
benötigt nur, dass A auf einem 8 wegzusammenhängenden Teilgebiet von ML konstant ist.
Im Verlauf der Simulation kann es theoretisch vorkommen, dass mehrere Ereignisse
gleichzeitig eintreffen. Dies erschwert Analyse und Implementierung, da das Verhalten in
diesem Fall undefiniert ist. Deshalb wollen wir nur Konfigurationen betrachten, die in allgemeiner Lage sind:
Definition 5. Wir sagen eine Konfiguration befindet sich in in allgemeiner Lage, wenn in
dieser Konfiguration höchstens eines der betrachteten Zertifikate degeneriert ist.
Degenerierte Zustände von Zertifikaten sind gerade die interessanten Momente. Hier kann
sich der Wert eines bestimmten Attributes ändern. Durch die Beschränkung auf diese Art
von Konfigurationen9 kann Mehrdeutigkeit vermieden werden.
Ein weiterer zentraler Begriff ist der des Beweisschemas:
8
9
Und zwar auf dem, das die Konfiguration π enthält.
Diese Annahme ist durchaus vertretbar, da in einem kontinuierlichen System bereits eine infinitesimale
Änderung ausreichen wird, um die degenerierten Zertifikate zu trennen.
Eine Einführung in kinetische Datenstrukturen
79
Definition 6 (Beweisschema). Ein Beweisschema für ein Attribut A weißt allen Konfigurationen in allgemeiner Lage einen Gültigkeitsbeweis zu, der A in der jeweiligen Konfiguration zertifiziert (stark oder schwach).
Ein Beweisschema erlaubt es uns also Gültigkeitsbeweise für Attribute und Konfigurationen zu „erstellen“.
Die nächsten beiden Begriffe sind zentrale Gesichtspunkte in der Analyse kinetischer
Datenstrukturen, da sie gewisse Aspekte der Effizienz eben dieser beschreiben.
Definition 7 (Lokalität). Die Lokalität eines Beweisschemas beschreibt die maximale Anzahl an Zertifikaten, an denen ein beliebiges Objekt in einem Gültigkeitsbeweis des Schemas
beteiligt ist.
Mit diesem Begriff kann der Aufwand beschrieben werden, der nötig ist um den Zustand
der kinetischen Datenstruktur an die Änderung einer Trajektorie10 anzupassen. Ist L die
Lokalität des verwendeten Beweisschemas und beschreibt c die Kosten ein Element aus der
Ereigniswarteschlange zu entfernen und hinzuzufügen, so ist dieser Aufwand gegeben durch
O(cL).
Definition 8 (Antwortzeit). Beschreibt die worst-case Berechnungszeit, um ein Ereignis aus der Ereigniswarteschlange vollständig zu bearbeiten. Dies umfasst insbesondere die
Anpassung des aktuellen Gültigkeitsbeweises und die nötigen Aktualisierungen in der Ereigniswarteschlange selbst.
Im Hinblick auf die Analyse kinetischer Datenstrukturen ist es notwendig, die Szenarien,
insbesondere die Art der zugelassenen Trajektorien, genauer zu beschreiben. Wir werden
uns deshalb in der Analyse auf folgende Szenarien-Klassen einschränken:
Definition 9 ((δ, n)-Szenario). Ein Szenario (πt )t∈[0,1] bezüglich n Objekten, so dass die
Trajektorie t 7→ πt (s) eines Objektes s ein Vektor von Polynomen in t vom Grade höchstens
δ ist, heißt (δ, n)-Szenario.
Definition 10 ((δ, n, m)-Szenario). (δ, n, m)-Szenarien beschreiben ein dynamisches Szenario, d.h. die beteiligten Objekte bewegen sich nicht nur, sondern es können auch Objekte
hinzugefügt oder entfernt werden. Zur Modellierung erweitern wir den Vektorraum V um ein
Sondersymbol ω. Ein Objekt s mit π(s) = ω in einer Konfiguration π wird als nicht sichtbar
betrachtet. Ein Szenario (πt )t∈[0,1] auf einer Objektmenge S mit Positionen in R ∪ {ω} ist
ein (δ, n, m)-Szenario, falls:
• ∀s ∈ S ist γs : t 7→ πt (s) auf allen Intervallen I ⊆ [0, 1] mit ω ∈
/ γs (I) ein Polynom vom
Grade
höchstens
δ
P
•
/ γs (I)}| = m
s∈S |{I ⊆ [0, 1]|I ist maximales Intervall mit ω ∈
• |{s ∈ S|πt (s) 6= ω}| ≤ n ∀t ∈ [0, 1]
In einem (δ, n, m)-Szenario dürfen also maximal n Objekte gleichzeitig sichtbar sein,
und es gibt insgesamt m verschiedene Bewegungsabschnitte, auf denen die Trajektorien
Polynome sind. In der Analyse gehen wir bei (δ, n, m)-Szenarien davon aus, dass m = |S|
10
z.B. nach einer Kollision zweier Objekte
80
Peter Kling
gilt, also m der Anzahl aller betrachteten Objekte entspricht. Damit ist jedes Objekt in
genau einem Zeitintervall sichtbar11 .
Anhand dieser Typen von Szenarien kann man die Effizienz einer kinetischen Datenstruktur analysieren. Darunter verstehen wir die gesamten Berechnungskosten, welche bei
der Simulation eines gegebenen Szenarios anfallen.
4 Anwendung kinetischer Datenstrukturen
Es soll nun eine einfache eindimensionale Anwendung für kinetische Datenstrukturen untersucht werden. Wir betrachten für eine endliche Menge S von reellen Zahlen das MaximumAttribut. Ausgehend von einem statischen Lösungsansatz konstruieren wir eine kinetische
Variante, die das Maximum der Menge S über zeitliche Änderungen hinweg aufrecht erhält.
Eine solche kinetische Datenstruktur bezeichnen wir als kinetische Prioritätswarteschlange.
Die hier vorgestellte kinetische Prioritätswarteschlange heißt Kinetic Tournament.
Kinetic Tournament
Ausgangspunkt ist ein rekursiver Algorithmus zur Berechnung des Maximums (siehe Algorithmus 6). Die Ausgangsmenge S wird in zwei in etwa gleich große Hälften geteilt, auf
denen rekursiv das Maximum bestimmt wird. Die Ergebnisse werden schließlich verglichen
und das größere von beiden zurück geliefert.
Algorithmus 6 RecursiveMaximum(S = (s1 , s2 , . . . , sn ))
1: if n = 1 then
2:
return s1
3: else
4:
k = d n2 e
5:
m1 = RecursiveMaximum(s1 , . . . , sk )
6:
m2 = RecursiveMaximum(sk+1 , . . . , sn )
7:
return max(m1, m2)
Wir wollen zunächst ein geeignetes Beweisschema aus diesem Algorithmus extrahieren.
Dazu stellen wir den Ablauf des Algorithmus in Form eines Turnierbaumes dar (siehe Abbildung 7). Um die Rundungsoperation in Zeile 4 in der Analyse zu vermeiden, füllen wir
die Objektmenge S mit dem Sentinel −∞ solange auf, bis |S| eine Zweierpotenz ist.
So ein Turnierbaum beschreibt für eine gegebene Objektmenge, wie die einzelnen Vergleiche im Algorithmus (Zeile 7) jeweils ausfallen. Jeder innere Knoten zusammen mit seinen
zwei Kindern entspricht dabei genau einem Aufruf von Zeile 7 und je tiefer im Baum der
Knoten liegt, desto größer ist die Rekursionstiefe des zugehörigen Aufrufes. Das Ergebnis
des Vergleichs der beiden Kinderknoten wird im Vaterknoten gespeichert. Die Wurzel des
Baumes stellt schließlich das Maximum der Objektmenge dar.
Ein Turnierbaum kann nun offensichtlich als Gültigkeitsbeweis für die kinetische Prioritätswarteschlange benutzt werden. Die einzelnen Zertifikate entsprechen den inneren Knoten
11
Dies vereinfacht die Analyse, ohne tatsächlich eine Einschränkung darzustellen: schließlich kann man
einfach verschiedene Objekte identifizieren und so auch Objekte betrachten, welche mehrmals auftauchen
und wieder verschwinden.
Eine Einführung in kinetische Datenstrukturen
81
b
b
a
c
b
c
-∞
Abb. 7. Ein Turnierbaum (mit Sentinel) für S = {a, b, c} und a < b, c < b.
des Baumes, genauer gesagt dem Vergleich der beiden Kinder so eines Knotens. Zusammen
beschreiben diese inneren Knoten das Maximum offensichtlich eindeutig, es handelt sich
hierbei also um Gültigkeitsbeweise mit starker Zertifizierung (vgl. Abschnitt 3.2). Es ist
zu bemerken, dass der Turnierbaum innerhalb eines Szenarios immer der gleiche ist; verschiedene Gültigkeitsbeweise innerhalb eines Szenarios unterscheiden sich nur im Inhalt der
Knoten.
Die beschriebene Konstruktion des Turnierbaumes ergibt ein Beweisschema, erlaubt sie
es doch für jede Konfiguration (in allgemeiner Lage) einen entsprechenden Gültigkeitsbeweis
anzugeben. Die darauf basierende kinetische Datenstruktur wollen wir im Folgenden als Kinetic Tournament bezeichnen. Nun können wir bereits zwei einfache Ergebnisse festhalten:
Lemma 1. Das oben beschriebene Beweisschema hat Lokalität O(log(n)) und Größe12 O(n).
Beweis. Bei einem Turnierbaum handelt es sich offenbar um einen ausgeglichenen binären
Baum mit O(n) Blättern und Höhe blog(n)c. Die Zertifikate eines beliebigen Gültigkeitsbeweises, also eines Turnierbaumes, sind gerade dessen inneren Knoten. Die Anzahl an Knoten
eines ausgeglichenen binären Baumes ist O(n), folglich ist auch die Größe des Beweisschemas
linear in n.
Jedes Objekt o ∈ S ist durch ein Blatt des Turnierbaumes gegeben. Die Zertifikate, an
denen dieses Objekt beteiligt ist, sind gerade alle Zertifikate auf dem Pfad vom zugehörigen
Blatt zur Wurzel, für die das Objekt das Maximum darstellt. Die Länge dieses Pfades ist
durch die Höhe des Baumes beschränkt. Folglich ist die Lokalität O(log(n)).
u
t
Die Größe des Beweisschemas liefert uns gleichzeitig die maximale Anzahl an Elementen,
die in der Ereigniswarteschlange verwaltet werden müssen. Ein Ereignis kann schließlich nur
durch den Fehlschlag eines Zertifikates ausgelöst werden. Insbesondere erhalten wir folgendes
Ergebnis:
Korollar 1. Die Größe der Ereigniswarteschlange ist linear in n. Insbesondere benötigt
das Hinzufügen bzw. Entfernen eines Ereignisses in die Ereigniswarteschlange Aufwand
O(log(n)).
12
Die Größe eines Beweisschemas ist die maximale Anzahl an Zertifikaten in einem Gültigkeitsbeweis des
Beweisschemas.
82
Peter Kling
Die Effizienz einer mit diesem Beweisschema ausgestattete kinetische Datenstruktur soll
im Folgenden anhand eines (δ, n, m)-Szenarios analysiert werden. Falls ein Objekt unsichtbar
wird, ersetzen wir es im Baum durch den Sentinel −∞. Wird ein Objekt sichtbar, ersetzen
wir ein beliebiges Blatt mit Inhalt −∞ durch das Objekt13 .
Zunächst untersuchen wir die Antwortzeit dieser Datenstruktur.
Lemma 2. Kinetic Tournament hat Antwortzeit O(log2 (n)).
Beweis. Ein Ereignis bedeutet das Fehlschlagen von genau einem Zertifikat (Erinnerung:
wir betrachten Konfigurationen in allgemeiner Lage). Das heißt, dass sich das Ergebnis des
Vergleichs am zugehörigen inneren Knoten v möglicherweise verändert hat. Das neue Maximum muss im Turnierbaum weiter nach oben propagiert werden. Insbesondere müssen
nur Knoten auf dem Pfad von v zur Wurzel aktualisiert werden. Die Anzahl der Aktualisierungen liegt also in O(log(n)). Jeder solchen Aktualisierung entspricht das Entfernen und
Hinzufügen je eines Ereignisses in die Ereigniswarteschlange, was wiederum Zeit O(log(n))
benötigt (Korollar 1). Zusammen ergibt sich die Antwortzeit zu O(log2 (n)).
t
u
Nun wollen wir die Effizienz des Kinetic Tournament untersuchen. Wir greifen dazu auf
die Davenport-Schinzel Sequenzen zurück. Für den geneigten Leser enthält Abschnitt 5 die
nötigen Definitionen sowie einige wichtige Ergebnisse, die im Folgenden benutzt werden.
Zum Verständnis sollte man insbesondere Definition 13 sowie Korollar 3 beachten.
Theorem 1. Kinetic Tournament hat in einem (δ, n, m)-Szenario Effizienz O(λδ+2 (m) log2 (n)).
Beweis. Wir müssen die gesamten anfallenden Berechnungskosten für das betrachtete Szenario abschätzen. Das Eintreten eines Ereignisses führt zu der Aktualisierung des derzeitigen
Gültigkeitsbeweises. Wie im Beweis von Lemma 2 gezeigt wurde, bedeutet eine solche Aktualisierung die Änderung von (möglicherweise mehreren) Zertifikaten. Betrachtet man den
Turnierbaum, entspricht eine solche Zertifikatänderung dem Wechsel des Inhaltes an einem inneren Knoten. Jede solche Zertifikatänderung bewirkt wiederum die Entfernung und
Hinzufügung eines Ereignisses in der Ereigniswarteschlange. Es wird nun gezeigt, dass die
Anzahl µ der Änderungen in allen Knoten des Baumes durch λδ+2 (m)blog(n)c beschränkt
ist. Dies liefert schließlich zusammen mit Korollar 1 die Behauptung.
Sei dazu zunächst v ein beliebiger Knoten des Turnierbaumes T und bezeichne Tv den in
v gewurzelten Teilbaum von T . Mit µv wollen wir die Anzahl
P der Änderungen des Inhaltes
von v während des Szenarios bezeichnen (es gilt also µ = v∈T µv ).
Es bezeichne Sv ⊆ S die Teilmenge der betrachteten Objekte, die während des gegebenen
Szenarios in Tv auftauchen. Setze außerdem nv = |Sv |. Betrachtet man das Szenario eingeschränkt auf den Baum Tv und die zugehörige Objektmenge, stellt der Inhalt des Knotens v
zu jedem Zeitpunkt das Maximum des eingeschränkten Szenarios dar. Nun liefert Korollar
3 aus Abschnitt 5.2 die Abschätzung:
µv < λδ+2 (nv )
13
(1)
So ein Blatt existiert hier immer, da der Baum in einem (δ, n, m)-Szenario maximal n Blätter mit Wert
6= −∞ haben kann, und wir die restlichen Blätter anfangs mit Sentinels aufgefüllt haben.
Eine Einführung in kinetische Datenstrukturen
83
P Bezeichnet L14i die Menge aller Knoten der Höhe i im Baum T , so gilt offensichtlich
. Zusammen mit Gleichung (1) und Lemma 3 (aus Abschnitt 5.1) liefert
v∈Li nv = m
dies folgende Abschätzung für die Anzahl der Änderungen in allen Knoten der Höhe i:
X
µv <
v∈Li
X
λδ+2 (nv ) ≤ λδ+2 (m)
(2)
v∈Li
Summation über alle blog(n)c Ebenen des Turnierbaumes liefert damit µ ≤ blog(n)cλδ+2 (m).
Zusammen mit den Kosten einer Zertifikatänderung (siehe Korollar 1) liegt die Effizienz damit schließlich in O(λδ+2 (m) log2 (n)).
t
u
5 Davenport-Schinzel Sequenzen
Die Abschätzungen in der Analyse des Kinetic Tournament (siehe Abschnitt 4) machen
Gebrauch von den sogenannten Davenport-Schinzel Sequenzen. Obwohl diese nicht spezifisch
für kinetische Datenstrukturen sind, sollen sie der Vollständigkeit halber hier kurz vorgestellt
und erläutert werden. Für eine detailliertere Untersuchung sei auf [1] verwiesen.
5.1 Definitionen und Begriffe
Bevor die Davenport-Schinzel Sequenzen eingeführt werden können, benötigen wir zunächst
folgenden Begriff:
Definition 11. Sei σ = (σ1 , σ2 , . . . , σm ) eine endliche Folge in Z. Dann heißt σ nicht wiederholend, falls σi 6= σi+1 ∀1 ≤ i < m.
Nun kann eine Davenport-Schinzel Sequenz wie folgt definiert werden:
Definition 12. Seien n, s ∈ N und σ = (σ1 , σ2 , . . . , σm ) eine endliche Folge von natürlichen
Zahlen mit σi ∈ {1, 2, . . . , n} ∀1 ≤ i ≤ m. Dann heißt σ eine (n, s)-Davenport-Schinzel
Sequenz, falls jede sich nicht-wiederholende Teilfolge von σ bestehend aus maximal zwei
unterschiedlichen Zahlen höchstens die Länge s + 1 besitzt.
Es mag zunächst fraglich erscheinen, inwiefern dieser Begriff bei einer Abschätzung im
Zusammenhang mit der kinetischen Prioritätswarteschlange behilflich sein kann. Tatsächlich
ist es weniger die Davenport-Schinzel Sequenz an sich, die hier von Interesse ist. Vielmehr
interessiert uns, wie lang eine solche Sequenz bei gegebenen Parametern höchstens werden
kann.
Definition 13. Es bezeichne λs (n) die Länge einer längsten (n, s)-Davenport-Schinzel Sequenz.
Bevor der Zusammenhang mit der kinetischen Prioritätswarteschlange erläutert wird,
soll noch folgendes Ergebnis festgehalten werden:
14
Ein Objekt wird genau für ein Zeitintervall sichtbar und kann von dem Blatt in dem es erscheint nur
„nach oben“ wandern. Betrachtet man benachbarte Teilbäume, kann ein Objekt insbesondere nicht den
Teilbaum wechseln.
84
Peter Kling
Lemma 3. Seien s, n, m ∈ N. Dann gilt:
λs (n) + λs (m) ≤ λs (n + m)
Beweis. Man betrachtet dazu zwei Davenport-Schinzel Sequenzen die gerade Länge λs (n)
bzw. λs (m) haben. Addition von n auf alle Komponenten der zweiten Folge und Konkatenation beider Folgen liefert eine (n+m, s)-Davenport-Schinzel Sequenz der Länge λs (n)+λs (m).
Es folgt die Behauptung.
t
u
5.2 Verbindung zu kinetischen Prioritätswarteschlangen
Die Abschätzungen aus Kapitel 4, welche auf die Davenport-Schinzel Sequenzen zurück
greifen, schätzen ab wie oft bei einer gegebenen Familie (fi )ni=1 von Polynomfunktionen15
die Funktion, die das Maximum darstellt, wechseln kann. Dieser Abschnitt soll aufzeigen,
wo genau in der Betrachtung der kinetischen Prioritätswarteschlange aus Kapitel 4 die
Davenport-Schinzel Sequenzen ein Rolle spielen.
Definition 14. Sei (fi )i∈I eine Familie von Funktionen der Form fi : Rd → R (d ∈ N,
I Indexmenge). Dann heißt F := supi∈I (fi ) die obere Kontur (engl.: upper envelope) der
Funktionenfamilie16 .
Wir interessieren uns insbesondere für den Fall einer endlichen Indexmenge (also I =
{1, 2, . . . , n} für ein n ∈ N) und dass alle fi Polynome in einer Variablen vom Grade höchstens δ ∈ N sind. Diese Situation liegt in einem einfachen eindimensionalen (δ, n)-Szenario
(vgl. Abschnitt 3.2) vor: die Trajektorien der einzelnen Objekte entsprechen den Funktionen
fi (vgl. Abbildung 8). Die obere Kontur der Trajektorien enthält offensichtlich die Information, welches Objekt zu welchem Zeitpunkt das Maximum darstellt. Vernachlässigt man die
Zeiten, zu denen ein Wechsel stattfindet, kann die obere Kontur als endliche Indexsequenz
codiert werden: die Folge gibt den Index der Funktion an, welche gerade das Maximum
darstellt.
Wie sich heraus stellt, ist so eine Indexsequenz für n Funktionen vom Höchstgrad δ
gerade eine (n, δ)-Davenport-Schinzel Sequenz.
Lemma 4. Sei (fi )ni=1 eine endliche Familie von n Funktionen wobei die Funktionen fi :
R → R Polynome vom Grade höchstens δ seien. Weiterhin sei σ = (σ1 , σ2 , . . . , σr ) r ∈ N
die Indexsequenz zur oberen Kontur von (fi )ni=1 . Dann ist σ eine (n, δ)-Davenport-Schinzel
Sequenz.
Beweis. Sei σ 0 eine beliebige, sich nicht wiederholende Teilfolge von σ bestehend aus maximal zwei unterschiedlichen Zahlen i und j. Es ist zu zeigen: σ 0 hat höchstens Länge δ + 1.
Für i = j ist die Aussage trivial (da σ 0 nicht wiederholend ist). Sei also i 6= j. Betrachte die zu den Indizes gehörenden Funktionen fi und fj . Beides sind Polynome und haben
höchstens Grad δ, d.h. fi − fj hat auch höchstens Grad δ und damit maximal δ Nullstellen. Folglich wechselt die Funktion, die max(fi , fj ) darstellt, höchstens δ-mal. Insbesondere
können fi und fj in der oberen Kontur maximal δ-mal wechseln. D.h. σ 0 hat höchstens die
Länge δ + 1.
t
u
15
16
Jede Funktion fi entspricht dabei gerade der Trajektorie eines Objektes.
Analog kann die untere Kontur (engl.: lower envelope) definiert werden.
Eine Einführung in kinetische Datenstrukturen
85
R
f1
obere Kontur
f2
f3
f4
0
1
Zeit
Abb. 8. Funktionenfamilie (Trajektorien) mit oberer Kontur. Zugehörige Indexsequenz: (1, 2, 4)
Damit stellt nun λδ (n) als maximale Länge einer (n, δ)-Davenport-Schinzel Sequenz insbesondere eine obere Schranke für die Anzahl der möglichen Änderungen des Maximums in
einem (δ, n)-Szenario für kinetische Prioritätswarteschlangen dar.
Korollar 2. In einer kinetischen Prioritätswarteschlange ist die Anzahl der Änderungen des
Maximums in einem (δ, n)-Szenario durch λδ (n) beschränkt.
Für den etwas komplizierteren Fall eines (δ, n, m)-Szenarios kann ein ähnliches Resultat
erziehlt werden:
Korollar 3. In einer kinetischen Prioritätswarteschlange ist die Anzahl der Änderungen des
Maximums in einem (δ, n, m)-Szenario durch λδ+2 (m) beschränkt.
Lemma 4 lässt sich nicht direkt auf diesen Fall übertragen. Probleme macht insbesondere
die Tatsache, dass die Funktionen hier nur stückweise stetig sind. Folgende Beobachtungen
helfen allerdings ein analoges Lemma zu beweisen, aus dem direkt Korollar 3 folgt:
• Es sind genau m Trajektorien fi : R → R ∪ {ω} (1 ≤ i ≤ m) zu betrachten.
• Jede Trajektorie fi ist auf genau einem Intervall I ungleich ω (die Zeitspanne, in der das
zugehörige Objekt sichtbar ist).
• Je zwei Trajektorien fi , fj (i 6= j) schneiden sich maximal δ-mal. Zusätzlich gibt es
zwei weitere Stellen, an denen sich die obere Kontur hinsichtlich fi und fj ändern kann:
der Zeitpunkt, zu dem die zweite Funktion sichtbar wird und der Zeitpunkt, zu dem die
erste der beiden Funktionen wieder unsichtbar wird. Insgesamt hat man also höchstens
δ + 2 viele Stellen, an denen die Funktion, die max(fi , fj ) darstellt, wechseln kann.
Da der entsprechende Beweis mit diesen Beobachtungen analog zu dem von Lemma 4
geführt werden kann, wird hier auf ihn verzichtet.
86
Peter Kling
6 Fazit und Ausblick
Ich habe in dieser Arbeit den Begriff der kinetischen Datenstruktur eingeführt und an einem eindimensionalen Beispiel — der kinetischen Prioritätswarteschlange — vorgestellt.
Die vorgestellten Ergebnisse basieren dabei auf einer Arbeit von Julien Basch [2]. Gänzlich
ausgelassen wurden bisher Beispiele höherer Dimension. Ein Beispiel für zweidimensionale Anwendungen sind z.B. die konvexe Hülle oder das nächste Paar einer Punktmenge in
der Ebene (vgl. auch Abbildung 5). Einen detaillierteren Einblick in das Thema sowie eine
Analyse solch höher dimensionaler Beispiele kann in [3] gefunden werden.
Kinetische Datenstrukturen versprechen eine effiziente Möglichkeit viele (geometrische)
Probleme in veränderlichen Systemen zu lösen. Die ereignisbasierte Arbeitsweise hat gegenüber der klassischen zeitbasierten Simulation den Vorteil, dass der Tradeoff zwischen
Effizienz und Genauigkeit bei weitem nicht so stark ausgeprägt ist. Allerdings stellen kinetische Datenstrukturen auch hohe Anforderungen an das Anwendungsgebiet. So müssen
für die hier beschriebenen Anwendungen die Trajektorien der Objekte im Voraus bekannt
sein. Auch dürfen diese — um eine aussagekräftige Analyse durchführen zu können — nicht
von beliebiger Gestallt sein, sondern sollten polynominell in dem Zeitparameter sein. Es soll
aber nicht unerwähnt bleiben, dass man auch diese Probleme mit kinetischen Datenstrukturen adressieren kann. So können kompliziertere Trajektorien z.B. durch Spline-Interpolation
(siehe [5]) stückweise durch Polynome beschrieben werden. Sind die Trajektorien nicht bekannt, kann versucht werden durch Extrapolation Schätzungen für zukünftige Ereignisse zu
bestimmen.
Tatsächlich handelt es sich bei dem vorgestellten Konzept nicht um ein rein theoretisches. So enthält beispielsweise die Bibliothek CGAL17 Implementierungen kinetischer
Datenstrukturen für einige ein- bis dreidimensionale Probleme. Eine Beschreibung und Beispielanwendungen können in [4] gefunden werden.
Literaturverzeichnis
1. Pankaj K. Agarwal and Micha Sharir (1995) Davenport-Schinzel sequences and their geometric applications. Technical Report DUKE-TR-1995-21, Department of Computer Science, Duke University
2. Julien Basch and Leonidas J. Guibas (1999) Kinetic data structures.
3. Sabine Naewe (2007) Kinetische Datenstrukturen für zweidimensionale Probleme. Seminararbeit, Universität Paderborn
4. Daniel Russel (2007) Kinetic data structures. In CGAL Editorial Board, editor, CGAL User and
Reference Manual. 3.3 edition
5. Hans R. Schwarz and Norbert Koeckler (2004) Numerische Mathematik, Seiten 104–124, 5. überarbeitete Auflage Teuber
6. Cgal. Computational Geometry Algorithms Library. http://www.cgal.org.
17
Computational Geometry Algorithms Library, siehe [6].
Das Steinerbaumproblem - Ein klassisches Problem der
Graphentheorie
Linda Röhrkohl
Universität Paderborn [email protected]
Zusammenfassung. Das Steinerbaumproblem ist ein klassisches N P-vollständiges Problem der Graphentheorie. In dieser Ausarbeitung wird dieses Problem erläutert und eine vollständige Komplexitätsanalyse
durchgeführt. Anschließend werden Spezialfälle des Steinerbaumproblems, allesamt bekannte graphentheoretische Probleme, motiviert und Algorithmen zu ihrer Lösung präsentiert. Desweiteren werden zwei Algorithmen untersucht, mit denen sich das Steinerbaumproblem exakt lösen lässt. Da diese Algorithmen für
die meisten Probleminstanzen exponentielle Laufzeit besitzen, wird abschließend ein Approximationsalgorithmus mit Güte 2 vorgestellt.
Durch wiederholende, grundlegende Definitionen, soll es auch den Lesern, die sich als Amateure auf dem
Gebiet der theoretischen Informatik betrachten, möglich sein dem vermittelten Inhalt einfach zu folgen.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
2
Graphentheoretische Defintionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
3
Das Steinerbaumproblem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
4
Die Komplexität des Steinerbaumproblems . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5
Spezialfälle des Steinerbaumproblems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
5.1 Das Problem des kürzesten Weges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
5.2 Minimale Spannbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6
Exakte Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.1 Der Enumerations-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.2 Die Idee des Dreyfus-Wagner Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7
Approximationsalgorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.1 Ein einfacher Algortihmus mit Approximationsgüte 2 . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.2 Verbesserung der Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
8
Offene Fragen - Ein Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
1 Einleitung
Das Steinerbaumproblem ist ein Problem der Graphentheorie. Es besitzt jedoch viele praktische Anwendungsbereiche, wie z.B. die Netzwerktheorie oder die Modernisierung von Streckennetzen.
88
Linda Röhrkohl
Diese Ausarbeitung ist angelehnt an die Kapitel 1 bis 6 von [1].
Zur ersten Veranschaulichung des Steinerbaumproblems kann man als Beispiel den dreispurigen Ausbau eines vorhandenen zweispurigen Autobahnnetzes nennen. Da es aus Kostengründen nicht möglich ist alle Autobahnen dreispurig umzubauen, macht die Regierung die
Einschränkung, dass es nur möglich sein solle, von jeder Großstadt in jede andere Großstadt
über dreispurige Autobahnen zu gelangen. Für die Straßenplaner gilt es somit, die Verbindungen im Autobahnnetz zu identifizieren, über die man alle Großstädte erreichen kann und
die alles in allem eine minimale Gesamtlänge besitzen. Denn nur so können die Kosten für
das gesamte Projekt minimiert werden.
Betrachtet man den Bereich der Netzwerktechnik, so kann man sich vorstellen, dass es
verschiedene Teilnehmer gibt, die über ein Netzwerk miteinander kommunizieren wollen.
Teilweise sind die Teilnehmer direkt miteinander vernetzt, es gibt aber auch Kreuzungspunkte in denen Leitungen von verschiedenen Teilnehmer zusammentreffen. Jeder Leitungabschnitt hat eine individuelle Übertragungszeit. Die Teilnehmer können Nachrichten, die
sie von anderen Teilnehmern empfangen an andere Teilnehmer weiterleiten. Um die schnellste Kommunikation aller Teilnehmer untereinander zu ermöglichen, ist es nötig das Teilnetz
zu finden, an dem alle Teilnehmer angeschlossen sind und das eine minimale Gesamtübertragungszeit unter allen möglichen Teilnetzen besitzt.
2 Graphentheoretische Defintionen
Zunächst ist es nötig einige Begriffsklärungen vorzunehmen.
In dieser Ausarbeitung werden stets ungerichtete Graphen betrachtet. Wird im Folgenden
von einer Kante (x, y) oder einer Weglänge p(x, y) gesprochen, so impliziert dieses stets, dass
auch die Kante (y,x) bzw. die Weglänge p(y,x) gemeint ist.
Außerdem wird zwischen Graphen G = (V, E) und Netzwerken N = (V, E, l) unterschieden. Als Netzwerke werden hierbei gewichtete Graphen mit nichtnegativer Gewichtsfunktion l : E(N ) → R≥0 bezeichnet.
Ein Baum ist ein zusammenhängender, kreisfreier Graph. Gibt es einen Baum, der alle
Knoten eines Graphen umfasst, so wird dieser Spannbaum genannt.
Für zwei Knoten x und y bezeichnet p(x, y) stets die Länge des kürzesten Weges von x nach
y.
3 Das Steinerbaumproblem
Formalisiert man die in der Einleitung vorgestellten Problembeschreibungen, so gelangt man
zu folgendem Ergebnis:
Das Steinerbaumproblem behandelt die Fragestellung des Findens eines minimalen Teilgraphen zu einem Graphen G = (V, E), der alle Knoten k ∈ K einer Terminalmenge K ⊆ V
beinhaltet.
Definition 1 (Steinerbaum).
Ein Teilgraph T von G heißt Steinerbaum für K (K ⊆ V (T )), wenn T ein Baum ist, der
alle Knoten aus K enthält, sodass alle Blätter von T Knoten aus K sind. Knoten aus K
heißen Terminale und Knoten aus V (T ) \ K heißen Steinerpunkte von T .
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
89
Betrachtet man die Problemstellung als Optimierungsproblem, so gilt es den Steinerbaum
mit minimalem Gewicht zu finden.
In ungewichteten Graphen gilt es somit den Steinerbaum mit minimaler Kantenzahl zu
identifizieren, was zu folgender Problemdefintion führt:
Definition 2 (Minimales Steinerbaumproblem in Graphen).
Gegeben: Ein zusammenhängender Graph G = (V, E) und eine Menge von Terminalen
(K ⊆ V ).
Gesucht: Ein Steinerbaum T für K so, dass |E(T )| = min{|E(T ∗ )| |T ∗ ist ein Steinerbaum
für K in G}.
Betrachtet man hingegen Netzwerke, so minimiert man nicht die Kantenanzahl, sondern das
Gesamtgewicht des Steinerbaums. Dieses spiegelt die folgende Problemdefinition wieder:
Definition 3 (Minimales Steinerbaumproblem in Netzwerken).
Gegeben: Ein zusammenhängendes Netzwerk N=(V,E,l) und eine Menge von Terminalen
(K ⊆ V ).
Gesucht: Ein Steinerbaum T für K so, dass l(T ) = min{l(T ∗ ) |T ∗ ist ein Steinerbaum für
K in N}.
Bei diesen Definitionen sollte auffallen, dass das Steinerbaumproblem in Graphen ein Spezialfall des Steinerbaumproblems in Netzwerken ist. Wählt man nämlich l(e) = 1 für alle
e ∈ E, so kann man einfach eine Probleminstanz des Steinerbaumproblems in Graphen in
eine Instanz für das Steinerbaumproblem in Netzwerken transformieren.
4 Die Komplexität des Steinerbaumproblems
Die Untersuchung der Komplexität des Steinerbaumproblems erfordert, dass das Optimierungsproblem in ein Entscheidungsproblem transformiert wird.
Dazu wird die Problemstellung in der Weise abgeändert, dass nicht mehr eine maximale
oder minimale Lösung gesucht wird, sondern entschieden werden soll, ob es eine Lösung
gibt, die eine entsprechende Schranke einhält.
Für die Formulierung des Steinerbaumproblems in Graphen als Entscheidungsproblem ergibt sich dann die folgende Definiton:
Definition 4 (Steinerbaumproblem in Graphen).
Gegeben: Ein zusammenhängender Graph G=(V,E), eine Menge von Terminalen (K ⊆ V )
und eine ganze Zahl B.
Frage: Existiert ein Steinerbaum T für K mit |E(T )| ≤ B?
Zunächst werden nun die nötigen Definitionen und Grundlagen, die für eine Komplexitätsanalyse nötig sind, wiederholt, wobei von einer vorherigen Kenntnis der Leser ausgegangen wird.
Ein grundlegendes Entscheidungsproblem ist das Satisfiability-Problem, das wie folgt
definiert ist:
90
Linda Röhrkohl
Definition 5 (Satisfiability).
Gegeben: Eine boolsche Formel F in konjuktiver Normalform.
Frage: Gibt es eine gültige Variablenbelegung, die F erfüllt?
Betrachtet man nicht beliebige Formeln in konjunktiver Normalform, sondern beschränkt
man die Anzahl Literale einer Klausel, so ergibt sich das kSAT-Problem.
Definition 6 (k-Satisfiability(kSAT)).
Gegeben: Eine boolsche Formel F in konjuktiver Normalform, bei der jede Klausel maximal
k Literale besitzt.
Frage: Gibt es eine gültige Variablenbelegung, die F erfüllt?
In der Komplexitätstheorie geht es darum, den zur Lösung eines Entscheidungsproblems
minimal benötigten Ressourcenbedarf zu bestimmen. Ressourcen können hierbei beispielsweise Laufzeit oder Speicherbedarf sein.
Die Klassen P und N P fassen beispielsweise die Probleme zusammen, die in polynomieller
Zeit entschieden werden können. In P sind die Probleme, die durch deterministische Turingmaschinen, in N P die, die durch nichtdeterministische Turingmaschinen in polynomieller
Zeit entschieden werden können.
Für ein Entscheidungsproblem Π = (I, Sol) ( mit I ist die Menge der Instanzen, die in
polynomieller Zeit entscheidbar sind und Sol, die Menge der Entscheideungen die für diese
Instanzen getroffen werden) bedeutet dies, dass es in N P ist, genau dann, wenn
1. die Größe der Lösung einer Instanz polynomiell abhängig ist von der Größe der Instanz
selber. Es existiert also ein Polynom p mit |x| ≤ p(|I|) ∀I ∈ I und x ∈ Sol(I).
2. ein Algorithmus A und ein Polynom q existieren so, dass für alle I ∈ I gilt
a) Wenn Sol(I) 6= ∅, dann gibt es ein x0 ∈ Sol(I), sodass A die Eingabe (I, x0 ) in Zeit
q(|I|) akzeptiert.
b) Wenn Sol(I) = ∅, dann verwirft A für jedes x ∈ Σ ∗ die Eingabe (I, x) in Zeit q(|I|).
Um die Komplexität zu analysieren wird zudem das Mittel der polynomiellen Reduktion
benötigt.
Definition 7. Ein Entscheidungsproblem Π = (I, Sol) heißt polynomiell auf ein anderes
Entscheidungsproblem Π ∗ = (I ∗ , Sol∗ ) reduzierbar, Π ≤p Π ∗ , falls es eine Funktion f :
I → I ∗ gibt, die in polynomieller Zeit berechenbar ist und für die gilt
∀I ∈ I : Sol(I) 6= ∅ ⇐⇒ Sol∗ (f (I)) 6= ∅
Die polynomielle Reduktion macht es nun möglich, die schwierigsten Probleme in N P
zu beschreiben.
Definition 8. Ein Entscheidungsproblem Π ∗ ist N P-vollständig genau dann, wenn Π ∗ ∈
N P und ∀Π ∈ N P : Π ≤p Π ∗ .
Im Jahre 1971 zeigte der kanadische Wissenschaftler Stephen Cook, dass Satisfiability in
N P ist und sich auf alle anderen Probleme in N P reduzieren lässt [2]. Hiermit bewies er
das Theorem 1.
Theorem 1. Satisfiability ist N P-vollständig.
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
91
Mittels dieses fundamentalen Satzes ist es nun möglich die N P-Vollständigkeit vieler
Entscheidungsprobleme durch polynomielle Reduktion auf SAT zu zeigen. Denn wenn sich
alle Probleme in N P polynomiell auf SAT reduzieren lassen und gezeigt werden kann, dass
sich SAT auf ein anderes Problem polynomiell reduzieren lässt, so folgt aus der Transitivität
der polynomiellen Reduktion, dass sich alle Problem in N P auf dieses Problem polynomiell
reduzieren lassen.
Korollar 1. 3SAT ist N P-vollständig.
Beweis. 3SAT ist offensichtlich in N P, denn für eine gegebene Variablenbelegung ist es
einfach zu entscheiden, ob sie eine Formel in konjunktiver Normalform erfüllt oder nicht.
SAT lässt sich einfach polynomiell auf 3SAT reduzieren, denn jede Boolsche Formel F in
konjunktiver Normalform lässt sich in eine Formel F3 mit 3 Literalen pro Klausel umstellen.
Dieses funktioniert wie folgt:
Jede Klausel C = (l1 ∨ ... ∨ lk ) mit k > 3 in F ersetze durch die Klauseln C3 = (l1 ∨ l2 ∨
y1 ) ∧ (y1 ∨ l3 ∨ y2 ) ∧ ... ∧ ((yk−3 ∨ lk−1 ∨ lk ) in F3 . F3 ist so genau dann erfüllt, wenn F erfüllt
ist.
u
t
Zur Zeit ist kein Algorithmus bekannt, der jede Instanz des Steinerbaumproblems in
polynomieller Zeit löst. Dieses ist, da allgemein angenommen wird, dass P =
6 N P gilt, nicht
verwunderlich, denn:
Theorem 2. Das Steinerbaumproblem in Graphen ist N P-vollständig.
Beweis. Es ist offensichtlich, dass das Steinerbaumproblem in N P liegt, denn es ist trivial
einen Algorithmus anzugeben, der prüft ob eine gegebene Lösung zulässig ist und die geforderte Schranke erfüllt.
Somit gilt es nun, die zweite Bedingung für N P-Vollständigkeit zu beweisen: Das Steinerbaumproblem ist schwerer als alle anderen Probleme in N P. Dazu reduzieren wir 3SAT auf
das Steinerbaumproblem.
Seien x1 , ..., xn die Variablen und K1 , ..., Km die Klauseln einer zufälligen 3SAT -Instanz F.
Es ist also nötig einen Graphen G = (V, E), eine Terminalmenge K und eine Grenze B so
zu konstruieren, dass G genau dann einen Steinerbaum T für K beinhaltet, der maximal
Länge B besitzt, wenn die gegebene 3SAT -Instanz erfüllbar ist.
G wird wie folgt aufgebaut:
Seien u und v zwei Knoten, die über einen Literal-Pfad P(siehe Abbildung 1) miteinander
Abb. 1. Transformation von 3SAT in das Steinerbaumproblem: Der Literal-Pfad [1, S.52]
verbunden sind. Dieser Pfad besitzt als Knoten die Literale aus F in negierter und unnegierter Form. Es ist über den Pfad P nur möglich von u nach v zu gelangen, wenn für
92
Linda Röhrkohl
jedes Literal aus F der negierte oder der unnegierte Knoten ein Mal passiert wird. Für jede
Klausel Ki von F sei Ci ein Knoten, der über Pfade zu allen Literalen verbunden ist, die in
Ki vorkommen. Dieses wird in Abbildung 2 illustriert. Jeder dieser Pfade erhält die Länge
t = 2n + 1.
Die Terminalmenge ist K = {u, v} ∪ {C1 , ..., Cm } und B = 2n + tm.
Abb. 2. Die Graphenkonstruktion für die Klausel Ki = x2 ∨ xj ∨ xn . Die gestrichelten Linien stellen Pfade
der Länge t = 2n + 1 von Ci zu den entsprechenden Knoten des Literal-Pfads dar. [1, S.52]
Es sind nun zwei Richtungen zu zeigen.
3SAT-Instanz F ist erfüllbar =⇒ Es gibt einen Steinerbaum T in G mit Länge
≤ B:
Ist F erfüllbar, dann besteht der Steinerbaum zunächst aus einem (u, v)-Pfad P, der eine erfüllende Variablenbelegung repräsentiert. Ist xi in F wahr, dann ist xi ∈ P , sonst ist xi ∈ P .
Der (u, v)-Pfad hat somit die Länge 2n. Jeder Klauselknoten Ci , (1 ≤ i ≤ m), kann mit P
über einen Pfad der Länge t verbunden werden. Somit erhält man einen Steinerbaum der
Länge 2n + tm = B;
Es gibt einen Steinerbaum T in G mit Länge ≤ B =⇒ es gibt eine erfüllende
Variablenbelegung für die 3SAT-Instanz:
Jede Klausel Ci muss offensichtlich mit dem Literal-Pfad verbunden werden.
Annahme: Es gibt eine Klausel Ci0 , die mit dem Literal-Pfad über mindestens zwei ihrer
Pfade verbunden ist. Dann gilt aber |E(T )| ≥ (m + 1)t = 2n + 1 + mt > B. Dies ist ein
Widerspruch und die getroffene Annahme kann nicht gelten.
Somit müssen u und v über den Literal-Pfad miteinander verbunden sein was mindestens
2n Kanten bedeutet. Da jede Klausel einen Pfad mit Gewicht t benötigt um Ci mit dem
Literal-Pfad zu verbinden, muss der Literal-Pfad genau 2n Kanten beinhalten. Somit repräsentiert der (u, v)-Pfad eine erfüllende Variablenbelegung.
Da die Konstruktion des Graphen offensichtlich in polynomieller Zeit erfolgen kann gilt
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
93
3SAT ≤p Steinerbaumproblem in Graphen.
u
t
5 Spezialfälle des Steinerbaumproblems
In diesem Kapitel werden zwei Spezialfälle des Steinerbaumproblems in Bezug auf die besondere Kardinalität der Terminalmenge vorgestellt. Beide Spezialfälle sind berühmte Probleme
der Graphentheorie.
Ist N = (V, E, l) ein Netzwerk und K ⊆ V die Terminalmenge, dann entspricht das Steinerbaumproblem im Fall von |K| = 2, also z.B. K = {s, t}, dem Problem des Findens des
kürzesten Weges von s nach t in N . Gilt hingegen K = V , d.h. alle Knoten des Netzwerks
sind auch Terminale, so ist das Problem äquivalent mit der Bestimmung eines minimalen
Spannbaumes für N . Beide Problemstellungen und die bekanntesten Algorithmen zu ihrer
Lösung werden im Folgenden vorgestellt.
5.1 Das Problem des kürzesten Weges
Beim Problem des kürzesten Weges betrachtet man ein Netzwerk N = (V, E, l) und zwei
Knoten s, t ∈ V . Es gilt einen kürzesten Weg von s nach t in G zu bestimmen.
Der Algorithmus nach Dijkstra
Ein Algorithmmus zur Lösung des Problems des kürzesten Weges wurde im Jahr 1959 von
Edsger W. Dijkstra entwickelt. [3]
Die Idee des Algorithmus ist die Folgende:
Die Knotenmenge V lässt sich in jeder Runde, die der Algorithmus durchläuft, in drei
disjunkte Teilmengen aufsplitten. Die erste Menge, im Folgenden mit W bezeichnet, enthält
die Knoten die vom Startknoten s erreichbar sind und deren kürzeste Distanz von s bereits
bestimmt wurde.
Die zweite Menge fasst die Knoten x ∈ V \W zusammen, die über eine Kante e=(w,x) von
einem Knoten w ∈ W erreichbar sind. Dieses sind die Knoten um die der kürzester Pfad
sukzessive erweitert wird.
In der dritten Menge sind die Knoten, die weder zur ersten noch zur zweiten Menge gehören.
Die Funktion d : V (N ) → N gibt die jeweils aktuelle minimale Distanz des Knoten v von
s an. Die Funktion π : V (N ) → V (N ) gibt den Vorgängerknoten des Knotens v an über
den er auf dem kürzesten Weg von s erreicht wird. Bei Initialisierung erhält jeder Knoten
v ∈ V \s die Distanz d[v] = ∞ zugewiesen. Es gilt d[s] = 0 und π[s] = nil.
So lange wie der Zielknoten t nicht in W ist, also kein kürzester Weg von s nach t gefunden
wurde, nimmt der Algorithmus den Knoten x aus V \ W , der die kürzeste Entfernung d[x]
besitzt und fügt ihn zu W hinzu. Für alle Nachbarn y dieses Knotens, die nicht bereits in
W sind, wird geprüft, ob ihre Entfernung d[y] durch den Weg über x und die Nutzung der
Kante (x, y) ∈ E verringert werden kann. Ist dieses der Fall, so wird ihre Distanz d[y] und
ihr Vorgänger π[y] entsprechend geändert.
Theorem 3. Dijkstras Algorithmus ist korrekt und kann mit Laufzeit O(m + n log n) implementiert werden.
94
Linda Röhrkohl
Algorithmus 7 DIJKSTRAS ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N=(V,E,l) und zwei Knoten s, t ∈ V .
Ausgabe: Ein kürzester (s,t)-Pfad in N.
{Initialisierung}
W := ∅; d[s]:=0; π[s] :=nil;
for all v ∈ V \{s} do
d[v] = ∞
while t ∈
/ W do
Wähle x0 ∈ V \ W mit d[x0 ] = min{d[v]|v ∈ V \ W };
W := W ∪ {x0 }
for all v ∈ Γ (x0 ) ∩ (V \ W ) do
if d[v] > d[x0 ] + l(x0 , v) then
d[v] = d[x0 ] + l(x0 , v)
π[v] := x0
Beweis. Um die Korrektheit zu zeigen werden folgende Schleifeninvarianten gewählt, die
nach jeder Iteration der while-Schleife gelten:
1. Für alle v ∈ W ist d[v] die Länge eines kürzesten (s, v)-Pfades und es existiert (wenn
s 6= v) ein kürzester (s, v)-Pfad, der mit der Kante (π[v], v) endet.
2. Für alle v ∈ V \ W , mit d[v] < ∞, ist d[v] die Länge eines kürzesten (s,v)-Pfades im
Netzwerk N [W ∪ {v}], dass durch die Knotenmenge W ∪ {v} induziert wird. Es existiert
ein kürzester (s,v)-Pfad, der mit der Kante (π[v], v) endet.
Trivialerweise gelten 1. und 2. nach der Initialisierung. Somit reicht es zu zeigen, dass, wenn
1. und 2. zu Beginn einer Iteration der while-Schleife gelten, sie auch am Ende der Iteration
gelten. Aus diesem Grunde betrachte man den Knoten x0 der zu W hinzugefügt wird. Nach
Invariante 2. existiert ein (s, x0 )-Pfad P in N [W ∪ {v}], der mit (π[v], v) endet und der
Länge l(P ) = d[x0 ] besitzt.
Sei P 0 ein beliebiger (s, x0 )-Pfad, der nicht vollständig in N [W ∪ {x0 }] liegt. Dann enthält
P 0 einen Knoten y ∈
/ W ∪ {x0 }. Aufgrund der Wahl von x0 als Knoten mit minimalem
d[v] und der Tatsache, dass alle Kantenlängen nichtnegativ sind, kann man folgern, dass
l(P ) = d[x0 ] ≤ d[y] ≤ l(P 0 ). Somit gilt 1. für die neue Menge W ∪ {x0 }. Die d-Werte von
Knoten werden in der for-Schleife nur geändert werden, wenn man den Knoten über einen
kürzeren Pfad, der über x0 führt erreichen kann. Dann werden die d-Werte dieser Knoten
genau auf diesen kürzere Pfadlänge geändert und x0 der entsprechende Vorgänger. Hiermit
folgt direkt, dass 2. ebenso gilt.
Betrachtet man die Laufzeit so stellt man direkt fest, dass die Wahl des x0 der zeitaufwändigste Schritt des Algortihmus ist. Sie ist abhängig von der Implementierung. Speichert man
die d-Werte in einem Array so dauert die Suche nach dem besten x0 Zeit von O(n). Da die
while-Schleife bis zu (n − 1)-mal durchlaufen wird, würde für diese Verwaltung der d-Werte
eine Laufzeit von O(n2 ) folgen.
Eine bessere Laufzeit erreicht man, wenn man eine Priority Queue als Speicherstruktur für
die d-Werte nutzt. Verwendet man beispielsweise einen Fibonacci Heap, wie er in [4] vorgestellt wird, erreicht man eine Laufzeit von O(m + n log n). Die Initialisierung benötig Zeit
O(n). Dann werden maximal n − 1 Extract-Min Operationen zur Findung des x0 benötigt
und maximal m Decrease-Key Operationen. Die Veränderung der Werte der Nachbarknoten
kann in Zeit O(m) geschehen, da jede Kante maximal zweimal betrachtet wird.
t
u
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
95
Anmerkung 1. Ändert man die Terminierungsbedingung der while-Schleife von t ∈
/ W zu
W 6= V so berechnet Dijkstras Algorithmus die kürzeste Distanz des Knotens s zu allen
anderen Knoten innerhalb der gleichen Laufzeitbeschränkung. Es gilt somit offensichtlich
das folgende Theorem.
Theorem 4. Sei N=(V,E,l) ein Netzwerk und s ∈ V . Dann kann man kürzeste Wege von s
zu allen Knoten v ∈ V in Zeit O(m + n log n) berechnen.
u
t
5.2 Minimale Spannbäume
Betrachtet man ein Netzwerk N = (V, E, l), so besteht das Problem des minimalen Spannbaums für N darin, einen Baum T in N zu finden, der alle Knoten v ∈ V beinhaltet, für den
also gilt V (T ) = V und der dabei minimales Gewicht besitzt. Für T muss folglich gelten:
P
e∈E(T ) l(e) ist minimal.
Der Algorithmus von Jarnik und Prim
Ein Algorithmus zur Lösung dieses Problems wurde von Jarnik und Prim entwickelt. [5] Die
Idee dieses Algorithmus ist ähnlich der, des Algortihmus von Dijkstra zur Berechnung des
kürzesten Weges.
Im Algorithmus wird zunächst ein beliebiger Knoten s ∈ V ausgewählt und dem Spannbaum T hinzugefügt. Alle Knoten, die zum Spannbaum gehören werden in der Menge W
zusammgengefasst. Die Menge F ⊆ E enthält die Kanten von N , die den Spannbaum T
bilden. Die Funktion d : V (N ) → N gibt die Distanz des Knoten v zu einem Knoten aus
W zum jeweiligen Zeitpunkt des Algorithmus an. Die Funktion π : V (N ) → V (N ) gibt den
Vorgängerknoten des Knotens v an, über den er beim Aufbau des minimalen Spannbaums
von einem Knoten aus W erreicht wird. In jeder Runde wird der Knoten x0 ∈ V \ W zu W
hinzugefügt, der die kürzeste Distanz von einem Knoten w ∈ W besitzt. Die Kante, über die
der Knoten erreicht wird, wird in F ergänzt. So fährt der Algorithmus fort bis alle Knoten
aus V in W enthalten sind und somit zum Spannbaum gehören.
Algorithmus 8 JARNIK-PRIM ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N=(V,E,l).
Ausgabe: Ein minimaler Spannbaum T=(V,F) für N.
{Initialisierung}
Wähle beliebiges s ∈ V
W := ∅; F := ∅; d[s] := 0; π[s] :=nil;
for all v ∈ V \{s} do
d[v] = ∞
while W 6= V do
Wähle x0 ∈ V \ W mit d[x0 ] = min{d[v]|v ∈ V \ W };
W := W ∪ {x0 }; F := F ∪ {(x0 , π[x0 ])};
for all v ∈ Γ (x0 ) ∩ (V \ W ) do
if d[v] > l(x0 , v) then
d[v] = l(x0 , v)
π[v] := x0
96
Linda Röhrkohl
Theorem 5. Der Jarnik-Prim Algortihmus ist korrekt und kann mit Laufzeit O(m+n log n)
implementiert werden.
Beweis. Die Korrektheit des Algorithmus zeigen wir mittels drei Schleifeninvarianten, die
nach jeder Iteration der while-Schleife gelten:
1. Die Kanten in F bilden einen Spannbaum für die Knoten in W
2. Für alle v ∈ V \ W gilt
d[v] = min{l(x, v)|x ∈ W und (x, v) ∈ E}
und
d[v] = l(π[v], v).
Der Wert d[v] repräsentiert also die Länge der kürzesten Kante, die v mit den Knoten
in W verbindet und (π[v], v) ist eine solche Kante.
3. Es existiert ein minimaler Spannbaum T ∗ = (V, F ∗ ) mit F ⊆ F ∗ .
Trivialerweise gelten 1.-3. nach der Initialisierung. Nun nehmen wir an, dass 1.-3. zu Beginn
einer Interation gelten, dann kann man einfach sehen, dass 1. und 2. auch am Ende der
Iteration mit neuer Menge W gelten. Der Beweis verläuft analog zum Beweise von Dijkstras
Algorithmus. Um 3. zu zeigen sei T ∗ = (V, F ∗ ) ein minimaler Spannbaum, der den (alten)
Spannbaum F beinhaltet. Der Fall, dass (x0 , π[x0 ]) in F ∗ enthalten ist, ist trivial. Ist dieses
nicht der Fall, dann existiert ein Pfad P in T ∗ der π[x0 ] und x0 verbindet. Da π[x0 ] in W
ist und x0 nicht, muss der Pfad P mindestens eine Kante (y,z) enthalten bei der gilt y ∈ W
und z ∈
/ W . Aufgrund der Wahl von x0 und Invariante 2 weiss man, dass
l(π[x0 ], x0 ) = d[x0 ] ≤ d[z] ≤ l(y, z).
Sei nun F̃ := (F ∗ \ {(y, z)}) ∪ {(π[x0 ], x0 )}. Dann ist T̃ = (V, F̃ ) ein Spannbaum der Länge
l(T̃ ) = l(T ∗ ) − l(y, z) + l(π[x0 ], x0 ) ≤ l(T ∗ ).
Dann ist T̃ ein minimaler Spannbaum und F̃ beinhaltet, wie behauptet, die neue Menge
F := F ∪ {(π[x0 ], x0 )}. Somit ist der Algorithmus korrekt.
Die Zeitkomplexität von O(m + n log n) erreicht man wenn man als Speicherstruktur für
die d-Werte Fibonacci-Heaps verwendet. Dann dauert die Initialisierung Zeit von O(n). In
jeder Iteration der while-Schleife wird zur Bestimmung des x0 eine Extract-Min-Operation
und maximal m Decrease-Key-Operationen durchgeführt. Da es maximal n − 1 Durchläufe
der Schleife gibt, ergibt sich eine Gesamtlaufzeit von O(m + n log n).
t
u
Die Idee des Algorithmus von Kruskal
Einen anderen Ansatz zur Lösung des Problems liefert der Algortihmus von Kruskal. [6]
Dieser Algorithmus funktioniert nach der Greedy-Strategie. Alle Kanten e ∈ E werden
ensprechend ihres Gewichts l(e) austeigend sortiert. Der Algorithmus prüft in jeder Iteration
für die Kante, die unter den verbleibenden Kanten minimales Gewicht hat, ob ihr Hinzufügen
zu F einen Kreis in T ergeben würde. Ist dieses der Fall, so wird die Kante verworfen,
andernfalls wird sie zu F hinzugefügt. Kruskals Algorithmus kann so implementiert werden,
dass seine Laufzeit durch die Zeit, die für das Sortieren der Kanten benötigt wird, dominiert
wird. Das Sortiern ist in Lauzeit O(m log n) möglich.
Auf den Korrektheitsbeweis wird an dieser Stelle verzichtet.
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
97
Algorithmus 9 KRUSKALS ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N=(V,E,l).
Ausgabe: Ein minimaler Spannbaum T=(V,F) für N.
{Initialisierung}
Sortiere die Kanten so, dass l(e1 ) ≤ ... ≤ l(em ).
Sei F := ∅.
{Aufbau des Spannbaums}
for i := 1 to m do
if (V, F ∪ {ei }) ist kreisfrei then
F := F ∪ {ei }.
6 Exakte Algorithmen
Im letzten Abschnitt wurde gezeigt, dass es für Spezialfälle der Terminalmenge K Algortihmen gibt, die das Steinerbaumproblem in Netzwerken exakt und in polynomieller Laufzeit
lösen.
In diesem Abschnitt werden nun Algorithmen vorgestellt, die das Steinerbaumproblem exakt
lösen. Ihre Laufzeit ist im Allgemeinen exponentiell. Sie kann aber auch polynomiell sein,
wenn entweder davon ausgegangen werden kann, dass die die Anzahl der Nicht-Terminale
|V | − |K| oder die Anzahl der Terminale |K| konstant ist.
Die erste Idee für einen solchen exakten Algorithmus ist sehr einfach:
Zähle alle Teilmengen E 0 ⊆ E der Kanten von N auf, prüfe ob sie einen Steinerbaum für K
bilden und behalte die Menge, die den kleinsten Baum bildet.
Dieser Algortihmus ist offensichtlich korrekt, aber natürlich nicht sonderlich effizient. Seine
Laufzeit ist sogar exponentiell abhängig von der Anzahl der Kanten |E|. Die Algorithmen,
die im Folgenden vorgestellt werden, funktionieren nach ähnlichen Prinzipien, sind allerdings
deutlich effizienter.
6.1 Der Enumerations-Algorithmus
Betrachtet man das Steinerbaumproblem für Netzwerke, so kann es nach Definition in einem
Steinerbaum für K in N bis zu |V \ K| Steinerpunkte, also Knoten v ∈ V \ K geben.
Da alle Blätter von T Terminale sind lässt sich die Anzahl Steinerpunkte, die einen Grad
von mindestens 3 haben und somit einen Kreuzungspunkt in T bilden, beschränken.
Diese Tatsache wird der im Folgenden beschriebene Enumerations-Algortihmus ausnutzen.[7]
[8]
Lemma 1. Ein Steinerbaum T für eine Terminalmenge K mit |K| = k beinhaltet maximal
k − 2 Steinerpunkte mit Grad von mindestens 3.
Beweis. Sei s2 die Anzahl Steinerpunkte in T , die einen Grad 2 haben und s3 die Anzahl
Steinerpunkte, die einen Grad von mindestens 3 haben.
Die Anzahl der Knoten des Steinerbaums ergibt sich somit als |V (T )| = k + s2 + s3 . Hiermit
und aus der Tatsache, dass T ein Baum ist, folgt für die Summe der Knotengrade aller
Knoten von T
X
dT (v) = 2|E(T )| = 2(|V (T )| − 1) = 2(k + s2 + s3 − 1).
v∈V (T )
98
Linda Röhrkohl
Aus der Defintion von s2 und s3 folgt andererseits
X
v∈V (T )
dT (v) =
X
v∈K
|
X
dT (v) +
dT (v) ≥ k + 2s2 + 3s3 .
v∈V (T )\K
{z
≥k
}
|
{z
≥2s2 +3s3
}
Durch Gleichsetzung folgt somit s3 ≤ k − 2.
t
u
Es seien nun u und w zwei Kreuzungspunkte in T , also zwei Knoten mit Grad von mindestens 3, die über einen Pfad P miteinander verbunden sind.
Da T ein minimaler Steinerbaum ist folgt, dass P ein kürzester (u,w)-Pfad ist, wenn alle
Knoten auf P den Grad 2 besitzten und keine Terminale sind.
Die Steinerpunkte mit Grad 2 eines minimalen Steinerbaum liegen folglich immer auf einem
kürzesten Weg von einem Terminal zu einem anderen Terminal, von einem Terminal zu
einem Kreuzungspunkt, oder von einem Kreuzungspunkt zu einem Kreuzungspunkt in T .
Das sogenannte (vollständige) Distanz-Netzwerk von N, D(N ) = (V, ED , lD ), definiert für
jedes Knotenpaar u, v ∈ V die kürzeste Distanz voneinander. Es ist also definiert als ED =
V × V und lD (u, v) = p(u, v), mit p(u, v) ist die Länge des kürzesten Pfades von u nach v
in N.
Das Distanznetzwerk kann in polynomieller Zeit berechnet werden, indem beispielsweise der
Algorithmus von Dijkstra für jeden Knoten v ∈ V einmal ausgeführt wird.
Aus den bisherigen Ergebnissen gelangt man zu der Aussage, dass sich der minimale Steinerbaum T für N einfach in polynomieller Zeit berechnen lässt, wenn man die Menge seiner
Kreuzungspunkte S kennt. In diesem Fall bestimmt man zunächst das vollständige Distanznetzwerk D(N ). In dem Teilnetzwerk von D(N ), dass von den Knoten K ∪ S induziert
wird, berechnet man einen minimalen Spannbaum TSp . Dieser beinhalt alle Terminale K
und alle Kreuzungspunkte des minimalen Steinerbaums. Um letztendlich den minimalen
Steinerbaum zu bekommen müssen die Kanten e = (u, v) ∈ E(TSp ), die schließlich den
kürzesten Pfad von u nach v repräsentieren, noch durch den tatsächlichen kürzesten Weg
von u nach v in N ersetzt werden.
Der Enumerations-Algorithmus nutzt nun die Tatsache, dass die Anzahl der Kreuzungspunkte |S| durch den Wert k − 2 beschränkt ist und führt die Berechnung des minimalen
Spannbaums für alle entsprechenden Kreuzungspunktemengen durch. Der kleinste minimale
Spannbaum wird schließlich in den zugehörigen minimalen Steinerbaum T transformiert.
Algorithmus 10 ENUMERATIONS ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N = (V, E, l) und eine Terminalmenge K ⊆ V .
Ausgabe: Ein minimaler Steinerbaum T für N .
1: Berechne das Distanz-Netzwerk D(N ) = (V, ED , lD ) und speichere für jede Kante (u, v) ∈ ED den
kürzesten (u, v)-Pfad in N.
2: Berechne für alle S ⊆ V \ K mit |S| ≤ k − 2 einen minimalen Spannbaum TSp für das Teilnetzwerk von
D(N ), das von K ∪ S induziert wird.
3: Transformiere den kleinsten der Spannbäume TSp , die in Schritt 2 berechnet wurden, in einen Steinerbaum T in N .
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
99
Theorem 6. Der Enumerations-Algorithmus berechnet einen minimalen Steinerbaum. Er
kann so implementiert werden, dass seine Laufzeit beschränkt ist von O(n2 log n + nm +
min{nk−2 , 2n−k } · k 2 ).
Beweis. Die Korrektheit des Algorithmus folgt unmittelbar aus den zuvor gemachten Bemerkungen. Die Laufzeit ergibt sich aus den einzelnen Schritten. Schritt 1, die Berechnung
des Distanz-Netzwerks, kann in Zeit O(n2 log n + nm) geschehen indem man Dijkstras Algortihmus n mal ausführt.
In SchrittP2 berechnet
man einen minimalen Spannbaum (mit maximal 2k-2 Knoten) für
k−2 n−k
maximal i=0 i ≤ min{nk−2 , 2n−k } verschiedene Mengen K ∪ S. Da jede dieser Berechnungen in Zeit O(k 2 ) gemacht werden kann, indem man den Algortihmus von Jarnik
und Prim verwendet, dauert Schritt 2 maximal O(min{nk−2 , 2n−k } · k 2 ) Zeit. In Schritt 3
wird nur noch der kleinste minimale Spannbaum TSp in einen Steinerbaum transformiert.
Da jede Kante des Netzwerks N maximal in einem kürzesten Pfad, also einer Kante in TSp
enthalten sein kann, kann Schritt 3 in Zeit O(m) erledigt werden.
t
u
Aus diesem Beweis kann man weiterhin folgern, dass die Laufzeit des Algorithmus polynomiell beschränkt in der Größe des Netzwerks ist, wenn man nur Instanzen des Problems
betrachtet, in denen die Anzahl der Nicht-Terminale von einer festen Konstante begrenzt ist.
Denn so ist es möglich über alle Teilmengen S ⊆ V \K in polynomieller Zeit zu enumerieren.
Korollar 2. Sei C ∈ N beliebig, aber fest. Dann berechnet der Enumerations-Algorithmus
für alle Netzwerke N = (V, E, l) und Terminalmengen K ⊆ V mit |V \ K| ≤ C einen
minimalen Steinerbaum in Zeit O(n2 log n + nm).
6.2 Die Idee des Dreyfus-Wagner Algorithmus
Nachdem im letzten Abschnitt ein Algorithmus vorgestellt wurde, der das Steinerbaumproblem bei konstanten Nicht-Terminalmengen in polynomieller Zeit optimal löst, wird nun die
Idee eines Algorithmus vorgestellt, der bei konstanten Terminalmengen die optimale Lösung
in polynomieller Zeit berechnet.
Der Dreyfus-Wagner-Algorithmus [9] arbeitet nach dem Prinzip der dynamischen Programmierung. Hierbei berechnet er die Länge eines minimalen Steinerbaums für eine Terminalmenge K, aus den Längen der Steinerbäume für alle echten Teilmengen K’ von K.
Zunächst werden also die Steinerbäume für alle 2-elementigen Teilmengen von K berechnet. Aus diesen Ergebnissen lassen sich die Steinerbäume für alle 3-elementigen Teilmengen
berechnen bis schließlich ein minimaler Steinerbaum für die gesamte Terminalmenge K berechnet wird.
Im Folgenden sei für X ⊆ K und v ∈ V \ X der Wert s(X ∪ {v}) die Länge eines minimalen
Steinerbaums für X ∪ {v}. sv (X ∪ {v}) sei die Länge eines minimalen Steinerbaums für
X ∪ {v} in dem v mindestens den Grad 2 besitzt. Gibt es einen solchen Steinerbaum nicht,
ergibt sich die Länge nach Definition als sv (X ∪ {v}) = ∞. Die Werte s(X ∪ {v}) und
sv (X ∪ {v}) können rekursiv berechnet werden, was folgendes Lemma zeigt:
Lemma 2. Sei X ⊆ K, X 6= ∅ und v ∈ V \ X. Dann ist
100
Linda Röhrkohl
sv (X ∪ {v}) =
min {s(X 0 ∪ {v}) + s((X \ X 0 ) ∪ {v})}
∅6=X 0 (X
und
s(X ∪ {v}) = min{min {p(v, w) + s(X)}, min {p(v, w) + sw (X ∪ {w})}}.
w∈X
w∈V \X
Beweis. Um die erste Gleichung zu zeigen, betrachtet man den minimalen Steinerbaum T
für eine Teilmenge X von K und einen Knoten v aus V \ X mit Grad von mindestens 2.
Die Länge des minimalen Steinerbaums ist somit sv (X ∪ {v}). T kann man am Knoten v in
zwei disjunkte Steinerbäume trennen, von denen der eine die Knotenmenge X 0 ∪ {v} und
der andere die Knotenmenge X \ X 0 ∪ {v} umfasst. Beide Steinerbäume enthalten v mit
Grad ≥ 1. Die Länge des gesamten Steinerbaums sv (X ∪ {v}) erhält man nun, indem man
die Längen der beiden kleineren Steinerbäume addiert. Minimiert man über alle nichtleeren,
echten Teilmengen X 0 , so erhält man die erste Gleichung. Dieses wird durch die Abbildung
3 verdeutlicht.
Um die 2. Gleichung zu zeigen sei T ein minimaler Steinerbaum für X ∪ {v}, bei dem der
Abb. 3. Beweis der 1. Gleichung der Dreyfus-Wagner-Rekursion. [1, S.79]
Grad von v keiner Beschränkung unterliegt. Für ein Blatt u in T sei Pu der längste Pfad in
T, der in u beginnt und auf dem alle inneren Knoten den Grad 2 besitzen und zudem nicht
in K liegen. Es sind nun 3 Fälle zu unterscheiden. Minimiert man über alle 3 Fälle, erhält
man die Gültigkeit von Gleichung 2.
Fall 1: v hat Grad von mindestens 2. Dann ist s(X ∪ {v}) = sv (X ∪ {v}). Dieser Fall wird
durch Wahl von w = v eingeschlossen.
Fall 2: v ist ein Blatt in T und Pv endet in einem Knoten w ∈ X. Dann ist T die
Vereinigung eines minimalen Steinerbaums für X und eines kürzesten (v, w)-Pfades. Also
gilt s(X ∪ {v}) = p(v, w) + s(X).
Fall 3: v ist ein Blatt in T und Pv endet in einem Knoten w ∈
/ X. Dann hat w einen Grad
von mindestens 3. Also ist T in diesem Fall die Vereinigung eines minimalen Steienerbaums
für X ∪ {w} in dem w mindenstens den Grad 2 besitzt und einem kürzesten (v, w)-Pfad.
Also gilt s(X ∪ {v}) = p(v, w) + sw (X ∪ {w}).
Diese 3 Fälle werden durch Abbildung 4 illustriert.
t
u
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
101
Abb. 4. Beweis der 2. Gleichung der Dreyfus-Wagner-Rekursion. [1, S.79]
Der Dreyfus-Wagner-Algorithmus berechnet mit der Rekursionsformel von Lemma 2 die
Länge eines minimalen Steinerbaums. Diese ergibt sich für ein beliebiges v ∈ K als s(K) =
s((K \ {v}) ∪ v).
Algorithmus 11 DREYFUS-WAGNER ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N=(V,E,l) und eine Terminalmenge K ⊆ V .
Ausgabe: Die Länge eines minimalen Steinerbaum T für K
{Initialisierung}
for all v, w ∈ V do
berechne p(v,w);
for all {x, y} ⊆ K do
s({x, y}) := p(x, y);
{Rekursionsausführung analog zu Lemma 2}
for i := 2 to k − 1 do
for all X ⊆ K mit |X| = i und alle v ∈ V \ X do
sv (X ∪ {v}) = min∅6=X 0 (X {s(X 0 ∪ {v}) + s((X \ X 0 ) ∪ {v})}
for all X ⊆ K mit |X| = i und alle v ∈ V \ X do
s(X ∪ {v}) = min{minw∈X {p(v, w) + s(X)}, minw∈V \X {p(v, w) + sw (X ∪ {w})}}
Theorem 7. Der Dreyfus-Wagner Algorithmus berechnet die Länge eines minimalen Steinerbaums in O(3k n + 2k n2 + n2 log n + nm)Schritten.
Beweis. Die Korrektheit des Algorithmus folgt durch Lemma 2. Die Laufzeit ergibt sich
durch n-malige Ausführung von Dijkstras Algorithmus (O(n2 log n + nm)) und die Anzahl
Berechnungen in der ersten und zweiten Rekursionsgleichung. Die Anzahl der Berechnungen
der ersten Rekursionsformel ist abhängig von den Möglichkeiten v, X 0 und X zu wählen. Da
jedes Terminal zu genau einer der Mengen X 0 , X \ X 0 und K \ X gehört, sind sie begrenzt
durch O(3k n). Anhand der Anzahl Möglichkeiten X und v zu wählen ergibt sich, dass die
zweite Rekursionsformel für O(2k n) Tupel ausgeführt werden muss. Da für jedes Tupel n
Berechnungen nötig sind führt dieses zum Summanden O(2k n2 ).
u
t
Möchte man nicht nur die Länge eines minimalen Steinerbaums berechnen, sondern den
Steinerbaum an sich, so muss man neben den Längenberechnungen auch die Knoten und
Kanten speichern, für die sich die entsprechenden Längen ergeben und sie am Schluss zu einem Steinerbaum zusammenfügen. Die Lösungsidee, des Dreyfus-Wagner-Algorithmus sollte
nun erkannt sein. Es ergibt sich für ihn abschließend folgendes Korollar:
Korollar 3. Sei C ∈ N beliebig, aber fest. Dann berechenet der Dreyfus-Wagner-Algorithmus
für alle Netzwerke N=(V,E,l) und Terminalmengen K ⊆ V mit |K| ≤ C einen minimalen
Steinerbaum in Zeit O(n2 log n + nm).
102
Linda Röhrkohl
7 Approximationsalgorithmen
Da das Steinerbaumproblem N P-vollständig ist, ist es solange nicht möglich einen polynomiellen Algorithmus zu finden, der das Problem exakt löst, wie nicht P = N P bewiesen
wurde.
Auch kann besonders in praktischen Anwendungen nicht immer vorausgesetzt werden, dass
die Kardinalität der Terminalmenge bzw. der Nichtterminalmenge konstant ist und die Instanz des zugrundeliegenden Netzwerks hinreichend klein ist um einen der vorgestellten
exakten Algorithmen zur Lösung des Problems in Betracht zu ziehen.
Um dennoch in polynomieller Zeit an gute Lösungen des Problems zu gelangen verwendet
man sogenannte Approximationsalgorithmen.
Approximationsalgorithmen sollen nicht zwingend die optimale Lösung liefern, sondern eine
Lösung, die möglichst einen Wert besitzt, der nah am Optimum liegt. Die Qualität eines
Approximationsalgorithmus wird durch die Approximationsgüte angegeben.
Die Approximationsgüte eines Approximationsalgorithmus gibt an, um wieviel schlechter
eine Lösung des Algortihmus maximal, im Vergleich zur optimalen Lösung des Problems
ist. Das Maximum wird hierbei über alle Instanzen des Problems bestimmt.
Bezeichnet lopt (I) den Wert einer optimalen Lösung für eine Instanz Iund l(I), der Wert der
Lösung, die der Algorithmus für die Instanz I bestimmt, dann ist die Approximationsgüte
g für ein Minimierungsproblem definiert durch
g = max{
l(I)
| I ist Instanz des P roblems}.
lopt (I)
Im Fall des Steinerbaumproblems ist die Approximationsgüte definiert durch den maximalen Quotienten der Länge des Steinerbaums, den der Algorithmus ermittelt und der Länge
des minimalen Steinerbaums. Hierbei werden alle Instanzen des Steinerbaumproblems betrachtet.
7.1 Ein einfacher Algortihmus mit Approximationsgüte 2
In diesem Abschnitt wird ein Approximationsalgorithmus für das Steinerbaumproblem mit
Approximationsgüte 2 vorgestellt. Dieser Algorithmus liefert also im schlechtesten Fall einen
Steinerbaum, der doppelt so lang wie der minimale Steinerbaum ist.
Um diese Approximationsgüte zu erreichen nutzt der Algorithmus einen Zusammenhang
der Länge des minimalen Steinerbaum mit der Länge des minimalen Spannbaums für K im
zugehörigen vollständigen Distanznetzwerk ND = (K, ED , lD ). Dieser Zusammenhang wird
durch das folgende Lemma wiedergespiegelt:
Lemma 3. Sei N = (V, E, l; K) ein Steinerbaumproblem. Dann erfüllt jeder minimale
Spannbaum T im vollständigen Distanz-Netzwerk ND = (K, ED , lD )
2
lD (T ) ≤ (2 − ) · smt(N ),
k
mit k = |K| ist die Kardinalität der Terminalmenge und smt(N), die Länge des minimalen
Steinerbaums für K in N.
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
103
Beweis. Sei Topt ein minimaler Steinerbaum in N. Betrachtet man Topt im Gesamtnetzwerk
eingebettet und den Weg W um Topt herum (wie in Abbilung 5), dann passiert man auf W
jedes Terminal mindestens einmal und läuft zweimal entlang jeder Kante. Die Länge von
W ist somit doppelt so groß wie die Länge von Topt , also l(W ) = 2 · smt(N ).
Sei t die Anzahl Blätter von Topt , dann gibt es in W t ≤ k Pfade zwischen aufeinander-
Abb. 5. Illustration des Beweises des Lemma. Der Weg W besteht aus den Pfaden 1-2, 2-3, ...,7-8 und 8-1.
Um den Weg W 0 zu erhalten entfernt man den Pfad von 7 nach 8. [1, S.88]
folgenden Blättern in Topt . Entfernt man den längsten dieser Pfade, so ist die Länge des
verbleibenden Wegs l(W 0 ) maximal (1 − 1t )-mal so groß wie l(W ). Dieses ist der Fall, wenn
alle t Pfade die gleiche Länge besitzen.
Nun ist offensichtlich, dass man indem man dem Weg W 0 folgt einen Spannbaum für K in
ND konstruiert, der sogar ein Pfad ist. Die Länge dieses Spannbaum ist maximal l(W 0 ). Da
t ≤ k gilt, folgt somit
1
1
2
lD (T ) ≤ l(W 0 ) ≤ (1 − ) · l(W ) = (1 − ) · 2smt(N ) = (2 − ) · smt(N ).
k
k
k
u
t
Da ein minimaler Spannbaum nach Theorem 5 in polynomieller Zeit berechenbar ist und
ein minimaler Spannbaum im vollständigen Distanznetzwerk einen minimalen Steinerbaum
mit Güte 2 approximiert, kann man diesen Spannbaum dazu nutzen einen Steinerbaum zu
konstruieren, der maximal zweimal so lang ist wie der minimale Steinerbaum für dieses Netzwerk. Auf diese Weise berechnet der folgende MSP-Algorithmus [10] einen approximierten
Steinerbaum.
Das Beispiel in Abbildung 6 illustriert die verschiedenen Schritte des Algorithmus. Außerdem macht es deutlich, dass die Schritte 4 und 5 für die Probleminstanzen benötigt werden
bei denen das Teilnetzwerk N [TD ] nicht kreisfrei ist. Um aus N [TD ] einem Steinerbaum
zu erzeugen muss folglich mindestens noch eine Kante entfernt werden. Aus diesem Grund
berechnet man in Schritt 4 erneut einen minimalen Spannbaum. Besitzt dieser Blätter, die
keine Terminale sind, sind die Kanten zu ihnen für einen Steinerbaum ebenfalls unnötig und
werden daher entfernt.
Theorem 8. Sei N = (V, E, l; K) ein Netzwerk. Dann berechnet der MST-Algorithmus in
polynomieller Zeit einen Steinerbaum SK für N so, dass gilt
2
l(SK ) ≤ (2 − ) · smt(N ).
k
104
Linda Röhrkohl
Algorithmus 12 MSP-ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N=(V,E,l) und eine Terminalmenge K ⊆ V .
Ausgabe: Ein minimaler Steinerbaum SK für N.
1: Berechne das Distanz-Netzwerk ND = (K, ED , lD ) und speichere für jede Kante (u, v) ∈ ED den kürzesten (u,v)-Pfad in N.
2: Berechne einen minimalen Spannbaum TD in ND .
3: Transformiere TD in ein Teilnetzwerk N [TD ] von N indem jede Kante von TD durch den entsprechenden
kürzesten Pfad in N ersetzt wird.
4: Berechne einen minimalen Spannbaum T für das Teilnetzwerk N [TD ].
5: Transformiere T in einen Steinerbaum SK für N, indem nach und nach die Blätter aus T entfernt werden,
die keine Terminale sind.
Abb. 6. Illustration der verschieden Schritte des MST-Algorithmus. [1, S.90]
Beweis. Aufgrund von Lemma 3 gilt l(TD ) ≤ (2 − k2 ) · smt(N ). Da l(TD ) in Schritt 3
unverändert bleibt, TD in Schritt 4 höchstens zu T verkleinert wird und T in Schritt 5
ebenfalls höchtens noch zu SK verkleinert wird, gilt l(TD ) ≥ l(T ) ≥ l(SK ). Somit ist auch
die Länge des approximierten Steinerbaum SK höchstens (2 − k2 )-mal so groß wie es der
minimale Steinerbaum ist.
t
u
Die Laufzeitanalyse des Algorithmus zeigt dass die Berechnung des Distanz-Netzwerks ND
der zeitaufwendigste Schritt ist, denn hierzu muss für alle k Terminale die Berechnung der
kürzesten Wege zu allen anderen Knoten erfolgen, was jeweils maximal Zeit von O(n log n +
m) benötigt. Die Berechnung der Spannbäume ist jeweils in Zeit O(n log n + m) möglich.
Für den Worst-Case k = |V | erhält man für den MSP-Algorithmus also eine Laufzeit von
O(n2 log n + nm).
7.2 Verbesserung der Laufzeit
Um die Laufzeit des MSP-Algorithmus zu verbessern, muss man den zeitaufwendigsten
Schritt, die Berechnung des vollständigen Distanznetzwerks überdenken.
Hierzu schlug der deutsche Informatiker Kurt Mehlhorn im Jahre 1988 vor, statt des voll∗ = (K, E ∗ , l∗ ) zu verwenden.[11] In diesem
ständigen, ein neuartiges Distanznetzwerk ND
D D
Netzwerk sollen alle Knoten v ∈ V in verschiedene Komponenten aufgeteilt werden. Jedes
Das Steinerbaumproblem - Ein klassisches Problem der Graphentheorie
105
Terminal s ∈ K entspricht einer Gruppe Ψ (s). Alle anderen Knoten v ∈ V \ K gehören
zu der Gruppe des Terminals zu dem sie die minimale Distanz p(s, v) besitzen. Haben sie
zu mehreren Terminalen die gleiche minimale Distanz, so werden sie einer beliebigen dieser
Gruppen zugeordnet.
∗ beinhaltet genau dann eine Kante zwischen zwei Komponentenknoten, wenn es in E
ED
eine Kante gibt, die zwei Knoten aus den beiden Komponenten miteinander verbindet. In
∗ sind sozusagen die Kreuzungskanten zweier Komponenten. Das Gewicht einer Kante ist
ED
der minimale Wert eines Pfades über den zwei Terminale miteinander verbunden werden
können. Formal bedeutet dies:
∗
∗ ∗
ND
= (K, ED
, lD ) mit
∗
(x, y) ∈ ED
⇐⇒ ∃(u, v) ∈ E mit u ∈ Ψ (x) und v ∈ Ψ (y),
∗
lD
(x, y) = min{p(x, u) + l(u, v) + p(v, y)|u ∈ Ψ (x), v ∈ Ψ (y), (u, v) ∈ E}.
Ein solches Neztwerk lässt sich schnell berechnen. Man fügt in das ursprüngliche Netzwerk
N einen Knoten s0 ein, den man mit allen Terminalen s ∈ K über eine Kante mit Gewicht
0 verbindet. Dann berechnet man mit einer Ausführung von Dijkstras Algorithmus die kürzesten Wege von s0 zu allen Knoten v ∈ V . Der erste Knoten, der auf dem kürzesten Weg
von s0 zu v passiert wird, ist offensichtlich das Terminal s, zu dem v die kürzeste Distanz
besitzt und in dessen Gruppe Ψ (s) v somit gehört. Die Pfadlängen p(s, v) aller Knoten zu
den entsprechenden Terminalen werden durch die Ausführung von Dijkstras Algorithmus
automatisch mit berechnet, denn sie entsprechen der kürzesten Pfadlänge p(s0 , v).
∗ und l∗ ist anschließend einfach und kann im Vergleich zur BeDie Berechnung von ED
D
rechnung der Komponenten vernachlässigt werden. Es ergibt sich also für die Berechnung
∗ die Laufzeit O(n log n + m) durch einmaliges Ausführen von Dijkstras
des Netzwerkes ND
∗ auch
Algorithmus. Mehlhorn bewies anschließend, dass jeder minimale Spannbaum in ND
in minimaler Spannbaum in ND ist. Transformiert man diesen Spannbaum anschließend in
den Teilgraphen von N, erhält man einen Steinerbaum für K in N, der der gleichen Approximationsgüte wie der MSP-Algorithmus genügt, aber nur eine Laufzeit O(n log n + m)
benötigt. Mehlhorns Algorithmus sieht folgendermaßen aus:
Algorithmus 13 MEHLHORNS-ALGORITHMUS
Vorbedingung: Ein zusammenhängendes Netzwerk N=(V,E,l) und eine Terminalmenge K ⊆ V .
Ausgabe: Ein minimaler Steinerbaum SM für N.
∗
∗
∗
1: Berechne das Distanz-Netzwerk ND
= (K, ED
, lD
).
∗
∗
2: Berechne einen minimalen Spannbaum TD in ND
.
∗
∗
∗
3: Transformiere TD
in einen Steinerbaum SM := N [TD
] für N, indem jede Kante von TD
durch den
entsprechenden Pfad in N ersetzt wird.
8 Offene Fragen - Ein Ausblick
In dieser Arbeit wurde das klassische Steinerbaumproblem ausführlich untersucht. Komplexität, Spezialfälle und Lösungsansätze wurden betrachtet. Es wurden sowohl exakte als
106
Linda Röhrkohl
auch approximative Lösungsansätze vorgestellt, doch es sind sicherlich auch noch Fragestellungen unbeachtet geblieben. Sind die exakten Lösungsansätze für einen Einsatz in der
Praxis überhaupt zu verwenden, oder ist es unrealistisch anzunehmen dass die Terminalmenge oder die Nichtterminalmenge konstant bleibt? Gibt es Approximationsalgorithmen,
die eine bessere Güte als 2 besitzen? Wie berechnet man Steinerbäume in Netzwerken, in
denen sich die Strukturen ständig verändern können? Hier wären beispielsweise Computernetze zu nennen, in denen Computer die Terminale und Router die Nicht-Terminale bilden
können und in denen die Computer sich am Netz an- und abmelden können. Alles dieses
sind Fragen, mit denen sich die Forschung bereits befasst hat und auf die in einer Vielzahl
von Papern eingegangen wird. Unter anderem waren dieses auch Fragen aus dem Gebiet der
dynamischen Steinerbäume, die die Seminarausarbeitung betrachtet.
Literaturverzeichnis
1. Prömel H. J., Steger A. (2002) The Steiner Tree Problem. A Tour through Graphs, Algorithms, and
Complexity. Vieweg, Braunschweig/Wiesbaden
2. Cook S. A. (1971) The complexity of theorem-proving procedure. In: 3rd Annual Symposium on Foundations of Computer Science: 431–439
3. Dijkstra E. (1959) A note on two problems in connexion with graphs. In: Numerische Mathematik 1,
Springer, Berlin Heidelberg New York, 269–271
4. Fredman M., Tarjan R. (1987) Fibonacci heaps and ther uses in improved network optimization algorithms. J. ACM 34: 596–615
5. Prim R. (1957) Shortest connection networks and some generalizations. Bell Systems Technical Journal
36: 1389–1401
6. Kruskal J. (1956) On the shortest spanning subtree of a graph and the traveling salesman problem.
Proceedings of the American Mathematical Society 7: 48–50
7. Hakimi S. (1971) Steiner’s problem in graphs and its applications. Networks Vol. 1, Nr.2: 113–133
8. Lawler E. (1976) Combinatorial Optimization: Networks and Matroids. Holt, Rinehart and Winston,
New York
9. Dreyfus S., Wagner R. (1972) The Steiner problem in graphs. Networks Vol. 1: 195–207
10. Kou L., Markowsky G., Berman, L. (1981) A fast algorithm for Steiner trees. Acta Inform. 15: 141–145
11. Mehlhorn K. (1988) A faster approximation algorithm for the Steiner problem in graphs. Inform.
Process. Lett 27: 125–128
Aspektgraphen und Verdeckung
Michael Kruse
Universität Paderborn [email protected]
Zusammenfassung. In dieser Ausarbeitung wird eine Repräsentation eines Objektes oder einer ganzen
Szene einer 3D-Computergrafik vorgestellt, der so genannte Aspektgraph. Ein Aspektgraph beschreibt Eigenschaften der Szene, die von der Position des Betrachters abhängig ist. Die zu wählenden Eigenschaften
sind von Anwendung abhängig. Die hier gewählte Eigenschaft ist die Sichtbarkeit von Elementen der Szene
von der Betrachterposition aus gesehen. Dazu werden zwei Algorithmen vorgestellt. Zum einen die naive
Herangehensweise und zum Anderen der Algorithmus von Plantinga und Dyer aus der Veröffentlichung [1].
Zum besseren Verständnis werden bei Algorithmen zuerst auf 2D-Grafiken mit orthographischer Projektion
angewandt, um sie dann auf 3D-Grafiken in orthographischer und perspektivischer Projektion zu verallgemeinern. Für alle Fälle wird die Größenkomplexität der nötigen Strukturen und die Zeitkomplexität beider
Algorithmen gezeigt.
1
Anwendungen und Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
1.1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
1.2 Beispielanwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
1.3 Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2
Verdeckung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
3
2D-Rendering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
3.1
3.2
3.3
3.4
3.5
Perspektivische Projektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Orthographische Projektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Der naive Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Der Algorithmus von Plantinga und Dyer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
4
3D-Rendering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Orthographische Projektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Perspektivische Projektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Maximale Größe eines Aspektgraphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Minimale Größe eines Aspektgraphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Der naive Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Der Algorithmus von Plantinga und Dyer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
5
Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
108
Michael Kruse
1 Anwendungen und Definition
1.1 Einleitung
Das Informatik-Fachgebiet Computergrafik beschäftigt sich mit dem Abbilden von 3DObjekten oder 3D-Szenen auf eine 2D-Bildfläche (Projektion). Je nachdem in welcher Position sich ein Betrachter relativ zum Objekt befindet, hat das Objekt eine andere Darstellung.
In dieser Ausarbeitung wird die Darstellung eines Objektes zumeist auf die topologische
Erscheinung von einem bestimmten Sichtpunkt, auch Aspekt genannt, reduziert.
Ein Aspektgraph speichert die Darstellungen eines Objektes oder einer Szene und welche
ineinander übergehen können. Eine weitere Datenstruktur namens VSP beschreibt, wann
sich der Aspekt ändert. Unter anderem können diese Informationen dazu genutzt werden,
alle sichtbaren Elemente der Szene zu bestimmen. Dies ist der Schwerpunkt dieser Ausarbeitung.
1.2 Beispielanwendungen
Objekterkennung in Bildern
Auf einer Rastergrafik ist ein Objekt abgebildet, z.B. auf einer Fotografie. Ein Computerprogramm, welchem möglichst viele Ansichten (bzw. Aspekte) dieses Objektes bekannt
sind, kann das abgebildete Objekt mit den bekannten Aspekten vergleichen. Bei genügender
Ähnlichkeit gilt das Objekt als erkannt.
Billboarding
Ein Billboard ist ein 2D-Bild innerhalb einer 3D-Computergrafik. Die Normale des Billboards
ist dabei immer zum Betrachter gerichtet, so dass das Objekt von allen Seiten gleich aussieht.
In älteren Computerspielen wurde dies z.B. für Bäume genutzt.
Statt immer das gleiche Bild darzustellen kann es der Perspektive des Betrachters angepasst werden. Dazu kann das passende Bild im zugehörigen Aspektgraphen abgespeichert
und bei der zugehörigen Ansicht verwendet werden.
Diese Technik wurde bereits beim PC-Spiel Wolfenstein 3D[2] eingesetzt (Abb. 1). Auf
dem linken Bild ist je ein Soldat von vorne und hinten abgebildet. Dies sind vordefinierte
2D-Grafiken. Die Grafik wird ausgetauscht, wenn sich der Sichtwinkel ändert (rechtes Bild).
Abb. 1: Screenshots aus dem PC-Spiel Wolfenstein 3D[2]
Als Aspektgraph modelliert würde eine Grafik für jeden Knoten des Aspektgraphens
erstellt werden. Einer Kante wird gefolgt und damit die Grafik des Billboards ausgetauscht,
wenn der andere Aspekt dem aktuellen Aspekt ähnlicher ist.
Aspektgraphen und Verdeckung
109
In Wolfenstein 3D wurden sicherlich keine Aspektgraphen genutzt, sondern die Differenz
zwischen der Sichtrichtung der Spielers und der des Soldaten. Daher kann sich die Grafik
ändern, wenn sich der Spieler nur dreht.
Occlusion-Culling
Culling bezeichnet das Entfernen von Elementen aus 3D-Szenen, die nicht auf der Projektion erscheinen. Occlusion-Culling (eng. Occlusion = Verdeckung) dementsprechend das
Entfernen von Elementen, die von weiteren Elementen verdeckt werden und daher nicht auf
der Projektion erscheinen. In der Computergrafik sind mit Elementen normalerweise ganze
Objekte gemeint, die vollständig oder gar nicht aus der Szene entfernt werden.
Ein Aspektgraph kann die sichtbaren Elemente für jede Betrachterposition speichern, es
werden dann nur diese Elemente gerendert.
1.3 Definitionen
Definition 1 (Aspektgraph). Ein Aspektgraph ist ein ungerichteter Graph G = (V, E),
in dem die Knoten v ∈ V einen Aspekt einer Szene oder eines Objekts entsprechen und die
Kanten e ∈ E die möglichen Übergänge zwischen diesen.
Zur Verdeutlichung ein Beispiel: Gegeben sei ein Würfel (Abb. 2). Von diesem gibt es 3
Projektionen: Mit einer sichtbaren Seite (A), mit zwei sichtbaren Seiten (B) und mit drei
sichtbaren Seiten (C).
A
B
C
Abb. 2: Ausgewählte Aspekte eines Würfels
Der Aspektgraph zu diesen Ansichten besteht aus drei Knoten, für jede Ansicht eine
(Abb. 2). Angenommen, die Projektion kann nicht direkt über eine Ecke des Würfels wechseln, so dass 2 Flächen auf einmal sichtbar werden, sondern nur indirekt über die Kanten
des Würfels. Unter dieser Voraussetzung sieht der Aspektgraph wie in Abb. 3 aus.
Abb. 3: Aspektgraph der 3 Ansichten von Abb. 2
2 Verdeckung
Im Folgenden sollen die sichtbaren Objektmerkmale (Ecken, Kanten, Seitenflächen, Polyeder) zu jeder Betrachterposition im Aspektgraphen gespeichert werden. Die Bestimmung
110
Michael Kruse
soll dabei genau sein, d.h. zu jeder Betrachterposition soll genau ermittelt werden können,
welche Merkmale sichtbar sind und welche nicht. Dies soll nun näher definiert werden.
Definition 2 (Objektraum, Bildraum, Sichtraum). Die Eingabe besteht aus ein oder
mehreren Objekten (Szene) im Objektraum. Diese sollen in den Bildraum niedrigerer Dimension abgebildet werden. Als weiterer Eingabeparameter dient die Position des Betrachters
(eng. Viewpoint) im Sichtraum (eng. Viewpoint Space).
Definition 3 (Labeled Image Structure Graph (LISG)). Der Labeled Image Structure Graph (aus [4]) ist eine Darstellung der Abbildung im Bildraum als Graph GLISG =
(VLISG , ELISG ). Eine Ecke des Objekts erscheint im LISG, wenn er in der Abbildung sichtbar ist. Ecken werden so miteinander durch Kanten verbunden, wie sie im Bildraum sichtbar sind. Sollten sich zwei Kanten im Bildraum schneiden, wird als Schnittpunkt ein neuer
Knoten eingeführt. Dieser wird T-Junction genannt. Ecken, Kanten und Seitenflächen im
Objektraum können Bezeichner (eng. label) gegeben werden, die dann auch im LISG erscheinen.
Da der LISG nach Definition ein Graph ist, haben die Ecken keine Koordinaten im
Bildraum, er beschreibt nur die Struktur. Die Bezeichner können aber sicherstellen, dass
Elemente aus dem Objektraum im LISG identifiziert werden können.
Es kann zwischen zwei Typen von LISGs unterschieden werden: der transparente LISG
und der verdeckende LISG (eng. opaque LISG). Im transparenten LISG sind alle Seitenflächen durchsichtig und daher sind alle Ecken und Kanten des Objektraumes zu sehen
(Abb. 4).
Bildraum
LISG
Abb. 4: Transparente Abbildungen
Bei dem verdeckenden LISG werden die Seitenflächen mit berücksichtigt (Abb. 5). Ecken
werden durch Flächen entweder ganz oder gar nicht verdeckt. Kanten können auch nur teilweise verdeckt werden. An den Schnittpunkten zwischen verdeckter Kante und verdeckender
Fläche entsteht dabei ein neuer Knoten, denn eine Kante eines Graphen kann nicht an einer
anderen Kante enden. Dieser neuer Knoten, der keine Abbildung einer Ecke des Objektes
ist, wird T-Junction genannt.
Aspektgraphen und Verdeckung
111
T-Junction
Bildraum
LISG
Abb. 5: Verdeckende Abbildungen
Für die Betrachtung von Sichtbarkeit ist nur der Teil der Topologie eines Objektes im
Bildraum interessant, der die sichtbare Struktur an einer Betrachterposition bestimmt. In
den folgenden Abschnitten wird ein Aspekt durch die zugehörige Topologie bestimmt. Für
diesen Zweck wird die Äquivalenz zweier Topologien (bzw. Aspekte) wie folgt definiert:
Definition 4 (Äquivalenz von Topologien im Bildraum). Zwei Topologien sind äquivalent, wenn die zugehörigen LISGs isomorph sind. Haben Ecken und Kanten Bezeichnungen, so muss der zugehörige Isomorphismus auch zwischen den Ecken und Kanten mit den
gleichen Bezeichnern abbilden.
Ein Aspektgraph beinhaltet nicht, wann eine Änderung der Betrachterposition eine Änderung des Aspektes zur Folge hat. Diesen Zweck erfüllt die folgende Struktur.
Definition 5 (Viewpoint Space Partition (VSP)). Ein Viewpoint Space Partition ist
eine Partitionierung des Sichtraumes in maximal große Regionen in denen die Topologie
äquivalent sind. Regionen sind zusammenhängend, d.h. zwei maximale Regionen mit äquivalenter Topologie, die aber nicht zusammenhängend sind, bleiben zwei unterschiedliche Regionen.
Der VSP ist zum Aspektgraphen dual, d.h. die Partitionen (bzw. Regionen) des VSP
sind die Ecken des Aspektgraphen und umgekehrt, denn innerhalb einer Region ist immer
derselbe Aspekt zu sehen.
3 2D-Rendering
Der zweidimensionale Objektraum ist einfacher zu verstehen als der dreidimensionale, deshalb sollen die Konzepte zuerst im zweidimensionalen Raum gezeigt und dann auf den
dreidimensionalen übertragen werden.
3.1 Perspektivische Projektion
Bei der perspektivischen Projektion (oder auch Zentralprojektion) ist der Objektraum auch
der Sichtraum, da sich der Betrachter in der Szene befindet. Da der Objektraum bereits
zweidimensional ist, muss der Bildraum eindimensional sein. Die Projektionsfläche soll ein
112
Michael Kruse
Kreis um den Betrachter sein, somit hat er eine Rundumsicht. Die Bildkoordinate ist eine
Bogenlänge auf dem Projektionskreis, also ein Winkel.
Dimensionen Koordinaten
Objektraum
2D
(x, y)
Sichtraum
2D
(u, v)
Bildraum
1D
(α)
Tabelle 1: Kenndaten perspektivischer 2D-zu-1D-Projektion
3.2 Ereignisse
Der Übergang von einer Region des VSP zu einer anderen wird (nach [5]) Ereignis genannt.
Wenn der Betrachter die Position wechselt, ist das Ereignis, dass sich der Aspekt (bzw. die
Topologie) ändert. Der Bereich des VSP, in der sich der Aspekt ändert, wird auch kritische
Region genannt.
Im zweidimensionalen Raum bedeutet ein Ereignis, dass zwei Ecken im transparenten
LISG ihre Position tauschen, zu sehen in Abb. 6. Es wird daher VV-Ereignis (VV für eng.
Vertex-Vertex) genannt. Im mittleren LISG sind beide Ecken an der gleichen Position, im
verdeckenden LISG wäre nur eine Ecke (im Beispiel „B“) zu sehen, die die andere verdeckt.
Danach wird die Ecke A durch eine Kante verdeckt, in der Abbildung angedeutet durch
ausgrauen.
A
B

AB

B
A
Abb. 6: Überquerung einer kritischen Region
Werden eine oder beide Ecken durch eine weitere Kanten verdeckt, so gibt es zwar eine
(pseudo-)kritische Region, aber kein Ereignis, da die Topologien äquivalent sind. Das Ereignis selbst wird verdeckt. Kritische Regionen, dessen Sichtbarkeit noch nicht geprüft wurde,
werden auch potenzielle kritische Regionen genannt.
Als weiteres Beispiel ändert der Betrachter in Abb. 7a seine Position wie in Abb. 7b.
Abb. 8 zeigt die zugehörigen Projektionen einer solchen Szene. Die Knoten aus dem Objektraum sind teilweise beschriftet. Daraus resultieren die zugehörigen LISGs in Abb. 9, die
eindimensional angeordnet sind. Von der einen zur anderen Position erscheinen gleich zwei
neue Ecken, die vorher verdeckt waren, d.h. es wurden gleich mehrere kritische Regionen
überquert.
Aspektgraphen und Verdeckung
113
B
A
C
A
(a)
(b)
Abb. 7: 2D-Objektraum
A
A BC
Abb. 8: Rendering durch Wolfenstein 3D[2]
A
A B C
Abb. 9: LISGs
Der VSP der gesamten Szene lässt sich berechnen. Zu der Arbeit [3] gehört ein Programm, welches den VSP für den zweidimensionalen perspektivischen Fall berechnen kann.
Abbildung 10 zeigt den berechneten VSP des vorigen Beispiels. Die gelben Strecken sind
die Kanten des Objektraumes und die schwarze Linien stellen die potentiellen kritischen
Regionen dar. In Regionen mit gleicher Färbung sind die gleiche Anzahl Kanten sichtbar.
Je heller die Farbe, desto mehr sichtbare Kanten.
Abb. 10: 2D-VSP erstellt mit dem Programm aspect.jar [3]
114
Michael Kruse
3.3 Orthographische Projektion
Bei der orthographischen Projektion (oder auch Parallelprojektion) befindet sich der Betrachter anschaulich unendlich weit von der Szene entfernt, so dass alle Sichtlinien parallel
verlaufen. Zur Angabe der Betrachterposition reicht daher der Winkel dieser Sichtlinien.
Dieser kann entweder als Bogenlänge (θ) oder als normierter Vektor (a, b) = (cos θ, sin θ)
angegeben werden. Durch die Normierung bleibt der dadurch definierte Raum eindimensional. Das hat den Vorteil, dass für weitere Berechnungen keine trigonometrischen Funktionen
beachtet werden müssen. Die Projektionsfläche ist ein Kreis mit unendlichem Radius, der
die gesamte Szene umschließt.
Dimensionen
Koordinaten
Objektraum
2D
(x, y)
Sichtraum
1D
(θ) oder (u, v) mit |(u, v)| = 1
Bildraum
1D
(s)
Tabelle 2: Kenndaten orthographischer 2D-zu-1D-Projektion
Abb. 11a zeigt die kritischen Regionen eines Objektes. Gestrichelte Linien deuten verdeckte Ereignisse an. Abb. 11b zeigt den VSP auf dem unendlich weit entfernten Projektionskreis. Eine vereinfachte Version ist Abb. 12.
(a)
(b)
Abb. 11: Objekt unter orthographischer Projektion
Abbildung 12a zeigt ein einfaches Beispielobjekt mit nur zwei Kanten. Die Linien zeigen
die kritischen Regionen. In Abb. 12b ist der VSP mit seinen Regionen eingezeichnet.
Aspektgraphen und Verdeckung
A
C
(a)
115
A
B
C
B
(b)
Abb. 12: Einfaches Objekt unter orthogonaler Projektion
3.4 Der naive Algorithmus
Der VSP und der Aspektgraph einer Szene soll nun berechnet werden. Dafür soll zuerst ein
einfacher Ansatz verwendet werden.
Algorithmus 14 Naiver Algorithmus zur Berechnung des Aspektgraphen unter orthogonaler 2D-Projektion
for jede Kombination (e1 , e2 ) zweier Ecken do
Bestimme die Linie durch beide Punkte
Bestimme die beiden Schnittpunkte der Linie auf dem Projektionskreis
Sortiere alle Schnittpunkte nach ihrer Koordinate
for jede Region r zwischen zwei aufeinander folgenden Schnittpunkten do
Erstelle den LISG für einen Punkt innerhalb der Region r
Füge einen neuen Knoten v mit diesem LISG dem Aspektgraphen hinzu
for alle Knoten v und v 0 , dessen Regionen nebeneinander liegen do
if die LISGs von v und v 0 sind äquivalent then
Vereinige beide Knoten
else
Verbinde v und v 0 durch eine Ecke
return den Aspektgraphen
Theorem 1 (Laufzeit des naiven 2D-Algorithmus). Die Laufzeit des Algorithmus 14
beträgt O(n4 )
Beweis. Es gibt m = n(n−1)
Kombinationen zweier Ecken und die doppelte Anzahl von
2
Schnittpunkten mit der Projektionsfläche sowie Regionen zwischen diesen, also O(n2 ).
Ein Vergleichssortierer sortiert diese in O(m log m) = O(n2 log n2 ). Die Laufzeit für das
Erstellen des LISG mit Bestimmung der Verdeckung eines Elementes mit allen anderen beträgt O(n2 ) ( hidden line removal-Algorithmus), für alle Regionen zusammen also
O(mn2 ) = O(n4 ).
116
Michael Kruse
Jede Region hat genau 2 Nachbarregionen und das Vergleichen benötigt nur lineare Laufzeit, sofern alle Ecken eindeutige Bezeichner haben. Das Vergleichen aller Nachbarregionen
benötigt also O(mn) = O(n3 ). Der höchste Aufwand beträgt damit O(n4 ).
t
u
3.5 Der Algorithmus von Plantinga und Dyer
Hier soll ein Algorithmus mit besserer Laufzeit als der in Abschnitt 3.4 gezeigt werden,
wie er in [1] für 3D vorgestellt wurde. Der „Trick“ dabei ist, den Aspektgraphen vor dem
VSP zu berechnen. Dafür wird ein neuer Raum eingeführt, der so genannte Aspektraum.
Bei der orthogonalen 2D-Projektion kann so eine Laufzeit von O(n3 ) (statt O(n4 )) für die
Berechnung des VSP erreicht werden.
Definition 6 (Der Aspektraum (ASP)). Der Aspektraum ist das kartesische Produkt
aus Sichtraum V und Bildraum I. Ein Element belegt einen Punkt des Aspektraumes (v, i) ∈
V × I, wenn es aus der Betrachterposition v ∈ V an der Position i ∈ I des Bildes sichtbar
ist.
Bei der zweidimensionalen orthographischen Projektion haben sowohl Sichtraum als auch
der Bildraum eine Dimension von eins. Folglich hat der Aspektraum zwei Dimensionen. Ein
Punkt im Aspektraumes soll mit (θ) × (s) = (θ, s) beschrieben werden.
Abbildung 13 zeigt die LISGs (vertikal ausgerichtet) des Objektes von Abb. 12 in 45°Schritten. Die vertikale Achse zeigt demnach den Bildraum und die horizontale Achse den
Sichtraum. Die Verläufe der Ecken A (rot), B (blau) und C (Olivfarben) sind linear approximiert. Hervorzuheben ist, dass B zwischen 135° und 180° sowie A zwischen 270° und 315°
verdeckt wird.
A
B
C
0°
45°
90°
135°
180°
235° 270° 315° 360°
θ
Abb. 13: Die LISGs von Abb. 12
Wie man nicht schwer erkennen kann handelt es sich bei A um eine cos-Kurve und
bei B um eine (− sin)-Kurve. Kennzeichnet man nicht die Ecken, sondern die Kanten im
Aspektraum, so ergeben sich Flächen wie in Abb. 14. Die Kante CA ist rot und die Kante
CB blau markiert.
Aspektgraphen und Verdeckung
117
Abb. 14: Der Aspektraum zu Abb. 12
Aus dieser Beobachtung lässt sich ein Algorithmus bauen. Für dreidimensionales Rendering werden in Abschnitt 4.7 ein paar mehr Details erläutert.
Algorithmus 15 Berechnung des Aspektraumes für orthogonale 2D-Projektion
for jede Kante e im Objektraum do
A ← Fläche von e im Aspektraum
for jede bereits vorhandene Fläche B im Aspektraum do
if A verdeckt B then
B ←B\A
if A wird von B verdeckt then
A ← A \ B (und aktualisiere A im Aspektraum)
Füge B zum Aspektraum hinzu
Es soll nun die Größe des Aspektraumes bestimmt werden. Bei den Position der Ecken im
Aspektraum handelt es sich immer um Sinuskurven mit unterschiedlichen Phasen (Winkel
zum Ursprung) und Amplituden (Entfernung zum Ursprung). Zwei solcher Kurven haben
maximal 2 Schnittpunkte. Angenommen, das Objekt habe O(n) Ecken (und Kanten), dann
haben diese bis zu O(n2 ) Schnittpunkte im Aspektgraphen. Da dieser außerdem planar ist,
gibt es auch nur höchstens O(n2 ) Kanten und Regionen, was damit die Obergrenze der
Komplexität des Aspektgraphen darstellt.
Das Kombinieren zweier Aspekträume benötigt O(nm), wobei m und n die Größe er
beiden Aspekträume sind. Das sukzessive Hinzufügen von Aspekträumen der Größe O(n)
zum gemeinsamen Aspektraum der Größe O(n2 ) benötigt eine amortisierte Laufzeit von
O(n3 ). Um auch den VSP zu bestimmen reicht es aus, die Bildkoordinate i wegzulassen
(Abb. 15). Der verbliebene Raum ist eindimensional und die Ecken müssen höchstens noch
118
Michael Kruse
nach ihrer Sichtraumkoordinate sortiert werden, was O(n2 log n2 ) benötigt. Jedes maximale
Intervall zwischen diesen Ecken ergeben genau einen Knoten im Aspektgraphen.
Abb. 15: Vom Aspektraum zum VSP unter Weglassung der Bildkoordinate
4 3D-Rendering
Das 2D-Rendering-Kapitel wurde zur Veranschaulichung eingeschoben. In diesem Kapitel
soll es um das „normale“ Projizieren von 3D-Szenen auf eine 2D-Projektionsfläche gehen.
Dabei gibt es ein paar Unterschiede, wie die Natur von Ereignissen.
4.1 Ereignisse
Im dreidimensionalen gibt es 2 Ereignistypen. Zum einen gibt es die Möglichkeit, dass ein
Element hinter einer Seitenfläche verschwindet oder auftaucht, der Beginn oder das Ende
eines verdeckenden Polygons wird durch eine Kante beschränkt. Nur Ecken kommen für das
andere Element in Frage da sie den Beginn oder das Ende der anderen Elemente markieren.
Deshalb wird dieses EV-Ereignis („EV“ für eng. edge-vertex) genannt.
Zu Beachten ist, dass es keine Rolle spielt, auf welcher Seite der Kante oder Ecke sich die
Seitenfläche befindet, in jedem Fall wird ein Ereignis erzeugt. Abbildung 16 illustriert davon
ein paar Möglichkeiten. Die erzeugte potenzielle kritische Region ist eine Ebene durch die
Kante und die Ecke, in den Abbildungen blau-transparent angedeutet.
Aspektgraphen und Verdeckung
119
Abb. 16: Ausprägungen von EV-Ereignissen
Der zweite Typ sind die EEE-Ereignisse („EEE“ für eng. edge-edge-edge). Dabei führt
die Sichtlinie an drei unterschiedlichen Kanten vorbei, die sich vom Betrachter aus gesehen
in einem Punkt schneiden (Abb. 18a und 17b). Der LISG ändert sich an dieser Stelle, weil
sich ein oder mehrere T-Junctions auf andere Kanten verschieben (Abb. 17 (a) und (c)).
Es spielt auch hier prinzipiell keine Rolle, auf welche Seite der Kanten die Seitenfläche zu
sehen ist.
→
(a)
→
(b)
(c)
Abb. 17: Ein EEE-Ereignis aus der Betrachterperspektive
Es soll nun die kritische Region bestimmt werden, welche durch ein EEE-Ereignis erzeugt
wird. Seien 3 Kanten gegeben. Kante 1 verbindet die Punkte p11 und p12 , Kante 2 die Punkte
p21 und p22 , Kante 3 die Punkte p31 , p32 . Die Sichtlinie schneidet jede dieser Kanten. Sei
nun p ein Punkt auf der ersten Kante, die die Sichtlinie kreuzt (Gleichung 1, Abb. 18b zeigt
drei solcher Sichtlinien).
p =p11 + s(p12 − p11 )
(a)
(b)
(1)
(c)
Abb. 18: EEE-Ereignis
Seien dann n2 und n3 die Normalen zweier Ebenen, die jeweils den Punkt p und die
Kante p21 p22 bzw. p31 p32 enthalten (Gleichung 2).
n2 =(p21 − p) × (p21 − p22 )
n3 =(p31 − p) × (p31 − p32 )
(2)
Die Schnittlinie dieser beiden Ebenen entspricht der gesuchten Sichtlinie, die den Punkt
p enthält sowie die beiden anderen Kanten kreuzt. Der Richtungsvektor ergibt sich durch
120
Michael Kruse
das Kreuzprodukt beider Normalen (Gleichung 3). Als Ortsvektor eignet sich der Punkt p.
Die sich ergebende Geradengleichung 4 ist linear abhängig von t und quadratisch von s.
Interpretiert man diese als Parameter eine bivarianten Funktion, so erhält man die Formel
für die Fläche der (potentiellen) kritischen Region.
d =n2 × n3
(3)
q =p + td
=p11 + s(p12 − p11 )
+ t(((p21 − (p11 + s(p12 − p11 ))) × (p21 − p22 ))
(4)
× ((p31 − (p11 + s(p12 − p11 ))) × (p31 − p32 )))
=f (t, s)
Damit sind die Regionen des VSP nicht unbedingt Polyeder, die durch gerade Flächen
begrenzt werden. Abbildung 18c zeigt die kritische Region für das gegebene Beispiel grautransparent.
Wie zwei quadratische univariante Funktionen nur höchstens 2 Schnittpunkte haben, so
haben zwei bivariante Funktionen nur höchsten 2 (quadratische) Schnittkurven. Dadurch,
dass es zwei Schnittkurven und -punkte geben kann, ändert sich jedoch nicht die Methodik
der Berechnung des VSP oder Aspektgraphen. Die asymptotische Laufzeit für die Berechnung bleibt gleich. Zur Vereinfachung werden daher in den folgenden Abschnitten Begriffe
verwendet, die eigentlich nur auf Polytope zutreffen.
Man kann ein EV-Ereignis auch als Spezialfall des EEE-Ereignisses ansehen: Wenn sich
zwei der Kanten eines EEE-Ereignisses in einem Punkt schneiden, so entsteht dort eine
Ecke. Zusammen mit der dritten Kante bildet diese das EV-Ereignis. Deshalb genügt die
Betrachtung das EEE-Ereignisses.
4.2 Orthographische Projektion
Für die orthographische 3D-zu-2D-Projektion (3D-Parallelprojektion) werden für den Sichtraum zwei Winkel für die Sichtlinien benötigt, z.B. θ für die XZ-Achse und ϕ für die XYAchse. Alternativ kann ein normierter Richtungsvektor der Sichtrichtung angegeben werden.
Der Bildraum bleibt jedoch durch zwei kartesische Koordinaten bestimmt.
Anschaulich ist der Sichtraum eine Sphäre mit unendlichem Durchmesser um die Szene
im Objektraum. Die Projektionsfläche und damit der Bildraum ist eine Ebene, die die Sphäre
am gewählten Sichtpunkt tangiert.
Dimensionen
Koordinaten
Objektraum
3D
(x, y, z)
Sichtraum
2D
(θ, ϕ) oder (u, v, w) mit |(u, v, w)| = 1
Bildraum
2D
(s, t)
Abb. 19: Kenndaten orthographischer 3D-zu-2D-Projektion
Abbildung 20 zeigt einen gerenderten Tetraeder, seinen VSP auf der Projektionsphäre
und den zugehörigen Aspektgraph. Regionen des VSP und Knoten des Aspektgraphen sind
grün markiert, wenn 3 Seitenflächen zu sehen sind, blau bei 2 Seitenflächen und grün bei
nur einer sichtbaren Seitenfläche.
Aspektgraphen und Verdeckung
Objektraum
VSP
121
Aspektgraph
Abb. 20: Ein Tetraeder unter orthographischer Projektion
4.3 Perspektivische Projektion
Analog kann man die perspektivische 3D-zu-3D-Projektion (3D-Zentralprojektion) betrachten. Der Sichtraum ist eine Position des Betrachters innerhalb des Objektraumes und somit
dreidimensional. Die Projektionsfläche soll eine Sphäre um den Betrachter sein, daher kann
ein Punkt im Bildraum mit zwei Winkeln angegeben werden.
Dimensionen Koordinaten
Objektraum
3D
(x, y, z)
Sichtraum
3D
(u, v, w)
Bildraum
2D
(α, β)
Abb. 21: Kenndaten perspektivischer 3D-zu-2D-Projektion
4.4 Maximale Größe eines Aspektgraphen
Sei eine Szene oder ein Objekt mit v Ecken, e Kanten und a Flächen gegeben und sei
n = max {v, e, a}. Allgemeiner beschrieben handelt es sich einfach um ein Objekt der Größe
O(n). Weiterhin soll angenommen werden, dass bei Schnitten immer der „Normalfall“ zutrifft. Sonderfälle wie parallele Geraden und Flächen sowie dass zwei Geraden oder Flächen
identisch fallen werden ausgeblendet. Zwei Geraden haben immer einen Schnittpunkt und
zwei Flächen immer eine Schnittgerade um Sonderfälle nicht einzeln behandeln zu müssen.
Sie gelten als well-behaved [4].
Theorem 2 (Maximale Größe bei orthographischer Projektion). Der Aspektgraph
hat bei orthographischer 3D-Projektion maximal O(n6 ) Ecken und Kanten, wobei n die Anzahl der Ecken, Kanten und Flächen der abgebildeten Objekts ist.
Beweis. Die Größe des VSP hängt primär von der Anzahl der Ereignisse ab. Für den allgemeineren Fall der EEE-Ereignisse müssen 3 Ecken kombiniert werden. Es gibt O(n3 )
solcher Kombinationen, die zusammen ein EEE-Ereignis erzeugen können. Dies sind die
potentiellen kritischen Regionen in Form von quadratischen Flächen.
Abgebildet auf den Sichtraum – die unendlich große Sphäre um das Objekt – werden diese
auf quadratische Kurven abgebildet (die Schnittmenge mit dieser Sphäre). Zwei quadratische
Kurven haben maximal 2 Schnittpunkte und somit gibt es insgesamt O(2n3 n3 ) = O(n6 )
122
Michael Kruse
Schnittpunkte aller Kombinationen zweier Kurven. Da der dadurch entstandene Graph von
Schnittpunkten und verbindende Kurven planar ist, gibt es auch höchstens O(n6 ) Kanten
und Regionen. Damit hat auch der Aspektgraph eine Größe von O(n6 ), denn dieser ist zum
VSP dual.
t
u
Theorem 3 (Maximale Größe bei perspektivischer Projektion). Der Aspektgraph
hat bei perspektivischer 3D-Projektion maximal O(n9 ) Ecken und Kanten, wobei n die Anzahl
der Ecken, Kanten und Flächen des abgebildeten Objektes ist.
Beweis. Auch hier gibt es O(n3 ) Kombinationen dreier Kanten und somit O(n3 ) EEEEreignisse. Im dreidimensionalen Raum werden drei Ebenen benötigt, um einen Schnittpunkt zu erzeugen. Zwei quadratische Flächen haben bis zu zwei Schnittkurven. Mit einer
weiteren quadratischen Fläche haben diese Kurven je bis zu 2 Schnittpunkte. Somit gibt es
O(4(n3 )3 ) = O(n9 ) Schnittpunkte mit allen Kombinationen dreier EEE-Ereignisse.
Man betrachte nun eine einzelne kritische Region eines EEE-Ereignisses. Alle anderen
O(n3 ) kritischen Regionen bilden O(n3 ) Schnittkurven auf der einzelnen kritischen Region.
Wie bei der orthographischen Projektion bilden diese einen planaren Graph mit O(n6 ) Ecken
(die Schnittpunkte der Kurven), Kanten und Flächen. Alle O(n3 ) haben dann zusammen
O(n3 ) · O(n6 ) = O(n9 ) Ecken, Kanten und Flächen.
Jede Fläche hat auf beiden Seiten eine räumliche Region ( Zelle). Mit den O(n9 ) Flächen
gibt es also höchstens O(2n9 ) = O(n9 ) Zellen im VSP. Wegen der Dualität ist auch der
Aspektgraph von der Größenordnung O(n9 ).
t
u
Sollte man für jeden Knoten des Aspektgraphen auch speichern, welche Flächen sichtbar
sind (z.B. den LISG), so erhöht sich der Speicherbedarf für jeden Knoten entsprechend um
O(n) oder O(log n)[4].
4.5 Minimale Größe eines Aspektgraphen
In diesem Abschnitt soll gezeigt werden, dass Szenen mit dieser Komplexität auch wirklich
gibt (und eigentlich auch der Regelfall ist).
Theorem 4 (Worst-Case-Größe bei orthographischer Projektion). Die Worst-CaseKomplexität eines Aspektgraphen bei orthographischer Projektion ist Ω(n6 )
Beweis. Gegeben sei folgendes Objekt: n vertikale Streifen mit gleicher Breite (rot in der
Abbildung 22a) und davor n horizontale Streifen (grün), welche ein Gitter bilden. Die vertikalen Streifen sind dabei leicht gedreht, so dass sie nicht ganz orthogonal zu den horizontalen
Streifen sind. Weiter davor befinden sich wiederum n vertikale Streifen (grau) mit kleineren
Sichtschlitzen. Diese sollen gerade so groß sein, dass eine vollständige Kante der leicht gekippten vertikalen Streifen zu sehen ist, aber es kann niemals das Gitter durch zwei Schlitze
gleichzeitig beobachtet werden. Die Ausdehnung der Streifen nach hinten sei vernachlässigbar.
Die Kanten der vertikalen Streifen, der horizontalen Streifen und der Sichtschlitze können
sich von bestimmten Positionen des Betrachters aus scheinbar in einem Punkt schneiden,
was zuvor EEE-Ereignis genannt wurde. Bewegt sich nun der Betrachter in horizontaler
Richtung, so bekommt er folgende EEE-Ereignisse mit: Das Gitter hat (n − 1)2 Löcher
mit jeweils 4 Ecken. Mit jedem Sichtschlitz schneidet sich jede dieser Ecken an den den
Seitenkanten des Schlitzes zwei mal. Einmal beim Auftauchen vor einem Streifen und ein
Aspektgraphen und Verdeckung
123
weiteres mal beim verdeckt werden durch den nächsten Streifen. Da es n − 1 Sichtschlitze
gibt, ändert sich der LISG 2(n − 1)3 = Θ(n3 ) mal, da jedesmal T-Junctions erscheinen oder
verschwinden.
Stellt man bei orthogonaler Projektion zwei solcher Streifenmuster nebeneinander, eines
davon um 90° gedreht (Abb. 22a), so schneiden sich alle vertikalen kritischen Regionen des
einen mit den horizontalen kritischen Regionen des anderen. Beide haben Θ(n3 ) kritische
Regionen, so dass es insgesamt Θ(n6 ) Schnittpunkte und Regionen auf der Projektionssphäre
gibt und somit Θ(n6 ) Knoten im zugehörigen Aspektgraphen.
u
t
(a)
(b)
Abb. 22: Beispiele mit maximaler asymptotischer Größe des Aspektgraphen
Theorem 5 (Worst-Case-Größe bei perspektivischer Projektion). Die Worst-CaseKomplexität eines Aspektgraphen bei perspektivischer Projektion ist Ω(n9 )
Beweis. Für die perspektivische Projektion benötigt man 3 solcher Streifenmuster, angeordnet wie in Abbildung 22b. Der Betrachter befindet sich zwischen allen Sichtschlitzen. Er kann
sich vertikal, horizontal und nach vorn und hinten bewegen und jedesmal überquert er bis zu
Θ(n3 ) kritische Regionen. Alle kritischen Regionen aller drei Streifenmuster treffen sich in
Θ((n3 )3 ) Punkten. Dies entspricht einer Anzahl von Θ(n9 ) Knoten im Aspektgraphen. u
t
4.6 Der naive Algorithmus
Wie für die 2D-Projektion soll hier exemplarisch nur der orthographische Fall behandelt
werden. Der perspektivische Fall folgt jedoch dem gleichen Schema.
124
Michael Kruse
Algorithmus 16 Naiver Algorithmus zur Berechnung des Aspektgraphen unter orthogonaler 3D-Projektion
for jede Kombination (e1 , e2 , e3 ) dreier Kanten do
Berechne kritische Region
Berechne Schnittkurve mit der Projektionssphäre
for jede Kombination (g1 , g2 ) zweier Kurven auf der Projektionsfläche do
Finde Schnittpunkt(e) zwischen g1 und g2
Verbinde Punkt(e) mit den bisher gefundenen Nachbarpunkten
Mit einem Graphensuchalgorithmus finde alle Regionen im Graphen
for jede gefundene Region r do
Erstelle den LISG für einen Punkt innerhalb der Region r
Füge einen neuen Knoten v mit diesem LISG dem Aspektgraphen hinzu
Füge eine Kante mit jedem Knoten einer Nachbarregion hinzu
for jeden Nachbarknoten v 0 do
if die LISGs von v und v 0 sind äquivalent then
Vereinige beide Knoten
break for
Theorem 6 (Laufzeit des naiven 3D-Algorithmus). Die Laufzeit des Algorithmus 16
ist O(n10 ) unter orthographischer Projektion.
Beweis. Die erste for-Schleife wird m = O(n3 )-mal durchlaufen, da es so viele Kombinationen dreier Kanten gibt. Projiziert auf die Projektionssphäre ergeben dies m Kurven. Jede
Kurve kann jede andere bis zu vier mal schneiden, so dass es q = O(4m2 ) = O(n6 ) Schnittpunkte gibt. Ein Graphensuchalgorithmus kann alle Regionen in linearer Laufzeit bezüglich
q finden. Das Erstellen des LISG mit Verdeckung für an einer Betrachterposition innerhalb
einer Region ist mit einem hidden-line-removal-Algorithmus in O(n2 ) möglich. Eine Region
kann durch alle O(m) Kurven begrenzt werden und sie von einer anderen Region trennen,
so das es O(m) Nachbarregionen gibt. Ein LISG hat O(n) Elemente, diese miteinander auf
Äquivalenz zu vergleichen kostet O(n) für jede Nachbarregion. Die letzte äußere Schleife hat
also eine Laufzeit von q(O(n2 ) + mO(n)) = O(n6 (n2 + n3 n)) = O(n10 ).
Verfolgt man das gleiche Schema für den perspektivischen Fall, so erhält man eine Laufzeit von O(n13 ). Damit ist die Laufzeit in beiden Fällen um das O(n4 )-fache größer als
die Ausgabegröße. Dass das auch besser geht zeigt, wie beim 2D-Fall auch, der folgende
Algorithmus im nächsten Abschnitt.
4.7 Der Algorithmus von Plantinga und Dyer
Wie bei Anwendung auf das 2D-Rendering ist der Trick dabei, den Aspektgraphen vor dem
VSP zu berechnen. Dabei werden die Objekte wieder in den Aspektraum übertragen. Dieser
ist (θ, ϕ, s, t) für orthogonale und (u, v, w, α, β) für die perspektivische Projektion und somit
4-dimensional (bzw. 5-dimensional).
Die orthogonale Projektion besteht im Wesentlichen aus einer Rotation des Objektraumes und dann dem Weglassen der dritten Koordinate. Verdeckungen werden noch nicht
berücksichtigt. Stellt man die Sichtrichtung nicht mit zwei Winkeln dar, sondern mit einem
Richtungsvektor, ergibt sich die Abbildungsmatrix 5. w ist dabei der normierte Richtungsvektor, v ein normierter zu w orthogonaler Vektor und u = w × v. v wird in der Computergraphik auch up-Vektor genannt. Er bestimmt die Rotation des Bildes und ist zur
Berechnung des LISG nicht von Bedeutung.
Aspektgraphen und Verdeckung
 
ux uy uz
x
s
100 
vx vy vz  y 
=
t
010
wx wy wz
z
125

(5)
Eine Ecke im Objektraum ergibt übertragen in den Aspektraum einen Grat (2D in
orthographischer, 3D bei perspektivischer Projektion), da er ohne Überdeckung von überall sichtbar ist und im Bildraum als ein Punkt (0D) erscheint. Analog ist eine Kante im
Objektraum eine Facette (3D in orthographischer, 4D in perspektivischer Projektion) im
Aspektraum. Eine Seitenfläche des Objektraumes (die andere Elemente verdecken kann)
ist eine volldimensionale Zelle im Aspektraum. Zu den Begriffen Peak, Grat, Facette und
Zelle siehe auch Tabelle 3. Auch wenn die Elemente keine Polytope sein müssen, sollen diese
Begriffe hier verwendet werden.
Dimension 3D-Raum
4D-Raum
5D-Raum
0D
Ecke, Punkt
Punkt
Punkt
1D
Kante, Linie
Linie, Peak
Linie
2D
Polygon, Seitenfläche Grat, Polygon
Polygon, Peak
3D
Polyeder
Facette, Polyeder
Grat, Polyeder
4D
Zelle, Polychor, 4-Polytop Facette, Polychor
5D
Zelle, 5-Polytop
Tabelle 3: Benennung von Elementen in höherdimensionalen Räumen
Der Aspektraum lässt sich berechnen, indem man alle Seitenflächen des Objektraumes
konsekutiv dem Aspektraum hinzufügt (Algorithmus 17). Eine Seitenfläche unterteilt den
Raum in zwei Halbräume. Elemente im Halbraum hinter der Seitenfläche können verdeckt
werden, während Elemente im vorderen Halbraum die Fläche verdecken können (Die Rückseite der Seitenfläche soll durchsichtig sein). Daher müssen die sich im Aspektraum überlappenden Elemente voneinander subtrahiert werden. Die Seitenfläche wird von den von
den Elementen im hinteren Halbraum und die Elemente des vorderen Halbraums von der
Seitenfläche subtrahiert.
Algorithmus 17 Berechnung des Aspektraumes für 3D-Projektion
1: A ← leerer Aspektraum
2: for jedes Polygon a im Objektraum do
3:
B ← Ausdehnung von a als Polytop des Aspektraumes
4:
Avorne ← A ∩ Halbraum auf der Vorderseite von a
5:
Ahinter ← A ∩ Halbraum auf der Rückseite von a
6:
Ahinter ← Ahinter \ B
7:
B ← B \ Avorne
8:
A ← Avorne ∪ Ahinter ∪ B
9: return A
Die Mengenoperationen sind nicht ganz trivial. Alle Elemente im Aspektraum können
durch Facetten beschrieben werden. Alle Zellen werden durch Facetten begrenzt. Facetten sind ihrerseits Repräsentationen von Kanten des Bildraumes. Zwei Facetten schneiden
sich in einem Grat und repräsentieren somit einen Punkt. Drei Facetten schneiden sich in
einem Peak und entsprechen einem EEE-Ereignis. Vier Facetten schneiden sich in einem
126
Michael Kruse
Punkt (bzw. Linie) und entsprechen einem Element, welches einen Punkt auf der Bildebene
darstellt, der nur bei einem ganz bestimmten Ansichtswinkel zu sehen ist.
Im 5D-Raum könnten sich auch fünf Facetten in einem Punkt schneiden. Dies entspräche
einem Punkt auf der Bildfläche, welcher nur an einer ganz bestimmten Betrachterposition
zu sehen wäre. Wenn es diesen Punkt allerdings gibt, so kann sich der Betrachter auf der
Sichtlinie zum Punkt beliebig vor und zurück bewegen, ohne den Punkt aus den Augen zu
verlieren, ein Widerspruch. Ein solches Ereignis kann es daher nicht geben.
Der Aspektraum hat also O(n) Facetten, O(n2 ) Grate, O(n3 ) Peaks und höchstens O(n4 )
Punkte (bzw. Linien) entsprechend der Anzahl von Kombinationen von Facetten. Wie die
zugehörigen EEE-Ereignisse sind die Peaks von den Aspektraumkoordinaten quadratisch
abhängig. Entsprechend sind die Punkte (bzw. Linien) Funktionen dritten Grades. Nun
kann auch die Laufzeit des Algorithmus bestimmt werden.
Theorem 7 (Laufzeit des Algorithmus von Plantinga und Dyer). Die Laufzeit des
Algorithmus 16 ist bei orthographischer und perspektivischer Projektion O(n5 )
Beweis. O(n) Elemente werden konsekutiv dem Aspektraum hinzugefügt. In [6] wird gezeigt,
dass die Laufzeit für das Vereinigen zweier Aspekträume O(nm) beträgt, n und m sind die
jeweiligen Größen der Aspekträume. Das Vereinigen aller Aspekträume zu einem Aspektraum
der Größe O(n4 ) ist in O(n5 ) möglich.
t
u
Aus dem Aspektraum kann auch der VSP bestimmt werden. Wie vorher gezeigt hat der
VSP – wie auch der Aspektgraph – eine Komplexität von Θ(n6 ) (bzw. Θ(n9 )), der Aspektraum jedoch nur O(n4 ). Das resultiert daraus, dass der Aspektraum auf den Sichtraum
abgebildet wird indem die Bildkoordinaten entfernt werden. Durch diese Operation kann es
deutlich mehr Schnitte zwischen den Elementen geben.
Die O(n3 ) Peaks (Linien) im orthogonalen Aspektraum sind Linien im Sichtraum, die
sich in O((n3 )2 ) = O(n6 ) Punkten schneiden können. Die O(n4 ) Linien im perspektivischen
Aspektraum könnten sich in O((n4 )2 ) = O(n8 ) Schnittpunkten treffen, aber die O(n3 ) Peaks
(Flächen) in O((n3 )3 ) = O(n9 ) Punkten.
Die die O(n6 ) (bzw. O(n9 )) Schnittpunkte im Sichtraum der O(n3 ) Peaks lassen sich
nach [1] mittels binärer Suche in nur O(log n) zum VSP hinzufügen. Das ergibt eine Gesamtlaufzeit von O(n6 log n) für die orthographische und O(n9 log n) für die perspektivische
Projektion. Um den VSP in den dualen Aspektgraphen zu konvertieren ist nur noch lineare
Laufzeit nötig, der jeweilige Aspekt (z.B. der LISG) wurde damit aber noch nicht bestimmt.
Dies kann wie beim naiven Algorithmus auch in O(n2 ) pro Knoten des Aspektgraphen geschehen.
5 Fazit
Ein Aspektgraph bietet eine Möglichkeit, Sichtbarkeiten einer Szene in einer Datenstruktur zu speichern. Die Laufzeit und der Speicherplatzbedarf der hier vorgestellten Methode
zur genauen Bestimmung der Sichtbarkeit jedes einzelnen Elementes ist zwar polynomiell
bezüglich der Anzahl der Elemente in der Szene, für praktische Einsätze in der Computergraphik aber viel zu hoch (vgl. Tabelle 4). Selbst durch den hier vorgestellten Algorithmus
von Plantinga und Dyer verbessert sich das nicht wesentlich. Für bestimmte Anwendungen
jedoch, wie z.B. Echtzeitgrafik, ist lineare Laufzeit ein Muss. In diesem Anwendungsgebiet
Aspektgraphen und Verdeckung
127
ergäbe es jedoch auch keinen Sinn, die Sichtbarkeit auf jede Ecke genau zu Bestimmen.
Daher kann man überlegen, wie der Aspektgraph approximiert werden kann.
Tabelle 4 fasst die Strukturgrößen und Berechnungslaufzeiten zusammen. Mit dem Zusatz konvex markierte Zeilen treffen auf den Spezialfall mit einem konvexen Polyeder im
Objektraum zu. Die Daten sind teilweise aus [1] entnommen.
Rendermodus
Größe des VSP Naiver Ansatz Erreichbar
2D orthographisch
O(n2 )
O(n4 )
O(n3 )
4
7
2D perspektivisch
O(n )
O(n )
O(n4 log n)
3D orthographisch konvex
O(n2 )
O(n7 )
O(n2 )
3
9
3D perspektivisch konvex
O(n )
O(n )
O(n3 )
3D orthographisch
O(n6 )
O(n10 )
O(n6 log n)
9
13
3D perspektivisch
O(n )
O(n )
O(n9 log n)
Tabelle 4: Vergleich der Größe und Berechnungslaufzeit eines VSP
Literaturverzeichnis
1. Plantinga WH, Dyer CR (1990) Int J Comput Vision, Volume 5, Number 2: 137–160
2. id Software, Apogee Software Ltd (1992) Wolfenstein 3D.
3. Matthias H (2007) Parametrisierte Generierung und automatische Bewertung virtueller Szenen. Diplomarbeit, University of Paderborn, Paderborn 2007
4. Schiffenbauer RD (2001) A survey of aspect graphs. PhD thesis, Polytechnic University of Brooklyn,
New York
5. Koendrick JJ, van Doorn AJ (1976) Biological Cybernetics 24: 51–59
6. Plantinga WH, Dyer CR (1990) The aspect representation. In: Technical Report 684. University of
Wisconsin-Madison, Wisconsin-Madison
Teil II
Seminar
Cell to Cell Visibility in PVS Systemen
André Gärtner
Universität Paderborn
Zusammenfassung. Um das Sichtbarkeitsproblem in Architekturen zu lösen, werden Räume in Zellen
aufgeteilt und über Portale miteinander verbunden. Diese Arbeit erklärt, wie man durch Berechnung von
Stabbing Lines, die durch die Portale gelegt werden, die Sichtbarkeit sowie Schatten, der durch lichtblockierende Objekte (z.B. Wände) entsteht, innerhalb der Zellen bestimmt werden kann. Dazu wird eine Methode
gezeigt, wie sich das Problem auf den Schnitt von Kanten eines fünfdimensionalen Polytops mit vierdimensionalen Hyperebenen übertragen läßt. Die Übertragung erfolgt mit Hilfe von Plücker-Koordinaten.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
2
Plücker-Koordinaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
3
Berechnung der Stabbing Lines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
4
Stabbing von 3D Portal-Sequenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
4.1
4.2
4.3
4.4
4.5
4.6
4.7
Penumbra und Antipenumbra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Oberflächen und Schneisen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Grenz- und innenseitige Schneisen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Zweidimensionales Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
EEE Schneisen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
VE Schneisen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Containment Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
5
Berechnung des Antipenumbra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
5.1 Algorithmus am Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
6
Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
1 Einleitung
In der Computergraphik ist ein häufiges Problem, die Sichtbarkeit verschiedener Objekte zu
bestimmen. Dies ist z.B. der Fall, wenn man innerhalb einer Szene entscheiden muss, was
von einem bestimmten Standpunkt aus sichtbar ist. Die Berechnung, ob ein Objekt von dort
aus sichtbar ist, ist zeitaufwendig und daher insbesondere für komplexe Architekturen oder
Videospiele, in denen viele Objekte durch Wände verdeckt sind, nur eingeschränkt oder gar
132
André Gärtner
nicht in Echtzeit möglich. Man versucht daher präventiv die Menge der potentiell sichtbaren
Objekte (engl. Potentially Visible Set, PVS ) zu bestimmen und alle nicht sichtbaren Objekte
auszusortieren, so dass zur Laufzeit nur noch eine kleine Teilmenge aller Objekte gerendert
werden muss.
Gelöst wurde dieses Problem von Teller und Séquin [5, 6] für den zweidimensionalen
Raum. Räume eines Gebäudes werden dabei in Zellen aufgeteilt, die über durchsichtige
Portale miteinander verbunden sind. Zwischen einzelnen Zellen besteht genau dann eine
Sichtbarkeit, wenn durch eine Sequenz von Portalen eine Gerade (engl. Sightline oder Stabbing line) hindurch gelegt werden kann. Auf diese Weise können nun für jede Zelle die
von dort aus sichtbaren Zellen bestimmt werden, so dass die Anzahl der zur Laufzeit zu
betrachtende Objekte auf die in diesen Zellen befindlichen Objekte verringert werden kann.
Dieses Vorgehen lässt sich auch im dreidimensionalen Raum, durch Suchen einer Stabbing Line, die durch eine Sequenz aus Portalen in der Form konvexer orientierter Polygone
verläuft (Abb. 1), anwenden. Übertragen läßt sich das Problem auf den Schnitt der Kanten
eines fünfdimensionalen Polytops mit einer vierdimensionalen Hyperebene1 . Die Übertragung erfolgt mit Hilfe von Plücker-Koordinaten [3, 6], die die Darstellung einer Geraden des
R3 als Punkt oder Hyperebene des fünfdimensionalen projektiven Raumes ermöglichen.
Ein weiterer Anwendungsbereich, der die Suche nach Stabbing Lines ausnutzt, ist die Berechnung von Licht und Schatten, wie sie in einer weiteren Arbeit von Teller [2, 6] beschrieben wird. Versteht man die Stabbing Lines nicht als Sichtlinien sondern als Lichtstrahlen, so
kann auf diese Weise berechnet werden, wie viel Licht auf ein Objekt fällt. Je nachdem, ob
Lichtstrahlen ganz, teilweise oder gar nicht durch andere Objekte verdeckt werden, befindet
sich das Objekt entweder in einem Schatten oder Halbschatten oder aber ist voll erleuchtet.
Abb. 1. Stabbing Line durch vier unterschiedliche Polygone
2 Plücker-Koordinaten
Zur Darstellung von Punkten im projektiven Raum werden homogene Koordinaten verwendet. Punkte des euklidischen Raums Rn werden dazu im projektiven Raum P n durch
ein (n + 1)-Tupel beschrieben, indem den n ursprünglichen Koordinaten eine zusätzliche
Koordinate w hinzugefügt wird, wobei w eine reele Zahl mit w 6= 0 ist. In der Computer1
Eine Hyperebene ist das Äquivalent zu einer Ebene in höher-dimensionale Räumen. Sie teilt diesen Raum
in zwei Hälften.
Cell to Cell Visibility in PVS Systemen
133
graphik wird zumeist w = 1 gewählt, so dass der Punkt (x, y, z) des R3 auf (x, y, z, 1) im
P 3 abgebildet wird.
Ein geordnetes Paar voneinander verschiedener Punkte p = (px , py , pz ) und q =
(qx , qy , qz ) definiert eine gerichtete Gerade l im R3 . Im projektiven Raum P 3 kann dies
als 2 x 4 Matrix dargestellt werden:
px p y p z 1
qx qy qz 1
Durch Plücker-Koordinaten [7] ist es möglich diese Darstellung auf ein 6-Tupel Πl =
(πl0 , πl1 , πl2 , πl3 , πl4 , πl5 ) abzubilden, das diese Gerade ebenfalls eindeutig beschreibt. Dazu
werden die Determinanten der sechs 2 x 2 Untermatrizen berechnet und wie folgt den πi
zugeordnet:
πl0 = px qy − qx py
πl1 = px qz − qx pz
πl2 = px − qx
πl3 = px qy − qx py
πl4 = pz − qz
πl5 = qy − py
Die Elemente des so entstandene 6-Tupels können als homogene Koordinaten eines Punktes im P 5 (dem Plücker-Raum) aufgefasst werden. Eine Gerade im R3 entspricht somit
einem Punkt im P 5 . Durch Permutation der einzelnen Koordinaten erhält man den Vektor (π4 , π5 , π3 , π0 , π1 , π2 ), mit dem sich eine Hyperebene im R5 beschreiben lässt, die alle
Geraden enthält, die die ursprüngliche Gerade im R3 schneiden. Die Untersuchung der gegenseitigen Lage zweier Geraden im R3 lässt sich nun auf die Überprüfung der Lage eines
homogenen Punktes (als Repräsentant der einen Gerade) zu einer Hyperebene (als Repräsentant der anderen Gerade) im P 5 zurückführen.
Wenn a und b zwei gerichtete Gerade sind, und Πa , Πb die korrespondierenden Plücker
Darstellungen, kann eine Relation side(a, b) als permutiertes inneres Produkt definiert werden:
Πa Πb = πa0 πb4 + πa1 πb5 + πa2 πb3 + πa4 πb0 + πa5 πb1 + πa3 πb2
Mit Hilfe dieser Relation kann bestimmt werden, wie die beiden Geraden zueinander
liegen (Abb. 2). Gilt side(a, b) < 0, so läuft die Gerade b dem Uhrzeigersinn an a vorbei,
wenn man auf die Spitze der gerichteten Geraden a schaut. Für side(a, b) > 0 läuft b
genau entgegengesetzt an a vorbei (Rechte-Hand-Regel). In beiden Fällen sind die Graden
windschief zueinander. Gilt hingegen side(a, b) = 0, so sich beide Geraden koplanar, d.h.
sie scheiden sich oder aber sie sind parallel.
Jede gerichtete Gerade in 3D-Raum korrespondiert mit einen Punkt im Plücker-Raum,
aber nicht umgekehrt. Nur die Punkte Π, die der quadratischen Relation genügen
Π Π =0
korrespondieren zu realen Geraden im 3D-Raum. Bei allen anderen Punkten handelt es
um imaginären Gerade (Geraden mit komplexen Koeffizienten).
134
André Gärtner
Abb. 2. Anordnungen von Geraden im 3D-Raum und ihre Entsprechung im 5D-Raum
Abb. 3. Anordnungen von Geraden im 3D-Raum und ihre Entsprechung im P 5
Graphisch kann man sich die Punkte, die die obige quadratische Gleichung erfüllen, als
eine 4-dimensionale, durch eine Linie begrenzte Fläche im P 5 (ein so genannten PlückerQuadrik) vorstellen, oder - in den R3 übertragen - als einen einschaligen Hyperboloiden
(Abb. 3).
Im Folgenden wird für die Abbildung einer gerichteten Geraden l des R3 auf PlückerKoordinaten die Funktion Π : l 7→ Π(l) verwendet. Für die Rückübertragung von Punkten,
die auf der Plücker-Quadrik liegen, dient die Funktion L : Π 7→ l(Π).
3 Berechnung der Stabbing Lines
Angenommen, eine Szene besteht aus einer beliebigen Anzahl konvexer orientierter Polygone, die jeweils ein Portal repräsentieren. Insgesamt besitzen diese Polygone n Kanten (auch
Generatorkanten genannt). Jede Kante Ek mit k1, ..., n dieser Polygone ist durch ein Segment einer gerichtete Gerade ek bestimmt. Da die Polygone orientiert sind, kann jede dieser
Geraden ek so orientiert werden, dass eine durch die Portal gelegte Stabbing Line s zu jeder
dieser Geraden ek im gleichen Verhältnis verlaufen muss (Abb. 4). In einem rechtsgerichteten Koordinatensystem bedeutet dies, dass s die Relation side(s, ek ) ≥ 0 mit k1, ..., n
erfüllen muss.
Die zu ek korrespondierende Hyperebene hk ist definiert als:
hk = {xP 5 : x Πk = 0}
Cell to Cell Visibility in PVS Systemen
135
Abb. 4. Verlauf der Stabbing Line s entlang der Kanten eines Polygons
Für jede Stabbing Line s mit side(s, ek ) ≥ 0 gilt daher S Πk ≥ 0, wobei S die Darstellung von s in Plücker-Koordinaten ist. Im P 5 muss sich der Punkt S folglich in oder
oberhalb der Hyperebenen hk befinden (Abb. 5). Bezeichnet h+
k den durch hk abgeschlosseT
nen Halbraum, dann liegt S innerhalb oder auf der Grenze des konvexen Polytops k h+
k,
das durch diese Hyperebenen gebildet wird.
Abb. 5. Lage von S = Π(s) zu den Hyperebenen hk
T
Die Oberflächenstruktur eines konvexen Polytops k h+
k (die konvexe Hülle) besitzt eine
Worst-Case Komplexität quadratisch zu der Anzahl der definierenden Halbräume [8] und
kann durch einen randomisierten Algorithmus in O(n2 ) berechnet werden [9].
Allerdings ist es nicht ausreichend, einen Punkt innerhalb des durch die Hyperebenen
gebildeten Polytops zu finden, da nicht alle Punkte innerhalb dieses Polytops tatsächlich
einer Gerade im R3 entsprechen. Eine solche Gerade existiert genau dann, wenn es einen
Punkt x gibt, der sich sowohl innerhalb oder auf der Grenze des konvexen Polytops befindet
(x Πk ≥ 0,∀k) und zugleich auch auf einer Plücker-Quadrik liegt (x x =T0).
Gesucht ist somit die Schnittmenge der Plücker-Quadrik mit dem durch k h+
k begrenzten Polytop. Diese Menge lässt sich durch die folgende Überlegung weiter einschränken:
Existiert eine - durch eine Reihe von Polygonen - durchgehende Gerade, die keine der Polygonkanten berührt, so lässt sich diese Gerade derart verschieben, dass sie zunächst eine
Kante, dann zwei, drei und schließlich vier Kanten berührt. Die Menge der so gebildeten
Stabbing Lines wird Extremal genannt (dazu mehr in Kapitel 4).
Die Anzahl von vier Kanten ergibt sich aus der Tatsache, dass eine Geraden im dreidimensionalen Raum gerade durch die Bestimmung von vier Freiheitsgrade spezifiziert wird.
136
André Gärtner
So kann eine Gerade z.B. durch Angabe zweier Abschnitte auf zwei vorgegebenen Koordinatenebenen bestimmt werden, wofür jeweils zwei Koordinaten ausreichen. Alternativ können
für die Abdeckung der Freiheitsgrade auch vier Geraden (eben die Polygonkanten) verwendet werden, die die gesuchte Gerade scheiden. Diese Gerade verläuft dann entweder durch
die Vertices2 zweier Polygone, durch den Vertex eines Polygons und die windschiefe Kanten zweier anderer Polygone oder aber durch die windschiefen Kanten von vier verschieden
Polygonen.
Abb. 6. Schnitt einer aus vier Hyperebenen Πk gebildeten fünfdimensionalen Linie L mit dem PlückerQuadrik
Betrachtet man je vier dieser Geraden als Hyperebenen im Plücker-Raum, so spezifiziert
ihre Schnittmenge eine Gerade L T
des fünfdimensionalen Raumes. Die so gebildete Gerade
entspricht einer Kante des durch k h+
k begrenzten Polytops. Zur Ermittlung aller extremalen Stabbing Lines reicht es also aus, die Geraden durch die Kanten dieses Polytops mit
der entsprechenden Plücker-Quadrik zu schneiden (Abb. 6). Analog zum dreidimensionalen Raum ergeben sich hieraus null, ein, zwei oder unendlich viele Schnittpunkte, die den
extremalen Stabbing Lines entsprechen (Abb. 7).
Abb. 7. Zwei Schnittgeraden durch vier generische Linien im R3
Die Berechnung einer durch vier Geraden festgelegten Gerade [4] erfolgt daher in zwei
Schritten. Als erstes muss aus allen vier Geraden lk (bzw. ihre entsprechenden Hyperebe2
Einzahl: Vertex, ist ein Grundbaustein der polygonalen Modellierung: Zwei Vertices ergeben zusammen
die Endpunkte einer Linie, drei Vertices definieren ein Dreieck, usw.
Cell to Cell Visibility in PVS Systemen
137
nen) eine Gerade l des fünfdimensionalen Raumes bestimmt werden. Diese Gerade l wird
anschließend mit dem Plücker-Quadrik geschnitten, d.h. sie muss die Gleichung l l = 0
erfüllen.
Der erste Schritt beruht auf der Singulärwertzerlegung von Matrizen [10, 11]. Diese wird
auf eine Matrix M , bestehend aus den vier Hyperebenen Πk , angewendet, die zu vier Polygonkanten lk korrespondieren, um den Kern dieser Matrix zu bestimmen:


Π04 Π05 Π03 Π00 Π01 Π02
Π14 Π15 Π13 Π10 Π11 Π12 

M =
Π24 Π25 Π23 Π20 Π21 Π22 
Π34 Π35 Π33 Π30 Π31 Π32
Nach der Anwendung der Singulärwertzerlgung kann M als das Produkt dreier Matrizen
als U ΣV T geschrieben werden, wobei U eine orthogonale 4x4 Matrix, Σ eine diagonale 4x6
Matrix und V eine 6x6 Matrix ist:

 σ 0 0 0 0 0 

0
u00 · · · π03
u00 · · · π05

  0 σ0 0 0 0 0
  .. . . . .. 
M = U ΣV T =  ... . . . ...  
. 
 0 0 σ0 0 0 0  .
u30 · · · π33
u
·
·
·
π
50
55
0 0 0 σ0 0 0
Die Werte der Diagonalen von Σ ergeben sich dabei aus den Eigenwerten von M . Die
Anzahl der von 0 verschiedenen Zeilen bestimmt dabei den Rang der Matrix. Jede dieser
von 0 verschiedenen Zeilen korrespondiert mit einer Spalte in V und bilden in Kombination
den Kern der Matrix M . Dieser enthält die Plücker-Koordinaten der Geraden, die die vier
Geraden schneiden, aus denen M gebildet wurde.
Sind alle Zeilen in Σ von 0 verschieden (d.h. linear unabhängig) dann hat M den Rang
4. Die letzten beiden Zeilen von V bilden dann den Kern von M . Benennt man diese beiden
Zeilen mit F und G, dann lässt sich eine Abbildung Λ : P 7→ P 5 mit
Λ(t) ≡ F + tG
definieren. Aus der Kern-Eigenschaft geht nun hervor, dass Λ(t) Πk = 0 für 0 ≤ k ≤ 3
gilt. Da es sich bei Λ um eine injektive Funktion handelt, besteht ein Isomorphismus zwischen P und der Menge aller realen und imaginären Geraden, die durch je vier Polygonkanten
spezifizierten sind. Die Menge der tatsächlich vorhandenen Schnittgeraden im R3 korrespondiert daher mit den Nullstellen der quadratischen Gleichung Λ(t) Λ(t) = 0. Diese lässt
sich durch Einsetzen der obigen Definition für Λ nach
F F t2 + 2F Gt + G G = 0
auflösen. Für die Diskriminante d dieser Gleichung ergibt sich (F G)2 −(F F )∗(GG).
Daraus folgt für d < 0, dass keine Schnittgerade im R3 existiert. Für d = 0 gibt es genau
eine Schnittgerade und für d > 0 zwei. Gilt hingegen (unabhängig von t) (F F )2 + (F G)2 + (G G)2 = 0, dann gibt es unendlich viele Lösungen für die Gleichung und somit
genau so viele Schnittgeraden im R3 .
Hat M den Rang 3 (die letzten drei Zeilen von V bilden den Kern von M ), dann ergibt
sich in diesem Fall Λ(u, v) : P 2 7→ P 5 mit
138
André Gärtner
Λ(u, v) = uF + vG + H.
F , G und H entsprechen dann den letzten drei Zeilen der Matrix V . Auch die hierdurch
bestimmten Geraden müssen wieder die quadratische Gleichung Λ Λ = 0 erfüllen. Das
Ergebnis dieser Gleichung hängt jetzt jedoch von zwei Parametern ab. Ergeben sich als
Lösung zwei Geraden, dann wird die Menge der Schnittgeraden durch zwei ein-parametrige
Geradenscharen gebildet. Andernfalls kann die Funktion durch eine einzelne Variable t parametrisiert werden. Daraus ergibt sich dann für u(t) und v(t) die Menge der Schnittgeraden
als L(u(t)F + v(t)G + H).
Die Bestimmung der Schnittgeraden für Matrizen mit Rang 2 oder 1 erfolgt analog auf
der Basis von drei bzw. vier Parametern.
4 Stabbing von 3D Portal-Sequenzen
Im vorherigen Kapitel wurde gezeigt, wie man die Lage von Stabbing Lines innerhalb von
Portalen berechnet. Nun wird ein Algorithmus vorgestellt, wie man mit Hilfe dieser Stabbing Lines Licht und Schatten berechnen kann. Versteht man die Stabbing Lines nicht als
Sichtlinien sondern als Lichtstrahlen, so kann auf diese Weise berechnet werden, wie viel
Licht auf ein Objekt fällt. Diese Methode wird sowohl für den 2D als auch für den 3D Fall
vorgestellt und analysiert.
4.1 Penumbra und Antipenumbra
Angenommen ein Flächenlicht strahlt in einer Szene mit mehrere Occludern3 . Diese Occluder
erzeugen einen Schatten und verhindern so, dass Licht bestimmte Regionen in der Szene
erreicht. Jeder Punkt in der Szene läßt sich somit im Bezug zur Lichtquelle charakterisieren.
Abbildung 8 zeigt ein zweidimensionales Beispiel. Wenn ein Punkt nichts von der Lichtquelle
”sehen” kann, sagt man, dass der Punkt im Umbra (Schatten) liegt. Kann ein Punkt hingegen
etwas, aber nicht alles, von der Lichtquelle ”sehen”, sagt man, dass dieser im Penumbra
(Halbschatten) liegt. Wenn keins der beiden Situationen zutrifft, wird der Punkt von der
ganzen Lichtquelle bestrahlt.
Abb. 8. Umbra und Preumbra eines Occluder im 2D-Raum
Stellt man sich vor, das die Occluder durch konvexe Portale bzw. transparente Ebenen ersetzt werden, kann man jeden Punkt komplementär charakterisieren. Als Antiumbra
3
Ein Objekt das den Durchfall von Licht teilweise oder komplett verhindert
Cell to Cell Visibility in PVS Systemen
139
definiert man den Lichtkegel (auch als Volume bezeichnet), von dem aus die Lichtquelle
komplett einsehbar ist (Abb. 9). Für eine gegebene Lichtquelle und eine Menge von Portalen oder Occludern definiert sich Umbra als das räumliche Komplement der Vereinigung
von Antiumbra und Antipenumbra. Ähnlich ist Antiumbra das Komplement der Vereinigung
von Umbra und Penumbra.
Abb. 9. Antiumbra und Antipenumbra durch eine Portal-Sequenz
Man möchte nun die beleuchteten Bereiche einer Lichtquelle (im Folgenden immer das
erste Portal der Sequenz) innerhalb einer erreichten Zelle durch eine Gerade, die die Sequenz
durchdringt, charakterisieren. Die Charakterisierung für den Bereich einer Sequenz mit einem Portal ist trivial. In diesem Fall, ist das Antipenumbra die ganze Halbebene hinter dem
Portal, die Nachbarzelle der Quellzelle ist. Durch die Konvexität der Zellen liefert es genau
das Volumen der erreichten Zelle. Berechnungen des Antipenumbra für Portalsequenzen mit
zwei oder mehr Portalen, beziehen Schnitte zwischen Vertices und Kanten von Portalen mit
ein. Es wird im weiteren dieses Kapitels gezeigt, dass dies lineare und quadratische Primitive
einschließt um das beleuchtete Volumen korrekt zu beschreiben.
In Kapitel 3 wurden die Portale als orientiert dargestellt. In zwei Dimensionen bedeutet
das, dass jedes Portal vom Sichtpunkt eines Portal traversierenden Lichtstrahls, ein ”linkes” und ”rechtes” Ende besitzt. Im R3 bedeutet die Portal-Orientierung, dass das PortalPolygon, gesehen als eine geordnete Sequenz von Punkten, vom Sichtpunkt eines Betrachters
auf die Lichtquelle, im Uhrzeigersinn erscheint.
4.2 Oberflächen und Schneisen
Es gibt drei Arten von extremalen Stabbing Lines: Vertex-Vertex Geraden (kurz: VV),
Vertex-Edge-Edge Geraden (kurz: VEE) und vierfach Edge Geraden (kurz: 4E). Stellen wir
uns vor, dass man eine extremale Stabbing Line (egal von welchem Typ) durch Lockerung
von genau einer der vier Freiheitsgrade von der ursprünglichen Position weg schiebt (vgl.
Abb. 10). Die Oberfläche, oder Schneise (engl. Swath), die durch die Verschiebung entsteht,
ist planar oder gebogen wie eine Schar. Schneisen, wie VE oder EEE Geraden, werden Event
Surfaces genannt.
Abbildung 10-i zeigt eine extremale VV Stabbing Line, die an vier Kanten A, B, C
und D gebunden ist. Durch Lockerung der Beschränkung an C erhält man eine VE Schneise
(planar), die über A, B und D gespannt ist. Kommt die Schneise an ein Hindernis (in diesem
Fall: Kante E), so terminiert diese als eine VV Gerade, die über A, B, D und E gespannt ist.
Abbildung 10-ii zeigt eine extremale 4E Stabbing Line, die an die Kanten A, B, C und D
140
André Gärtner
Abb. 10. Verschiebung einer Stabbing Line, die im 3D eine planare VE Schneise (i) oder eine quadratische
EEE Fläche (ii) generiert
gebunden ist. Die Lockerung der Beschränkung an A produziert eine EEE Schneise (Schar),
die über B, C und D gespannt ist. In dem Beispiel trifft die Gerade auf die Ecke E und stop
als VEE Gerade.
Bedenken wir nun die gleiche Situation im 5D-Raum, gegeben durch eine Plücker Transformation (Abb. 11). Extremale Geraden bilden auf einzelne Punkte in Plücker Koordinaten
T
ab und zwar die Schnittpunkte der Kanten bzw. die 1D-Flächen des Polytops k h+
k mit
der Plücker-Quadrik. Da Schneisen zur ein-parametrischen Geradenfamilie gehören, korrespondieren diese zu Kurven in Plücker-Koordinaten. Diese Kurven sind die Spuren (engl.
Traces) oder Schnittpunkte der 2D-Fläche des Polytops mit der Plücker-Quadrik und daher
kegelförmig. Die 3D Schneisen, die zu den 5D kegelförmigen Spuren korrespondieren, nennt
man auch extremale Schneisen. Alle Schneisen haben drei Generatorgeraden und somit drei
Generatorkanten, die von Elementen der Portal Sequenzen entstehen.
Abb. 11. Spuren (Schnittpunkte) von Extremalen auf dem Plücker-Raum
4.3 Grenz- und innenseitige Schneisen
Eine 1D-Geradenfamilie kann extremal im 5D sein, solange sie komplett im Antipenumbra
liegt (im 3D-Raum). Sobald extremale Stabbing Lines in dem Inneren des Antipenumbra
Cell to Cell Visibility in PVS Systemen
141
liegen, sind auch extremale Schneisen im Inneren. Eine extremale Schneise die auf der Grenze des Antipenumbra liegt wird als Grenzschneise (engl. Boundary Swath) definiert. Alle
anderen extremalen Schneisen
sind innenseitig (engl. internal ). Untersuchungen der 2DT
Flächen des Polytops k h+
liefern
alle extremalen Schneisen. Es ist dabei wichtig, diese
k
Unterscheidung zwischen Grenzschneisen und innenseitigen Schneisen zu machen. Diese Unterscheidung kann nur lokal gemacht werden, durch Untersuchung der drei Generatorkanten
und ihrer Generator-Polygone. Nur durch Berücksichtigung dieser konstanten Anzahl von
geometrischer Begrenzungen wird im Folgenden gezeigt, wie man berechnen kann, ob eine
Stabbing Line auf ”beiden Seiten” existieren kann. Wenn das der Fall sein sollte, kann die
Schneise nichts zu der Antipenumbra Grenze betragen und sie wird als innenseitig klassifiziert.
4.4 Zweidimensionales Beispiel
Die Begriffe für Grenz- und innenseitige Schneisen lassen sich am einfachsten am zweidimensionalen Beispiel erklären (Abb. 12). Portale und die Lichtquelle sind Geradensegmente.
Die über Kreuz verlaufenden Geraden, die die Portalsequenz durchdringen, enthalten eine
extremale Schneise (im 2D ein Geradensegment), wo eine beschränkte Stabbing Line (z.B
durch Portal Endpunkte) vorkommen kann. Die dargestellte Fläche hinter dem letzten Portal ist eine konvexe Fläche, die durch die zwei überkreuzenden Kanten und das Portal selbst
aufgespannt wird. Diese Kanten sind solange Grenzschneisen im 2D, wie sie den Antipenumbra Bereich von dem unbeleuchteten Bereich voneinander trennen. Die restlichen Kanten
sind gültige Stabbing Lines aber innenseitige Schneisen.
Abb. 12. Schneisen eines 2D-Beispiels
Um dies etwas genauer zu verstehen, stellt man sich eine nicht überkreuzende Kante E
vor, die langsam von den begrenzenden Punkten p und q rund herum wegbewegt wird (Abb.
13). Die Grenzpunkte der Portale liegen dabei auf der selben Seite von E. In dem Beispiel
wird nun die Gerade um den Punkt p gedreht, die nur ins innere des mittleren Portals
wandern kann. Daraus ergibt sich, das die Kante E in dem unteren Bereich des letzten
Portals wandert (gestrichelte Linie). Dreht man die Kante E um den Punkt q, so wandert
die Kante in den oberen Bereich des letzten Portals (gepunktete Linie). Solange E gültige
Stabbing Lines erlaubt (egal ob nach oben oder unten), kann diese keine beleuchteten von
nicht-beleuchteten Region separieren. Die Schnittgerade gilt somit als innenseitige Schneise.
Betrachten wir jetzt die Situation noch für eine überkreuzende Kante E (Abb. 14). Die
Portal Endpunkte p und q liegen also auf der entgegengesetzten Seite von E. Dreht man
142
André Gärtner
Abb. 13. innenseitige Schneise einer Portalsequenz
die Gerade nun um diese Punkte, wandert diese nur in eine Richtung des jeweiligen Portals.
Dies liefert nur Geraden auf einer Seite von E (die beinhaltende Seite des Antipenumbra).
E wird in diesem Fall Grenzschneise bezeichnet.
Abb. 14. Grenzschneise einer Portalsequenz
4.5 EEE Schneisen
Im Dreidimensionalen, können innenseitige und Grenzschneisen folgendermaßen unterschieden werden. Angenommen, drei Generatorkanten A, B und C bilden eine Basis für eine
EEE-Schneise. Über diese Geraden wird eine Gerade L an den Punkten a, b und c gespannt
(Abb. 15-i). An diesen Punkten erheben sich drei Vektoren Na , Nb und Nc senkrecht zu L
und den Generatorkanten. Wichtig ist dabei, dass die Richtung so gewählt wird, dass man
ein positives Skalarprodukt mit einem ins Portal gerichteten Vektor erhält.
Man sagt, dass drei koplanare Vektoren enthalten (engl. contained ) sind, wenn ein anderer Vektor existiert, dessen Skalarprodukt mit allen drei Vektoren strikt positiv ist. Eine
Schneise ist innenseitig, genau dann wenn dessen korrespondierende Ni enthalten sein können. Angenommen die Ni können wie in Abbildung 15 enthalten sein, dann hat ein Vektor
ein positives Skalarprodukt mit den Ni (zeigend in Richtung des grauen Bereichs wie in Abb.
15-ii), und man teilt die Konfiguration mit einer Ebene, die L und diesen Vektor beinhaltet.
Die Spur (Schnitt) der Schneise auf dieser Ebene ist die Stabbing Line L, welche die
Teilungsebene in zwei Bereiche L+ und L− partitioniert (Abb. 15-iii). L kann in winzigen
Schritten bewegt werden, z.B. um Punkt a. Das Innere der zwei Portale erlaubt L nur in die
Richtung L+ zu drehen (gepunktete Stabbing Lines). Analog entstehen die Stabbing Lines
Cell to Cell Visibility in PVS Systemen
143
Abb. 15. Eine innenseitige EEE-Schneise (i), herunter geschaut an L (ii) und in Richtung L traversiert (iii)
(gestrichelt) im L− wenn man um Punkt c dreht. Auf Grund der Tatsache, dass Stabbing
Lines in beide Richtungen gehen, kann es keine Grenzschneise sein.
Abb. 16. Eine Grenz-EEE-Schneise (i), herunter geschaut an L (ii) und in Richtung L traversiert (iii)
Im Vergleich, kann Ni in Abbildung 16 nicht enthalten sein. Jeder Vektor hat mit den
anderen Vektoren ein negatives Skalarprodukt. Angenommen es gibt ein negatives Skalarprodukt mit Nc und man teilt die Konfiguration mit einer Ebene, die L und einen solchen
Vektor beinhaltet (Abb. 16-iii). Eine Drehung um den Punkt b generiert Stabbing Lines
im L− (gepunktet) und so auch eine Drehung um Punkt c. Diese Konfiguration liefert also
keine Stabbing Lines im L+ . Solange dies für irgendeine Teilungsebene für L zutrifft, ist die
Schneise eine Grenzschneise.
4.6 VE Schneisen
Angenommen die Schneise ist von Type VE. Dies ist ein Spezialfall einer EEE Konstruktion,
in der zwei der drei Kanten involviert sind. Es ist nötig diesen Fall gesondert zu betrachten,
da es das einfache Verhalten der Containment-Funktion erklärt (dazu mehr im nächsten
Unterkapitel).
In Abbildung 17 sind die Generatorkanten A und B gegeben, die die VE Schneise am
Vertex v definieren, sowie eine Kante C, die zwei Generator-Polygone P und Q, eine Ebene
144
André Gärtner
durch C und die Gerade S. Orientiere S so, dass Q über dieser Geraden liegt (S + ). Solange
Q konvex ist, ist dieses immer möglich. S teilt den Raum hinter der Ebene von Q in zwei
Regionen S + und S − . Wenn Stabbing Lines in einer dieser Regionen existieren können, ist
die Schneise eine Grenzschneise. Dies ist möglich, genau dann wenn S eine Teilungsebene
von P und Q ist bzw. sich Polygon P komplett unter S befindet.
Abb. 17. Grenz- (i) und innenseitige (ii) VE-Schneise
Angenommen S teilt Polygon P und Q voneinander und man wählt eine Schnittgerade
der Schneise, die so wegbewegt wird, dass diese sich vom Schneisen-Vertex v löst, aber noch
bei Kante C verbleibt. Der bewegende Linienschnitt mit P kann dann nur unter S liegen
(Abb. 17-i). Folglich müssen alle Stabbing Lines den Bereich S + unter der Ebene von Q
schneiden. Ähnliches Verhalten ergibt sich, wenn man die Stabbing Line von C ins Innere
von Q wegbewegt und weiter an v gebunden bleibt. Die Schneise liefert nur Stabbing Lines
im S + und ist somit eine Grenzschneise.
Zum Vergleich sei angenommen, das die Ebene S P und Q nicht teilt, so dass die Kanten
A und B im S + liegen (Abb. 17-ii). Wieder bewegt man eine Schneise so dass sie vom Vertex
v losgelöst kommt, aber bei Kante C bleibt. Wenn die Gerade (gestrichelt) nach A über
Ebene S wandert, wird diese sich mit der Region S − hinter der Ebene von Q schneiden.
Sollte Kante B unter S liegen, würde die Bewegung nach B Stabbing Lines (gepunktet) im
S + produzieren. Wenn A und B unter S liegen, liegen die Geraden bei v und schneiden das
Innere von Q. Die Schneise liefert Stabbing Lines, die in S − und S + liegen und kann somit
keine Grenzschneise sein.
Sei darauf hingewiesen, dass die drei-Vektor Konstruktion für EEE Schneisen auch für
diese degenerierte Einstellung einsetzbar ist.
4.7 Containment Funktion
Die Containment-Funktion ist ein Kriterium um zwischen Grenz- und innenseitigen Schneisen zu unterscheiden. Dies trifft nur auf eine einzelne Stabbing Line zu, nicht aber auf eine
ganze Schneise. Praktischer Weise liefert die Auswertung der Containment-Funktion auf
einen Teil der Schneise aber Resultate. Grund dafür ist, dass die Konfiguration der Normalen, die von den Portalkanten ausgehen, erhalten bleiben. Um zu zeigen wieso das so
ist, stellt man sich eine Konfiguration von drei koplanaren Vektoren Na , Nb und Nc vor.
Angenommen, die Konfiguration ändert ständig von beinhaltend zu nicht beinhaltend (z.B.
Cell to Cell Visibility in PVS Systemen
145
durch Drehung des Vektors Nc ) wie in Abbildung 18. An dem Moment wo Nc die Grenze
(gepunktete Linien) überschreitet, muss Nc und einer von Na oder Nb antiparallel sein.
Abb. 18. Containment und Non-Containment, mit bewegendem Nc für feste Na und Nb
Damit dies in der EEE-Schneisen-Konstruktion passiert, müssen zwei oder drei Generatorkanten koplanar sein. Ähnlich bei einer VE-Schneisen-Konstruktion, muss ein Kantenpaar
koplanar sein. Die Generatorkanten sind aber fest, nur die Verschiebungsgeraden variieren.
Folglich wird nur durch Verschiebung einer extremalen Geraden entlang einer Schneise eine
sich ständig ändernde Vektorkonfiguration generiert. Der Containment des Vektors ist eine
konstante Funktion.
5 Berechnung des Antipenumbra
Der benötigte rechnerische Mechanismus für die Berechnung des Antipenumbra ist nun vollständig. Folgende Annahmen werden getroffen: Eingabe ist eine Liste von m orientierten
Polygonen P1 ...Pm (gegeben als Liste von n Kanten). Das erste Polygon P1 ist die Lichtquelle, die restlichen sind Löcher (Portale). Die Polygone sind disjunkt und so geordnet,
dass der negative Halbraum definiert durch die Ebene von Pi alle Polygone Pj , i < j ≤ m
beinhaltet.
Der Algorithmus wandelt jede gerichtete Kante in eine Hyperebene in Plücker-Koordinaten
um und ermittelt dann die gemeinsamen Schnitte der sich ergebenden Halbräume, ein konvexes 5D Polytop. Wenn kein Schnitt vorliegt, oder das Polytop keinen Schnitt mit der
Plücker-Fläche hat, gibt es kein Antipenumbra. Gibt es Schnitte, wird die Polytop-Struktur
nach Spuren von Grenzschneisen (Schnitt von 1D-Flächen (Kanten) und 2D-Flächen (Dreiecke) mit der Plücker-Quadrik) abgesucht (Abb. 11). Diese Spuren sind mit einer Schleife
verknüpft, welche mit Komponenten der Antipenumbra-Grenze korrespondieren. Es kann
mehrere Schleifen geben, da der Schnitt der Polytop-Grenze mit der Plücker-Quadrik mehrere Komponenten haben kann.
Jede Schleife besteht aus wechselnden Polytop-Kanten und -Dreiecken mit der PlückerQuadrik (vgl. Abb. 19). Jede Kante, die sich mit der Plücker-Fläche schneidet ist ein Dual
einer extremalen Stabbing Line im R3 . Der Schnitt zwischen Dreieck und der PlückerQuadrik ist ein Dual einer extremalen Schneise. Die Vorkommnis von Kanten und Dreiecken
auf dem Polytop impliziert so die Adjazenz von korrespondierenden Linien und Schneisen
im 3D. Das Übergehen einer Kante von einem Dreieck zum nächsten auf einem Polytop
ist äquivalent zum Übergehen von extremalen Stabbing Lines zwischen zwei extremalen
146
André Gärtner
Abb. 19. Schleife über Polytope-Kanten und -Dreiecke
Schneisen im 3D. Folglich kann der Algorithmus von 2D-Fläche zu 2D-Fläche der PolytopFläche ”gehen”, nur durch Überquerung der 1D-Flächen Vorkommnisse.
Jeder vorgefundene Kegel im 5D impliziert drei Generatorkanten im 3D, die in konstanter Zeit auf Containment untersucht werden (man beachte, das die Containment-Achse,
Gerade L in Abb. 16, als Dual irgendeiner Überschneidung der Dreieckskanten mit der
Plücker-Quadrik genommen werden kann). Kegel, deren Dual-Kanten enthalten sind, sind
Duale von innenseitigen Schneisen (andernfalls sind sie Duale von Grenzschneisen). Sobald
die Oberflächenstruktur des Polytops traversiert ist und die Grenzschneisen ermittelt sind,
werden diese ausgegeben. Wenn eine Schleife durchlaufen ist, wird die Suche an einer noch
ungeprüften Kante fortgesetzt. Jede geschlossene Schleife im 5D dieser Methode, ist das
Dual der Grenze einer verbundenen Komponente des Antipenumbra im 3D.
Algorithmus 18
Eingabe der gerichteten Kanten Ek der Polygone P1 ...Pm
gerichtete Kanten in gerichtete Geraden ek konvertieren
ek in PlückerTHalbräume hk = Π(ek ) transformieren
5D Polytop k h+
k berechnen
T
2D-Flächen Schnitte von k h+
k mit der Plücker Oberfläche ermitteln
Extremale Schneisen als Grenz- oder innenseitige Schneisen klassifizieren
für alle durch DFS gefundene Komponenten
des Antipenumbra
T
traversiere Grenz-2D-Flächen von k h+
k
bilde jede gefundene Spur auf eine 3D Grenzschneise ab
Ausgabe der Schneisen als quadratische Oberfläche
5.1 Algorithmus am Beispiel
Um die Komplexität des Algorithmus zu verdeutlichen, wurde dieser von Teller in der Programmiersprache C und FORTRAN-77 auf einer 20-MIP Silicon Superworkstation implementiert. Um die konvexe Hülle von n Hyperebenen im 5D zu berechnen, wurden Algorithmen verwendet, die von Allan Wilks, Allen McIntosh und Michael Hohmeyer geprägt
worden sind [2].
Abbildung 20 zeigt eine Menge von Polygonen mit n = 15, wobei das erste Polygon
die Lichtquelle darstellt.TDie Antipenumbra Berechnung braucht bei zwei CPUs nur wenige
Sekunden. Das Polytop k h+
k , entstanden aus 15 Halbräumen im 5D, hat 80 Fassetten, 186
2D-Flächen (Dreiecke) und 200 1D-Flächen (Kanten). Von den 186 Dreiecken werden 78
Cell to Cell Visibility in PVS Systemen
147
Abb. 20. Ein Lichtquelle mit drei Portalen (i) und den sich daraus ergebenden VE- (rot), EEE-Schneisen
(grün) (ii)
Dual-Spuren auf der Plücker-Quadrik induziert und somit auch 78 extremale Schneisen generiert. Von den 78 Schneisen sind 62 innenseitig und 16 grenzend (Abb. 20-ii). Von den 16
Grenzschneisen sind 10 VE- (rot) und 6 EEE-Schneisen (grün). Von den 200 Kanten schneiden 39 den Plücker-Quadrik und liefern die extremalen VV, VEE und 4E Stabbing Lines
(Abb. 21). Man beachte, dass die extremalen Stabbing Lines die Form der AntipenumbraGrenze gestalten.
Abb. 21. 39 Extremale Stabbing Lines (i) prägen die Antipenumbra-Grenze (ii)
6 Fazit
Teller hat gezeigt, dass sich der Schatten - entstehend durch ein Lichtquelle - durch eine Portalsequenz mit n Kanten mit einem erwarteten Aufwand von O(n2 ) berechnen läßt. Beschrieben wurde das Antipenumbra als ein Volumen begrenzt durch die Regionen von quadratischen und planaren Flächen und gezeigt, dass jede Schneise oder Anteil der AntipenumbraGrenze im 3D durch einen Schnitt einer fünfdimensionalen konvexen Hülle mit einer vierdimensionalen Fläche, der Plücker-Quadrik, entsteht. Dieser Algorithmus ist an die Berechnung von Aspekt Graphen angelehnt, die Bereiche mit qualitativ unterschiedlichen Sichten
einer Lichtquelle in einer Szene trennen.
Es wurde eine Implementierung einer Antipenumbra-Berechnung über mehrere Polygonsequenzen demonstriert. Wie Teller beschreibt, wurde der Algorithmus durch ein Sichtbarkeitsprojekt, der statisches und Volumen-basierendes Culling im Dreidimensionalen umfasste, angeregt. Der Aufwand zur Bestimmung des Antipenumbra und somit auch der Stabbing
148
André Gärtner
Lines lohnt sich insbesondere dann, wenn eine Szene einen Vielzahl verdeckter Objekte aufweist, wie es z.B. auf das Innere von Gebäuden, dicht bebaute Innenstädte oder ähnliches
zutrifft. Werden so bereits im Vorhinein für jede Zelle die von dieser aus potentiell sichtbaren Zellen bestimmt, verringert sich der Aufwand für das Culling und Rendering erheblich,
da viele Objekte aus nicht sichtbaren Zellen nicht mehr betrachtet werden müssen.
Damit die Berechnung des Antipenumbra und Stabbing Lines überhaupt möglich wurde,
wurde ein Verfahren gezeigt, mit dem sich der Schnitt von Kanten eines fünfdimensionalen
Polytops mit einer vierdimensionalen Hyperebene berechnen läßt. Die Übertragung erfolgt
mit Hilfe von Plücker-Koordinaten, die die Darstellung von Geraden des R3 als Punkte oder
Hyperebenen des fünfdimensionalen projektiven Raumes ermöglichen.
Literaturverzeichnis
1. Seth Teller und Pat Hanrahan, 1993, Global visibility algorithms for illumination computations, International Conference on Computer Graphics and Interactive Techniques, Seiten: 239 - 246.
2. Seth J. Teller, 1992, Computing the antipenumbra of an area light source, ACM SIGGRAPH Computer
Graphics, Volume 26 - Issue 2, Seiten: 139-148.
3. Seth J. Teller und Michael E. Hohmeyer, 1992, Stabbing Oriented Convex Polygons in Randomized
O(n2 ) Time, Technischer Bericht, Computer Science Department, U.C. Berkeley.
4. Seth J. Teller und Michael E. Hohmeyer, 1992, Computing the lines piercing four lines, Technischer
Bericht, Computer Science Department, U.C. Berkeley.
5. Seth J. Teller und Carlo H. Séquin, 1991, Visibility preprocessing for interactive walkthroughs, ACM
SIGGRAPH Computer Graphics, Volume 25 - Issue 4, Seiten: 61-68.
6. Seth J. Teller, 1992, Visibility Computations in Densely Occluded Polyhedral Environments, Dissertation, Computer Science Department, U.C. Berkeley, Seiten: 70-99.
7. Jorge Stolfi, 1989, Primitives for computational geometry, Technischer Bericht 36, DEC SRC, Seiten:
189-197.
8. Branko Grünbaum, 1967, Convex Polytopes, Wiley-Interscience, New York.
9. Kenneth L. Clarkson und Peter W. Shor, 1989, Applications of random sampling in computational
geometry II, Discrete Computational Geometry, Seiten: 387-421.
10. Wikipedia, Begriff: Singulärwertzerlegung, Stand: Jan. 2008,
http://de.wikipedia.org/wiki/Singul%C3%A4rwertzerlegung.
11. Gene H. Golub und Charles F. Van Loan, 1989, Matrix Computations, John Hopokins University Press.
Hohe Verfügbarkeit in skalierbaren verteilten Hashingdateien
mit Mirroring
Marco Müller
Universität Paderborn [email protected]
Zusammenfassung. Heutzutage findet die Datenhaltung in Softwareprojekten nicht mehr nur auf einem
Computer statt, sondern ist oftmals in einem Netz aus mehreren Computern verteilt und besteht aus einer
großen Anzahl von Daten. Allerdings ist es dann nicht gewährleistet, dass alle Computer des Netzes auch
immer verfügbar sind. Mirroring ist ein bekanntes Konzept, um diesem Problem zu begegnen. In dieser
Arbeit soll dieses Konzept in das LH*-Schema, ein Hashingverfahren für skalierbare, verteilte Dateien,
integriert werden. Dabei sollen Ausfälle von einem oder mehreren Computern so abgefangen werden, dass die
Daten trotzdem verfügbar bleiben, ohne dabei die sonstigen Eigenschaften zu verlieren. Die hier vorgestellten
Schemata erreichen immer noch sowohl eine ähnliche Zugriffszeit, als auch eine ähnliche Skalierbarkeit wie
das LH*-Schema. Der Preis dafür sind ein höherer Speicherbedarf und ein erhöhter Bedarf an Nachrichten
zur Kommunikation. Die verschiedenen Schemata haben unterschiedliche Eigenschaften, die sich aus den
Anforderungen ergeben. Dies schlägt sich vor allem in den Kosten für die Wiederherstellung nach einem
Ausfall nieder.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
1.1 Lineares Hashing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
2
Das LH*-Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
2.1 Clients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
2.2 Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
2.3 Weitere Eigenschaften des LH*-Schemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
3
Das LH*-Schema mit Mirroring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
3.1 Allgemeine Eigenschaften von LH* mit Mirroring . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
3.2 Besonderheiten des SA-Mirrors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
3.3 Besonderheiten des SD-Mirrors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
4
Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
1 Einleitung
Hashing als eine Möglichkeit, große Datenmengen zu speichern, wird heutzutage in vielen
Bereichen der Informatik eingesetzt. Durch die schnellen Zugriffszeiten und den geringen
Speicherbedarf, den Hashingverfahren im Gegensatz zu Algorithmen, die Baumstrukturen
150
Marco Müller
verwenden, besitzen, sind solche Verfahren sehr attraktiv für z.B. die Indexierung von Tabellen in einer Datenbank. Allerdings muss beim statischen Hashing im Vorfeld klar sein,
wie groß der Wertebereich zu wählen ist, da es sonst zu vielen Kollisionen kommt und die
Zugriffszeit zu sehr erhöht wird. Um diesem Problem entgegenzutreten, wurden dynamische
Hashingverfahren entwickelt, die den Wertebereich dynamisch erweitern. Das bekannteste
unter ihnen ist das Lineare Hashing [Lit80].
Diese Verfahren operieren auf dem Arbeitsspeicher eines Rechners und lagern, wenn nötig,
Teile des Bildbereichs auf Festplatten oder ähnliche Medien aus. Allerdings sind heutzutage die Zugriffszeiten auf eine Festplatte höher als auf den Arbeitsspeicher eines anderen
Computers. Demnach ergeben sich Vorteile bezüglich der Zugriffszeit, wenn man Hashingverfahren auf verteilte Systeme oder auf Computercluster ausweitet. Ein Verfahren, dass
sich dieser Problemstellung widmet, ist das LH*-Schema [Lit93]. Dieses wird in dieser Arbeit näher beleuchtet. Allerdings gilt es bei der Realisierung von z.B. Software für Banken
noch eine Komponente zu beachten: die Verfügbarkeit. In einem verteilten System kann
es zu Ausfällen einzelner Knoten kommen, sei es durch Stromausfälle, temporäre Ausfälle
von Teilen des Arbeitsspeichers, Wartungsarbeiten oder ähnliches. Das kann dazu führen,
dass ein Computer nicht verfügbar ist, auf dem gerade ein Hashwert gespeichert werden soll,
bzw. sich ein Hashwert befindet, nach dem gesucht wird. Solche Ausfälle müssen abgefangen
werden. In dieser Arbeit soll dazu das Mirroring als zusätzliche Funktion des LH*-Schemas
vorgestellt werden.
Im folgenden Abschnitt werden die Grundprinzipien des Linearen Hashing, auf dem das
LH*-Schema aufbaut, vorgestellt. Die Kapitel 2 und 3 beschäftigen sich dann mit dem LH*Schema und wie man Mirroring in dieses integrieren kann, ohne seine sonstigen Vorzüge zu
verlieren. Abschließend wird ein Fazit gezogen.
1.1 Lineares Hashing
Das Lineare Hashing ist die am häufigsten genutzte Möglichkeit des dynamischen Hashings.
Es verwendet dabei das verzeichnislose Schema des dynamischen Hashings und erweitert die
Hashtabelle in jedem Schritt um lediglich einen Slot. Die zugrunde liegende Datenstruktur
bilden sogenannte Tries, eine spezielle Art von Bäumen, bei denen ein Durchlauf dadurch
charakterisiert ist, dass an den Kanten jeweils ein Zeichen des Alphabets hinzugenommen
wird. Ein Knoten ist durch den Pfad zu ihm kodiert. Eine genauere Beschreibung von Tries
findet sich in [Enb88].
Um Lineares Hashing effizient durchführen zu können, müssen bestimmte Anforderungen
an die verwendete Hashfunktion gestellt werden. Der Wertebereich der Schlüssel muss dynamisch veränderbar sein. Die am häufigsten genutzte Methode, dies zu erreichen, ist eine
binäre Kodierung des Schlüssels. Durch Hinzunahme eines Bits wird der Schlüssel erweitert und der Bildbereich vergrößert. Das Reduzieren des Bildbereich geschieht analog. So
wird beispielsweise ein Slot, der zunächst durch den Schlüssel 00 adressiert wird, nach einer
Erweiterung des Schlüssels mit dem Schlüssel 000 adressiert. Soll der Bildbereich reduziert
werden, so wird ein Bit, analog dem Vergrößern des Bildbereichs, entfernt.
Um zu gewährleisten, dass die schon vorhandenen Schlüssel/Werte-Paare weiterhin benutzt
werden können und keine neue Berechnung durchgeführt werden muss, werden mehrere Hashfunktionen hi benutzt, die jeweils den Adressraum {0, 1, ..., 2i − 1} abdecken, wobei i eine
beliebige natürliche Zahl ist. Bei der Gestaltung der Hashfunktionen ist zu beachten, dass
Skalierbare verteilte Hashingverfahren mit Mirroring
151
für jeden Hashwert hi (k) immer eine der folgenden Gleichungen gilt:
hi (k) = hi−1 (k)
hi (k) = hi−1 (k) + 2i−1
Da alle Schlüssel von der Form hi (k) = bi−1 ...b1 b0 sind, mit b ∈ {0, 1}, kann der Adressraum der Schlüssel erweitert werden, ohne dass die bisherigen Werte neu berechnet werden
müssen. In der Handhabung gibt es einige Unterschiede zwischen dem verzeichnisorientierten und dem verzeichnislosen Verfahren, auf die ich nicht näher eingehen möchte (vgl. dazu
[Enb88]). Für das Lineare Hashing ist nur das verzeichnislose Verfahren relevant. Dazu wird
eine Variable, im Folgenden p genannt, eingeführt, die als sogenannter Split-Pointer fungiert. Kommt es zu einem Überlauf, so wird der Slot gesplittet, auf den p gerade zeigt.
Dabei ist zu beachten, dass dies nicht notwendigerweise der Slot sein muss, der den Überlauf ausgelöst hat. Auch wird lediglich ein Slot zum Bildbereich hinzugefügt, es findet keine
Verdopplung des Bildbereichs statt, wie man es beim Hinzufügen eines Bits erwarten würde. Dadurch wird gewährleistet, dass durch schlechte Wahl der Schlüssel der Bildbereich
nicht unnötig groß wird, was bei einem Hinzufügen des zusätzlichen Bits zu allen Slots der
Fall wäre. Als Ergebnis wird im Schnitt eine Auslastung von 60% erreicht(vergleiche dazu
[Lit80]). Abbildung 1 auf Seite 153 soll die Expansion verdeutlichen. Sei s die Anzahl Slots
beim Start der i-ten Expansion. Es gilt: s = 2i und die momentan genutzte Hashfunktion sei
hi (k). w, x, y und z bezeichnen hier sogenannte Überlaufslots, die genutzt werden, wenn ein
Slot überläuft, der nicht im nächsten Schritt gesplittet wird. Im Beispiel gibt es vier Slots,
demnach sind s = 4, i = 2 und die verwendete Hashfunktion ist h2 (k). Der Split-Pointer p
zeigt auf den Slot 0, da wir uns am Beginn der zweiten Expansionsphase befinden (Beispiel
in Abbildung 1, Position (a) ). Nehmen wir nun an, Slot b läuft über. Es wird nach dem
letzten Slot (in diesem Fall nach d) ein neuer Slot eingefügt und der Slot, auf den p zeigt,
in diesem Fall Slot a, wird auf a und A aufgeteilt. Dann wird p inkrementiert. Um den
Überlauf von b abzufangen, wird ein Überlaufslot eingeführt, in diesem Beispiel w, der die
Werte, die über die Kapazität des Slots hinausgehen, speichert. Nun ergibt sich das Bild,
das Position (b) im Beispiel zeigt. Um zu unterscheiden, ob ein Wert in Slot a oder in Slot
A gespeichert werden soll, wird ein zusätzliches Bit benötigt. Nun wird also hi+1 (k) zur
Adressierung für diese beiden Slots verwendet. Für alle übrigen Slots wird weiterhin hi (k)
verwendet. Im Allgemeinen gilt für die Adressierung der Slots folgender Algorithmus:
begin
i f hi (k) ≥ p then s l o t := hi (k)
e l s e s l o t := hi+1 (k) ;
i f necessary , chase the overflow chain
end
Listing 1. Adressierung der Slots [Enb88]
152
Marco Müller
Alle Slots links vom Split-Pointer p werden also mit hi+1 (k) adressiert, alle rechts von p
bis zur Grenze s − 1 (der letzte Slot, der noch mit i Bits adressierbar ist) werden weiterhin
mit hi (k) adressiert.
Nun läuft der Slot d über und Slot b, inklusive seines Überlaufslots w, wird aufgeteilt auf
b und B. Die Werte, die zum Überlauf von Slot d geführt haben, werden im Überlaufslot x
gespeichert. Man erkennt, dass es einen Zusammenhang zwischen dem Slot, auf den p zeigt
(derjenige, der gesplittet wird), und dem neuen Slot gibt. Der neue Slot lässt sich immer
durch s + p adressieren. Im nächsten Schritt läuft erneut d (bzw. der Überlaufslot x) über,
was dazu führt, dass c gesplittet wird und ein zweiter Überlaufslot, hier y, eingeführt werden muss (siehe Position (d) im Beispiel). Im letzten Schritt für diese Expansionsstufe soll
Slot B überlaufen. Nun wird d mit seinen beiden Überlaufslots gesplittet. Da nun nach dem
Inkrementieren von p gilt: p = s wird p wieder auf 0 gesetzt, was signalisiert, dass dieser
Expansionsschritt beendet ist. Für alle Slots wird nun hi+1 (k) zur Adressierung verwendet.
Nun wird i inkrementiert, s = 2i neu berechnet und die Grenze für den nächsten Expansionsschritt (s − 1) wird ebenfalls neu berechnet. Dies führt zur Position (e) im Beispiel. p
ist wieder bei 0, i hat den Wert 3 und s den Wert 8. Zur Adressierung wird ausschließlich
h3 (k) verwendet.
Es besteht die Möglichkeit, durch Wahl von anderen Strategien, was das Splitten der Slots
angeht, eine Verbesserung herbeizuführen. Dazu kann man sich überlegen wann ein Slot
gesplittet und ein neuer Slot eingeführt wird, aber auch wie ein Slot gesplittet wird. Dies
soll hier nicht weiter erläutert werden, nachzulesen sind diese Möglichkeiten in [Enb88].
2 Das LH*-Schema
LH* stellt eine Erweiterung des Linearen Hashing dar. Im Gegensatz zum Linearen Hashing,
welches auf einem Prozessor läuft, ist eine LH*-Datei auf mehreren Computern verteilt. Dabei existiert keine zentrale Instanz, die alles koordiniert. Man unterscheidet zwischen Clients,
die Schlüssel suchen, bzw. einfügen und Servern, die die Schlüssel und die dazugehörigen
Werte speichern. Zur Kommunikation der Clients mit den Servern werden Nachrichten ausgetauscht. Auf die Besonderheiten der einzelnen Komponenten wird später näher eingegangen. Um solch ein Netzwerk umsetzen zu können, werden bestimmte Anforderungen an die
zugrundeliegende Datenstruktur gestellt [Lit93]:
1. Eine Datei wird nur schrittweise erweitert und auch nur, wenn alle Server, die sich gerade
in Benutzung befinden, zu einem gewissen Grad ausgelastet sind.
2. Es existiert keine zentrale Steuerungseinheit, die zunächst benachrichtigt werden muss.
3. Keine Operation (Suchen, Einfügen, Splitten usw.) benötigt atomare Ausführungen unter verschiedenen Clients.
Datenstrukturen, die diese Anforderungen erfüllen, werden auch SDDS1 [Lit93] genannt.
Anforderung 1 ist intuitiv klar und galt schon beim Linearen Hashing. Anforderung 2 ist
essentiell, um mit weniger Nachrichten auszukommen und für die Größe der LH*-Datei nicht
durch die Größe der zentralen Instanz beschränkt zu sein. Anforderung 3 ist unverzichtbar,
da nicht garantiert werden kann, dass zu jedem Zeitpunkt alle Clients verfügbar sind. Um
solch eine SDDS effizient nutzen zu können, müssen möglichst wenige Nachrichten zum Einfügen, bzw. Suchen eines Schlüssels gebraucht werden und die Auslastung sollte möglichst
1
Scalable Distributed Data Structure
Skalierbare verteilte Hashingverfahren mit Mirroring
Abb. 1. Beispiel für Lineares Hashing
153
154
Marco Müller
hoch sein. Beides ist beim LH*-Schema gegeben, wie später gezeigt wird. Eine LH*-Datei
wird auf mehreren Servern gespeichert. Dabei wird auf jedem Server genau ein Slot gespeichert, und zwar in dessen Arbeitsspeicher. Eine LH*-Datei expandiert genau so wie eine
Datei beim Linearen Hashing. Da es genauso viele Server wie Slots gibt, ist dies ohne weiteres möglich. Genau wie beim Linearen Hashing hat jeder Slot ein Expansionslevel i und
es gibt einen Split-Pointer p, der auf einen Slot zeigt.
In den folgenden Abschnitten 2.1 und 2.2 wird näher auf die beiden Komponenten des
LH*-Schemas, die Clients und die Server eingegangen.
2.1 Clients
Clients manipulieren eine LH*-Datei, indem sie mit einem Server über Nachrichten kommunizieren. Sie fügen Schlüssel ein oder suchen nach Schlüsseln. Da es viele Clients gibt, die
von der Existenz anderer Clients nichts wissen und unabhängig voneinander die LH*-Datei
verändern können, verändert ein Client die Datei, ohne dass andere Clients davon erfahren.
Man könnte eine zentrale Instanz einführen, die die beiden Werte, das Expansionslevel i
und den Split-Pointer p, verwaltet und alle Clients informiert, oder jeder Client benutzt
eine eigene Kopie. Letzteres führt dazu, dass die Clients unterschiedliche Werte für ihre
Kopien haben. Diese sind im Regelfall nicht die Werte der Datei. Beides ist nicht optimal,
aber im weiteren Verlauf wird die zweite Variante verwendet.
Im nächsten Abschnitt soll näher auf die Adressberechnung des Clients eingegangen werden.
Im darauffolgenden Abschnitt wird das Verfahren zum Anpassen der Werte eines Clients an
die der LH*-Datei näher erläutert.
Adressierung
Da die Clients alle unterschiedliche Werte von i und p haben können, besitzen alle eine
Kopie der beiden Werte, im Folgenden als i0 und p0 bezeichnet. Mit diesen Kopien berechnet
jeder Client den Hashwert für den Schlüssel mit demselben Algorithmus wie beim Linearen
Hashing (siehe Listing 1 auf Seite 151). Da die Kopien des Clients aber typischerweise nicht
den tatsächlichen Werten entsprechen, kann es sein, dass die Berechnung des Hashwertes
falsch war. In diesem Fall würde dieser Fehler durch die Server entdeckt werden (genaueres
dazu findet sich in Kapitel 2.2) und eine IAM2 wird an den Client geschickt. Im folgenden
Abschnitt wird darauf näher eingegangen. Ist der berechnete Wert korrekt, bleibt diese
Nachricht aus, auch wenn i0 und p0 nicht i und p entsprechen.
Anpassung der eigenen Kopie
Wenn ein Client eine falsche Kopie der Werte hat und somit einen falschen Server anspricht, so wird eine Nachricht von diesem Server an den Client geschickt, die sogenannte
IAM. Durch diese Nachricht werden die Kopien i0 und p0 neu gesetzt und nähern sich den
tatsächlichen i und p an (Die übermittelten Werte müssen nicht den tatsächlichen entsprechen, da der Server, der zuerst vom Client angesprochen wird, seine Werte übermittelt, nicht
derjenige, wo der Hashwert tatsächlich gespeichert ist). Dies sorgt dafür, dass Nachrichten
nur übermittelt werden, wenn es zwingend notwendig ist, denn auch wenn die Kopien falsch
2
Image Adjustment Message
Skalierbare verteilte Hashingverfahren mit Mirroring
155
sind, aber trotzdem die richtige Adresse berechnet wird, wird keine Nachricht gesendet. Das
Result sind weniger Fehler bei der Adressierung, denn mit jedem Fehler, den ein Client
macht, werden seine Kopien erneuert und den tatsächlichen Werten angenähert, sofern ein
Client aktiv genug ist. Ein Client, der kaum Schlüssel sucht, bzw. Schlüssel einfügen möchte,
verpasst natürlich viele Änderungen an der Datei und wird demnach mehr Fehler bei der
Adressierung haben, als ein Client, der häufiger aktiv ist. Listing 2 zeigt den Algorithmus
zum Anpassen der Kopien eines Clients. Dabei sind i das Expansionslevel der LH*-Datei, i0
die Kopie des Clients, p0 der Split-Pointer des Clients und a die Adresse des Servers bzw. des
Slots. Die beiden Schritte decken die beiden möglichen Fälle ab: einmal, dass der adressierte
Slot schon gesplittet wurde (Schritt 1), und dass der adressierte Slot noch nicht gesplittet
wurde (Schritt 2). In jedem der beiden Fälle entspricht das Expansionslevel i0 nun dem der
Datei. Lediglich der Split-Pointer kann von dem der Datei abweichen.
1 : i f i > i0 then i0 ← i − 1 , p0 ← a + 1 ;
0
2 : i f p0 ≥ 2i then p0 ← 0 , i0 ← i0 + 1 ;
Listing 2. Adjustment Algorithmus [Lit93]
2.2 Server
Server speichern Schlüssel mit den dazu korrespondierenden Werten. Dabei ist auf jedem
Server genau ein Slot gespeichert. Server bekommen von Clients Nachrichten mit den einzufügenden Schlüsseln, bzw. Schlüsseln, nach denen gesucht wird. Wie im vorigen Abschnitt
erläutert, kann es vorkommen, dass ein Server eine Nachricht erhält, die eigentlich nicht
für ihn bestimmt ist. Deshalb überprüft jeder Server, ob er der richtige Empfänger der
Nachricht ist und leitet die Nachricht an einen anderen Server weiter, falls er nicht der richtige Empfänger ist. Der genaue Ablauf dieses Prozesses wird im nächsten Abschnitt näher
erläutert.
Adressierung
Jeder Server berechnet nach Erhalt einer Nachricht vom Client die Adresse neu, um zu
überprüfen ob er der richtige Empfänger ist. Wenn nicht, berechnet er die Zieladresse neu
und leitet die Nachricht an die neue Adresse weiter. Dann schickt er eine IAM an den Client,
der die Anfrage gestellt hatte. Diese IAM enthält den aktuellen Wert des Servers für das
Expansionslevel. Die Weiterleitung der Nachricht an einen weiteren Server findet höchstens
zweimal statt, wie später noch gezeigt wird. Da ein Server den Wert des Split-Pointers p
nicht kennt, kann er nicht den Algorithmus verwenden, den der Client benutzt (Listing 1
auf Seite 151). Er verwendet folgenden Algorithmus:
a0 ← hi (C) ;
i f a0 6= a then
a00 ← hi − 1(C)
i f a00 > a and a00 < a0 then a0 ← a00 ;
Listing 3. Adressberechnung des Servers [Lit93]
156
Marco Müller
Dabei ist i das Expansionslevel des Servers und a0 die neu berechnete Adresse für den
Schlüssel C, sowie a die vom Client berechnete und übermittelte Adresse. Sollte bei der Berechnung herauskommen, dass a0 = a gilt, so ist der Server der richtige Empfänger und führt
die Anfrage vom Client aus. Ansonsten wird die Nachricht an den Server mit der Adresse
a0 weitergeleitet. Dieser führt wiederum den Algorithmus aus und sendet die Nachricht gegebenenfalls weiter. Spätestens dann wird, wie oben erwähnt, der richtige Server gefunden.
Dies verdeutlicht folgender Satz [Lit93]:
Theorem 1. Der Algorithmus aus Listing 3 auf Seite 155 findet die richtige Adresse für
jeden Schlüssel C, der mit dem Algorithmus aus Listing 1 auf Seite 151 berechnet wurde.
Dabei wird C höchstens zweimal weitergeleitet.
Beweis zu Theorem 1:
Sei a die Adresse des Servers, der C vom Client empfangen hat, j sei das Expansionslevel
des Servers mit Adresse a und i das Level der Datei, sowie i0 das Level des Clients. Mit
Level(a) wird das Expansionslevel des Servers mit der Adresse a bezeichnet. Wenn gilt: a
= a0 = hj (C), so ist a die richtige Adresse für C und der Algorithmus terminiert. Sonst
sei a00 = hj−1 (C). Nun gibt es zwei Möglichkeiten: (i.) n ≤ a < 2i oder (ii.) a < n oder
a ≥ 2i . Zunächst zu (i.): Dann gilt: j = i. Angenommen a00 6= a (Im Fall a00 = a würde die
Nachricht zu a0 weitergeleitet werden und a0 wäre die richtige Adresse),
⇒ Nachricht wird weitergeleitet an a00 und es gilt: i0 < j − 1 und a00 > a, sowie Level(a00 ) =
j = i und a00 = hLevel(a00 )−1 (C). Nun gilt entweder: a00 = a0 = hi (C) und a00 ist die richtige
Adresse für C oder: a00 < a0 . Dann ist Level(a0 ) = i und a0 ist die richtige Adresse für C.
Somit gibt es in jedem Fall von (i.) höchstens zwei Weiterleitungen.
Nun zu (ii.): Dann gilt: j = i + 1 und a00 ≥ a. Angenommen a00 > a (Im Fall a00 = a würde
die Nachricht zu a0 weitergeleitet werden und a0 wäre die richtige Adresse),
⇒ Nachricht wird weitergeleitet an a00 und Level(a00 ) = i oder Level(a00 ) = i + 1. Im Fall
Level(a00 ) = i + 1 gilt: hLevel(a00 ) (C) = a00 und a00 ist somit die richtige Adresse für C. Sonst
gilt: a00 = hLevel(j)−1 (C). Sei nun a0 = a00 , ⇒ a00 ist die Adresse für C. Ansonsten gilt: a0 > a00
und a0 ≥ 2i , ⇒ Level(a0 ) = i + 1 und a0 ist die richtige Adresse für C. Somit gibt es auch
in Fall (ii.) höchstens zwei Weiterleitungen.
Der Algorithmus aus Listing 3 auf Seite 155 verwendet diese Beweisführung zur Berechnung von a00 , bzw. a0 . Darüber hinaus gibt es Möglichkeiten, den Algorithmus zu verbessern.
Beispielsweise könnte man die Berechnung von a00 verwenden, um herauszufinden, ob C
schon einmal weitergeleitet wurde. Dadurch könnte man sich die Berechnung von a00 beim
zweiten Empfänger sparen.
2.3 Weitere Eigenschaften des LH*-Schemas
Splitten von Slots
Wie schon weiter oben erwähnt, erfolgt die Expansion genauso wie beim linearen Hashing.
Um das Splitten eines Slots durchzuführen, wird ein Koordinator eingesetzt, der die aktuellen Werte i und p der LH*-Datei verwaltet und ändert. Das Splitten kann wieder kontrolliert (z.B. abhängig von der Auslastung) oder unkontrolliert (z.B. bei jeder Kollision)
Skalierbare verteilte Hashingverfahren mit Mirroring
157
durchgeführt werden. Jeder Slot, der ein Splitten auslöst, schickt eine Nachricht an diesen
Koordinator. Dieser schickt die Nachricht weiter an den Slot, auf den p gerade zeigt und
aktualisiert seine Werte nach demselben Schema wie beim Linearen Hashing. Der Server,
der die Nachricht zum Splitten erhält (mit Expansionslevel i), führt folgende Schritte durch
[Lit93]:
(a) Erstellen des neuen Slots mit der Adresse p + 2i mit Expansionslevel i + 1.
(b) Splitten der enthaltenen Werte mit der Funktion hi+1 auf den eigenen und den neuen
Slot.
(c) Sein eigenes Expansionslevel um einen erhöhen.
(d) Den Koordinator benachrichtigen, dass der Split vollzogen wurde.
Durch Schritt (d) wird die Sichtbarkeit der Splits serialisiert. Wenn solche Splits für
Clients sichtbar wären, die falsche Kopien von i und p haben, könnte eine Adresse berechnet
werden, die außerhalb der Datei liegen würde, was die Korrektheit des Algorithmus zum
Anpassen der kopierten Werte (Algorithmus 2 auf Seite 155) beeinträchtigen würde. Weitere
Möglichkeiten existieren, um das Splitten zu variieren [Lit93], beispielsweise ohne einen
Koordinator.
Güte
Die Güte des LH*-Schemas wird durch die Anzahl der Nachrichten, die zum Einfügen, bzw.
Suchen eines Schlüssels erforderlich sind, ermittelt. Beim Suchen sind im besten Fall zwei
Nachrichten nötig (eine zum Senden des zu suchenden Schlüssels und eine zum Empfangen
der Informationen) und im schlechtesten Fall werden noch zwei Nachrichten benötigt, um
die Suchanfrage weiterzuleiten. Beim Einfügen eines Schlüssels sind mindestens eine, wenn
der Client die richtige Adresse berechnet, und höchstens drei Nachrichten, falls die Anfrage
zweimal weitergeleitet wird, nötig. In [Lit93] wurden Simulationen durchgeführt, um zu
evaluieren, wieviele Nachrichten im Schnitt benötigt werden und wie sich die Fehlerrate
verhält. Dabei wurde beobachtet, dass die Nachrichtenzahl steigt, wenn die Kapazität eines
Slots geringer ist und dass die Zahl sich dem Minimum von zwei, bzw. einer Nachricht
annähert. Was ebenfalls beobachtet wurde ist, dass die durchschnittliche Fehlerrate ca.
log2 (k) entspricht, wobei k die Anzahl der Slots darstellt. Darüber hinaus haben aktive
Clients einen deutlichen Vorteil, was die Fehlerrate angeht, als weniger aktive Clients. Dies
ist intuitiv erkennbar, da aktive Clients ihre Kopien seltener anpassen müssen als inaktive
Clients.
Abschließend sei noch zu sagen, dass die Auslastung einer LH*-Datei immer zwischen 65%
und 95% liegt (siehe dazu [Lar80]).
3 Das LH*-Schema mit Mirroring
Für gewisse Anforderungen, z.B. Bank-Applikationen, ist es unerläßlich, dass die gespeicherten Daten immer verfügbar sind. Dies gilt auch für das Speichern mittels Hashing. Das
LH*-Schema - wie es im vorangegangenen Kapitel vorgestellt wurde - garantiert dies jedoch
nicht. Wenn man beispielsweise davon ausgeht, dass die Wahrscheinlichkeit pd , dass ein Slot
verfügbar ist, bei 99% liegt und die Ausfälle der einzelnen Slots unabhängig voneinander
158
Marco Müller
sind, so ist die Wahrscheinlichkeit, dass die gesamte LH*-Datei verfügbar ist bei pF = pN
d ,
mit N = Anzahl Slots in der Datei. Ein Vorteil des LH*-Schemas, die Skalierbarkeit, wird
so abgeschwächt, da bereits ab einer Slotanzahl von 1000 die Wahrscheinlichkeit, dass die
Datei verfügbar ist bei pF = 0,00004 liegt, also bei nahezu 0%. Trotz der Vorteile, die LH*
sonst bietet, ist diese Wahrscheinlichkeit für Applikationen, die mit großen Datenbeständen
arbeiten, nicht tragbar, da sie entweder auf die Skalierbarkeit oder auf die Verfügbarkeit
verzichten müssten.
Mirroring ist ein beliebte Technik, um eine hohe Verfügbarkeit zu erreichen, und findet schon
in unterschiedlichen Bereichen Anwendung. Schon unter der Annahme, dass es zwei Slots
gibt, die dieselbe Information tragen, vergrößert sich die Wahrscheinlichkeit für die Verfügbarkeit enorm. So ist die Wahrscheinlichkeit für einen Slot pc = (1−(1−pd )2 ) = 0,9999. Für
1000 Slots ergibt sich für die Datei eine Wahrscheinlichkeit von pF = (1−(1−pd )2 )N = 91%.
Das ist wesentlich besser als ohne Mirroring und für die oben erwähnten Applikationen tragbar. Natürlich muss dafür gesorgt werden, dass die Vorteile des LH*-Schemas nicht verloren
gehen. Eine Möglichkeit wäre, das Mirroring auf der Ebene der Server durchzuführen und
jeden Server zu spiegeln. Dadurch würde keine Anpassung des LH*-Schemas notwendig werden, da es für jeden Key weiterhin eine Adresse zum Speichern gibt. Allerdings sind solche
komplizierten Server sehr teuer im Vergleich zu den konventionellen Servern, die zahlreich
produziert werden. Außerdem sind sie nicht gegen unvorhergesehene Ereignisse wie Stromausfälle oder Brände gesichert. Eine weitere Möglichkeit ist, das Mirroring auf der Ebene
des LH*-Schemas durchzuführen. Dann müssen Anpassungen vorgenommen werden, z.B.
müssen alle Kopien eines Slots verschiedene Adressen haben und diese müssen anderen
Komponenten sichtbar sein. Dadurch lassen sich die oben genannten Nachteile von Mirroring auf Server-Ebene lösen.
Das LH*-Schema, wie es in Kapitel 2 vorgestellt wurde, soll in diesem Kapitel um Mirroring
erweitert werden, um eine größtmögliche Verfügbarkeit zu garantieren. Dabei sind folgende
Eigenschaften wünschenswert [Lit96]:
1.
2.
3.
4.
5.
Verfügbarkeit aller Daten trotz des Ausfalls eines Knotens
Verfügbarkeit aller Daten in den meisten Fällen bei Ausfällen mehrerer Knoten
Verfügbarkeit der meisten Daten bei Ausfällen eines Knotens in jedem Mirror
Balancierte Auslastung nach Ausfällen
Effiziente Wiederherstellung nach Ausfällen
Es werden zwei verschiedene Arten von Schemata, die LH* um Mirroring erweitern, vorgestellt. In Kapitel 3.2 wird der Structurally-Alike Mirror (SA-Mirror) vorgestellt und in
Kapitel 3.3 die beiden Arten des Structurally-Dissimilar Mirror (SD-Mirror), der looselycoupled SD-Mirror und der minimally coupled SD-Mirror. In Abbildung 2 werden diese
schematisch dargestellt. Der nächste Abschnitt beschäftigt sich mit allgemeinen Eigenschaften, die ein LH*-Schema mit Mirroring haben muss.
3.1 Allgemeine Eigenschaften von LH* mit Mirroring
Zunächst sei festgelegt, dass es zwei LH*-Dateien gibt, im weiteren F1 und F2 genannt,
die als Mirror bezeichnet werden. Sie sind gespiegelt, jede Änderung an der einen Datei
wird sofort an der anderen durchgeführt. Beide Dateien haben gleich viele Slots und einen
LH*-Koordinator (vgl. Abschnitt 2.3), der das Splitten durchführt.
Skalierbare verteilte Hashingverfahren mit Mirroring
159
Abb. 2. Die verschiedenen Typen der LH*-Mirror: (a) SA-Mirror, (b) loosely-coupled SD-Mirror, (c) minimally coupled SD-Mirror
Jeder Server und jeder Client ist in der Lage, die Slots selbstständig zu lokalisieren, um die
Kopie zu finden, falls ein Slot nicht verfügbar ist. Dabei müssen die beiden Dateien nicht
gleich aufgebaut sein. Im Allgemeinen gilt für einen Schlüssel c, der in Datei F1 in Slot d
gespeichert ist und in Datei F2 in Slot d0 , dass d 6= d0 ist. Es werden also nicht dieselben
Hashfunktionen genutzt, aber der Aufbau beider Dateien ist sowohl für die Server, als auch
für die Clients transparent.
Jeder Mirror hat seine eigenen Clients und jeder Client hat einen primären Mirror, auf den
er immer zugreift. Zugriffe auf den jeweils anderen Mirror, den sekundären Mirror, werden
nur im Ausnahmefall realisiert. Dies geschieht sobald der Slot des primären Mirrors ausfällt.
Ein Client, der den Mirror F1 als primären hat, wird auch F1 -Client genannt.
Sollte ein Server ausfallen und somit ein Slot nicht verfügbar sein, so muss dieser wiederhergestellt werden, sobald er wieder verfügbar ist. Dazu wird dem LH*-Koordinator eine
Funktion hinzugefügt, die das Wiederherstellen übernimmt. Für die Wiederherstellung gibt
es zwei Ansätze [Lit96]:
• Die Wiederherstellung wird solange verzögert, bis der nicht verfügbare Slot wieder verfügbar ist. In dieser Zeit wird eine Kopie aller Schlüssel, die in diesem Slot eingefügt
werden sollen, angelegt.
• Ein neuer Slot, auch Spare genannt, wird sofort angelegt.
Durch den Spare wird eine höhere Verfügbarkeit erreicht, allerdings benötigt man auch
mehr Speicher. Dies könnte in manchen Applikationen zu Problemen führen. Im weiteren
Verlauf wird die interessantere Möglichkeit mit den Spares näher untersucht.
160
Marco Müller
3.2 Besonderheiten des SA-Mirrors
Beim SA-Mirror (Structurally-Alike Mirror ) sind beide Mirrors strukturell gleich. Sie haben dieselbe Slotgröße, verwenden ähnliche Hashfunktionen und dieselben Verfahren, um die
Auslastung zu kontrollieren. Änderungen an einem Mirror werden dem anderen so schnell
wie möglich mitgeteilt. Dies übernimmt der Server mit der richtigen Adresse für die gesendete Anfrage. Den zu einem Slot korrespondierenden Slot des anderen Mirror nennt man
Buddy. Das führt dazu, dass ein Schlüssel in beiden Mirrors in den Slot mit derselben Nummer gespeichert wird. Dies unterscheidet sich von der ursprünglichen Annahme. Dadurch
wird die Weiterleitung von Anfragen durch die Clients über die Mirrors vereinfacht und ist
effizienter, da ein Server eine Anfrage an seinen Buddy typischerweise ohne Fehler bei der
Adressierung, bzw. Weiterleitung an einen anderen Server durchführen kann.
Weiterhin werden Splits nach derselben Abfolge von Anfragen durchgeführt, egal ob sie
von einem F1 -Client oder einem F2 -Client vorgenommen wurden. Dabei werden benötigte
Splits unabhängig von dem jeweils anderen Mirror entdeckt und durchgeführt. Ein Server,
der einen Split entdeckt, leitet die Anfrage an seinen Buddy weiter und leitet den Split
ein, unabhängig von den Aktionen, die sein Buddy veranlasst. Dieser wird typischerweise
seinerseits einen Split einleiten. Durch Fehler bei der Propagierung der Anfrage oder durch
verschiedene Splitzeiten kann es vorkommen, dass ein Slot in einem Mirror existiert, der
im anderen Mirror noch nicht existiert. Durch diese Asynchronizität könnte ein Client eine
Anfrage an einen Server stellen, dessen Slot noch nicht existiert. Dies kann dadurch geschehen, dass ein Client eine IAM von einem Server bekommt, der gerade gesplittet hat und
der korresponierende Buddy seinen Split noch nicht vollzogen hat. Wenn der Client nun
eine Anfrage an den anderen Mirror stellt und den Buddy des gerade erzeugten Slots als
Adresse ausmacht, so tritt der oben erwähnte Fall ein. Nun sendet der Client die Anfrage an den Eltern-Server (derjenige, der das Splitten veranlassen müsste). Dieser wiederum
sendet die Anfrage an den eigentlichen Server, sobald dessen Slot erzeugt wurde. Sollte der
Eltern-Server nicht verfügbar sein, so wird der Koordinator informiert.
Allgemein sieht das Verfahren des Clients folgendermaßen aus: Ein Client berechnet die
Adresse für den Server, der seine Anfrage bearbeiten soll, nach dem LH*-Schema (vgl. Kapitel 2) und schickt diese dann an diesen Server, beispielsweise Adresse a. Wenn es sich
um einen F1 -Client handelt, wird dieser Server zur F1 -Datei gehören. Existiert der Slot
von Adresse a nicht, so wird die Anfrage an den Eltern-Server gesendet. Sollte der Client
erfahren, dass a nicht verfügbar ist, so wird die Anfrage an den Buddy a0 gesendet. Dieser
verarbeitet die Anfrage dann. Solange der Client keine Benachrichtigung bekommt, dass a
wieder verfügbar ist, wird er nun immer a0 benachrichtigen, anstelle von a, sofern er diese
Adresse berechnet. Bekommt er eine Mitteilung, dass a wieder verfügbar ist, aktualisiert er
seine Zuordnungstabelle.
Wie schon beim LH*-Schema erwähnt, kann der Client einen Fehler bei der Adressierung
begehen. Dann wird die Anfrage weitergeleitet. Bei einem SA-Mirror gibt es zusätzlich zu
den Möglichkeiten des LH*-Schemas, wie eine Anfrage propagiert wird, weitere Möglichkeiten, da die Anfrage zwischen den beiden Mirrors propagiert werden kann. Jeder Server
- nehmen wir an, er gehört zu einer F1 -Datei und hat die Adresse a1 - der eine Anfrage
empfängt, überprüft zunächst, ob der Client ein F1 -Client, also ein primärer Client ist. Ist
dem so, wird weiter verfahren wie beim LH*-Schema und die Anfrage wird gegebenenfalls
an weitere Server innerhalb der F1 -Datei weiter propagiert. Zusätzlich propagiert der Server
mit der richtigen Adresse die Nachricht an seinen Buddy weiter, sofern es sich bei der An-
Skalierbare verteilte Hashingverfahren mit Mirroring
161
frage um ein Update handelt. Ist der Client ein sekundärer Client, so überprüft der Server
zunächst, ob sein Buddy a01 verfügbar ist. Ist dieser verfügbar, versucht a1 , die Anfrage an
a01 weiterzuleiten. Dann übernimmt a01 die Bearbeitung der Anfrage. In jedem Fall wird
eine IAM an den Client geschickt, mit der Information, dass a01 wieder verfügbar ist, da
dies ja ein primärer Server für den Client ist. Diese IAM kann mit einer anderen IAM
kombiniert werden, beispielsweise wenn die Anfrage an einen weiteren Server weitergeleitet
würde. Sollte das Senden von a1 an a01 fehlschlagen, informiert a1 den Koordinator. Ist a01
die richtige Adresse, antwortet der Server auf die Anfrage, ansonsten leitet er die Anfrage
an einen anderen Server a2 ∈ F1 weiter. Dieser verfährt genauso wie a1 . Er überprüft, ob
er der richtige Empfänger ist und handelt dementsprechend. Sollte a2 nicht verfügbar sein,
wird die Anfrage an a02 gesendet und dieser handelt wie oben beschrieben. Sollte die Anfrage
weder von a2 noch von a02 beantwortet werden können, so wird noch einmal weitergeleitet.
Dann ist in jedem Fall die richtige Adresse gefunden (siehe dazu auch Theorem 1 auf Seite
156).
Der Koordinator, der hier auch als Wiederherstellungs-Manager fungiert, kann ebenfalls
entdecken, dass ein Server nicht verfügbar ist, wenn er einen Split veranlassen möchte. In
diesem Fall veranlasst der Koordinator das Erzeugen eines Spares. Dieser Thematik widmet
sich der nächste Abschnitt.
Erzeugen eines Spares
Ein Spare wird immer dann erzeugt, wenn ein Server nicht verfügbar ist und auf diesen
zugegriffen werden soll. Angenommen der Server mit der Adresse f ist nicht mehr verfügbar. Es muss zunächst Speicherplatz für den Spare allokiert werden. Dazu wird zunächst
ein Knoten s für den Spare gesucht. So ein Knoten besteht überlicherweise aus mehreren
Servern. Dann wird eine Tabelle angelegt, in der gespeichert wird, welche Adresse zu welchem Server gehört. Nun wird in dieser Tabelle eingetragen, dass Anfragen, die eigentlich
für f bestimmt sind, nun an den Spare in Knoten s gesendet werden. Der Spare nimmt nun
die Rolle von Server f ein und empfängt alle Anfragen, die eigentlich für f vorgesehen sind.
Die Werte, die bisher in f gespeichert waren, werden vom Buddy von f gesendet. Da das
Erzeugen eines Spares im SD-Mirror genauso verläuft, wird es hier nicht weiter beleuchtet,
sondern findet in Abschnitt 3.3 statt. Sollte der Server mit der Adresse f wieder verfügbar
sein, bevor alle Clients ihre Anfragen für f schon automatisch zum Spare umleiten, wird
eine Anfrage für den „alten“ Speicherort von f vom Knoten, der diesen Speicherort beinhaltet zum Spare umgeleitet und eine IAM wird an den Client zurückgesendet, in der dann
die „neue“ Adresse für Server f enthalten ist. So wird dann nach und nach für jeden Client
die logische Adresse f auf die tatsächliche Speicheradresse vom Spare angepasst und der
vorherige Speicherplatz für f kann neu vergeben werden.
Güte
Typisch für Verfahren, die Mirroring nutzen, ist, dass doppelt soviel Speicherplatz erforderlich ist wie bei einem Verfahren ohne Mirroring. Gibt es keine Fehler, weil ein Slot nicht
verfügbar ist, so ändert sich die Anzahl Nachrichten, die verschickt werden, minimal. Für
eine Suche bleibt sie genauso wie beim LH*, für das Einfügen wird eine zusätzlich Nachricht für die Benachrichtigung des Buddys benötigt. Das Splitten eines Slots kostet doppelt
162
Marco Müller
soviele Nachrichten, da es zwei identische LH*-Dateien gibt.
Sollten Fehler, aufgrund von ausgefallenen Servern auftreten, so erhöht sich die Anzahl der
Nachrichten bei jedem Versuch, einen ausgefallen Server zu erreichen, um zwei.
Um einen Spare zu erzeugen, werden typischerweise zwei zusätzliche Nachrichten gebraucht,
gemäß dem Fall, die zu kopierenden Werte können in einer Nachricht gesendet werden. Für
einen Verlust von Daten aufgrund des Ausfalls von einem Server in jedem Mirror ergibt
sich eine Wahrscheinlichkeit von (1 − pd )2 . Falls dies auftritt, würden die Kosten für den
Verlust durchschnittlich 0,7 * b Werten betragen, wobei b der Slotgröße entspricht.
3.3 Besonderheiten des SD-Mirrors
Die beiden SD-Mirrors (Structurally-Dissimilar Mirror ) haben im Allgemeinen unterschiedliche Eigenschaften, beispielsweise unterschiedliche Slotgrößen oder andere Verfahren um
die Auslastung zu kontrollieren. Die Hashfunktionen, die gewählt werden, müssen sich nicht
ähneln, auch wenn dies das Erzeugen eines Spares vereinfachen würde. Der Vorteil des SDMirrors im Vergleich zum SA-Mirror liegt in der Allgemeingültigkeit, man kann z.B. die
Mirrors auf heterogenen Systemen speichern mit unterschiedlichen Speichergrößen.
Der Hauptunterschied zwischen dem SA-Mirror und dem SD-Mirror ist jedoch, dass sich
ein Slot hinsichtlich des SD-Mirrors ebenso verhält wie ein Client, also eine Kopie der beiden Werten i und p einer LH*-Datei hat und IAM s empfängt.
Beim SD-Mirror unterscheidet man zwischen zwei verschiedenen Arten. Diejenigen, die
dieselben Hashfunktionen verwenden und Änderungen sofort dem jeweils anderen Mirror
mitteilen, werden loosely-coupled SD-Mirror genannt. Diejenigen, die keine Voraussetzungen an die Eigenschaften der Mirrors stellen, werden auch minimally coupled SD-Mirror
genannt. Wie man in Abbildung 2 auf Seite 159 sieht, liegt der Vorteil des loosely-coupled
SD-Mirrors darin, dass die Wiederherstellung effizienter geschieht, da die einzelnen Werte
nicht so über den zweiten Mirror verteilt sind wie beim minimally coupled SD-Mirror. In
den letzten beiden Abschnitten wird näher auf diese beiden Arten eingegangen.
Loosely-coupled SD-Mirror
Auf der Seite des Clients gibt es im Gegensatz zum SA-Mirror nur einen Unterschied: der
Client hat für jeden Mirror eine Kopie von i und p, also typischerweise zwei Kopien. Jede
Kopie wird aktualisiert, wenn sie zur Berechnung einer Adresse genutzt wird. Typischerweise
nutzt ein Client eine Kopie wesentlich häufiger, nämlich die seiner primären Datei. Dies führt
dazu, dass die andere Kopie sehr häufig falsche Berechnungen liefert und es somit häufig
zu Fehlern kommt, wenn ein Server der primären Datei ausfällt. Dieses Problem hat ein
SA-Mirror nicht, was sich positiv auf dessen Zugriffszeit auswirkt. Die Rolle der Server ist
ebenfalls ein wenig anders. Da es keine Buddys gibt, wird in jedem Schritt die Berechnung
der Adresse durchgeführt, so wie sie bei LH* vorgestellt wurde. Dementsprechend wird eine
Anfrage an den anderen Mirror geschickt, wenn der korrekte Server gefunden wurde. Splits
sind genau wie beim SA-Mirror asynchron.
Erzeugen eines Spares
Angenommen, es fällt der Slot mit der Adresse n1 in Mirror F1 aus und sein Expansionslevel
ist j1 . Um den Spare effizient erzeugen zu können, müssen im Mirror F2 die Slots, in
Skalierbare verteilte Hashingverfahren mit Mirroring
163
denen die Werte für n1 gespeichert sind, gefunden werden. Da beide Mirrors dieselben
Hashfunktionen benutzen, gibt es zwei Möglichkeiten:
1. Die gesuchten Werte befinden sich alle in einem Slot. Dann existiert entweder noch kein
Slot, für den gilt n1 = n2 oder das Expansionslevel j2 von n2 ist kleiner als j1 und
enthält dann möglicherweise mehr Werte als n1 .
2. Die gesuchten Werte sind über mehrere Slots verstreut, das bedeutet, dass j2 > j1 gilt.
Um den 1. Fall abzudecken, kann folgende Formel genutzt werden, um den gesuchten
Slot n2 zu finden:
(n2 = n1 ) ∨ (n2 = n2,1 = n1 − 2j1 −1 ) ∨ (n2 = n2,1,1 = n2,1 − 2j1 −2 ) ∨ ...(n2 = 0)
Für den 2. Fall müssen mehrere Slots durchsucht werden. Dazu muss n1 selber sowie alle
Slots im Teilbaum durchsucht werden. m bezeichnet hier alle Slots, die durchsucht werden
müssen. Folgende Formel drückt dies aus:
(m = n1 ) ∨ (m = n1,1 = n1 + 2j1 −1 ) ∨ (m = n1,2 = n1 + 2j1 ) ∨ ...(m = n1 + 2j2 −1 )∨
(m = n1,1,1 = n1,1 + 2j1 ) ∨ (m = n1,1,2 = n1,1 + 2j1 +1 )∨ (m = n1,1,1,1 = n1,1,1 + 2j1 +1 )....
Typischerweise tritt Fall 1 ein, wenn die Slotgröße b2 von F2 größer ist als die von F1
(b1 ). Der 2. Fall tritt ein, falls b1 > b2 gilt. Für b1 = b2 handelt es sich um einen SA-Mirror.
Die durchschnittliche Anzahl r1 der Slots, die in F2 durchsucht werden müssen, um einen
Spare in F1 zu erzeugen, ist dabei (vergleiche dazu auch Bild (b.) in Abbildung 2 auf Seite
159):
r1 = M ax[1, bb21 ]
Güte
Die Kosten zum Suchen und Einfügen von Schlüsseln, unter der Annahme, dass es keine
Ausfälle gibt, ist genauso wie beim SA-Mirror. Die Kosten zum Splitten erhöhen sich in
F2 um (1 + r1 ), im Vergleich zu den Split-Kosten von F1 . Die Kosten, wenn Serverausfälle
geschehen, sind höher als beim SA-Mirror. Wenn eine Propagierung im SA-Mirror eine
Nachricht benötigt, so werden im loosely-coupled SD-Mirror bei einem gleichen F1 bis zu
zwei Nachrichten mehr benötigt. Die exakten Werte müssen noch gefunden werden.
Das Erzeugen eines Spares kostet (1 + 2 ∗ r1 ) Nachrichten, unter der Annahme, dass jeweils
eine Nachricht zum Allokieren eines Slots und zum Senden der Werte eines Slots ausreichen.
Die Wahrscheinlichkeit für einen Ausfall eines Servers in jedem Mirror ist M in[N11 ,N2 ]2 , ist
also sehr gut skalierbar. Falls dies auftritt, würden die Ausfallkosten im Durchschnitt 0,7
* M in[b1 , b2 ] betragen, was um r1 weniger ist als beim SA-Mirror. Somit würden weniger
Werte ausfallen, als beim SA-Mirror
Minimally coupled SD-Mirror
Die Funktionsweise der Clients und der Server sind genauso wie beim loosely-coupled SDMirror, ebenso die Berechnung der Adressen. Das Verfahren zur Erzeugung des Spare ist
164
Marco Müller
allerdings anders, da die Werte, die in den Spare kopiert werden müssen, auf dem Mirror
verteilt sind. Somit müssen alle Server bzw. Slots durchgegangen werden, um alle Werte
zu bekommen. Dadurch erhöhen sich die Kosten für das Wiederherstellen. Die Wahrscheinlichkeit, dass bei einem Ausfall eines Slots und seines korrespondierenden Slots im anderen
Mirror einige Werte nicht mehr verfügbar sind, ist größer als bei den anderen Verfahren,
nahezu 1 bei großen Slots. Dafür fehlen weniger Werte und der Speicherbedarf ist gering.
Uniformes Hashing vorausgesetzt, ist die Anzahl der fehlenden Werte approximiert 0,7 *
b1
M ax[ M
, b2 ], wobei gilt: M = 2i−1 und i ist das Level des jeweiligen Mirror.
2 M1
4 Fazit
Die hier vorgestellten Schemata eignen sich alle, um Hashing bei einer guten Skalierbarkeit auf verteilten Systemen anzuwenden. Die drei Schemata, die LH* noch um Mirroring
erweitern, erhöhen zudem die Verfügbarkeit der gespeicherten Werte. Sie brauchen zwar wesentlich mehr Speicherplatz als das zugrundeliegende LH*-Schema, allerdings verliert dieser
Faktor immer mehr an Bedeutung, da der Preis für Speicher mit jedem Jahr fällt. Im Gegensatz dazu erreichen sie weiterhin eine sehr gute Zugriffszeit, die nahe am Optimum liegt.
Die einzelnen Unterschiede der drei Verfahren sind in den Anforderungen, die man an die
Schemata stellt, begründet. Es lassen sich nicht alle Anforderungen zusammen umsetzen
und jedes Schema setzt andere Anforderungen um. Der SA-Mirror beispielsweise kommt
mit weniger Nachrichten bei der Wiederherstellung von ausgefallenen Servern aus, hat aber
eine größere Ausfallrate wie der loosely-coupled SD-Mirror.
Für zukünftige Arbeiten ist eine detailliertere Analyse der Kosten der hier vorgestellten
Schemata wünschenswert, um einen besseren Vergleich machen zu können. Ebenfalls könnte
man sich weitere Varianten vorstellen, die beispielsweise ohne einen Koordinator auskommen, oder die Technik der Spares verfeinern oder austauschen. Ein weiterer Ansatz wäre
die Verwendung von mehr als zwei Mirrors, wie es hier die Fall ist, um evtl. eine höhere
Verfügbarkeit zu erreichen.
Literaturverzeichnis
Com77. D. Comer & R. Sethi (1977) The complexity of trie index construction, Journal of the ACM, Vol.
24, P. 428-440
Enb88. R. J. Enbody & H. C. Du (1988) Dynamic Hashing Schemes, ACM Computer Surveys, Vol. 20, Nr.
2, P. 85-113
Lar80. P.A.Larson (1980) Linear Hashing with partial expansions, ACM Transactions on Database Systems,
Vol. 7, No. 4, P. 566-587
Lit80. W. Litwin (1980) Linear Hashing : A new tool for file and table adressing, Sixth International
Conference on Very Large Data Bases, P. 212-223
Lit93. W. Litwin & M.-A. Neimat & D.A. Schneider (1993) LH* - Linear Hashing for Distributed Files,
Proceedings of the 1993 ACM SIGMOD international conference on Management of data, P. 327-336
Lit96. W. Litwin & M.-A. Neimat (1996) High-Availability LH* Schemes with Mirroring, Proceedings of
the First IFCIS International Conference on Cooperative Information Systems, P. 196-207
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten
Wegen in 2D-Umgebungen
Benjamin Eikel
Universität Paderborn, [email protected]
Zusammenfassung. Das vorgestellte Verfahren berechnet einen kürzesten Weg in einer zweidimensionalen
Umgebung zwischen einem Start- und einem Zielpunkt. Hierbei umgeht es Hindernisse in der Umgebung,
die beliebig geformt sein können. Die Berechnung ist schneller als die bei Gitter-basierten Verfahren, aber
mindestens so genau. Wenn ein kürzester Weg existiert, wird er im Gegensatz zu anderen Quadtree-basierten
Verfahren von diesem Verfahren gefunden, auch wenn die Platzierung der Hindernisse ungünstig ist. Es wird
eine neue Datenstruktur, der Framed-Quadtree, vorgestellt, die eine erweiterte Form eines Quadtrees ist.
Diese sorgt für die hohe Effizienz und Genauigkeit des Verfahrens.
Schlüsselwörter: Quadtree, kürzester Weg, Wegeberechnung, Roboter
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
1.2 Bisherige Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
2
Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
2.1
2.2
2.3
2.4
Datenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Wellenausbreitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Ablaufplanung für Eintrittspunkte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Bestimmung des kürzesten Weges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
3
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
3.1 Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
3.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
1 Einleitung
1.1 Motivation
Der hier behandelte Algorithmus findet einen kürzesten Weg in einer bekannten, zweidimensionalen Umgebung, der an Hindernissen vorbeiführen muss. Solche Wege sind interessant
für die Wegeplanung von Robotern, für GPS-gestützte Navigationssysteme und den Entwurf von integrierten Schaltkreisen. Diese Seminararbeit basiert auf dem Artikel von Chen,
Szczerba und Uhran, Jr. [1].
166
Benjamin Eikel
1.2 Bisherige Verfahren
Dieses Verfahrens vereint die Vorteile von früheren Verfahren, die als Datenstruktur Gitter
oder Quadtrees benutzen.
Verfahren mit quadratischen Gitterzellen finden kürzeste Pfade. Allerdings sind sie ineffizient, wenn es große Regionen ohne Hindernisse gibt, da alle Zellen in diesen Regionen
betrachtet werden müssen.
Verfahren, die Quadtrees benutzen, sind allgemein effizienter als Gitter-basierte Verfahren. Dies liegt an der Eigenschaft des Quadtrees, große Regionen nicht zwangsläufig weiter
unterteilen zu müssen, wie dies beim Gitter geschieht. Solche Verfahren finden aber nicht
immer den kürzesten Weg. Wenn ein Hindernis genau auf den Grenzen zweier Quadranten
eines Quadtrees wie in Abbildung 1 liegt, liefern die Verfahren keinen optimalen Weg. Eine
Verschiebung des Quadtrees funktioniert zwar für ein Hindernis, bei mehreren Hindernissen
kann dies aber dazu führen, dass nach der Verschiebung ein anderes Hindernis auf einer
Grenze liegt. Außerdem ist der Aufwand für die Neuberechnung des Quadtrees hoch.
Abb. 1. Beispiel, bei dem ein Verfahren mit einem Quadtree nicht den kürzesten Weg findet. Pfad A (rot)
ist der von dem Verfahren gefundene Weg, Pfad B (blau) ist der kürzeste Weg. Die Zahl in einer Zelle des
Quadtrees sind die Kosten, um von dieser Zelle zum Ziel zu gelangen.
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
167
2 Algorithmus
Das im Folgenden vorgestellte Verfahren erhält als Eingabe eine Umgebung mit Hindernissen. Die Hindernisse können beliebig beschrieben sein (Vielecke, Gitterzellen oder mathematische Funktionen). Aus der Umgebung wird die in Abschnitt 2.1 vorgestellte Datenstruktur
erstellt. Hierfür muss lediglich geprüft werden, ob ein Teil eines Hindernisses in einem Quadrat liegt, was durch Schnittberechnungen erfolgen kann.
2.1 Datenstruktur
Wegen der genannten Nachteile der bisherigen Verfahren wird hier eine neue Datenstruktur vorgestellt. Diese Datenstruktur heißt Framed-Quadtree und ist eine Erweiterung des
Quadtrees. In einem Quadtree repräsentiert ein Knoten einen quadratischen, zweidimensionalen Bereich. Im Framed-Quadtree gibt es drei verschiedene Arten von Knoten. Freie
Knoten stehen für einen Bereich, in dem sich keine Hindernisse befinden. Bereiche, in denen
sich Hindernisse befinden, werden durch Hindernis-Knoten modelliert. Diese beiden Knotenarten sind Blätter des Framed-Quadtrees. Die dritte Knotenart, der Mischknoten, ist
ein innerer Knoten des Framed-Quadtrees und beinhaltet vier Kindknoten. Er repräsentiert
Bereiche, die sowohl frei als auch durch Hindernisse blockiert sind. Die Bereiche werden
solange weiter unterteilt, bis ein Knoten entweder nur aus freien oder blockierten Bereichen
besteht und dann zur ersten oder zweiten Knotenart gehört, oder der Knoten die kleinste erlaubte Größe (Auflösung) erreicht hat, aber noch Teile des Hindernisses enthält. Im
letzten Fall wird der Knoten als Hindernis markiert. Falls es sich anstatt um einen Punktroboter um einen Roboter mit Ausdehnung handelt, sollte die Auflösung so gewählt werden,
dass sich der Roboter durch die kleinstmöglichen Bereiche bewegen kann. Also sollte die
kleinstmögliche Größe mindestens so groß wie die Ausdehnung des Roboters sein.
Die Blattknoten des Framed-Quadtrees erhalten zusätzlich einen Rahmen aus quadratischen Zellen. Diese Zellen haben die kleinste erlaubte Größe (Auflösung). Der Sinn dieser
Rahmenzellen liegt in der möglichen Durchquerung des Quadranten durch den Roboter.
Wenn der Roboter einen freien Quadranten durchqueren soll, sind nur der Eintrittspunkt
und Austrittspunkt dieses Quadranten wichtig. Beide müssen auf dem Rand des Quadranten
liegen. Ein Pfad durch den Quadranten kann also festgelegt werden, indem eine Rahmenzelle als Eintrittspunkt und eine als Austrittspunkt bestimmt wird. Abbildung 2 zeigt einen
Framed-Quadtree in graphischer Darstellung und als Baum.
Bei der Berechnung des kürzesten Weges in einem Framed-Quadtree muss erwähnt werden, dass dieser nur aus stückweise kürzesten Wegen zusammengesetzt ist. Der Weg durch
einen Quadranten ist wirklich ein kürzester Weg. Allerdings kann ein Roboter beim Übergang von einer Rahmenzelle eines Quadranten in eine Rahmenzelle eines benachbarten Quadranten in nur acht Richtungen gehen, da eine Rahmenzellen höchstens so viele benachbarte
Rahmenzellen haben kann. Der größte Teil des Weges führt allerdings durch freie Quadranten, so dass dieses Problem nicht allzu stark ins Gewicht fällt. Weiterhin kann ein nahezu
kürzester Weg berechnet werden, indem der gefundene Weg geglättet wird.
2.2 Wellenausbreitung
Zur Berechnung des kürzesten Weges wird ein Verfahren angewandt, das eine Welle beginnend bei der Anfangsposition des Roboters aussendet. Diese Welle weist jeder freien Zelle
168
Benjamin Eikel
Abb. 2. Die Beispielsumgebung oben links wird in den Framed-Quadtree oben rechts unterteilt. Die Darstellung als Baum ist im unteren Teil zu sehen. Abbildung übernommen aus [1].
des Framed-Quadtrees ähnlich einer Breitensuche einen Distanzwert zu. Dieser Distanzwert beschreibt die Kosten für den Roboter, diese jeweilige Position vom Startpunkt aus zu
erreichen. Es wird die L2 -Metrik verwendet. Die Lp -Metrik ist definiert als
q
distp (a, b) := p |ax − bx |p + |ay − by |p
[2].
Die L2 -Metrik beschreibt im zweidimensionalen Raum R2 also die bekannte Distanz zwischen zwei Punkten a, b ∈ R2 mit
q
.
dist2 (a, b) = (ax − bx )2 + (ay − by )2
Innerhalb eines Quadranten des Framed-Quadtrees breitet sich die Welle von Rahmenzelle zu Rahmenzelle aus. Hierbei kann die Ausbreitung von einer Rahmenzelle zu einer
Rahmenzelle innerhalb desselben Quadranten oder zu einem benachbarten Quadranten erfolgen. Eine Rahmenzelle, die durch eine Rahmenzelle eines benachbarten Quadranten erreicht wird, heißt Eintrittspunkt. Die Wellenausbreitung kann einen Quadranten mehrfach
erreichen und daher kann es mehrere Eintrittspunkte geben. Die maximale Anzahl an Eintrittspunkten ist die Anzahl an Rahmenzellen eines Quadranten.
Die Wellenausbreitung erfolgt nun rundenweise. Eine WFT (wave frontier table) beinhaltet die aktuell durch die Welle erreichten Quadranten, deren Rahmenzellen noch nicht
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
169
vollständig abgearbeitet worden sind. Zu Beginn beinhaltet diese Tabelle nur den Quadranten mit der Anfangsposition des Roboters. In jeder Runde wird die Welle nun in benachbarte
Quadranten ausgebreitet, welche bei Erreichen zu der Tabelle hinzugefügt werden.
Weiterhin wird eine Kontrollvariable wellenwert benutzt, die in jeder Runde um eins
erhöht wird. In der i-ten Runde ist der Wert also i. Während einer Iteration i breitet
sich die Welle in alle Rahmenzellen aller Quadranten aus der WFT aus, zu denen der
kürzeste Weg von der Anfangsposition des Roboters bis zu dieser Rahmenzelle eine Distanz
d mit i − 1 < d ≤ i hat. In jeder Runde werden die Eintrittspunkte der Quadranten
aus der WFT betrachtet und die Welle von dort in diesen Quadranten oder benachbarte
Quadranten ausgebreitet. Wenn alle Rahmenzellen eines Quadranten und alle benachbarten
Rahmenzellen einen Distanzwert erhalten haben, dann wird der Quadrant aus der WFT
entfernt.
Für die Terminierung gibt es zwei Möglichkeiten. Entweder erreicht die Ausbreitung
der Welle den Quadranten, der die Zielposition enthält, oder die WFT ist leer. Wenn die
WFT leer ist und die Welle das Ziel nicht erreicht hat, dann kann der Roboter von seiner
Anfangsposition die Zielposition nicht erreichen.
2.3 Ablaufplanung für Eintrittspunkte
Sei n die Seitenlänge eines Quadranten gemessen in der Anzahl der Rahmenzellen. Bei
einem Gitter-basiertem Verfahren bestünde ein Quadrant aus n × n Zellen und eine Wellenausbreitung in diesem Quadranten benötigte O(n2 ) Schritte. In einem Framed-Quadtree
wird der freie Bereich in der Mitte nicht verwendet und die Welle breitet sich nur über die
Rahmenzellen aus. Ein Quadrant hat 4 · n − 4 = O(n) Rahmenzellen.
Definition 1. Sei RQ die Menge von Rahmenzellen eines Quadranten Q in einem FramedQuadtree. Seien a, b ∈ RQ Eintrittspunkte von Q. Sei dist(y, z) eine Funktion, die einer
Rahmenzelle y ∈ RQ einen Distanzwert zuweist, wenn sich die Welle von Eintrittspunkt
z ∈ RQ ausgebreitet hat. Sei RQ (a) = {y ∈ RQ | dist(y, a) < dist(y, b)}. Dann dominiert
Eintrittspunkt a den Eintrittspunkt b über RQ (a).
RQ (a) ist also eine Menge von Rahmenzellen eines Quadranten Q, zu denen sich die Welle
von Eintrittspunkt a mit einem geringeren Distanzwert ausbreitet hat als von Eintrittspunkt
b aus.
Ein Quadrant kann mehrere Eintrittspunkte enthalten. Von jedem dieser Eintrittspunkte
wird die Welle weiter ausgebreitet. Im schlimmsten Fall können alle Rahmenzellen auch Eintrittspunkte sein. Wenn von jedem dieser Eintrittspunkte aus versucht würde, die Welle zu
allen anderen Eintrittspunkten auszubreiten, führte dies zu einer Laufzeit von O(n2 ). Die im
Folgenden vorgestellte Ablaufplanung sorgt dafür, dass für die Wellenausbreitung in einem
Quadrant eine Laufzeit in O(n) eingehalten wird. Dafür ist die Beobachtung wichtig, dass
einige Eintrittspunkte nicht betrachtet werden müssen, da sie von anderen Eintrittspunkten
dominiert werden.
Wenn während einer Runde mehrere Eintrittspunkte derselben Rahmenzelle einen Distanzwert zuweisen wollen, dann wird der Rahmenzelle der niedrigste Wert zugewiesen.
Bei den zwei kleinstmöglichen Quadranten mit einer Rahmenzelle oder vier Rahmenzellen, bei denen kein freier Bereich in der Mitte existiert, wird die Welle zu allen angrenzenden
170
Benjamin Eikel
Abb. 3. Aufteilung der Rahmenzellen eines Quadranten in vier Seiten.
Rahmenzellen ausgebreitet. Bei diesen Quadranten kann dies in O(1) Zeit durchgeführt werden.
Vorerst wird nur noch der Fall betrachtet, dass Eintrittspunkte an einer Seite eines Quadranten auftreten. Hierfür werden die Rahmenzellen eines Quadranten wie in Abbildung 3
zu sehen aufgeteilt. Wenn eine Ablaufplanung von Eintrittspunkten für eine Seite gelingt,
so kann diese für die anderen drei Seiten benutzt werden, indem der Quadrant um 90°, 180°
und 270° gedreht betrachtet wird.
Definition 2. Sei RQ die Menge von Rahmenzellen einer bestimmten Seite j eines Quadranten Q in einem Framed-Quadtree. Ein Eintrittspunkt a von Q wird blockiert auf Seite
j nach Runde iT genannt, wenn es andere Eintrittspunkte von Q gibt, die a über RQ nach
Runde iT dominieren. Das bedeutet, dass a nach Runde iT weiteren Rahmenzellen auf Seite
j keinen Distanzwert mehr zuweisen kann.
Jeder Eintrittspunkt erhält vier binäre Blockierungsmarkierungen. Diese zeigen an, ob
der Eintrittspunkt für die jeweilige Seite des Quadranten blockiert ist. In jeder Runde i
werden die Eintrittspunkte überprüft, die mindestens für eine Seite nicht blockiert sind
und es wird versucht, den Rahmenzellen auf den nicht blockierten Seite des Quadranten
Distanzwerte von diesen Eintrittspunkten aus zuzuweisen.
Die Eintrittspunkte auf Seite 1 können den Rahmenzellen auf vier Seiten Distanzwerte
zuweisen. Die Ablaufplanung muss vier Fälle unterscheiden, die den vier Seiten entsprechen.
Diese vier Fälle werden im Folgenden einzeln abgehandelt. Hierfür sei Q der betrachtete
Quadrant und i die Runde, in welcher der erste Eintrittspunkt Seite 1 von Q erreicht. Der
Quadrant Q hat also vor Runde i keine Eintrittspunkte. Es wird gezeigt, wie die notwendigen
Datenstrukturen für Runde i aufgebaut werden und wie eine Aktualisierung für die folgenden
Runden erfolgt.
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
171
Seite 1
In Runde i erreichen k ≥ 1 Eintrittspunkte die Seite 1. Diese k Eintrittspunkte werden in
eine Liste eingefügt. In jeder Runde wird diese Liste durchlaufen und die Eintrittspunkte
versuchen, die Welle nach links und nach rechts auszubreiten. Falls beide Seiten des Eintrittspunktes durch kleinere Distanzwerte blockiert sind oder der Rand des Quadranten
erreicht ist, so ist dieser Eintrittspunkt blockiert und wird aus der Liste entfernt. Nach
jeder Runde enthält die Liste dann nur nicht blockierte Eintrittspunkte. Falls in späteren
Runden neue Eintrittspunkte die Seite 1 erreichen, werden sie an den Anfang der Liste eingefügt. Den Rahmenzellen wird nach jeder Runde, wie bereits oben erwähnt, der kleinste
Distanzwert zugewiesen.
Lemma 1. Sei Q ein n × n Quadrant in einem Framed-Quadtree. Die Wellenausbreitung
durch die Eintrittspunkte kann allen Rahmenzellen auf Seite 1 von Q Distanzwerte in Laufzeit O(n) zuweisen. Die Laufzeit ist unabhängig von der Anzahl von Eintrittspunkten.
Beweis. Die Eintrittspunkte auf Seite 1 können die Welle zu höchstens einer Rahmenzelle
auf der rechten und einer auf der linken ausbreiten. Daher kann zu einer Rahmenzelle b auf
Seite 1 die Welle von höchstens zwei Eintrittspunkten ausgebreitet werden. Der Rahmenzelle
wird der niedrigere Distanzwert zugewiesen. In jeder Runde wird die Welle von einem Eintrittspunkt zu mindestens einer der O(n) Rahmenzellen ausgebreitet oder der Eintrittspunkt
wird aus der Liste entfernt. Jeder dieser zwei Fälle benötigt konstante Laufzeit. Da in jeder
Runde mindestens einer Rahmenzelle ein Distanzwert zugewiesen wird, beträgt die Laufzeit
für Seite 1 O(n).
Seite 2
In diesem Fall wird die Wellenausbreitung von Eintrittspunkten auf Seite 1 zu Rahmenzellen
auf Seite 2 betrachtet. Es wird wieder angenommen, dass k ≥ 1 Eintrittspunkte in Runde i
das erste Mal auf Seite 1 auftreten. Die Eintrittspunkte werden in eine Liste eingefügt. Weil
diese Eintrittspunkte in Runde i auftreten, müssen sie einen Distanzwert zwischen i − 1 und
i haben. Welche Rahmenzellen auf Seite 2 von Eintrittspunkten auf Seite 1 Distanzwerte
erhalten, hängt von der Entfernung zwischen den Rahmenzellen und den Eintrittspunkten
ab. Daher wird die Liste mit den k Eintrittspunkten nach x-Koordinate sortiert (Festlegung
der x-Achse in Abbildung 3). Da die Koordinaten ganzzahlige Werte in einem bekannten
Bereich sind, kann eine Sortierung mit dem Bucket-Sort-Algorithmus [3] in linearer Zeit
erfolgen.
Lemma 2. Seien a und b zwei verschiedene Eintrittspunkte auf Seite 1 eines Quadranten Q
in einem Framed-Quadtree. Sei adw der Distanzwert und ax die x-Koordinate von a. Wenn
adw ≤ bdw und ax < bx , dann wird b von a auf Seite 2 dominiert und b muss nicht weiter
betrachtet werden.
Beweis. Sei z eine beliebige Rahmenzelle auf Seite 2, der sowohl a als auch b einen Distanzwert zuweisen wollen. Wenn der Distanzwert von z vom Eintrittspunkt a zugewiesen wird,
dann gilt zdw = adw + dist2 (a, z). Wenn ax < bx gilt, dann gilt auch dist2 (a, z) < dist2 (b, z)
für jede Rahmenzelle z auf Seite 2. Eine Rahmenzelle erhält von den Eintrittspunkten a
und b den kleineren Distanzwert zdw = min {adw + dist2 (a, z), bdw + dist2 (b, z)}. Wenn nun
172
Benjamin Eikel
adw ≤ bdw und ax < bx , dann gibt es keine Rahmenzelle auf Seite 2, die von b einen Distanzwert erhalten kann, der kleiner ist als der von a. Daher dominiert a den Eintrittspunkt
b über alle Rahmenzellen auf Seite 2 und b muss nicht weiter betrachtet werden.
Aus der sortierten Liste mit k Eintrittspunkten können nun die Punkte extrahiert werden,
die nicht wie in Lemma 2 beschrieben nicht weiter betrachtet werden müssen. Diese neue
Liste kann durch eine Variante der „dominating maxima of planar points“ [1] in Zeit O(k) =
O(n) berechnet werden. Die auf Seite 2 nicht blockierten Eintrittspunkte dieser Liste müssen
die Welle nun zu den Rahmenzellen auf Seite 2 ausbreiten. Dies muss erfolgen, ohne dass
jeder Eintrittspunkte eine Ausbreitung zu jeder der Rahmenzellen versucht, da dies zu einer
zu hohen Laufzeit führt. Daher werden hierzu die Voronoi-Domänen auf Seite 2 berechnet.
Definition 3. Die Voronoi-Domäne V Di (a) auf Seite i eines Eintrittspunktes a auf Seite
1 ist ein Bereich von Rahmenzellen auf Seite i, in dem a alle anderen Eintrittspunkte auf
Seite 1 dominiert.
Wenn die Voronoi-Domäne auf Seite 2 eines Eintrittspunktes die leere Menge ∅ ist, dann
ist er blockiert auf Seite 2 und kann aus der Liste der nicht blockierten Eintrittspunkte
entfernt werden. Die nicht blockierten Eintrittspunkte p1 , p2 , . . . , pk0 mit k 0 ≤ k befinden
sich absteigend nach x-Koordinate sortiert in der Liste (p1 x > p2 x > . . . > pk0 x ). p1 ist
der Eintrittspunkt, der am weitesten rechts auf Seite 1 liegt. Die Liste wird nun, beginnend
mit p1 , durchlaufen und die folgenden Datenstrukturen werden für die bisher betrachteten j
Eintrittspunkte p1 , p2 , . . . , pj verwendet, bevor pj+1 betrachtet wird. Erstens die Liste Lj ⊆
{p1 , p2 , . . . , pj }. Sie enthält einen Eintrittspunkt pγ ∈ {p1 , p2 , . . . , pj } genau dann, wenn pγ
nicht von einem Eintrittspunkt aus {p1 , p2 , . . . , pj } dominiert wird auf Seite 2. Zweitens die
Voronoi-Domänen auf Seite 2 der Eintrittspunkte aus Lj . Die Liste wird durchlaufen, bis alle
Voronoi-Domänen der Eintrittspunkte aus Lk0 berechnet wurden. Zu Beginn kann L1 und
V D2 (p1 ) leicht berechnet werden, denn L1 = {p1 } und V D2 (p1 ) enthält alle Rahmenzellen
der Seite 2. Nun sollen die Voronoi-Domänen der Eintrittspunkte in Lj+1 aus denen der
Eintrittspunkte in Lj berechnet werden. Der erste Eintrag in der Liste Lj sei der zuletzt
hinzugefügte Eintrittspunkt pj 0 mit 1 ≤ j 0 ≤ j. Es werden jetzt nur die Voronoi-Domänen
auf Seite 2 der Eintrittspunkte pj+1 und p0j berechnet. Dies geschieht durch Berechnung
der gemeinsamen Grenze zwischen den beiden Voronoi-Domänen. Sei die Rahmenzelle z
diese gemeinsame Grenze auf Seite 2 und seien a, b zwei Eintrittspunkte auf Seite 1. Für
die Rahmenzelle z auf Seite 2 gilt zx = 0 und für die zwei Eintrittspunkte auf Seite 1 gilt
ay = by = 0. Es muss gelten:
zdw = zdw
⇒
⇒
⇒
adw + dist2 (a, z) = bdw + dist2 (b, z)
q
q
2
2
(ax − zx ) + (ay − zy ) + adw = (bx − zx )2 + (by − zy )2 + bdw
q
q
a2x + zy2 + adw = b2x + zy2 + bdw
(i)
Die Werte der Eintrittspunkte ax , adw , bx , bdw sind bekannt und die Gleichung kann für zy
gelöst werden. Bei zwei Lösungen wird nur die positive Lösung benötigt, denn Rahmenzellen mit negativer y-Koordinate sind nicht vorhanden. Der Wert von zy bestimmt eine
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
173
Rahmenzelle z auf Seite 2, welche die gemeinsame Grenze der Voronoi-Domänen von a und
b ist.
Jede Voronoi-Domäne auf Seite 2 kann durch zwei begrenzende Rahmenzellen festgelegt werden, eine obere und eine untere Begrenzungszelle. Die untere Begrenzungszelle
von V D2 (pj 0 ) ist die Rahmenzelle in der unteren, linken Ecke des Quadranten, weil die
x-Koordinate der nicht blockierten Eintrittspunkte mit steigendem j abnimmt und pj 0 der
zuletzt eingefügte Eintrittspunkt ist. Da pj 0 , um überhaupt eingefügt zu werden, mindestens
eine Rahmenzelle dominieren muss, muss die Voronoi-Domäne mindestens aus der untersten
Rahmenzelle auf Seite 2 bestehen. Die Rahmenzelle auf der Grenze zwischen den VoronoiDomänen gehöre ohne Beschränkung der Allgemeinheit zur Voronoi-Domäne von pj 0 . Die
Liste der Eintrittspunkte Lj+1 und deren Voronoi-Domänen können dann wie folgt berechnet werden.
Fall 1: z ist die Rahmenzelle in der unteren, linken Ecke des Quadranten. Da die Grenze
z per Definition zu pj 0 gehört, erhält pj+1 keine Voronoi-Domäne auf Seite 2 und wird
nicht zu Lj hinzugefügt, weshalb Lj+1 = Lj gilt. Die Voronoi-Domänen bleiben also
unverändert. Der nächste Eintrittspunkt pj+2 kann betrachtet werden.
Fall 2: zy > 0 und ist nicht oberhalb der oberen Begrenzungszelle der Voronoi-Domäne
V D2 (pj 0 ). Dann ist die neue untere Begrenzungszelle der Voronoi-Domäne V D2 (pj 0 ) die
Rahmenzelle z. Die Rahmenzelle direkt unterhalb von z ist die obere Begrenzungszelle
von V D2 (pj+1 ) und die Rahmenzelle in der unteren, linken Ecke wird die untere Begrenzungszelle. Die Voronoi-Domäne von V D2 (pj 0 ) wird also verkleinert und V D2 (pj+1 )
erhält die frei gewordenen Rahmenzellen wie in Abbildung 4 zu sehen. Der Eintrittspunkt pj+1 wird zu Lj hinzugefügt; Lj+1 = Lj ∪ {pj+1 }. Die Betrachtung kann mit pj+2
fortgesetzt werden.
Fall 3: Wenn z oberhalb der oberen Begrenzungszelle der Voronoi-Domäne V D2 (pj 0 ) ist,
dann wird pj 0 von pj+ 1 dominiert auf Seite 2 und pj 0 wird aus Lj entfernt. Der nächste
Eintrittspunkt in Lj sei pj 00 . Die untere Begrenzungszelle der Voronoi-Domäne V D2 (pj 00 )
sei dann nun die untere, linke Rahmenzelle des Quadranten. Der gesamte Vorgang wird
nun für pj+1 und pj 00 anstelle von pj 0 wiederholt. Wenn der Vorgang schlussendlich
terminiert und pj+1 in Lj+1 enthalten ist, kann mit pj+2 fortgefahren werden.
Die Berechnung der begrenzenden Rahmenzelle z kann in konstanter Zeit erfolgen. In Fall
1 geschieht nichts, im zweiten Fall wird pj+1 zu Lj+1 hinzugefügt und im dritten Fall wird
ein Eintrittspunkt aus Lj entfernt. Alle drei Operationen benötigen konstante Zeit. In einer
Runde i werden zuerst die Eintrittspunkte sortiert, dann die blockierten Eintrittspunkte
entfernt und anschließend die Liste der Eintrittspunkte Lk0 durchlaufen, um die VoronoiDomänen auf Seite 2 zu berechnen. Die ersten beiden Operationen benötigen O(n) Zeit, der
Durchlauf der Liste mit der Aktualisierung der Voronoi-Domänen benötigt O(k) Zeit. Wenn
also k neue Eintrittspunkte in einer Runde i auftreten, ist die Laufzeit zur Verarbeitung
O(n + k) = O(n).
Nachdem in Runde i die ersten k Eintrittspunkte aufgetreten sind, können in folgenden
Runden i + j, j ≥ 1 neue Eintrittspunkte auf Seite 1 auftreten. Die bestehenden Datenstrukturen können dann aktualisiert werden. Angenommen in Runde i + j treten m neue
Eintrittspunkte auf.
174
Benjamin Eikel
Abb. 4. Zweiter Fall: Neue Voronoi-Domäne für pj+1 durch Verkleinerung der Voronoi-Domäne von pj 0 .
Lemma 3. Sei b der am weitesten links liegende Eintrittspunkt auf Seite 1 in oder vor
Runde i + j − 1, j ≥ 1 in einem Quadranten eines Framed-Quadtrees. Ein in Runde i + j
auftretender Eintrittspunkt e auf Seite 1 wird dominiert auf Seite 2 wenn ex > bx .
Beweis. Da b schon vor Runde i + j aufgetreten ist und e erst in Runde i + j auftritt, muss
für die Distanzwerte edw > bdw gelten. Lemma 2 besagt, dass e von b dominiert wird, wenn
bdw ≤ edw und bx < ex . Wenn also auch ex > bx gilt, dominiert b den Eintrittspunkt e
bezüglich Seite 2.
Sei b der Eintrittspunkt auf Seite 1, der vor Runde i + j aufgetreten ist und der am weitesten links liegt. Aufgrund des Lemmas 3 können in einer Runde alle Eintrittspunkte, die
rechts von b auftreten, sofort verworfen werden. Sei Ei+j die Menge der anderen Eintrittspunkte, also diejenigen, die links von b aufgetreten sind. Sei b0 ∈ Ei+j der Eintrittspunkt,
der am weitesten links liegt. Mit einem Bucket-Sort in dem Intervall b0x bis bx können die
Eintrittspunkte aus Ei+j in Laufzeit O(bx − b0x + 1) sortiert werden. Die nach Lemma 2
dominierten Eintrittspunkte können dann entfernt werden, was Zeit O(m) benötigt. Die
0 . Für die Eintrittspunkte aus dieser Menge müssen nun
dann entstehende Menge sei Ei+j
die vor dieser Runde berechneten Voronoi-Domänen aktualisiert werden. Hierfür kann das
0
oben beschriebene Verfahren für Runde i verwendet werden, mit dem man die Menge Ei+j
durchläuft. Die Operation für jeden Eintrag der Menge benötigt konstante Laufzeit, die
gesamte Aktualisierung benötigt Laufzeit O(m).
In jeder Runde der Wellenausbreitung ab Runde i + 1 versucht jeder Eintrittspunkt auf
Seite 1 den Rahmenzellen auf Seite 2, die in der eigenen Voronoi-Domäne sind, einen Distanzwert zuzuweisen. Dies kann nur erfolgen, wenn der zuzuweisende Distanzwert kleiner oder
gleich wellenwert ist. Das Verfahren wird so lange fortgesetzt, bis die obere Begrenzungszelle einer Voronoi-Domäne einen Distanzwert erhalten hat. Denn dann hat der Eintrittspunkt
allen Rahmenzellen, über die er dominiert, einen Distanzwert zugewiesen und ist danach
blockiert für Seite 2. Er kann dann aus der Liste der Eintrittspunkte entfernt werden. Wenn
diese Liste leer ist, endet das Verfahren.
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
175
Lemma 4. Sei Q ein n × n Quadrant in einem Framed-Quadtree. Die Welle kann durch die
Eintrittspunkte auf Seite 1 zu den Rahmenzellen auf Seite 2 in Laufzeit O(n), unabhängig
von der Anzahl von Eintrittspunkten, durchgeführt werden.
Beweis. Die Voronoi-Domänen für mehrere Eintrittspunkte, die in Runde i auftreten, können in Zeit O(n) berechnet werden. In allen darauffolgenden Runden i+j, j ≥ 1 benötigt der
Bucket-Sort-Algorithmus O(n) Zeit, denn jeder Eintrittspunkt auf Seite 1 kann höchstens
ein Mal in allen Runden neu auftreten und sortiert werden müssen. Die gesamte Laufzeit
der Aktualisierung der Voronoi-Domänen ist linear in der Anzahl N ≤ n der auftretenden
Eintrittspunkte, denn die Operationen für die Aktualisierung der Voronoi-Domäne für einen
Eintrittspunkt ist konstant. Da jeder Eintrittspunkt nur Rahmenzellen aus seiner VoronoiDomäne Distanzwerte zuweisen kann und diese Voronoi-Domänen in Zeit O(n) verwaltet
werden können, ist die Laufzeit für die Wellenausbreitung O(n).
Seite 3
Um die Welle von Eintrittspunkten auf Seite 1 zu Rahmenzellen auf Seite 3 auszubreiten,
kann das Verfahren für Seite 2 in gespiegelter Form benutzt werden.
Seite 4
Bei der Ablaufplanung für Seite 4 ist es problematisch, dass hier nicht wie bei Seite 2
Eintrittspunkte aufgrund ihrer Lage auf Seite 1 direkt als blockiert ausgeschlossen werden
können. Doch es kann ein Ausschluss von Eintrittspunkten auf Seite 1 anhand des Zeitpunkts
ihres Auftretens durchgeführt werden.
Angenommen in einem n × n Quadrant Q in einem Framed-Quadtree treten die ersten
Eintrittspunkte auf Seite 1 in Runde i auf. Sei t1 der Wert von wellenwert, wenn√die
Eintrittspunkte auftreten (hier t1 = i). Angenommen während der Runden t1 bis dt1 + 2 ·
n − ne treten k ≥ 1 Eintrittspunkte auf Seite 1 auf. Diese werden beim Auftreten in eine
Liste eingefügt.
√
Lemma 5. Jeder Eintrittspunkt auf Seite 1, der nach Runde dt1 + 2 · n − ne auftritt, kann
keine Voronoi-Domäne auf Seite 4 erhalten und muss daher nicht weiter betrachtet werden.
Beweis. Sei x der erste Eintrittspunkt auf Seite 1 in Runde t1 . Wenn keine anderen Eintrittspunkte auftreten, dann wäre die Zeit, um von x allen Rahmenzellen auf Seite 4 einen
Distanzwert zuzuweisen gleich der Zeit, um die Rahmenzelle zu erreichen, die am weitesten
von x entfernt ist. Im schlimmsten Fall, wenn x eine Rahmenzelle in der Ecke des Quadranten ist, ist die am weitesten entfernte Zelle die diagonal gegenüberliegende Rahmenzelle
auf Seite 4. In Abbildung 5 ist dieser schlimmste Fall zu sehen und die Zelle
√ auf Seite 4
mit z bezeichnet. Um die Entfernung zu dieser√
Zelle zu überbrücken, werden 2 · n Runden
benötigt. Also wird diese Zelle in Runde t1 + 2 · n erreicht. Falls andere Eintrittspunkte
auf Seite 1 auftreten, können diese ebenfalls versuchen, den Rahmenzellen auf Seite 4 einen
Distanzwert zuzuweisen. Die minimal benötigte Anzahl von Runden hierfür ist n, mit der die
direkt oberhalb liegende Rahmenzelle
erreicht werden kann. Daher kann ein Eintrittspunkt
√
y, der in Runde t2 mit t2 > t1 + 2 · n − n auftritt, keine Rahmenzelle auf Seite 4 vor Runde
t2 + n erreichen. Aber zu diesem Zeitpunkt sind bereits alle Rahmenzellen auf Seite 4 durch
den Eintrittspunkt x erreicht worden. Daher ist y blockiert und muss nicht mehr betrachtet
werden.
176
Benjamin Eikel
Abb. 5. Die Wellenausbreitung von x nach z benötigt
√
2 · n Schritte, die von y nach z benötigt n Schritte.
√
In Runde dt1 + 2 · n − ne werden die k Eintrittspunkte nun nach ihren x-Koordinaten mit
einem Bucket-Sort sortiert, so wie dies bei der Ablaufplanung für Seite 2 der Fall war. Für
die Berechnung der Voronoi-Domänen auf Seite 4 wird wieder eine Rahmenzelle z benötigt,
die auf der Grenze zwischen zwei Voronoi-Domänen von Eintrittspunkten a und b liegt. Die
Koordinaten ay und by sind gleich null und zy ist gleich der Seitenlänge des Quadranten.
Setzt man das in Gleichung (i) ein, erhält man die gesuchte Rahmenzelle z durch Auflösen
der folgenden Gleichung zur x-Koordinate zx .
q
q
2
2
(ax − zx ) + zy + adw = (bx − zx )2 + zy2 + bdw
Nun wird das gleiche Verfahren verwendet wie für Seite 2. Die Liste der Eintrittspunkte wird
durchlaufen und die Voronoi-Domänen werden berechnet und in den darauffolgenden Runden aktualisiert. Dann weisen die Eintrittspunkte den Rahmenzelle in ihrer Voronoi-Domäne
die Distanzwerte zu, bis alle Rahmenzellen einen Wert erhalten und alle Eintrittspunkte blockiert sind.
Lemma 6. Sei Q ein n × n Quadrant in einem Framed-Quadtree. Die Eintrittspunkte auf
Seite 1 können in Zeit O(n) allen Rahmenzellen auf Seite 4 einen Distanzwert zuordnen.
Die Zeit ist nicht abhängig von der Anzahl der Eintrittspunkte.
Beweis. Es gibt maximal n Eintrittspunkte auf Seite 1, die den n Rahmenzellen auf Seite
4 einen Distanzwert zuordnen wollen. Die Voronoi-Domänen der Eintrittspunkte können in
O(n) Zeit berechnet werden. Jeder Eintrittspunkt weist nur Rahmenzellen in seiner VoronoiDomäne einen Distanzwert zu. Also ist die gesamte Laufzeit wie für Seite 2 O(n).
Gesamter Quadrant
Lemma 7. Sei Q ein n × n Quadrant in einem Framed-Quadtree. Unabhängig von der
Anzahl der Eintrittspunkte in Q benötigt die Wellenausbreitung über Q Laufzeit O(n).
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
177
Beweis. Wenn der Quadrant entweder eine oder vier Rahmenzellen besitzt, kann die Welle
wie bereits oben beschrieben in konstanter Zeit ausgebreitet werden. Bei größeren Quadranten kann die Welle über die vier Seiten in linearer Zeit ausgebreitet werden (Lemmata 1,
4, 6). Während jeder Runde der Wellenausbreitung wird jede Seite eines Quadranten einmal als Seite 1 angesehen und die Wellenausbreitung von dieser Seite zu den vier Seiten
durchgeführt. Den Rahmenzellen wird der kleinste der vier Werte zugewiesen. Hier ergibt
sich also eine Laufzeit von O(4 · n) = O(n).
Die Korrektheit dieses Algorithmus kann genauso gezeigt werden wie bei Gitter-basierten
Algorithmen. Der Beweis wird hier nicht durchgeführt.
2.4 Bestimmung des kürzesten Weges
Während der Durchführung der Wellenausbreitung werden von den Eintrittspunkten den
Rahmenzellen Distanzwerte zugewiesen. Sobald eine Rahmenzelle r ihren endgültigen Distanzwert von einem Eintrittspunkt e erhält, wird ein Zeiger von r auf e gesetzt. Wenn der
Quadrant mit der Zielposition gefunden wird, können diese Zeiger zurück verfolgt werden.
Dies ergibt einen kürzesten Weg vom Ziel zur Anfangsposition des Roboters. Wenn man
diesen Weg umgekehrt, erhält man den kürzesten Weg vom Roboter zum Ziel.
Theorem 1. Sei T ein Framed-Quadtree und Ta ⊂ T enthalte alle Quadranten, die Blätter des Baums sind und keine Hindernisse enthalten. Für einen Quadranten Q ∈ Ta , sei
u(Q) der Umfang von Q. u(Q) entspricht also der Anzahl an Rahmenzellen in Q. Das hier
vorgestellte Verfahren
berechnet einen kürzesten Weg in Laufzeit O(U ) + O(TNachbar ). HierP
bei ist U = i∈Ta u(i) und TNachbar ist die Zeit zur Aktualisierung der Nachbar-Zeiger der
Quadranten in T .
Beweis. Die Welle breitet sich nur durch freie Quadranten aus und sobald ein Quadrant vollständig abgearbeitet wurde, wird er nicht noch einmal besucht. Durch jeden Quadrant kann
laut Lemma 7 die Welle in linearer Zeit bezogen auf den Umfang des Quadranten ausgebreitet werden. Im schlimmsten Fall wird jeder freie Quadrant einmal besucht, weshalb sich der
erste Summand in Abhängigkeit von der Summe des Umfangs aller Quadranten ergibt. Die
Aktualisierung der Nachbar-Zeiger erfolgt durch Suche des entsprechenden Nachbarquadranten im Baum, woraus sich der zweite Summand ergibt. Dieser ist linear in der Auflösung
des Framed-Quadtrees und in den meisten Fällen sogar konstant. Man kann U auch ansehen
als die Gesamtanzahl von Rahmenzellen, die in allen freien Quadranten enthalten sind.
3 Zusammenfassung
3.1 Fazit
Das hier vorgestellte Verfahren spielt seine Vorteile hauptsächlich in Umgebungen aus, in denen große, freie Bereiche vorhanden sind. In diesen Fällen ist es weitaus schneller, als Gitterbasierte Verfahren, die solche Bereiche nicht zusammenfassen können. In Gitter-basierten
Verfahren kann der Roboter bei einer Bewegung von einer Gitterzelle zur nächsten auch
nur aus acht verschiedenen Richtungen wählen. In dem hier gezeigten Verfahren werden in
großen, freien Bereichen echte kürzeste Wege mit beliebigen Richtungen benutzt. Weitherhin
besitzt es durch Einführung der neuen Datenstruktur Framed-Quadtree nicht den Nachteil,
178
Benjamin Eikel
dass es den kürzesten Weg in einigen Fällen nicht findet, wie es bei anderen Quadtreebasierten Verfahren vorkommen kann. Es ist aber durch die aufwändigeren Verfahren zur
Wellenausbreitung und Ablaufplanung rechenintensiver als einfache Quadtree-basierte Verfahren.
Die Laufzeit in Abhängigkeit von der Anzahl an Rahmenzellen in allen Quadranten hat
auch Nachteile. Falls die Hindernisse in der Umgebung so platziert sind, dass der FramedQuadtree nur aus Quadranten kleinster Größe besteht, dann gibt es so viele Rahmenzellen
wie es bei einem Gitter-basierten Verfahren Gitterzellen gäbe. Der Vorteil in der Laufzeit
gegenüber Gitter-basierten Verfahren verschwindet dann und möglicherweise wird das Verfahren aufgrund des Verwaltungsaufwandes sogar langsamer als diese Verfahren.
Das Verfahren wurde von den Autoren des zugrundeliegenden Artikels implementiert.
Die Abbildungen 6 und 7 zeigen zwei Ergebnisse bei der Suche eines kürzesten Weges in
einer Beispielumgebung. In der Umgebung in Abbildung 7 müsste ein Gitter-basiertes Verfahren ungefähr 14000 freie Gitterzellen durchsuchen und das Framed-Quadtree-Verfahren
durchsucht hier nur etwa 4250 Rahmenzellen. Dies entspricht einer Ersparnis von etwa zwei
Dritteln.
3.2 Ausblick
Ein Vorteil des Framed-Quadtree-Verfahrens ist die Möglichkeit zur Erweiterung. Es können
beispielsweise mehrere Ziele in die Umgebung eingefügt werden. Durch die Wellenausbreitung können mehrere Ziele erreicht werden, wenn das Verfahren nicht nach dem Erreichen
des ersten Ziels angehalten wird. Sind alle oder eine vorgegebene Anzahl von Zielen gefunden worden, kann der Roboter anhand der Distanzwerte der Ziele, die für ihn die Kosten
darstellen, um dieses Ziel zu erreichen, entscheiden, welches Ziel er anfährt. Hier könnten
für die Ziele verschiedene Prioritäten gesetzt und anhand derer eine Entscheidung getroffen
werden.
Eine weitere Erweiterung ist die Verwendung des Verfahrens im dreidimensionalen Raum.
Hierfür muss das dreidimensionale Pendant zum Quadtree, der Octree, zur neuen Datenstruktur Framed-Octree erweitert werden. Allerdings ist die Berechnung der VoronoiDomänen schwieriger als im zweidimensionalen Raum.
Literaturverzeichnis
1. Chen DZ, Szczerba RJ, Uhran, Jr. JJ (1997) A framed-quadtree approach for determining euclidean
shortest paths in a 2-d environment. IEEE Transactions on Robotics and Automation 13(5):668–681
2. de Berg M, van Kreveld M, Overmars M, Schwarzkopf O (2000) Computational Geometry: Algorithms
and Applications, Zweite Ausgabe. Springer-Verlag, Berlin Heidelberg New York
3. Cormen TH, Leiserson CE, Rivest RL, Stein C (2001) Introduction to algorithms, Zweite Ausgabe.
MIT Press, Cambridge, Massachusetts
Framed-Quadtree-Verfahren zur Bestimmung von kürzesten Wegen
179
Abb. 6. Framed-Quadtree mit einer Auflösung von 64 × 64 und zufälligen Hindernissen. Die schwarze Linie
zeigt den stückweise kürzesten Pfad. Abbildung übernommen aus [1].
Abb. 7. Framed-Quadtree mit einer Auflösung von 128 × 128 und zufälligen Hindernissen. Die schwarze
Linie zeigt den stückweise kürzesten Pfad. Abbildung übernommen aus [1].
Konstruktion von geometrischen Spannern mit geringem
Durchmesser
Philipp Wissneth
Universität Paderborn [email protected]
Zusammenfassung. Geometrische Spanner werden zur Approximation vollständiger euklidischer Graphen
eingesetzt. Es handelt sich hierbei um Graphen, deren Knotenmenge einer Punktmenge im Rd entspricht
und deren Kanten so definiert sind, dass der kürzeste Pfad zwischen zwei Knoten p und q höchstens um einen
konstanten Faktor größer ist als der euklidische Abstand zwischen den beiden Punkten. Der Durchmesser
eines Spanners ist definiert als die maximale Anzahl Kanten über alle Pfade mit minimaler Anzahl Kanten
von jedem beliebigen Punkt p zu jedem beliebigen Punkt q.
In dieser Arbeit wird eine randomisierte Datenstruktur für einen geometrischen Spanner vorgestellt, welche, bezogen auf eine Menge von n Punkten, mit hoher Wahrscheinlichkeit einen Durchmesser von O(log n)
hat. Des Weiteren wird ein Algorithmus zur Beantwortung von Pfadanfragen auf dieser Datenstruktur vorgestellt und analysiert.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
2
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
2.1
2.2
2.3
2.4
Grundlegende Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Θ-Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Algorithmische Konstruktion von Θ-Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Bemerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
3
Der Skip List Spanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
3.1 Konstruktion des Skip List Spanners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
3.2 Ein Algorithmus zur Konstruktion von t-Spanner Pfaden . . . . . . . . . . . . . . . . . . . . . . 189
4
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
1 Einleitung
Geometrische Spanner dienen der Approximation vollständiger euklidischer Graphen. Dabei soll sich die Summe der einzelnen euklidischen Abstände der Kanten in einem Pfad von
einem Punkt p zu einem Punkt q höchstens um einen konstanten Faktor gegenüber dem
euklidischen Abstand zwischen p und q unterscheiden. In dieser Ausarbeitung wird eine
randomisierte Datenstruktur vorgestellt, welche mit hoher Wahrscheinlichkeit einen geringen Durchmesser besitzt. D.h., die Anzahl der Kanten in einem Pfad von einem beliebigen
Punkt p zu einem beliebigen Punkt q soll möglichst gering sein ohne dabei die Spannereigenschaft zu verletzen. Des Weiteren wird ein Algorithmus vorgestellt, mit dessen Hilfe es
182
Philipp Wissneth
möglich ist, einen Pfad zwischen zwei beliebigen Punkten in der vorgestellten Datenstruktur
zu bestimmen. Sowohl die Datenstruktur als auch der Algorithmus wurden von Arya, Mount
und Smid in [4] eingeführt. Zur effizienten Konstruktion solcher Datenstrukturen wird eine Technik vorgestellt, welche auf der Beantwortung von orthogonalen Bereichsanfragen
basiert.
2 Grundlagen
In diesem Kapitel werden für die Konstruktion des Algorithmus zur Beantwortung von
Pfadanfragen nötige Datenstrukturen vorgestellt. Zunächst werden der Begriff t-Spanner
definiert und einige Eigenschaften von Spannern vorgestellt. Im Anschluss wird eine zur
Konstruktion von t-Spannern eingesetzte Datenstruktur, der Θ-Graph, eingeführt. Zur effizienten Konstruktion von Θ-Graphen wird eine Datenstruktur zur Beantwortung orthogonaler Bereichsanfragen verwendet.
2.1 Grundlegende Definitionen
Sei S eine Menge von n Punkten im Rd . Bei einem euklidischen Graphen für S entspricht
die Knotenmenge der Menge S. Eine Kante eines solchen Graphen ist definiert als (p, q) :
p, q ∈ S. Das Gewicht einer Kante (p, q) ist definiert als der euklidische Abstand zwischen
den Punkten p und q.
Sei E die Kantenmenge eines Graphen G. Für ein t > 1 ist der Graph G = (S, E) ein
t-Spanner, wenn für jedes Paar von Punkten p, q ∈ S ein Pfad von p nach q existiert, dessen
Gewicht höchstens um den Faktor t größer ist als der euklidische Abstand zwischen p und
q. Für einen t-Spanner kann eine Pfadanfrage für ein Paar von Punkten (p, q) ∈ S gestellt
werden. Das Resultat einer solchen Anfrage wird dann als t-Spanner Pfad von p nach q
bezeichnet.
Der Durchmesser D eines t-Spanners bezeichnet die maximale Pfadlänge über alle Pfade
von jedem beliebigen Punkt p zu jedem beliebigen Punkt q, deren Anzahl der Kanten im
t-Spanner-Pfad minimal ist. Der euklidische Abstand zwischen zwei Punkten p und q im Rd
wird im folgenden Text mit |pq| bezeichnet.
2.2 Θ-Graphen
Eine Form von t-Spannern sind die sogennannten Θ-Graphen. Die Idee bei der Konstruktion
von Θ-Graphen besteht darin, ausgehend von einem Punkt p zunächst eine Kante zu einem
Knoten zu wählen, welcher sich grob in der Richtung des Zielknotens q befindet. Dafür wird
der Raum Rd durch Kegel in mehrere Sektionen aufgeteilt.
Ein Kegel ist definiert als die Schnittmenge von d Halbräumen im Rd . Die einzelnen Halbräume werden jeweils durch eine Hyperebene begrenzt, welche sich in einer allgemeinen Lage
befindet. Der Punkt, an dem sich sämtliche Halbräume schneiden ist definiert als die Kegelspitze. Zur Veranschaulichung dienen hier R2 und R3 : Im R2 entspricht eine Hyperebene
einer Geraden. Die von der Geraden abgegrenzte Ebene entspricht nun einem Halbraum
Konstruktion von geometrischen Spannern mit geringem Durchmesser
183
(in diesem Spezialfall auch Halbebene genannt). Im R3 entspricht eine Hyperebene einer
Ebene. Der von der Ebene abgegrenzte Raum entspricht einem Halbraum. Der Winkel Θ
(0 < Θ < π) legt fest, in welchem Winkel die d Halbräume zueinander stehen. Da sich die
einzelnen Halbräume in einem gemeinsamen Punkt schneiden, entsteht ein geometrisches
Konstrukt in Form eines Kegels.
Die Menge C sei definiert als eine Sammlung von Kegeln, welche ihren Ursprung im Koordinatenursprung haben, dessen Kegel einen Winkel von Θ besitzen und den Rd abdecken.
In [8] wird gezeigt, wie eine solche Menge C, bestehend aus O((c/Θ)d−1 ) Kegeln, für eine
geeignete Konstante c konstruiert werden kann.
Jeder Kegel besitzt einen Strahl lC , welcher vom Ursprung des Kegels ausgeht und sich innerhalb des Kegels befindet. Dabei darf sich lC irgendwo im Kegel befinden (in den folgenden
Zeichnungen wurde die Winkelhalbierende gewählt). Ein verschobener Kegel Cp ist definiert
als der Kegel C, dessen Ausgangspunkt vom Koordinatenursprung zum Punkt p verschoben
wurde. Formal kann Cp wie folgt beschrieben werden: Cp := C +p := {x+p : x ∈ C}. Abbildung 1 zeigt zwei Kegel im R2 . Einer hat seinen Ausgangspunkt im Koordinatenursprung,
der zweite Kegel ist um den Punkt p verschoben worden. Analog hierzu wird der verschobene Strahl lC,p definiert. Der Strahl lC,p hat seinen Ursprung im Punkt p und entspricht
dem um den Punkt p verschobenen Strahl lC .
lC,p
lC
p
0
0
Abb. 1. Ein Kegel mit Ausgangspunkt im Koordinatenursprung inklusive Strahl lC und ein zugehöriger,
um den Punkt p verschobener Kegel (d = 2).
Definition 1 (Θ-Graph [1]). Sei k ≥ 2 ein ganzzahliger Wert und Θ = 2π/k. S sei eine
Menge von Punkten im Rd . Der gerichtete Graph Θ(S, k) ist wie folgt definiert.
1. Die Knoten von Θ(S, k) sind die Punkte in S.
2. ∀p ∈ S und ∀C ∈ C, sodass in dem verschobenen Kegel Cp Punkte aus S\{p} enthalten
sind, existiert eine Kante von p zu einem Punkt r in Cp ∩ S\{p}, dessen orthogonale
Projektion auf den Strahl lC,p dem Punkt p am nächsten ist. Existieren mehrere solcher
Punkte, wird ein beliebiger Punkt gewählt.
Abbildung 2 illustriert die Auswahl einer Kante (p, r) in einem Kegel Cp . Für den ΘGraph lässt sich folgendes Lemma definieren:
184
Philipp Wissneth
lC,p
r
p
Abb. 2. Ein Kegel mit Ausgangspunkt p und Strahl lC,p (d = 2). In einem Θ-Graphen wird für diesen
Kegel die Kante (p, r) hinzugefügt, da die orthogonale Projektion auf lC,p am nächsten zu p ist.
Lemma 1. Sei k > 8 ein ganzzahliger Wert, Θ = 2π/k und sei S eine Menge bestehend aus
n Punkten im Rd . Dann ist der Graph Θ(S, k) ein t-Spanner für t = 1/(cos Θ − sin Θ). Der
Graph enthält O((c/Θ)d−1 n) Kanten für eine Konstante c.
Die Anzahl der Kanten ergibt sich daraus, dass in jedem der n Punkte p ∈ S für alle Kegel
(welche O((c/Θ)d−1 ) betragen) eine Kante bestimmt wird. Ein Beweis für die Bestimmung
von t folgt in Kapitel 3.
2.3 Algorithmische Konstruktion von Θ-Graphen
Der folgende Abschnitt befasst sich mit der algorithmischen Konstruktion von Θ-Graphen.
Arya, Mount und Smid beschreiben in [4] eine Datenstruktur, mit welcher sich der Graph
Θ(S, k) in Zeit O(n logd−1 n) und einem Speicherbedarf von O(n logd−2 n) erstellen lässt.
Vor der eigentlichen Konstruktion werden einige Notationen eingeführt: Sei C ein Kegel aus C. Es seien h1 , h2 , . . . , hd die Hyperebenen, welche die Halbräume begrenzen, die C
definieren. H1 , H2 , . . . , Hd seien Linien durch den Koordinatenursprung, so dass jedes Hi
(1 ≤ i ≤ d) jeweils orthogonal zu hi ist. Hi ist so gerichtet, dass Hi in die Richtung zeigt,
in welche sich der Kegel C ausbreitet. Des Weiteren ist L definiert als die Linie, welche den
Strahl lC enthält und ebenfalls durch den Koordinatenursprung geht.
Für einen beliebigen Punkt p im Rd seien im Folgenden seine Koordinaten in Bezug auf die
entsprechende Achse mit p1 , p2 , . . . , pd gekennzeichnet. Der Wert von p0i mit 1 ≤ i ≤ d kennzeichne den vorzeichenbehafteten euklidischen Abstand zwischen dem Koordinatenursprung
und der orthogonalen Projektion von p auf Hi . Das Vorzeichen wird dadurch bestimmt, ob
sich die entsprechende Projektion in Bezug zur Richtung von Hi “rechts” oder “links” vom
Koordinatenursprung befindet. Analog hierzu bezeichne p0d+1 den vorzeichenbehafteten euklidischen Abstand zwischen dem Koordinatenursprung und der orthogonalen Projektion
von p auf L. Abbildung 3 verdeutlicht diesen Zusammenhang für d = 2.
Sei nun angenommen, dass p ein Punkt in S ist. Bei der Berechnung des Graphen Θ(S, k)
muss eine Kante ausgehend von p zu einem Punkt q in Cp mit minimalem Abstand in
Bezug zur orthogonalen Projektion von q auf lC,p gefunden werden. Dies ist äquivalent zum
Bestimmen eines Punktes q ∈ S\{p}, sodass aus allen 1 ≤ i ≤ d mit qi0 ≥ p0i ein Punkt mit
0
minimaler qd+1
-Koordinate gefunden wird.
Die Datenstruktur, auf dessen Basis dieser Punkt bestimmt wird, ist eine erweiterte
Version eines Bereichsbaumes (vgl. [5]). Sie ist wie folgt aufgebaut: Auf oberster Ebene
Konstruktion von geometrischen Spannern mit geringem Durchmesser
H1
h1 + p
p'2
lC,p
L
p
0
H2
p'1
185
h2 + p
Abb. 3. Die Linien Hi sind orthogonal zu hi (1 ≤ i ≤ d). Die gestrichelten Linien kennzeichnen die
orthogonale Projektion des Punktes p auf die Linien Hi (d = 2).
existiert ein balancierter binärer Suchbaum in dessen Blättern die Punkte aus S gespeichert
sind. Diese Punkte sind nach ihren q10 -Koordinaten sortiert. Für jeden Knoten v dieses
Baumes sei Sv die Teilmenge aus S, welche in dem Teilbaum unter v gespeichert ist. Jeder
Knoten v enthält nun einen Zeiger auf die Wurzel eines sortierten binären Suchbaumes über
Sv , welcher in seinen Blättern nach seinen q20 -Koordinaten sortiert ist. Sämtliche Knoten
dieses Baumes enthalten wiederum einen Zeiger auf sortierte binäre Suchbäume, welche in
ihren Blättern nach ihrer q30 -Koordinate sortiert sind usw. Diese rekursive Konstruktion wird
bis zu Suchbäumen, welche nach ihrer qd0 -Koordinate sortiert sind, fortgesetzt. Ein Baum,
welcher in seinen Blättern qi0 -Koordinaten enthält, wird im Folgenden als Baum der Ebene
i bezeichnet.
Zusätzlich zu dem in einem Knoten u eines Baumes der Ebene d gespeicherten Suchintervall wird dort eine weitere Information gespeichert. Es handelt sich hierbei um den Punkt,
welcher in Bezug auf die in den Blättern des von u gespeicherten Teilbaumes enthaltene
0
-Koordinate besitzt.
Teilmenge von S eine minimale qd+1
Sobald diese Datenstruktur konstruiert wurde, ist es möglich, die entsprechenden Kanten
von Θ(S, k) zu bestimmen. Für einen beliebigen Punkt p ∈ Rd wird eine entsprechende
Menge von Knoten aus Bäumen der Ebene d berechnet, sodass alle Teilmengen von S,
welche in den Teilbäumen dieser Knoten gespeichert sind, der Menge der Punkte innerhalb
des Kegels Cp entsprechen. In der vorgestellten Datenstruktur müssen also sämtliche Punkte
q ∈ S\{p} bestimmt werden, bei denen für alle 1 ≤ i ≤ d die Eigenschaft qi0 ≥ p0i gilt. Diese
Menge von Punkten kann durch eine orthogonale Bereichsanfrage bestimmt werden (siehe
[5]).
Die Bestimmung der Kante in Cp zur Berechnung von Θ(S, k) erweist sich nun als besonders leicht: Für jeden der eben bestimmten Knoten u ∈ S, welcher die Wurzel eines
0
Teilbaumes der Ebene d ist, wurde ein Knoten qu gespeichert, dessen qu,d+1
-Koordinate im
jeweiligen Teilbaum minimal ist. Sei nun q derjenige Knoten aus allen bestimmten Knoten
0
u, welcher den minimalen Wert für qu,d+1
besitzt. Folglich ist (p, q) eine Kante von Θ(S, k).
0
Bis auf die Bestimmung der minimalen Werte für qd+1
entspricht die vorgestellte Datenstruktur der eines Bereichsbaumes. Bereichsbäume haben einen Speichplatzbedarf von
O(n logd−1 n) und können in Zeit O(n logd−1 n) erstellt werden. Die Bestimmung des Punk0
tes eines Teilbaumes mit minimalem Wert für die qd+1
-Koordinate kann mit Hilfe einer
186
Philipp Wissneth
Bottom-Up Prozedur geschehen. Hier wird ausgehend von den Blättern eines Baumes der
0
Ebene d die Bezeichnung des Knotens mit minimaler qd+1
-Koordinate nach oben propagiert.
Auf Basis der Eigenschaften von Bereichsbäumen (vgl. [5] oder [6]) kann folgendes Lemma
definiert werden:
Lemma 2 (vgl. [4]). Sei S eine Menge von n Punkten im Rd und sei C ein Kegel aus
C. Die oben beschriebene Datenstruktur hat eine Größe von O(n logd−1 n) und kann in Zeit
O(n logd−1 n) erstellt werden. Die Zeit zum Einfügen oder Löschen eines Punktes in bzw.
aus dieser Datenstruktur beträgt O(logd n). Zu jedem Punkt p ∈ Rd kann in Zeit O(logd n)
0
ein Punkt q in Cp ∩ S\{p} bestimmt werden, dessen qd+1
-Koordinate minimal ist, beziehungsweise festgestellt werden, dass kein solcher Punkt existiert.
Es muss beachtet werden, dass sich die gezeigte Datenstruktur ausschließlich auf einen
einzigen Kegel C aus C bezieht. Es lassen sich also die Kanten für sämtliche verschobenen
Kegel Cp , welche auf C basieren, berechnen. Dies kann in Zeit O(n logd n) geschehen. Dieser
0
-Koordinate
Wert ergibt sich daraus, dass für die Berechnung einer Kante mit minimaler qd+1
für einen bestimmten Kegel Cp (wobei p ∈ S) die erstellte Datenstruktur mit dem Punkt p
befragt wird. Dies kann in Zeit O(logd n) geschehen (vgl. Lemma 2). Will man die Kanten
sämtlicher Kegel Cp erhalten, muss die erstellte Datenstruktur mit sämtlichen Punkten aus
S, (|S| = n) befragt werden. Es muss also n mal eine Anfrage auf die erstellte Datenstruktur
gestartet werden. Die Laufzeit beträgt folglich O(n logd n) (das Erstellen der Datenstruktur
benötigt O(n logd−1 n) Zeit und ist somit in der O-Notation enthalten).
Bei der Konstruktion des Θ-Graphen lässt sich sowohl beim Speicherplatzbedarf als auch
bei der Laufzeit ein Faktor von log n einsparen. Dies wird dadurch möglich, dass bereits a
priori sämtliche Punkte bekannt sind, mit denen die erstellte Datenstruktur befragt wird:
Alle Punkte aus S. Die Punkte aus S werden nun der Reihe nach absteigend nach ihrer
p01 -Koordinate sortiert. Die Berechnung der einzelnen Kanten in den verschobenen Kegeln
erfolgt nun entsprechend dieser Liste von p01 -Koordinaten in absteigender Reihenfolge. Wie
bereits oben gezeigt, wird auch hier für jeden Kegel C ∈ C ein erweiterter Bereichsbaum
konstruiert. Allerdings geschieht dies hier lediglich für die Koordinaten p02 , . . . , p0d+1 . Es wird
also die Datenstruktur aus Lemma 2 für Dimension d − 1 angewandt. Um sicherzustellen,
dass bei einer Anfrage für einen Punkt p ausschließlich Punkte r ∈ S mit einer r10 -Koordinate
betrachtet werden, welche größer oder gleich p01 sind, werden in den Bereichsbaum nur die
Punkte eingefügt, welche in der zuvor konstruierten Liste “über” dem aktuell betrachteten
Punkt p liegen.
Durch eine Anfrage der Datenstruktur für jeden Punkt p wird nun ein Punkt q bestimmt,
0
bei dem für alle 2 ≤ i ≤ d die Eigenschaft qi0 ≥ p0i gilt und qd+1
minimal ist. Des Weiteren
ist sichergestellt, dass die Datenstruktur zu diesem Zeitpunkt nur Punkte r aus S enthält,
deren Koordinate r10 größer oder gleich p01 ist. Daraus folgt, dass die Eigenschaft qi0 ≥ p0i
0
für alle 1 ≤ i ≤ d gilt und qd+1
minimal ist. Nachdem für die Anfrage mit Punkt p ein
passender Punkt q bestimmt wurde, wird p bezüglich seiner Koordinaten (p02 , . . . , p0d+1 ) in
den erweiterten Bereichsbaum eingefügt und es kann die Anfrage für den nächsten Punkt
aus der nach p01 -Koordinaten sortierten Liste von Punkten aus S gestartet werden. Da das
Einfügen von Punkten in den erweiterten Bereichsbaum Zeit O(logd−1 n) benötigt und dies
für alle n Punkte aus S durchgeführt wird, ergibt zusätzlich zum Konstruieren des erweiterten Bereichsbaumes für die Dimension d − 1 ein Zeitbedarf von O(n logd−1 n). Gemäß
Konstruktion von geometrischen Spannern mit geringem Durchmesser
187
Lemma 2 wird für die Konstruktion eines erweiterten Bereichsbaumes für die Dimension
d − 1 Zeit O(n logd−2 n) benötigt. Die benötigte Zeit zur Bestimmung sämtlicher Kanten
der verschobenen Kegel Cp zu einem Kegel C ∈ C ist also durch O(n logd−1 n) beschränkt.
Um Θ(S, k) vollständig zu berechnen, müssen für sämtliche Kegel C ∈ C die Kanten
der verschobenen Kegel Cp bestimmt werden. Aus Lemma 1 geht hervor, dass Θ(S, k)
O((c/Θ)d−1 n) Kanten enthält. Das bedeutet insbesondere, dass für die Konstruktion ein
Speicherplatz von O((c/Θ)d−1 n + n logd−2 n) benötigt wird, also dem Platz zum Speichern
der berechneten Kanten und dem Platz zum Speichern der einzelnen erweiterten Bereichsbäume. Ferner beträgt die Anzahl der Kegel C ∈ C O((c/Θ)d−1 ). Daraus ergibt sich eine
Laufzeit von O((c/Θ)d−1 n logd−1 n) zur Konstruktion des Graphen Θ(S, k).
Die Ergebnisse zum Graph Θ(S, k) und seiner algorithmischen Konstruktion werden wie
folgt zusammengefasst:
Theorem 1 (vgl. Theorem 5 in [4]). Sei k > 8 ein ganzzahliger Wert, Θ = 2π/k
und S eine Menge von n Punkten im Rd . Der Graph Θ(S, k) ist ein t-Spanner für
t = 1/(cos Θ − sin Θ). Er enthält O((c/Θ)d−1 n) Kanten für eine Konstante c. Unter einem Speicherplatzverbrauch von O((c/Θ)d−1 n + n logd−2 n) kann der Graph in Zeit
O((c/Θ)d−1 n logd−1 n) konstruiert werden.
2.4 Bemerkungen
Die hier eingeführten Θ-Graphen dienen als Grundlage für die im folgenden Kapitel vorgestellte Technik zur Konstruktion von t-Spannern mit geringem Durchmesser. Des Weiteren
wird in Kapitel 3 auf das folgende Lemma zurückgegriffen. Ein entsprechender Beweis ist
in [3] zu finden.
Lemma 3. Sei k > 8 ein ganzzahliger Wert und Θ = 2π/k. Ferner seien p und q beliebige
disjunkte Punkte im Rd und C sei ein Kegel aus C, sodass q ∈ Cp . Sei r ein beliebiger Punkt
im Rd ∩ Cp , sodass die orthogonale Projektion von r auf den Strahl lC,p mindestens so nah
zu p ist wie die orthogonale Projektion von q auf lc,p . Es gilt
1. |pr| cos Θ ≤ |pq|, und
2. |rq| ≤ |pq| − (cos Θ − sin Θ)|pr|.
Außerdem wird bei der Konstruktion der im nächsten Kapitel eingeführten Datenstruktur auf das Konzept von Skip Listen (vgl. [2]) zurückgegriffen, weshalb an dieser Stelle
kurz deren Eigenschaften wiederholt werden sollen: Skip Listen sind eine randomisierte Datenstruktur zur effizienten Suche auf geordneten Mengen. Die Datenstruktur besteht aus n
Listen, welche sich in verschiedenen Ebenen befinden. In der Liste der Ebene 1 befinden sich
alle Elemente. Es wird per Münzwurf bestimmt, ob sich ein Element einer Liste der Ebene
i in der übergeordneten Liste i + 1 befindet. Da es sich hierbei um einen fairen Münzwurf
handelt, ist zu erwarten, dass die Anzahl der Elemente einer Liste der Ebene i + 1 halb so
groß ist wie die Anzahl der Elemente der darunter liegenden Liste der Ebene i. Elemente,
welche in mehreren Listen auftreten besitzen einen Zeiger zu ihren Vorkommen in der jeweils
höheren bzw. niedrigeren Ebene. Die Anzahl der zu erwartenden Ebenen beträgt O(log n).
188
Philipp Wissneth
3 Der Skip List Spanner
Ziel dieses Kapitels ist die Vorstellung und Analyse eines t-Spanners, welcher einen möglichst geringen Durchmesser hat. Arya, Mount und Smid führen in [4] einen t-Spanner ein,
dessen Durchmesser mit hoher Wahrscheinlichkeit O(log n) beträgt. Der vorgestellte Spanner basiert auf der Kombination von den bereits im vorhergegangenen Kapitel eingeführten
Θ-Graphen und Skip-Listen.
3.1 Konstruktion des Skip List Spanners
Bevor eine entsprechende Datenstruktur angegeben werden kann, werden zunächst aus der
Menge S der Punkte im Rd entsprechende Teilmengen gebildet. Es sei S1 = S. Für ein i > 1
wird die Menge Si wie folgt ermittelt: Für jeden Punkt aus Si−1 wird ein fairer Münzwurf
ausgeführt. Jeder Punkt, für den der Münzwurf mit dem Ergebnis “Kopf” ausgegangen ist,
ist Bestandteil der Teilmenge Si . Die Konstruktion der Teilmengen ist dann beendet, wenn
für eine Menge Si ausschließlich das Ergenis “Zahl” geworfen wurde, also Si = ∅. Mit h sei
die Anzahl der Iterationen für diese Konstruktion gekennzeichnet. Es besteht also folgende
Beziehung zwischen den einzelnen Teilmengen von S:
∅ = Sh+1 ⊆ Sh ⊆ Sh−1 ⊆ Sh−2 ⊆ · · · ⊆ S2 ⊆ S1 = S
Die im Folgenden definierte Datenstruktur basiert auf den oben erstellten Mengen Si .
Definition 2 (Skip List Spanner [4]). Sei k ≥ 2 ein ganzzahliger Wert und Θ = 2π/k.
Sei S eine Menge von n Punkten im Rd . Si , 1 ≤ i ≤ h seien die oben durch den fairen
Münzwurf konstruierten Teilmengen von S. Der Skip List Spanner, SLS(S, k) ist wie folgt
definiert.
1. Für jedes 1 ≤ i ≤ h existiert eine Liste Li , welche die Punkte aus Si beinhaltet (in
beliebiger Reihenfolge).
2. Für jedes 1 ≤ i ≤ h existiert ein Graph Θ(Si , k).
3. Für jedes 1 ≤ i ≤ h existiert der umgekehrte Graph Θ0 (Si , k), welcher durch die Umkehrung der Kantenrichtung in Θ(Si , k) erhalten wird.
4. Für jedes 1 < i ≤ h enthält jedes p ∈ Si einen Zeiger von seinem Auftreten in Li zum
in Li−1 korrespondierenden Auftreten von p.
5. Für jedes 1 ≤ i < h enthält jedes p ∈ Si+1 einen Zeiger von seinem Auftreten in Li zum
in Li+1 korrespondierenden Auftreten von p.
Lemma 4. Sei k > 8 ein ganzzahliger Wert, Θ = 2π/k und sei S eine Menge von n
Punkten im Rd . Der Skip List Spanner SLS(S, k) ist ein t-Spanner für t = 1/(cos Θ −
sin Θ). Er enthält O((c/Θ)d−1 n) Kanten für eine Konstante c. Ferner kann dieser Graph
mit hoher Wahrscheinlichkeit in Zeit O((c/Θ)d−1 n logd−1 n) mit einem Speicherplatzbedarf
von O((c/Θ)d−1 n + n logd−2 n) konstruiert werden.
Beweis. Da der Skip List Spanner SLS(S, k) insbesondere den Graphen Θ(S1 , k) = Θ(S, k)
enthält, ist er nach Theorem 1 ein t-Spanner für t = 1/(cos Θ − sin Θ). Die Anzahl der
Kanten in Θ(S, k) ist begrenztPdurch O((c/Θ)d−1 n). Daraus folgt, dass die Anzahl der
Kanten in SLS(S, k) durch O( hi=1 (c/Θ)d−1 |Si |) begrenzt ist.
Konstruktion von geometrischen Spannern mit geringem Durchmesser
189
Da die Mengen Si durch einen fairen Münzwurf bestimmt wurden, wissen wir, dass ein
Punkt aus der Menge Si−1 mit einer Wahrscheinlichkeit von 1/2 in der Menge Si enthalten
ist. Die erwartete Anzahl an Punkten in Si beträgt folglich (1/2)|Si−1 |. Aufgrund dieser
Beobachtung
kann die Gesamtzahl aller Punkte in SLS(S, k) überPeine geometrische Reihe
Ph−1
1
der Form k=0 n( 21 )k berechnet werden, deren Grenzwert limi→∞ ik=0 n( 12 )k = n 1−(1/2)
=
2n beträgt. Setzt man nun für die Anzahl der Punkte in SLS(S, k) den Wert 2n ein, so
beträgt die Anzahl der Kanten in SLS(S, k) mit hoher Wahrscheinlichkeit O((c/Θ)d−1 n).
Sollte die Anzahl der Kanten wider Erwarten größer ausfallen, wird die Konstruktion des
Skip List Spanners so oft wiederholt, bis die Anzahl der Kanten O((c/Θ)d−1 n) beträgt.
Die Schranken für die Konstruktionszeit und den Speicherplatzbedarf werden analog zu der
oben gezeigten Schranke für die Anzahl der Kanten bestimmt.
3.2 Ein Algorithmus zur Konstruktion von t-Spanner Pfaden
Der Skip List Spanner stellt die für die Konstruktion von t-Spanner Pfaden grundlegende
Datenstruktur dar. Im Folgenden wird der Algorithmus skizziert, welcher einen Pfad von
einem Punkt p zu einem Punkt q konstruiert. Dass es prinzipiell möglich ist, t-Spanner Pfade
im SLS(S, k) zu berechnen, wurde bereits dadurch gezeigt, dass der Skip List Spanner den
Θ-Graphen Θ(S, k) enthält. Um die Anzahl der Kanten jedoch zu reduzieren, wird wie folgt
vorgegangen:
Gestartet wird der Algorithmus bei dem Punkt x = p. Zuerst wird gepüft, ob sich der Punkt
x auf Ebene 2 (also in der Menge S2 ) befindet. Ist dem nicht der Fall, wird nun in Ebene
1 eine Kante berechnet, welche sich in grober Richtung zu Punkt q befindet. Um dies zu
erreichen, wird der Kegel C aus C so bestimmt, dass q ∈ Cx (was bedeutet, dass sich q im
verschobenen Kegel Cx befindet). Nun sei x0 ein Punkt aus Cx ∩ S1 (also allen Punkten
aus der Menge S1 , die sich im verschobenen Kegel Cx befinden), welcher zusammen mit x
eine Kante (x, x0 ) im Θ-Graphen Θ(S1 , k) ist. x0 wird nun ein Punkt auf dem Pfad von p
zu q. Für den weiteren Verlauf wird x := x0 gesetzt. Der Punkt x kennzeichnet also immer
den zuletzt hinzugefügten Punkt eines zu berechnenden Pfades von p zu q. Der Pfad wird
auf diese Weise solange erweitert bis x = q gilt oder x in der zweiten Ebene des Skip List
Spanners enthalten ist (x ∈ S2 ). Sollte x in der zweiten Ebene vorkommen, wird gestartet,
einen Pfad von Punkt q zu x zu konstruieren. Der Pfad dorthin wird analog zu dem oben
beschriebenen Pfad von p zu x konstruiert: Der zuletzt zum Pfad hinzugefügte Punkt sei
hier mit y gekennzeichnet. Der Pfad wird solange erweitert, bis y einem Punkt des bereits
konstruierten Pfades von p nach x entspricht oder y in Ebene 2 des Skip List Spanners
enthalten ist (y ∈ S2 ). Sollte y einem Punkt p0 des Pfades von p nach x entsprechen, so wird
der Pfad von p nach p0 gefolgt vom umgekehrten Pfad von q nach p0 ausgegeben. Der Pfad
von p nach p0 ist in Θ(S1 , k) und der Pfad von q nach p0 ist in Θ0 (S1 , k) enthalten. Beide
Θ-Graphen sind in SLS(S, k) enthalten. Befindet sich y hingegen auf Ebene 2 des Skip List
Spanners, wird mit dem selben Vorgehen ausgehend von Ebene 2, ein Pfad von x nach y
berechnet usw. Der in [4] vorgestellte formale Algorithmus entspricht dem hier gezeigten
Algorithmus 19.
190
Philipp Wissneth
Algorithmus 19 walk(p, q)
p0 := p; q0 := q; a := 0; b := 0; r := 0; s := 0; i := 1;
/* p0 = p, p1 , . . . , pr , . . . , pa und q0 = q, q1 , . . . , qs , . . . , qb sind Pfade in SLS(S, k), r = min{j : pj ∈ Si },
s = min{j : qj ∈ Si } und pr , pr+1 , . . . , pa , qs , qs+1 , . . . , qb ∈ Si */
stop := false;
while stop = false do
while pa 6= qb und pa ∈
/ Si+1 do
C := Kegel aus C, sodass qb ∈ Cpa ;
pa+1 := Punkt aus Cpa ∩ Si sodass (pa , pa+1 ) eine Kante aus Θ(Si , k) ist;
a := a + 1;
/* pa = qb oder pa ∈ Si+1 */
while qb ∈
/ {pr , pr+1 , . . . , pa } und qb ∈
/ Si+1 do
C := Kegel aus C, sodass pa ∈ Cqb ;
qb+1 := Punkt aus Cqb ∩ Si sodass (qb , qb+1 ) eine Kante aus Θ0 (Si , k) ist;
b := b + 1;
/* qb ∈ {pr , pr+1 , . . . , pa } oder pa und qb treten in Si+1 auf */
if qb ∈ {pr , pr+1 , . . . , pa } then
l := Index, sodass qb = pl ;
Pfad p0 , p1 , . . . , pl , qb−1 , qb−2 , . . . , q0 ausgeben;
stop := true;
else
i := i + 1; r := a; s := b;
Lemma 5. Sei k > 8 und Θ = 2π/k. Für jedes Paar von Punkten p und q aus S konstruiert
der Algorithmus walk(p, q) im SLS(S, k) einen t-Spanner Pfad von p nach q für ein t =
1/(cos Θ − sin Θ).
Beweis. Der Beweis zu Lemma 5 geschieht durch Induktion über die Anzahl der Ebenen
des Skip List Spanners. Für den Induktionsanfang wird angenommen, dass der Skip List
Spanner SLS(S, k) aus lediglich einer Ebene besteht. Dabei wird das Verhalten während
der ersten Iteration der äußeren While-Schleife beobachtet (Eine zweite Iteration wäre in
diesem Fall ohnehin nicht möglich, da dort Kanten der Ebene 2 berechnet werden würden,
welche logischerweise nicht existieren können).
q
lC,p
a
pa+1
pa
Abb. 4. Nach Definition des Θ-Graphen muss die Projektion von pa+1 auf den Strahl lC,pa mindestens so
nah an pa sein wie die Projektion von q auf lC,pa (d = 2).
In der ersten inneren While-Schliefe wird ein Pfad, beginnend mit p = p0 , p1 , p2 , . . .
konstruiert. Die Berechnung des Pfades wird beendet, sobald der zuletzt hinzugefügte Punkt
dem Punkt q entspricht. Wir betrachten nun für a ≥ 0 die Punkte pa und pa+1 . Da pa einen
Konstruktion von geometrischen Spannern mit geringem Durchmesser
191
Nachfolger (pa+1 ) besitzt, ist klar, dass pa 6= q gilt. Sei nun C der Kegel, sodass q im
verschobenen Kegel Cpa enthalten ist. Laut Algorithmus ist pa+1 ∈ Cpa und (pa , pa+1 )
eine Kante von Θ(S1 , k) und damit auch eine Kante von SLS(S, k). Des Weiteren gilt laut
Definition des Θ-Graphen, dass die Projektion von pa+1 auf den Strahl lC,pa mindestens so
nah an pa sein muss wie die Projektion von q auf lC,pa . Abbildung 4 verdeutlicht diesen
Zusammenhang. Nach Lemma 3 gilt
|pa+1 q| ≤ |pa q| − (cos Θ − sin Θ)|pa pa+1 |.
(1)
Durch die Monotonieeigenschaften der Cosinus- und Sinusfunktion im Intervall [0, π4 ) folgt
|pa+1 q| < |pa q|,
(2)
womit gezeigt ist, dass bei jeder Iteration der ersten inneren While-Schleife der Abstand
zwischen den Punkten pa und q kleiner wird und die Schleife terminiert. Wird angenommen, dass z die Anzahl der durchgeführten Iterationen ist, wurde durch den Algorithmus
ein Pfad der Form p = p0 , p1 , p2 , . . . , pz = q konstruiert. Die zweite innere While-Schleife
wird nicht ausgeführt, da qb = pz = q Element des konstruierten Pfades ist und so die Abbruchbedingung der Schleife zutrifft. Der Algorithmus terminiert und gibt den konstruierten
Pfad von p nach q aus.
Um eine Gewichtsbeschränkung des konstruierten Pfades zu erhalten, wird zunächst die
Ungleichung (1) umgeformt zu
|pa pa+1 | ≤
1
(|pa q| − |pa+1 q|) = t(|pa q| − |pa+1 q|)
cos Θ − sin Θ
(3)
Das Gewicht des ausgegebenen Pfades ist die Summe der Gewichte der einzelnen Kanten.
Unter Zuhilfenahme von (3) kann nun eine Gewichtsbeschränkung des konstruierten Pfades
bestimmt werden:
z−1
X
a=0
|pa pa+1 | ≤ t
z−1
X
(|pa q| − |pa+1 q|)
(4)
a=0
Durch Auflösen der Teleskopsumme auf der rechten Seite erhält man
z−1
X
|pa pa+1 | ≤ t(|p0 q| − |pz q|) = t|pq|,
(5)
a=0
womit gezeigt ist, dass der Algorithmus für einen Skip List Spanner SLS(S, k) mit einer
Ebene einen t-Spanner Pfad von p nach q konstruiert. Der Induktionsanfang ist bewiesen.
Ferner konnte hier der in Lemma 1 genannte Wert für t bewiesen werden.
Im Folgenden wird ein Skip List Spanner mit h Ebenen betrachtet, wobei h > 1. Wir nehmen
an, dass das Lemma 5 für alle Skip List Spanner mit weniger als h Ebenen gilt.
Während der ersten Iteration der äußeren While-Schleife wird in der ersten inneren
While-Schleife ein Pfad der Form p = p0 , p1 , p2 , . . . , pz konstruiert. Der Punkt pz entspricht
192
Philipp Wissneth
entweder dem gesuchten Punkt q (pz = q) oder er ist in der Menge S2 enthalten und damit
Element der zweiten Ebene des Skip List Spanners (pz ∈ S2 ). Offensichtlich gilt die Ungleichung (2) auch hier.
Für den Fall, dass pz = q gilt, wird der Algorithmus den konstruierten Pfad ausgeben und
terminieren. Der Beweis, dass es sich bei der Ausgabe um einen t-Spanner Pfad handelt, ist
exakt derselbe wie bereits im Induktionsanfang gezeigt.
Für den Fall, dass pz 6= q gilt, muss pz ∈ S2 gelten. In der zweiten inneren While-Schleife
wird ein Pfad der Form q = q0 , q1 , q2 , . . . konstruiert. Gemäß Lemma 3 und den Monotonieeigenschaften der Cosinus- und Sinusfunktion im Intervall [0, π4 ) folgt
|qb+1 pz | ≤ |qb pz | − (cos Θ − sin Θ)|qb qb+1 | < |qb pz |.
(6)
Die zweite innere While-Schleife terminiert, wenn der zuletzt hinzugefügte Punkt des qPfades einem Punkt des bereits erstellten p-Pfades entspricht oder in Ebene 2 des Skip List
Spanners vorkommt. Durch (6) wurde gezeigt, dass mit jeder Iteration der zweiten inneren
While-Schleife die Abstände zwischen qb und pz echt kleiner werden. Folglich terminiert die
Schleife. Es sei y die Anzahl der Iterationen bis zum Terminieren der Schleife. Es können
nun zwei Fälle unterschieden werden: qy ∈ {p0 , p1 , p2 , . . . , pz } oder qy ∈ S2 .
Falls qy ∈ {p0 , p1 , p2 , . . . , pz } sei l so gewählt, dass qy = pl gilt. Der Algorithmus würde
dann den Pfad der Form p = p0 , p1 , p2 , . . . , pl = qy , qy−1 , . . . , q0 = q ausgeben. Das Gewicht
des Pfades ist bestimmt durch die Summe aller Kantengewichte, welches wiederum kleiner
oder gleich der Summe aller Kantengewichte des p- und q-Pfades ist.
l−1
X
|pa pa+1 | +
a=0
≤
z−1
X
|pa pa+1 | +
a=0
y−1
X
b=0
y−1
X
|qb qb+1 |
|qb qb+1 |
(7)
b=0
Analog zu (3) kann (6) umgeformt werden zu
|qb qb+1 | ≤
1
(|qb pz | − |qb+1 pz |) = t(|qb pz | − |qb+1 pz |).
cos Θ − sin Θ
(8)
Unter Zuhilfenahme von (3) und (8) lässt sich nun eine Gewichtsbeschränkung des konstruierten Pfades bestimmen, welche sich durch das Auflösen der Teleskopsummen kürzen
lässt:
Konstruktion von geometrischen Spannern mit geringem Durchmesser
z−1
X
|pa pa+1 | +
a=0
≤t
z−1
X
(|pa q| − |pa+1 q|) + t
a=0
y−1
X
193
|qb qb+1 |
b=0
y−1
X
(|qb pz | − |qb+1 pz |)
b=0
= t(|p0 q| − |pz q| + |q0 pz | − |qy pz |)
= t(|pq| − |qy pz |)
≤ t|pq|
(9)
Für den Fall, dass qy ∈ {p0 , p1 , p2 , . . . , pz } gilt, wird folglich ein t-Spanner Pfad konstruiert.
Als zweiter und letzter Fall muss noch die Annahme betrachtet werden, dass qy ∈
/
{p0 , p1 , p2 , . . . , pz } gilt. Demnach befindet sich qy in der nächsthöheren Ebene des Skip List
Spanners (qy ∈ S2 ). Laut Algorithmus wird die aktuell betrachtete Ebene um eins erhöht,
was bedeutet, dass nun ein Pfad vom Punkt pz nach qy im Skip List Spanner SLS(S2 , k)
berechnet wird. Laut Induktionsannahme konstruiert der Algorithmus einen t-Spanner Pfad
von pz nach qy . Das Gewicht des Pfades von pz zu qy ist also begrenzt durch t|pz qy |. Wurde dieser Pfad konstruiert, werden die Teilpfade p = p0 , p1 , . . . , pz und pz , pz+1 , . . . , qy und
qy , qy−1 , . . . , q0 = q aneinanderghängt ausgegeben, welche zusammen den Pfad von p nach
q beschreiben. Eine Gewichtsbeschränkung des Pfades lässt sich analog zu (9) definieren,
wobei hier zusätzlich das Gewicht des von pz nach qy konstruierten Pfades betrachtet wird:
z−1
X
|pa pa+1 | + t|pz qy | +
a=0
≤t
z−1
X
a=0
(|pa q| − |pa+1 q|) + t|pz qy | + t
y−1
X
|qb qb+1 |
b=0
y−1
X
(|qb pz | − |qb+1 pz |)
b=0
= t(|p0 q| − |pz q| + |pz qy | + |q0 pz | − |qy pz |)
= t|pq|
(10)
Für den Fall, dass sich qy in der nächsthöheren Ebene des Skip List Spanners befindet,
konstruiert walk(p,q) also ebenfalls einen t-Spanner Pfad.
Nachdem die Korrektheit des Algorithmus bewiesen wurde, sollen nun noch Aussagen
über zwei wichtige Eigenschaften getroffen werden: Die Laufzeit des Algorithmus und die
Anzahl der Kanten des erzeugten t-Spanner Pfades, welche den Durchmesser beschreibt.
Für die folgende Analyse beschreibt T die Laufzeit des Algorithmus walk(p,q) und N die
Anzahl der Kanten des erzeugten Pfades. Es soll ein Pfad vom Punkt p zum Punkt q erzeugt
werden.
Da die Punktmengen S1 , S2 , . . . Sh per Zufall durch einen Münzwurf bestimmt wurden, ist
194
Philipp Wissneth
zunächst festzuhalten, dass T und N Zufallsvariablen sind und sich folglich nicht deterministisch bestimmen lassen. Der Algorithmus muss als erstes für jeden zum p-Pfad hinzugefügten
Punkt pa einen Kegel C bestimmen, sodass sich der gesuchte Zielpunkt qb im verschobenen
Kegel Cpa befindet. Analog hierzu muss für jeden zum q-Pfad hinzugefügten Punkt qb die
Eigenschaft pa ∈ Cqb gelten.
In Kapitel 2 wurde angegeben, dass sich jeder Kegel in C aus d Hyperebenen zusammensetzt und dass C aus O((c/Θ)d−1 ) Kegeln besteht. Bezeichne m die Gesamtzahl aller
Hyperebenen, welche die Kegel definieren so gilt m = d|C| = O((c/Θ)d−1 ). Um nun den passenden Kegel bestimmen zu können, wird diese Ansammlung von Hyperebenen in der in [9]
beschriebenen Datenstruktur gespeichert. Die Datenstruktur hat einen Speicherplatzbedarf
von O(md ) und ermöglicht es, einen zu einem Punkt gehörenden Kegel in Zeit O(log m) zu
bestimmen. Da in der Datenstruktur keine verschobenen Kegel gespeichert werden, muss
vor jeder Anfrage der Punkt mit dem die Anfrage gestartet wird “normalisiert” werden: Um
einen Kegel C zu finden, sodass qb ∈ Cpa gilt, wird die Anfrage mit dem Punkt qb − pa
gestartet. Der ausgegebene Kegel ist nun der gesuchte. Die Zeit zum Auffinden eines Kegels
ist durch O(log(1/Θ)) beschränkt, da c und d konstante Faktoren sind.
Mit Hilfe dieser Beobachtungen kann nun eine generelle Formel für T aufgestellt werden:
Der Algorithmus berechnet einen Pfad bestehend aus N Kanten. Für die Bestimmung einer jeden hinzuzufügenden Kante muss zuerst ein passender verschobener Kegel gefunden
werden. Dies geschieht in den beiden inneren While-Schleifen. Gesteuert durch die äußere
While-Schleife geschieht dies im Worst-Case für alle h Ebenen des Skip List Spanners. Die
Laufzeit T ist also bestimmt durch T = O(N log(1/Θ) + h). Da es sich bei T , N und der
Anzahl der Ebenen h um Zufallsvariablen handelt, ist deren Erwartungswert von Interesse.
Es gilt E(T ) = O(E(N ) log(1/Θ) + E(h)) = O(E(N ) log(1/Θ) + log n), da die erwartete
Anzahl an Ebenen des Skip List Spanners (analog zu Skip Listen) logarithmisch zur Gesamtzahl der Punkte in S ist (siehe Kapitel 2). Damit der Erwartungswert der Laufzeit
bestimmt werden kann, muss nun noch der Erwartungswert von N bestimmt werden.
Um zu bestimmen, wie groß die Anzahl der Kanten eines von walk(p,q) erzeugten Pfades ist,
wird im Folgenden die Zahl der in einer Ebene i hinzugefügten Punkte abgeschätzt. Zusammen mit der zu erwartenden Anzahl der Ebenen im Skip List Spanner lässt sich dann eine
Aussage über den Durchmesser der erzeugten Pfade treffen. Für die folgende Abschätzung
wird angenommen, dass ein Pfad vom Punkt p zu Punkt q erzeugt werden soll. Dabei wird
eine feste Ebene i betrachtet, in welcher ein Teilpfad von einem Punkt pr ∈ Si zu einem
Punkt qs ∈ Si erzeugt wird. Es gilt 1 ≤ i ≤ h. Es ist zu beachten, dass, sobald die Mengen S1 , . . . , Si und p, q bekannt sind, die Indizes r und s deterministisch bestimmt werden
können.
Für die folgende Analyse sei angenommen, dass der Münzwurf, welcher die Menge Si+1
bestimmt, noch nicht ausgefürt wurde. Der Pfad p0r = pr , p0r+1 , p0r+2 , . . . , p0m = qs sei definiert
als der Pfad, welcher konstruiert werden würde, wenn alle Punkte aus Si nicht in der Menge
Si+i vorkommen würden. Des weiteren bezeichne z die Zahl der Punkte, welche in Ebene i
zum p-Pfad hinzugefügt wurden. Aufgrund der Tatsache, dass die Mengen S1 , . . . , Sh zufällig
bestimmt werden ist offensichtlich, dass es sich bei z um eine Zufallsvariable handelt.
Es sei nun l ≥ 0 und z = l. Auf Ebene i wurden dem p-Pfad also l Punkte hinzugefügt.
Für den konstruierten p-Pfad gilt offensichtlich p0r = pr , p0r+1 = pr+1 , . . . , p0r+l = p0r+l . Die
Konstruktion von geometrischen Spannern mit geringem Durchmesser
195
aktuell hinzugefügten Punkte entsprechen also bis zum l-ten hinzugefügten Punkt denen,
wenn keiner der Punkte aus Si in Si+1 enthalten gewesen wäre. Insbesondere gilt für alle
a, r ≤ a ≤ r + l − 1, dass p0a ∈
/ Si+1 . Daraus lässt sich folgende Aussage treffen:
!
r+l−1
^
P (z = l) ≤ P
(p0a ∈
/ Si+1 )
(11)
a=r
Wird nun angenommen, dass der Münzwurf für jeden Punkt p0a erst bei der Anfrage, ob
sich p0a auch in Ebene Si+1 befindet, ausgeführt wird, lässt sich eine Aussage über die entsprechende Wahrscheinlichkeit machen. Jeder Punkt aus Si ist mit einer Wahrscheinlichkeit
von 1/2 in Si+1 enthalten. Da alle Münzwürfe unabhängig voneinander sind, gilt
P (z = l) ≤
r+l−1
Y
P (p0a ∈
/ Si+1 ) = (1/2)l .
(12)
a=r
Aufgrund der Unabhängigkeit der Münzwürfe ist es bei jedem Wurf gleich wahrscheinlich,
dass das Ergebnis “Kopf” bzw. “Zahl” geworfen wird. D.h., dass die Zufallsvariable z geometrisch mit dem Parameter 1/2 verteilt ist. Der q-Pfad wird analog zu dem p-Pfad erstellt.
Folglich ist auch eine Zufallsvariable y, welche die Zahl der hinzugefügten Punkte zum
q-Pfad beschreibt, geometrisch mit dem Parameter 1/2 verteilt.
Angenommen, Mi beschreibt die Zahl der in Ebene i zum p-Pfad hinzugefügten Kanten
und Ni die Zahl der in Ebene i zum q-Pfad hinzugefügten Kanten (1 ≤ i ≤ h). Mi und
Ni sind Zufallsvariablen. Da die Zahl der zu einem Teilpfad hinzugefügten Punkte der Zahl
der hinzugefügten Kanten entspricht, gilt, dass Mi und Ni ebenfalls geometrisch mit dem
Parameter 1/2 verteilt sind. Die Erwartungswerte für alle Mi bzw. Ni betragen
E(Mi ) = E(Ni ) =
1
1
2
= 2.
(13)
P
Die Gesamtzahl N der Kanten im berechneten Pfad von p nach q beträgt hi=1 (Mi + Ni ).
Wie bereits weiter oben festgestellt wurde, beträgt die zu erwartende Anzahl an Ebenen des
Skip List Spanners (h) mit hoher Wahrscheinlichkeit log n, weshalb sich folgende Aussage
über den Erwartungswert von N treffen lässt:
E(N ) =
log
Xn
log
Xn
i=1
i=1
(E(Mi ) + E(Ni )) =
(2 + 2) = 4 log n
(14)
Da es sich bei den einzelnen Münzwürfen für die Punkte um jeweils voneinander unabgängige Bernoulli-Experimente handelt, lässt sich mit Hilfe der Chernoff-Schranke (vgl. [7]) die
Wahrscheinlichkeit einschränken, dass N von seinem Erwartungswert abweicht. Die generelle
Aussage der Chernoff-Schranke lautet
196
Philipp Wissneth
2 E(X)
)
2
2 E(X)
).
P (X ≥ (1 + )E(X)) ≤ exp(−
3
P (X ≤ (1 − )E(X)) ≤ exp(−
(15)
Wobei X eine Zufallsvariable oder die Summe über Zufallsvariablen ist und E(X) dessen
Erwartungswert. Für die Zufallsvariable N beschreibt die Chernoff-Schranke also
2 4 log n
)
2
2 4 log n
P (N ≥ (1 + )4 log n) ≤ exp(−
).
3
P (N ≤ (1 − )4 log n) ≤ exp(−
(16)
Daraus folgt, dass der tatsächliche Wert für N mit hoher Wahrscheinlichkeit nur gering von
dem des Erwartungswertes abweicht. Insbesondere ist die Wahrscheinlichkeit, dass N unter
dem Erwartungswert liegt etwas größer als die Wahrscheinlichkeit, dass der tatsächliche
Wert für N über dem Erwartungswert von N liegt.
Mit Hilfe dieser Beobachtung gilt mit hoher Wahrscheinlichkeit, dass E(N ) = 4 log n =
O(log n). Daraus folgt, dass der Durchmesser des Skip List Spanners ebenfalls mit hoher
Wahrscheinlichkeit durch O(log n) beschränkt ist. Die erwartete Laufzeit T von walk(p,q)
ist mit hoher Wahrscheinlichkeit beschränkt durch
E(T ) = O(E(N ) log(1/Θ) + h)
= O(log n log(1/Θ) + log n)
= O(log(1/Θ) log n).
(17)
Die Erkenntnisse über die Eigenschaften des Skip List Spanners und den zugehörigen Algorithmus walk(p,q) zur Bestimmung von t-Spanner Pfaden können wie folgt zusammengefasst
werden:
Theorem 2 (vgl. Theorem 10 in [4]). Sei k > 8 ein ganzzahliger Wert, Θ = 2π/k und
S eine Menge von n Punkten im Rd .
1. Der Skip List Spanner SLS(S, k) ist ein t-Spanner für t = 1/(cos Θ − sin Θ). Er enthält
eine erwartete Anzahl von O((c/Θ)d−1 n) Kanten für eine Konstante c.
2. Der Skip List Spanner kann in erwarteter Zeit O((c/Θ)d−1 n logd−1 n) mit einem erwarteten Speicherplatzbedarf von O((c/Θ)d−1 n + logd−2 n) konstruiert werden.
3. Die zu erwartende maximale Zeit zum konstruieren eines t-Spanner Pfades von einem
beliebigen Punkt aus S zu einem anderen beliebigen Punkt aus S ist beschränkt durch
O(log(1/Θ) log n).
4. Der zu erwartende Durchmesser des konstruierten Skip List Spanners ist beschränkt
durch O(log n).
5. Sämtliche Beschränkungen gelten mit hoher Wahrscheinlichkeit.
Konstruktion von geometrischen Spannern mit geringem Durchmesser
197
4 Zusammenfassung
In dieser Ausarbeitung wurde gezeigt, dass t-Spanner mit einem erwarteten Durchmesser
von O(log n) für t = 1/(cos Θ −sin Θ) existieren. Es handelt sich dabei um eine randomisierte Datenstruktur, welche auf Skip-Listen und Θ-Graphen basiert. Der sogenannte Skip List
Spanner enthält eine erwartete Anzahl von O((c/Θ)d−1 n) Kanten für eine Konstante c. Die
Zeit zum Bestimmen eines t-Spanner Pfades ist mit hoher Wahrscheinlichkeit beschränkt
durch O(log(1/Θ) log n). Der Algorithmus zum Bestimmen des gesuchten Pfades ist deterministisch, jedoch kann wegen der ihm zugrunde liegenden randomisierten Datenstruktur
lediglich eine Aussage über die zu erwartende Laufzeit getroffen werden.
Arya, Mount und Smid nennen in [4] einige Konstruktionen von geometrischen Spannern,
in welchen t-Spanner Pfade bis zu Ω(n) Kanten enthalten können. Durch den hier mit hoher
Wahrscheinlichkeit zu erzielenden Wert von O(log n) ist ein t-Spanner Pfad effizienter zu
speichern und durch die vergleichsweise geringe Anzahl an zu besuchenden Knoten und
Kanten in bestimmten Anwendungsfällen zu bevorzugen.
Um die dem Skip List Spanner zugrunde liegenden Θ-Graphen effizient konstruieren zu können, wurde eine auf orthogonalen Bereichsanfragen von Bereichsbäumen basierende Technik vorgestellt, mit dessen Hilfe es möglich ist, den Skip List Spanner
in erwarteter Zeit O((c/Θ)d−1 n logd−1 n) mit einem erwarteten Speicherplatzbedarf von
O((c/Θ)d−1 n + logd−2 n) zu konstruieren. Im Vergleich zu ähnlichen Verfahren konnte hier
durch das Vorwissen, dass für alle Punkte der Punktmenge S eine Bereichsanfrage gestartet
wird, Speicherplatz in Höhe eines Faktors von log n eingespart werden.
Literaturverzeichnis
1. J. Ruppert, R. Seidel (1991) Approximating the d-dimensional complete Euclidian graph, Proc. 3rd
Canadian Conf. on Computational Geometry 207–210.
2. W. Pugh (1990) Skip Lists: A probabilistic alternative to balanced search trees, Communications of
the ACM 33:668–676.
3. S. Arya, M. Smid (1997) Efficient construction of a bounded degree spanner with low weight, Algorithmica 17:33–54.
4. S. Arya, D. M. Mount, M. Smid (1999) Dynamic algorithms for geometric spanners of small diameter:
Randomized solutions, Computational Geometry: Theory and Applications 13(2):91–107.
5. M. de Berg, M. van Kreveld, M. Overmars, O. Schwarzkopf (1997) Computational Geometry – Algorithms and Applications. Springer Verlag.
6. R. Klein (1997) Algorithmische Geometrie – Grundlagen, Methoden, Anwendungen. Springer Verlag.
7. K. Mulmuley (1994) Computational Geometry, an Introduction through Randomized Algorithms. Prentice Hall, Englewood Cliffs.
8. A.C. Yao (1982) On constructing minimum spanning trees in k-dimensional spaces and related Problems, SIAM J. Comput. 11:721–736.
9. B. Chazelle, J. Friedman (1994) Point location among hyperplanes and unidirectional ray-shooting,
Computational Geometry – Theory and Applications. 4:53–62.
Ein einfacher, linearer (1+) - Approximationsalgorithmus für
das k-Means Clustering Problem
Markus Heberling
Universität Paderborn [email protected]
Zusammenfassung. k-Means Clustering ist das Auffinden von k Mittelpunkten zu einer Menge von Punkten, so dass die Summe aller Entfernungen von allen Punkten zu ihrem nächsten Mittelpunkt minimal ist.
In dieser Ausarbeitung wird ein Algorithmus beschrieben, der eine (1+) - Approximation des k-Means
Clusterings in linearer Zeit liefert.
Die Idee des Algorithmus ist es, den Mittelpunkt des größten Clusters einer Punktmenge zu approximieren, indem alle Untermengen einer konstanten Größe durchprobiert werden. Um diesen Mittelpunkt
können dann Punkte aus der Gesamtmenge weggenommen werden und es kann rekursiv der Mittelpunkt
des nächstkleineren Clusters ermittelt werden.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
1.1 Unreduzierbarkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
2
1-Means und 2-Means . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
2.1 1-Means . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
2.2 2-Means . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3
k-Means Näherung in linearer Zeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3.1 Idee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3.2 irred-k-means . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
3.3 k-Means . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
4
Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
5
Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
1 Einleitung
Diese Ausarbeitung beschäftigt sich mit dem Thema k-Means Clustering, und einer linearen Approximation, die in [6] beschrieben ist. Sie baut auf der Proseminar Ausarbeitung
von Holger Bürger zum Thema 2-Means auf. Zunächst folgt eine kurze Wiederholung der
Problemstellung.
P
Das k-Means Clusteringproblem ist durch die Formel min( p∈P d(p, C)2 ) definiert. Dabei ist C die Menge der Mittelpunkte und d(p, C) ist die Entfernung von p zum nächsten
Punkt aus C. Dies bedeutet, dass jeder Punkt p ∈ P seinem nächsten Mittelpunkt aus C
200
Markus Heberling
zugewiesen wird. Somit bilden alle Punkte, die dem gleichen Mittelpunkt zugewiesen sind,
einen Cluster.
Für variable k und n ist das Problem NP-Schwer. Bei konstanten k kann es in Polynomieller Laufzeit gelöst werden. So wird in [5] ein optimaler Algorithmus beschrieben,
der das k-Means Problem in O(nkd+1 ) löst. Einer der meist benutzten Algorithmen zur
Approximation des k-Means Problems ist Lloyds Algorithmus [7]. Dabei werden k zufällige Mittelpunkte gewählt. Für jeden Punkt der Gesamtmenge wird der Mittelpunkt mit
der kürzesten Distanz bestimmt. Punkte mit dem gleichen Mittelpunkt bilden dann einen
Cluster. Für jeden der erhaltenen Cluster wird dann ein neuer Mittelpunkt berechnet und
es werden wieder alle Punkte dem am kürzesten entfernten Mittelpunkt zugeordnet. Dies
wird solange wiederholt, bis keine Änderung mehr eintritt. Dabei kann man die Laufzeit
des Algorithmus nicht abschätzen. Außerdem kann es passieren, dass der Algorithmus in
einem beliebig schlechten lokalen Minimum endet. Es lassen sich also weder Aussagen über
Genauigkeit noch über das Laufzeitverhalten treffen.
Ein häufiger Verwendungszweck des k-Means Algorithmus ist im Data-Mining. Eine gegebene Datenmenge mit verschiedenen Dimensionen soll dabei in Ähnlichkeitscluster unterteilt
werden. Mithilfe des k-Means Clusterung können aber auch zum Beispiel Farben in in einem
Bild reduziert werden, um das Bild zu komprimieren (Abbildung 1). Dazu werden die RGB
oder CMYK Werte der einzelnen Pixel als Dimensionen angesehen. Dazu können dann k
Mittelpunkte gefunden werden. Jeder Pixel wird dann durch die Farbwerte seines zugehörigen Mittelpunktes ersetzt. Anstatt z.B. 24Bit/Pixel benötigt man bei einer Reduzierung
auf 32 Farben nur noch 5Bit/Pixel. Dazu kommt dann noch ein Index von 32*24Bit. Diese
Farbreduzierung ist sehr schnell und liefert relativ gute Ergebnisse. Zur weiteren Geschwindigkeitsverbesserung kann das Berechnen des Clusters auch auf eine Untermenge aller Pixel
angewendet werden.
Abb. 1. Bildkompression mit k=32[3]
(1+) - k-Means - Approximation
201
Eine lineare Annäherung für k = 2 wurde im Kapitel von Holger Bürger bereits beschrieben. Der Algorithmus für das k-Means Problem basiert hierauf. Ziel ist es für das k-Means
Problem einen Näherungsalgorithmus zu beschreiben, der in Laufzeit O(nd) eine Näherung
liefert, die maximal um einen konstant gewählten Faktor vom Optimum abweicht. In 2
wird ein 3-Means Clustering gezeigt. Dabei sind die Sterne die Clustermittelpunkte.
Abb. 2. 3-Means Beispiel
1.1 Unreduzierbarkeit
Im weiteren Verlauf wird der Begriff der Reduzierbarkeit bzw. Unreduzierbarkeit benötigt.
Definition 1. Ein Problem ist (k, ))-unreduzierbar, wenn gilt ∆k−1 (P ) ≤ (1 + 32)∆k (P )
Wenn wir für ein Problem also anstatt der k-Means Lösung eine (k-1)-Means Lösung
finden können, die Nahe an der optimalen k-Means Lösung liegt, so können wir das k-
202
Markus Heberling
Means Problem auf ein einfacheres (k-1)-Means Problem reduzieren. Ist dies nicht der Fall,
so ist das Problem unreduzierbar.
2 1-Means und 2-Means
Kurz zur Wiederholung sind hier die Konzepte für 1-Means und 2-Means aufgeführt. Die
Beweise dazu finden sich in der Ausarbeitung von Holger Bürger.
2.1 1-Means
Die optimale Lösung des 1-Means Problem ist der Mittelpunkt der gegebenen Punktmenge. Durch Random-Sampling kann in konstanter Zeit ein Mittelpunkt angenähert werden.
Dazu werden einige Punkte der Originalmenge zufällig ausgewählt, und es wird für diese
Untermenge der Mittelpunkt bestimmt. Verschiedene mögliche Ergebnisse sind in Abbildung 3 dargestellt. Wenn man dabei m = 2/ zufällige Punkte auswählt, erhält man mit
der Wahrscheinlichkeit 1/2 eine (1 + )-Approximation des 1-Means Problems.
Abb. 3. Random Sampling
(1+) - k-Means - Approximation
203
2.2 2-Means
Für das 2-Means Problem benötigen wir zunächst das Superset Sampling Lemma:
Lemma 1 (Superset Sampling Lemma). Es gilt
)∆1 (P 0 ) mit konstanter Wahrscheinlichkeit.
min
S 0 :S 0 ⊂S,|S 0 |= 2
∆(P 0 , c(S 0 )) ≤ (1 +
Dieses Lemma sagt aus, dass wir für eine Untermenge P 0 von P eine gute Approximation
erhalten, obwohl P 0 noch nicht bekannt ist. Dazu sei |P 0 | ≥ β|P |, wobei β zwischen 0 und 1
4
liegt. Dann können wir von P eine zufällige Menge S der Größe β
nehmen. Für alle mögli2
0
chen Untermengen S der Größe von S können wir nun den Mittelpunkt c(S 0 ) berechnen.
Nach Lemma 1 ist einer dieser Mittelpunkte eine gute Annäherung an den Mittelpunkt von
P 0.
Wir nehmen an die beiden optimalen Mittelpunkte seien c1 und c2 und die dazugehörigen
Cluster P1 und P2 . Es gelte P1 ≤ P2 , dann können wir von P eine Menge S der Größe 1
samplen. Wenn wir von S nun alle Mittelpunkte aller Untermengen der Größe 2 ermitteln
ist nach Lemma 1 eines davon eine gute Annäherung an c1 . Wir nennen diesen Mittelpunkt
c01 .
Um den Punkt c01 können wir nun alle Punkte entfernen, die einen Abstand kleiner als
t/4 zu c01 haben. t ist der Abstand der beiden optimalen Mittelpunkte c1 und c2 . Wenn
die Punkte entfernt sind kann im zweiten Schritt durch erneute Anwendung des Superset
Sampling Lemmas der Mittelpunkt c02 bestimmt werden. Da das Lemma jeweils eine Menge von Punkten zurück gibt, wird der zweite Schritt für jedes Element der ersten Menge
durchgeführt. Es wird dann zum Schluss das beste Ergebnis zurückgeliefert.
Zu beachten ist, dass der Wert t nicht bekannt ist. Es werden daher verschiedene Werte
für t ausprobiert. Dies wird in der 2-Means Ausarbeitung näher beschrieben.
3 k-Means Näherung in linearer Zeit
3.1 Idee
Die Grundidee zur Lösung des k-Means Problems ist die selbe wie beim 2-Means Problem.
Wir wollen rund um einen gefundenen Mittelpunkt, Punkte aus der Gesamtmenge entfernen, so dass die Gesamtpunktmenge kleiner wird und in der verbliebenen Punktmenge ein
anderer Cluster größer ist. Dies können wir dann für alle Cluster machen und so die Punktmenge immer weiter verkleinern und jeweils den Mittelpunkt des größten Clusters in der
verbliebenen Menge suchen.
Dazu suchen wir mittels Superset Sampling zunächst den Mittelpunkt des größten Clusters. Um diesen Mittelpunkt können wir nun alle Punkte entfernen, die in einem Radius
von t/4 um diesen Punkt liegen. t/4 ist dabei der Abstand zwischen dem optimalen Mittelpunkt dieses Clusters und dem optimalen Mittelpunkt, der am nächsten zu ihm liegt. Da die
optimalen Clustermittelpunkte nicht bekannt sind, muss t/4 wie beim 2-Means Verfahren
angenähert werden. Sobald die Punkte entfernt sind kann man in der verbliebenden Punktmenge den nächst größten Cluster suchen (Abbildung 4). Dabei ist zu beachten, dass das
Superset Sampling nicht genau einen Mittelpunkt zurück liefert, sondern eine Menge von
Punkten, von denen einer eine gute Annäherung zum richtigen Mittelpunkt ist. Wir führen
204
Markus Heberling
den 2. Schritt also nicht nur für einen Punkt aus sondern für jeden Punkt dieser Menge. Dies
wiederholen wir k-mal, so dass wir für jeden der k Mittelpunkte eine Annäherung erhalten.
Als Ausgabe liefern wir dann die beste Clusterung, die wir ermittelt haben.
t
t
t/4
Abb. 4. 3-Means Beispiel
3.2 irred-k-means
Wir gehen zunächst davon aus, das das gegebene Problem k-unreduzierbar ist. Zunächst sei
der Algorithmus angegeben:
Funktionsweise
Der Algorithmus kombiniert das Random-Sampling (Zeile 6) und das verkleinern der Punktmenge (Zeile 10). Die erste Rekursion in Zeile 9 führt dazu, dass der nächst kleinere Cluster
gefunden wird. Die zweite Rekursion in Zeile 9 ist die Verkleinerung der Punktmenge. Beim
(1+) - k-Means - Approximation
205
Algorithmus 20 Irred-k-Means(Q, m, k, C, α, Sum)
Vorbedingung: Q: Verbliebende Punkt Menge, m: Anzahl noch zu findender Cluster, k: Gesamtanzahl
Cluster, C Menge der k − m bereits gefundenen Mittelpunkte, α: Approximationsfaktor, Sum: Kosten
der Clustering von P − Q zu C
1: if m = 0 then
2:
Ordne alle Punkte in Q ihrem jeweiligen nächsten Mittelpunkt zu
3:
Sum = Sum+Clustering Kosten von Q
4:
return Clustering
5: else
6:
Erstelle ein Random Sampling der Größe O(k/α2 ) von Q
7:
for alle Untermengen S 0 der Größe O(1/α) von S do
8:
Finde den Mittelpunkt c von S 0
S
9:
Finde das Clustering irred-k-Means(Q, m − 1, k, C c, α, Sum)
10:
Betrachte die Punkte in Q in aufsteigender Entfernung von C
11:
U seien die ersten |Q|/2 Punkte dieser Sequenz
12:
Ordne alle Punkte in U ihrem jeweiligen nächsten Mittelpunkt aus C zu
13:
Sum = Sum+Clustering Kosten von U
14:
Finde das Clustering irred-k-Means(Q − U, m, k, C, α, Sum)
15:
return Clustering mit den minimalen Kosten
2-Means Clustering war die Punktmenge, die entfernt werden kann als Ball der Größe t/4
um den ersten gefunden Cluster definiert. Wobei t der Abstand der beiden optimalen Mittelpunkte c1 , c2 ist. Beim k-Means Clustering können wir t definieren als den Abstand des
optimalen Mittelpunkts ci zum nächsten anderen optimalen Mittelpunkt. Wie beim 2-Means
Clustering wissen wir vorab nicht, wie groß dieser Abstand ist. Deshalb benutzen wir die
gleiche Technik um trotzdem die entsprechenden Punkte entfernen zu können. Dabei nehmen wir jeweils die Hälfte der Punkte, die näher an den bereits gefunden Clustern liegen
und berechnen ein Clustering für P ohne diese Punkte. Da dies rekursiv geschieht bis wir
nur noch einen Punkt haben, ist eines dieser Clusterings das Clustering, bei dem genau
die Punkte des Balls mit dem Radius t/4 um ci entfernt worden sind. Da wir das beste
Clustering nehmen, erhalten wir als Rückgabe genau dieses Clustering.
Korrektheit
Theorem 1. Angenommen eine Punktmenge P ist (k, α)-unreduzierbar. dann liefert der
Algorithmus Irred-k-means(P, k, k, ∅, α, 0) mit der Wahrscheinlichkeit γ k eine Lösung des
k-Means Problems mit den Kosten (1 + α)∆k (P ). dabei ist γ eine von k unabhängige Konstante.
Beweis. Wir betrachten eine optimale k-Means Lösung für die Eingabemenge P . c1 , . . . , ck
seien die Mittelpunkte, die P in die Partitionen P1 , . . . , Pk aufteilen. Die einzige Zufallsquelle
in unserem Algorithmus ist das Superset-Sampling-Lemma (Lemma 1). Dieses Lemma liefert
aber nur mit einer gewissen Wahrscheinlichkeit das gewünschte Ergebnis. Wir nehmen fürs
erste an, dass das Lemma immer das gewünschte Ergebnis liefert, und berechnen hinterher
für welche Wahrscheinlichkeit unser Algorithmus erfolgreich ist.
Für die Eingabe (P, k, k, ∅, α, 0) wird der Algorithmus Irred-k-means mehrmals rekursiv Aufgerufen. Sei C die Menge aller Aufrufe von Irred-k-means mit der Eingabe
(P, k, k, ∅, α, 0). Ci sei die Menge der Aufrufe, in denen die Anzahl der bereits gefundenen
Mittelpunkte C die Größe i hat. Für alle i soll folgende Invariante gelten:
206
Markus Heberling
1. Sei C = {c01 , . . . , c0i }, dann gilt für j = 1, . . . , i, ∆(Pj , c0j ) ≤ (1 + α)∆(Pj , cj )
2. Die Menge P − Q ist eine Untermenge von P1 ∪ . . . ∪ Pi
Wenn wir zeigen können, dass die Invariante für i = k gilt, haben wir gezeigt, dass der
Algorithmus korrekt arbeitet. Für i = 0 ist die Invariante erfüllt. Wir zeigen jetzt mittels
Induktion, dass die Invariante für i + 1 gilt, wenn sie für i gilt.
Da die Invariante für i gilt, gibt es Parameterlisten in Ci , für die die Invariante gilt.
Von diesen Listen wählen wir die Liste (Q, m, k, C, α, Sum), für die |Q| minimal ist. Wir
betrachten das Paar von Mittelpunkten der Mengen cl ∈ {c1 , . . . , ci } und cr ∈ {ci +1, . . . , ck }
mit dem kürzesten Abstand von einander. Sei t = d(cl , cr )
Lemma 2. Sei S die Menge von Punkten B(c01 , t/4) ∪ . . . ∪ B(c0i , t/4)), also die Punkte, die
höchstens t/4 von {c01 , . . . , c0i } entfernt sind. Dann ist S in P1 ∪ . . . ∪ Pi enthalten und P − S
enthält höchstens |Pi+1 |/α Punkte von P1 ∪ . . . ∪ Pi .
Beweis. Wir nehmen an, dass Pj einen Punkt von S enthält, j > i. Wir sagen Pj enthalte
einen Punkt x ∈ B(c0q , t/4), q ≤ i.
Behauptung. d(cq , c0q ) ≥ t/4.
Beweis. Wir nehmen das Gegenteil an. Dann ist d(cq , x) < t/2. x ist aber seinem nächsten
Mittelpunkt zugeordnet, also d(cj , x) ≤ d(cq , x) < t/2. Dann gilt d(cj , cq ) < t, was ein
Widerspruch ist.
t
u
Wir wissen das ∆(Pq , c0q ) ≤ (1 + α)∆(Pq , cq ) ist. Aber durch die Gleichung (2)1 wissen
wir das ∆(Pq , c0q ) = ∆(Pq , cq ) + |Pq |d(cq , c0q )2 ist. Wir wissen also:
|Pq |d(cq , c0q )2 ≤ α∆(Pq , cq )
(1)
Es gilt d(cq , cj ) ≤ d(cq , c0j ) + d(cq , x) + d(x, cj ) und d(x, cj ) ≤ d(x, cq ) ≤ d(x, c0 q) +
d(cq , c0q ). Wir erhalten also d(cq , cj ) ≤ 2d(c0q , x) + 2d(cq , c0q ). Zusammen mit dem Claim von
oben erhalten wir, d(cq , cj ) ≤ 4d(cq , c0q ). Angenommen wir würden alle Punkte von Pq dem
Mittelpunkt cj zuordnen. Dann erhalten wir als Kosten:
∆(Pq , cj ) = ∆(Pq , cq ) + |Pq |d(cq , cj )2
≤ ∆(Pq , cq ) + 16|Pq |d(cq , c0q )2
≤ (1 + 16α)∆(Pq , cq )
Die letzte Ungleichung folgt von Gleichung 1. Aber dies widerspricht der Bedingung, das P
(k, α)-unreduzierbar ist. Also ist S in P1 ∪ . . . ∪ Pi enthalten.
Angenommen P −S enthält mehr als Pl /α Punkte von P1 ∪. . .∪Pi . In diesem Fall werden
diese Punkte Mittelpunkten zugewiesen, die mindestens eine Entfernung von t/4 haben. Es
2 |P |
l
sind. Dies bedeutet,
folgt, dass die Kosten der optimalen Lösung ∆k (P ) mindestens t16α
2
t |Pl | ≤ 16α∆k (P ). Wenn wir nun aber alle Punkte in Pl cr zuweisen, dann erhöhen sich
die Kosten maximal um 16α∆k (P ), was bedeuten würde, dass P (k, α)-reduzierbar ist, was
ein Widerspruch ist.
t
u
1
Definiert in der Ausarbeitung von Holger Bürger
(1+) - k-Means - Approximation
207
Sei S die Punktmenge B(c01 , t/4) ∪ . . . ∪ B(c0i , t/4) und P 0 = P − S. Wir wissen, dass
Pi+1 ∪ . . . ∪ Pk in P 0 ∩ Q enthalten ist.
Behauptung. |Pi+1 | ≥ αk |P 0 |.
Beweis. Wegen Lemma 2 gibt es höchstens |P i + 1|/α Elemente von P1 ∪ . . . ∪ Pi in P 0 .
Also gilt |P 0 | ≤ |Pi+1 |/α + |Pi+1 | + . . . + |Pk | ≤ |Pi+1 |/α + k|Pi+1 | ≤ αk |P i + 1|
t
u
Es folgt, dass |P i + 1| ≥ αk |P 0 ∩ Q|. Wenn wir also P 0 kennen würden, dann könnten wir
mit Lemma 1 einen Punkt c0i+1 berechnen der eine gute Approximation zu ci+1 ist, in dem
wir O(k/α2 ) Punkte von P 0 ∩ Q samplen. Leider kennen wir P 0 nicht.
Lemma 3. |P 0 ∩ Q| ≥ |Q|/2.
Beweis. Wir nehmen das Gegenteil an: |P 0 ∩ Q| ≤ |Q|/2.
Behauptung. Wir betrachten die Punkte in Q aufsteigend sortiert nach der Entfernung von
C. U seien die ersten |Q|/2 Punkte. Dann enthält U keinen Punkt aus P 0 ∩ Q.
Beweis. Sei x ∈ P 0 und y ∈ P − P 0 , dann behaupten wir, dass y näher zu C ist als x. Wegen
der Definition von P 0 gibt es einen Mittelpunkt c, für den gilt, dass d(c, y) ≤ t/4. Wäre x
näher an C als y, dann gäbe es einen Mittelpunkt in C, dessen Abstand zu x höchstens t/4
beträgt. Aber dann gilt x ∈ P − P 0 , ein Widerspruch zu x ∈ P 0 .
u
t
P 0 ∩Q ist also eine Untermenge von Q−U . da Pi+1 ∪. . .∪Pk in P 0 ∩Q enthalten ist (Lemma
2), folgt, dass Pi+1 ∪ . . . ∪ Pk eine Untermenge von Q − U ist. Daher ist die Parameterliste
(Q − U, C, k, m, α, Sum) in Ci . dies ist ein Widerspruch dazu, dass (Q, C, k, m, α, Sum) in
Ci ist. Dies beweist das Lemma.
u
t
Es wurde also gezeigt, dass die Invariante für alle i gilt und somit der Algorithmus das
korrekte Ergebnis liefert.
Wahrscheinlichkeit
Wir hatten bisher eine Wahrscheinlichkeit für das gewünschte Ergebnis des Superset Sampling Lemmas mit 1 angenommen. Das Superset Sampling Lemma 1 liefert das gewünschte
Ergebnis jedoch nur mit einer konstanten Wahrscheinlichkeit kleiner 1. In jedem Durchlauf
der Rekursion in Zeile 9 wird m um 1 verkleinert. Also sind in jeder Abfolge von Rekursionsaufrufen höchstens k Aufrufe des Samplings. Es wurde eben gezeigt, dass es eine Parameter
Liste Ck gibt, für die C eine Menge von Mittelpunkten enthält, die nah an den optimalen
Mittelpunkten liegen. Wenn wir uns nun die Abfolge von Aufrufe anschauen, die zu dieser
Parameter Liste geführt haben, sehen wir, dass wir k Aufrufe des Samplings haben. Jeder
dieser Aufrufe liefert das gewünschte Ergebnis mit konstanter Wahrscheinlichkeit γ. Die
Wahrscheinlichkeit, dass wir genau diese Parameter Liste erhalten ist also γ k .
208
Markus Heberling
Laufzeit
Theorem 2. Der Algorithmus irred-k-Means, aufgerufen mit den Parametern (P, m, k, C, α, 0),
O(1)
hat eine Laufzeit von O(2(k/α) ), wobei n = |P | ist.
Beweis. Sei T (n, m) die Laufzeit des Algorithmus mit der Eingabe (Q,m,k,C, α,Sum),
wobei n = |Q| ist.
T (n, 0) = O(nd), da in diesem Fall nur der erste Fall in Zeile 1 ausgeführt wird und das
Zuordnen aller Punkte zu ihrem Mittelpunkt O(nd) Zeit benötigt.
T (n, 0) = O(nd)
(2)
(k/α)O(1)
In Zeile 7 erhalten wir u(k, α) = O(2
) Samples. Das Zuordnen der Mittelpunkte
in Zeile 8 benötigt O(d) Schritte. In Zeile 10 des irred-k-Means-Algorithmus werden die
|Q|/2 Punkte mit der geringsten Entfernung zu ihren jeweiligen Mittelpunkten berechnet.
Wenn man dies wie hier angegeben zunächst durch Sortierung und dann Auswahl der Punkte
macht, erhält man dort eine Laufzeit von O(n∗log n+n). Dies widerspricht der Behauptung,
dass der gesamte Algorithmus eine lineare Laufzeit erreicht. Die Auswahl der kleinsten k
Punkte kann aber auch in linearer Zeit geschehen, wie in [1] gezeigt wird. Wir erhalten also
für die Zeilen 10 bis 13 eine Laufzeit von O(nd)
Für den allgemeinen Fall erhalten wir also die rekursive Gleichung
T (n, m) = O(u(k, α))T (n, m − 1) + T (n/2, m) + O((n + u(k, α))d)
Diese Gleichung lässt sich zu T (n, k) = O(2k/α
t
u
O(1)
(3)
dn) auflösen.
3.3 k-Means
Um eine gute Lösung auch für reduzierbare Probleme finden zu können, werden wir den
Algorithmus irred-k-means für alle i = 1 . . . k durchlaufen (Algorithmus 21) und das Minimum als Ergebnis ausgeben. Dies erhöht die Laufzeit um den Faktor k, bleibt also immer
noch linear in der Menge der Punkte.
Algorithmus 21 k-Means(P, k, )
Vorbedingung: P : Punktmenge, k: Gesamtanzahl Cluster, : Approximationsfaktor
1: for i = 1 . . . k do
2:
Finde das Clustering irred-k-Means(P, i, i, ∅, /64k, 0)
3: return Clustering mit den minimalen Kosten
Es bleibt also nur noch zu zeigen, dass der Algorithmus korrekt arbeitet.
Sei i der größte Index, für den P (i, α)-unreduzierbar ist. Daraus folgt ∆i ≤ (1 +
32α)∆i+1 (P ) ≤ . . . (1 + 32α)k−1 ∆k (P ).
Weiterhin wissen wir, dass Irred-k-means(P, i, i, ∅, α, 0) eine Menge C mit i Mittelpunkten liefert, für die gilt ∆(P, C) ≤ (1+α)∆i (P ). Also bekommen wir ein Ergebnis mit Kosten
von höchstens (1 + 32α)k ∆k (P ). Dabei ist (1 + 32α)k = (1 + /2k)k ≤ 1 + .
Der Algorithmus liefert also eine (1 + )-Approximation des k-Means Problems.
(1+) - k-Means - Approximation
209
4 Vergleich
Im Vergleich mit anderen Näherungsverfahren, hat dieser Algorithmus den Vorteil, lineare
Laufzeit in der Menge der Punkte zu haben. Allerdings sind die konstanten Faktoren sehr
hoch. Das bedeutet, dass der Algorithmus erst bei sehr großen Eingabemengen schneller
ist als andere Algorithmen. Gerade bei Erhöhung der Wahrscheinlichkeit steigt die Laufzeit
exponentiell an. Ein Vergleich mit den Algorithmen von Inaba [5], Matousek [8], de la Vega
[2] and Har-Peled [4] ist in Abbildung 5 dargestellt.
Inaba (exact)
Matousek
de la Vega
Har-Peled
Kumar, Sabharwal, Sen (this)
Zeit
inf
1e+300
1e+250
1e+200
1e+150
1e+100
1e+50
1
100
0 1000
2000 3000
4000 5000
6000 7000
8000 9000
n
10000 1
10
k
Abb. 5. Vergleich verschiedener k-Means Algorithmen
In Abbildung 6 zeigt die Algorithmen mit den Parametern k=2, e=0.9, d=2. Es ist
zu erkennen, dass der lineare Algorithmus ab einer Eingabegröße von ca. 3 ∗ 1021 besser
abschneidet als der genaue Algorithmus. Hier ist auch klar der lineare Verlauf zu sehen. Die
anderen Algorithmen sind in dieser Grafik nur am unteren Rand zu erkennen.
Wenn man sich nun aber die Algorithmen mit den gleichen Parametern mit Logarithmischer Darstellung der y-Achse ansieht, dann fällt auf, dass die anderen Näherungsverfahren
deutlich unter dem exakten und dem linearen Verfahren liegen. (Abbildung 7). Für höhere
Dimensionen sieht es für diesen Algorithmus wieder besser aus, da die Dimension nur linear eingeht (Abbildung 8). Aber auch hier gibt es eine bessere Alternative. Bei höheren k
(Abbildung 9) und kleineren (Abbildung 10) sind die anderen Algorithmen jedoch wieder
deutlich besser.
210
Markus Heberling
1.2e+108
Inaba (exact)
Matousek
de la Vega
Har-Peled
Kumar, Sabharwal, Sen (this)
1e+108
Zeit
8e+107
6e+107
4e+107
2e+107
0
0
5e+20
1e+21
1.5e+21
2e+21
2.5e+21
3e+21
3.5e+21
4e+21
n
Abb. 6. Vergleich der Laufzeit bei Änderung der Größe der Punktmenge n
1e+120
Inaba (exact)
Matousek
de la Vega
Har-Peled
Kumar, Sabharwal, Sen (this)
1e+100
Zeit
1e+80
1e+60
1e+40
1e+20
1
0
5e+20
1e+21
1.5e+21
2e+21
2.5e+21
3e+21
3.5e+21
4e+21
n
Abb. 7. Vergleich der Laufzeit bei Änderung der Größe der Punktmenge n (Zeit-Achse logarithmisch)
(1+) - k-Means - Approximation
211
inf
Inaba (exact)
Matousek
de la Vega
Har-Peled
Kumar, Sabharwal, Sen (this)
1e+300
1e+250
Zeit
1e+200
1e+150
1e+100
1e+50
1
0
100
200
300
400
500
600
700
800
900
1000
d
Abb. 8. Vergleich der Laufzeit bei Änderung der Dimensionen d
inf
Inaba (exact)
Matousek
de la Vega
Har-Peled
Kumar, Sabharwal, Sen (this)
1e+300
1e+250
Zeit
1e+200
1e+150
1e+100
1e+50
1
10
20
30
40
50
60
70
80
k
Abb. 9. Vergleich der Laufzeit bei Änderung der Anzahl Cluster k
90
100
212
Markus Heberling
inf
Inaba (exact)
Matousek
de la Vega
Har-Peled
Kumar, Sabharwal, Sen (this)
1e+300
1e+250
Zeit
1e+200
1e+150
1e+100
1e+50
1
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1
e
Abb. 10. Vergleich der Laufzeit bei Änderung der Genauigkeit 5 Fazit
Insgesamt ist zu sagen, dass dieser Algorithmus zwar eine lineare Laufzeit hat, durch die hohen konstanten Faktoren jedoch oft andere Näherungen, oder sogar der genaue Algorithmus
schneller sind.
k
In [9] werden drei weitere Algorithmen mit sehr guten Laufzeiten von O( k dn), O(k 3 n2 log n)
und O(k 5 log3 kd) beschrieben. Diese Algorithmen liefern allerdings keine (1+) Approximation, sondern sind in dieser Beziehung schlechter.
Offen bleibt, ob es möglich ist die Performance weiter zu steigern, indem zum Beispiel für
kleinere Teilprobleme innerhalb dieses Algorithmus einer der anderen Algorithmen benutzt
wird, ohne dass dabei die Gesamtgenauigkeit verloren geht.
Literaturverzeichnis
1. Manuel Blum, Robert W. Floyd, Vaughan R. Pratt, Ronald L. Rivest, and Robert Endre Tarjan. Time
bounds for selection. J. Comput. Syst. Sci., 7(4):448–461, 1973.
2. Wenceslas Fernandez de la Vega, Marek Karpinski, Claire Kenyon, and Yuval Rabani. Approximation
schemes for clustering problems. In STOC, pages 50–58. ACM, 2003.
3. Alessandro Giusti. Clustering colors in an image. http://www.leet.it/home/lale/clustering.
4. Sariel Har-Peled and Akash Kushal. Smaller coresets for k-median and k-means clustering. Discrete &
Computational Geometry, 37(1):3–19, 2007.
5. Mary Inaba, Naoki Katoh, and Hiroshi Imai. Applications of weighted voronoi diagrams and randomization to variance-based k-clustering: (extended abstract). In SCG ’94: Proceedings of the tenth annual
symposium on Computational geometry, pages 332–339, New York, NY, USA, 1994. ACM.
6. Amit Kumar, Yogish Sabharwal, and Sandeep Sen. A simple linear time (1 + ) - approximation algorithm
for k-means clustering in any dimensions. In FOCS ’04: Proceedings of the 45th Annual IEEE Symposium
(1+) - k-Means - Approximation
213
on Foundations of Computer Science (FOCS’04), pages 454–462, Washington, DC, USA, 2004. IEEE
Computer Society.
7. S. Lloyd. Least squares quantization in pcm. IEEE Transactions on Information Theory, 28:129–137,
1982.
8. Jirí Matousek. On approximate geometric k-clustering. Discrete & Computational Geometry, 24(1):61–84,
2000.
9. Mingjun Song and Sanguthevar Rajasekaran. Fast k-means algorithms with constant approximation. In
Xiaotie Deng and Ding-Zhu Du, editors, ISAAC, volume 3827 of Lecture Notes in Computer Science,
pages 1029–1038. Springer, 2005.
Peer-to-Peer Netzwerke: Skip-Graph
Marc Borowski
Universität Paderborn
Zusammenfassung. In dieser Ausarbeitung wird die Datenstruktur Skip-Graph vorgestellt. Diese ist in
der Lage Daten verteilt auf Knoten eines Peer-to-Peer Netzen zu speichern und zu suchen. Dabei werden die
Hauptanforderungen bei P2P Netze, wie Dezentralisierung, Fehlertoleranz, Skalierbarkeit und Lastverteilung
berücksichtigt. Gegenüber alternativen Lösungen bietet der Skip-Graph eine sehr hohe Ausfallsicherheit der
Datenstruktur bei jeder Art von Ausfällen einzelner Peers und eröffnet zudem weitere Möglichkeiten, wie
eine Bereichssuche.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
1.1
1.2
1.3
1.4
Eigenschaften von Peer-to-Peer Netzwerken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Existierende Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
Verteilte Hashtabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
2
Die Datenstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
2.1 Skip-Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
2.2 Skip-Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
3
Operationen auf einem Skip-Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
3.1
3.2
3.3
3.4
Die Suche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Einfügen neuer Peers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
Entfernen von Peers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Operationen bei mehrfachem gleichzeitigen Zugriff . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
4
Qualitätsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
4.1 Fehlertoleranz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
4.2 Auslastung der Peers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
5
Varianten und Erweiterungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
5.1 Mehrere Nachfolger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
5.2 SkipNet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
5.3 Expander Graphen in Skip-Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
6
Zusammenfassung und Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
216
M. Borowski
1 Einleitung
Die Verbreitung von Peer-to-Peer Netzwerken (P2P) hat in den letzten Jahren stark zugenommen. Die Verwendung kostengünstiger Massencomputer ermöglicht große finanzielle
Einsparungen gegenüber dem Betrieb großer Serverarchitekturen.
1.1 Eigenschaften von Peer-to-Peer Netzwerken
Heutige P2P-Anwendungen werden insbesondere durch drei wichtige Eigenschaften beschrieben:
Client- und Serverfunktionalität: In einem P2P-Netzwek kann jeder Knoten im Kontext einer Anwendung Daten speichern, senden und empfangen. Er ist damit in der Lage,
sowohl Client- als auch Serverfunktionalität zu leisten. Im idealen Fall sind alle Knoten
gleichberechtigt und gleichwertig.
Direkter Austausch zwischen Peers: Wenn zwei Knoten eines Netzwerks direkt miteinander
verbunden sind, können sie in Echtzeit miteinander interagieren. Es gibt keine zentrale
Instanz, die die Kommunikation verzögert oder filtert. Dabei ist es unerheblich welche
Daten zu welchem Zweck ausgetauscht werden.
Autonomie: Den Knoten eines P2P-Netzwerkes kommt dabei vollkommene Autonomie im
Sinne der (Selbst-) Kontrolle ihrer eigenen Aktivitäten zu, d.h. sie allein legen fest,
wann und in welchem Umfang sie ihre Ressourcen anderen zur Verfügung stellen. Als
Folge dieser Autonomie ist nicht sichergestellt, dass ein Knoten dem Netz ständig zur
Verfügung steht. Das Netzwerk muss also tolerieren, dass die Knoten nicht permanent
online sind.
1.2 Existierende Lösungen
Es gibt viele verschiedene Ansätze, wie Daten in einem P2P Netz bereitgestellt und gefunden
werden können. P2P Architekturen können dabei in zentrale und dezentrale Architekturen
unterteilt werden.
Bei zentralen P2P-Netzwerken ist ein zentraler Server erforderlich, auf dem gespeichert ist,
welcher User welche Daten zum Tausch bereitstellt. Nun richtet das Filetauschprogramm
des Users seine Suchanfrage direkt an diesen Server und erhält von dem wiederum die Suchergebnisse zurück. Hierbei werden die Suchergebnisse erheblich schneller geliefert als beim
dezentralen P2P. Wird nun ein File geladen, geschieht dies allerdings nun direkt vom anderen User.
Diese Technik hat aber den Nachteil, dass das File-Sharing-Programm im Falle eines Verbotes abgeschaltet werden kann. Dies kann dann ganz leicht durch ein Abschalten der Server
bewerkstelligt werden.
Napster
Napster ist kein reines P2P-System, da ein zentraler Datenbank-Server Suchanfragen verwaltet. Sobald sich ein Peer in das Napster-Netzwerk einloggt, werden vom Napster-Server
P2P: Skip-Graph
217
napster.com
S
S
P
P
S
P
Peer
S
Server
R
Response
Q
Query
S
P
R
P
Download
Q
P
P
Abb. 1. Napster
die Dateien registriert, die der Anwender zur Verfügung stellt. Bei einer Suchanfrage liefern
die Napster-Server eine Liste von Peers, die die gewünschte Datei zum Downloaden bereitstellen. Der Anwender kann dann eine direkte, serverlose Verbindung zu den Anbietern
aufbauen und die Dateien beziehen.
Die Server stellen damit den Flaschenhals des Netzwerkes dar: Die maximale Anzahl von
gleichzeitigen Suchanfragen ist durch die Hardware begrenzt und ein Ausfall führt zum Zusammenbruch des ganzen Netzes.
Gnutella
P
P
P
D
Peer
Q
Query
R
Response
D
File Download
R
P
P
R
P
Q
Q
P
P
Q
Q
Abb. 2. Gnutella
Gnutella wurde im März 2000 vom WinAmp-Entwickler Nullsoft herausgegeben und war
nur kurze Zeit - bis zur Übernahme via Nullsoft durch AOL - erhältlich.
Gnutella ist ein Protokoll für den Datenaustausch in dezentralen Netzwerken. Netzwerke
die auf der Gnutella-Technologie basieren, kommen damit ohne zentrale Instanzen aus. Alle
Rechner im Netz fungieren deshalb gleichzeitig sowohl als Server, als auch als Client. Sie
218
M. Borowski
werden deshalb auch als Servents bezeichnet.
Suchanfragen funktionieren hier nach dem „Schneeballprinzip“: Eine Suchanfrage wird an
alle direkt verbundenen Peers weitergeleitet. Diese leiten die Anfrage wiederum an benachbarte Peers weiter, bis eine zuvor bestimmte Suchtiefe erreicht wird. Positive Suchergebnisse
werden dann über die Route der eingehenden Anfrage zurück an den Anfrager gesendet, so
dass dieser die gewünschte Datei direkt von dem Anbieter herunterladen kann.
Durch das Fehlen einer zentralen Komponente ist eine Überwachung oder Abschaltung von
Gnutella-basierten Netzwerken kaum möglich. Das ist der wichtigste Unterschied zu Napster. Außerdem beschränkt sich Gnutella, anders als Napster, nicht nur auf MP3-Dateien
sondern bietet allgemeines File-Sharing an.
Freenet
Freenet ist ein dezentrales geschlossenes Netzwerk zum Speichern und Austausch von Informationen, welches ohne zentrale Instanz auskommt. Entwickelt wurde Freenet von Ian
Clarke mit dem Ziel, ein Netzwerk zu schaffen, in dem Informationen anonym bezogen werden und auf Anforderung zur Verfügung gestellt werden können. Die Dateien werden zu
diesem Zweck verschlüsselt auf den PCs der teilnehmenden Peers gespeichert. Nur der Herausgeber der Informationen ist in der Lage diese zu verändern. Die Peers wissen dabei nicht,
welche Daten auf ihrer Festplatte abgelegt werden. Nutzer dieses Systems Nutzer dieses System müssen lediglich eine kleine Software installieren, die als Server und Client funktioniert.
Jeder (der sich darauf versteht) kann Client oder Serverprogramme für Freenet schreiben.
Freenet basiert auf einem offenen Protokoll. Autoren und Leser von Informationen bleiben
anonym, wenn sie es wünschen. Informationen werden in einer Weise in Freenet verteilt,
dass es schwer zu beurteilen ist, wo die Information gespeichert ist. Jeder Computerbesitzer kann Informationen veröffentlichen. Dafür benötigt er weder einen Domainnamen, noch
gekauften Speicherplatz auf einem Webserver. Sein eigener Computer wird zum Webserver.
Welche Informationen des eigenen Computers der Nutzer freigibt, entscheidet er selbst.
Freenet arbeitet mit einer fehlertoleranten, anpassbaren, verteilten Suchmaschine (FASD).
FASD arbeitet mit Schlüsseln für Metadaten, das ist eine bewertete Liste, welche den Inhalt eines Dokumentes im darunterliegenden Netzwerk beschreibt. Obwohl FASD dezentral
arbeitet, ist diese Technik in der Lage so effektiv wie eine zentrale Suchmaschine zu arbeiten.
Wuala
Einen ähnlich Ansatz verfolgt auch das an der ETH Zürich entwickelte Wuala. Das erst vor
kurzen veröffentlichte System fragmentiert Dateien mit einem Reed-Solomon-Code. Diese
Fragmente sind redundant, sodass nur ein Teil der Fragmente zur Wiederherstellung der
vollständigen Datei benötigt wird. Die Fragmente werden anschließend auf Knoten des P2P
Netzes verteilt. Daten, die nur privat oder einer geschlossenen Benutzergruppe zur Verfügung stehen sollen werden zuvor mit AES verschlüsselt.
Die Daten werden auf den Knoten, wie in einer verteilten Hashtabelle gespeichert. Knoten
kennen dabei nur ihre direkten Nachbarn. Eine Suche erfolgt, indem die Suchanfrage immer
zu einem Knoten weitergeleitet wird, dessen Schlüssel eine größere Übereinstimmung mit
dem Ziel hat. Zur Optimierung des Netzes speichert jeder Knoten auch weitere zufällige
P2P: Skip-Graph
219
Verbindungen, die er aufgrund von Routinginformationen aus vorhergehenden Suchanfragen erzeugen hat.
1.3 Verteilte Hashtabellen
Es gibt viele Topologieansätze von P2P Netzwerken, die auf verteilten Hashtabellen (DHT)
aufbauen. Ihnen gemein ist die Methode, die Daten vorher durch die Anwendung einer Hashfunktion auf den Schlüssel auf die Peers zu verteilen. Anschließend wird über die physikalische Netzstruktur ein virtuelles Netz aufgebaut, dass das effiziente Auffinden der Schlüssel
ermöglicht.
Verteilte Hashtabellen dienen zur gleichmäßigen Verteilung von Datenobjekten auf die Knotenmenge. Der Speicherort soll dabei mit möglichst geringen Aufwand schnell und effizient
gefunden werden.
Der Begriff Content-Addressable Network (CAN) [Rat00] bezeichnet eine Variante des
ortsunabhängigen Routing mithilfe eines geometrischen Ansatzes. Jeder Knoten ist für einen
Teilbereich der gesamten Hashtabelle verantwortlich (Zone). Diese hat mehrere Dimensionen und jeder Knoten kennt die physikalische Adresse seiner Nachbarn in dieser räumlichen
Datenstruktur. Eine Suchanfrage kann so immer zu einen Nachbarn weitergeleitet werden,
der eine geringere Distanz zu der Zielzone hat. Das Einfügen neuer Knoten verursacht eine
Teilung einer bestehenden Zone, wodurch ein hierarchischer Suchbaum entsteht.
Am MIT wurde Chord [SMK01] als Algorithmus für eine verteilte Hashtabelle entwickelt.
Alle Rechner wenden die Hashfunktion auf ihre IP-Adresse an und bilden einen Datenring
in aufsteigender Sortierung ihrer gehashten IP-Adresse. Alle Datenschlüssel werden auf dem
Datenring verteilt und auf den Rechner gespeichert, der dem Schlüssel nachfolgt. Da jeder
Rechner seinen Nachfolger kennt ist ein Auffinden der Daten garantiert. In der in [SMK01]
beschriebenen erweiterten Variante, dem skalierten Routing, werden zur Minimierung der
Laufzeit der Operationen jedoch außer dem direkten Nachfolger noch weitere Zeiger auf
andere Knoten gespeichert, die in der sogenannten Fingertabelle zusammengefasst werden.
Die Entfernung der in der Tabelle gespeicherten Nachbarn nimmt exponentiell zu um einen
größeren Folgebrereich zu adressieren. Somit ist der i-te Eintrag der Fingertabelle der 2i−1
Nachbar auf dem Ring in Uhrzeigerrichtung. In dieser Variante besitzt jeder Knoten zudem
noch einen Zeiger auf seinen Vorgänger. Damit ist eine Suche mit der Laufzeit O(log n)
möglich.
Chord zeichnet sich wegen der Hashfunktion durch eine gute Lastverteilung aus. Zudem
steigen die Routingkosten nur logarithmisch an, weshalb dieses Verfahren gut Skalierbar ist.
1.4 Ausblick
Ein neue Möglichkeit Peers zu vernetzen zeigt der Skip-Graph. Ziel der Entwicklung dieser
Datentruktur ist es den Zusammenhang der Daten nicht zu zerstören, wie es bei verteilten Hashtabellen geschieht. Die Funktionsweise des von James Aspnes und Gauri Shah
[AspnesS2003] entwickelten Ansatzes zur Speicherung der Daten in einem P2P-Netz wird in
220
M. Borowski
den folgenden Kapiteln erläutert. Zudem wird die Laufzeit für die verschiedenen Operationen und die Eignung für ein P2P-Netz untersucht. Zum Schluss werden die Laufzeiten mit
anderen Architekturen verglichen.
2 Die Datenstruktur
Verteilte Hashtabellen (DHT) ermöglichen eine gute Lastverteilung auf einem Peer-to-Peer
Netz und garantieren eine gute Suchzeit von O(log n) bei einem Speicherverbrauch von ebenfalls O(log n). Auch das Einfügen neuer Schlüssel oder deren Löschung ist effizient möglich.
Allerdings nutzen sie nicht die Eigenschaft der räumlichen Nähe von Daten aus. Zudem ist
ihre gute Ausfallsicherheit nur bei einem gleichmäßig verteiltem Ausfall der Knoten gegeben.
Diese Nachteile sollen durch eine andere Datenstruktur behoben werden.
2.1 Skip-Liste
William Pugh veröffentlichte im Jahre 1990 eine Datenstruktur namens Skip-Liste [PUGH90],
die auf parallelen verketteten Listen aufbaut und bei der Effizienz mit einem binären Suchbaum vergleichbar ist. Er verkettet alle Elemente in aufsteigender Reihenfolge miteinander.
Abb. 3. Verwendet man nur alle Listen, die den Startknoten enthalten, so erhält man eine Skip-Liste
Hieraus wählt er mit einer bestimmten Wahrscheinlichkeit p zufällig einige Elemente aus
und verkettet diese Elemente erneut in einer Liste. Dies führt er so fort, bis nur noch 2
Elemente in einer Liste enthalten sind. Suchen, einfügen und löschen ist ein einer Skip-Liste
mit einer Laufzeit von O(log n) möglich.
2.2 Skip-Graph
James Aspnes und Gauri Shah stellen in ihrer Ausarbeitung Skip Graphs [AspnesS2003]
eine Datenstruktur vor, die den Ansatz der Skip-Listen verallgemeinert. Ihr Ziel ist es eine
Datenstruktur für Peer-to-Peer-Netze zu entwickeln, die das Hinzukommen neuer Peers bzw.
den Ausfall vieler Peers verkraften kann ohne den Zusammenhang der Daten zu verlieren.
Auf Ebene 0 sind alle Knoten in einer doppelt verketteten Liste miteinander verbunden.
Im Unterschied zu Skip-Listen können in jeder anderen Ebene mehrere verkettete Listen
vorhanden sein. Jeder Knoten ist einer der Listen einer Ebene zugeordnet, bis die Höhe
P2P: Skip-Graph
221
ausreicht, sodass er eindeutig adressiert werden kann. Formell wird die Zugehörigkeit eines
Knoten x zu den Listen durch den Mitgliedsvektor m(x) beschrieben. Da ein Knoten im
Skip-Graph nichts über die Größe des Adressraumes weiß, wird m(x) als unendliches langes
Wort über einem endlichen Alphabet σ definiert.
Abb. 4. Beispiel eines Skip-Graphen mit 5 Schlüsseln
Im folgenden Beispiel betrachten wir das Alphabet {0, 1}. Bei einem Skip-Graphen befinden sich alle Knoten auf Ebene 0 in einer doppelt-verketteten Liste. Auf Ebene 1 existieren
zwei doppelt-verkettete Listen. Jeder Knoten wird zufällig auf einer der Listen verteilt. Die
aufsteigende Sortierung der Liste muss dabei erhalten bleiben. In Ebene 2 wird jeder Knoten
aus einer der Listen aus Ebene 1 wieder zufällig auf zwei neue Listen aufgeteilt, sodass es
insgesamt 4 Listen auf Ebene 2 gibt. Diese Aufteilung wiederholt sich solange bis nur noch
ein Knoten in einer Liste vorhanden ist. In der Abbildung 4 wird dieses Beispiel graphisch
veranschaulicht.
Durch diesen Aufbau eines Skip-Graphen ist dieser äquivalent zu einer Sammlung von
Skip-Listen. Jeder Skip-Graph beschreibt deshalb einen Trie von Skip-Listen {Sw } (Abbildung 5).
Falls |w| ≥ i, bedeutet die Schreibweise w|i im folgenden der Prefix von w mit der Länge i.
Lemma 1. Sei {Sw } ein Skip Graph mit dem Alphabet Σ. Für ein z ∈ Σ ∞ ist die Sequenz
S0 S1 . . . mit Si = Sz|i eine Skip-Liste mit dem Parameter p = |Σ|−1 .
Beweis. Die Liste S0 entspricht der Basisliste S aller Knoten auf Ebene 0. Per Induktion
von i lässt sich zeigen, dass ein Knoten x in Si enthalten ist, wenn die ersten i-Stellen seines
Mitgliedsverktors denen des Vektors z entsprechen (m(x)|i = z|i). Die Wahrscheinlichkeit,
dass der Knoten x in der von der Skip-Liste benutzten Liste eine Ebene höher enthalten
ist, entspricht der Wahrscheinlichkeit, dass m(x)|(i + 1) = z|(i + 1) gilt. Dies ist aber gleich
der Wahrscheinlichkeit p = |Σ|−1 , da die Zugehörigkeit des Knoten x von der Wahl jedes
anderen Knoten unabhängig ist. Damit erfüllt die Sequenz S0 S1 . . . die Anforderung einer
Skip-Liste. 222
M. Borowski
Abb. 5. Verwendet man nur alle Listen, die den Startknoten enthalten, so erhält man eine Skip-Liste
3 Operationen auf einem Skip-Graph
In diesem Kapitel werden die verschiedenen möglichen Operationen auf einen Skip-Graphen
vorgestellt und ihre Laufzeit analysiert. Ein Skip-Graph ist definiert über einem endlichen
Alphabet Σ. Damit wird jede Liste in der nächsten höheren Ebene in maximal |Σ| Listen
unterteilt. Die Menge Σ ∗ enthält alle endlichen Wörter dieses Alphabets, die Menge Σ ∞
aller unendlich langen Wörter. Für eine Wort w ∈ Σ ∗ enthält die Liste Sw alle Knoten, bei
denen w ein Präfix ihres Mitgliedvektors m(x) ist. Sw befindet sich auf der Ebene i = |w|,
wobei w = w0 w1 w2 . . . wi−1 gilt.
3.1 Die Suche
In einem Skip-Graphen funktioniert die Suche ähnlich derer in Skip-Listen. Die Suche startet
in der Liste der höchsten Ebene des Knotens. Ist der gesuchte Schlüssel größer als der eigene
Schlüssel wird er mit dem rechten Nachbar in der Liste verglichen. Ist dieser kleiner oder
gleich dem gesuchten Wert, wird die Suche dort fortgesetzt. Anderenfalls wird der Schlüssel
mit den rechten Nachbarn der Liste einer Ebene tiefer verglichen. Ist der gesuchte Knoten
gefunden oder die Ebene 0 erreicht bricht die Suche ab. Falls der gesuchte Schlüssel zu Beginn
der Suche kleiner als der Startschlüssel ist, werden die Schlüssel der linken Nachbarn zum
Vergleich herangezogen.
Listing 1. Suchen in einem Skip-Graphen
1
s u c h e ( StartKnoten s , S u c h s c h l ü s s e l k , Ebene e )
2
3
4
F a l l s d i e s e r Knoten dem S u c h s c h l ü s s e l k e n t s p r i c h t
Melde e s an den StartKnoten s
5
6
7
8
9
10
11
Fa l l s Suchschlüssel k k l e i n e r aktuellem S c h l ü s s e l
S o l a n g e Ebene e > 0
F a l l s S c h l ü s s e l d e s r e c h t e n Nachbarn k l e i n e r k
Sende S u c h a n f r a g e an i h n w e i t e r
S e t z e Suche a u f Ebene e−1 f o r t
F a l l s Suchschlüssel k größer aktuellem S c h l ü s s e l
P2P: Skip-Graph
12
13
14
15
223
S o l a n g e Ebene e > 0
F a l l s S c h l ü s s e l d e s l i n k e n Nachbarn k l e i n e r k
Sende S u c h a n f r a g e an i h n w e i t e r
S e t z e Suche a u f Ebene e−1 f o r t
16
17
18
F a l l s a k t u e l l e Ebene e < 0
Sende M i s s e r f o l g d e r Suche an s
Abb. 6. Die Suche benutzt nur Knoten, die auch in der Skip-Liste des Startknoten B enthalten sind.
Lemma 2. Die Such-Operation in einem Skip-Graphen S mit n Knoten benötigt eine erwartete Anzahl von O(log n) Nachrichten und O(log n) Zeit.
Beweis. Sei z der Knoten an dem die Suche startet und Σ das Alphabet des Mitgliedvektors
m(z). Nach Lemma 1 ist jedes Element der Sequenz Sm(z) = S0 , S1 , S2 , ... eine Skip-Liste.
Eine Suche im Skip-Graphen S durchläuft die gleichen Elemente, wie eine Suche in der
Skip-Liste Sm(z) . [PUGH90] zeigt das die durchschnittliche Anzahl von Elementen O(log n log1 1 ) mit p =
p
1
|Σ|−1 beträgt und in jeder Ebene durchschnittlich auf 1−p
Knoten gesucht wird. Damit
ergibt sich die erwartete Anzahl von Nachrichten verbunden mit der benötigten Zeit:


1
 = O(log n)
O log n
(1)
(1 − p) log p1
Aus dem Ergebnis ist ersichtlich, dass bei einem kleinen Alphabet, also einem großen
p, die Suchzeit abnimmt, aber stattdessen die Anzahl der Ebenen zunimmt. Damit müssen
jedoch mehr Nachbarknoten in jedem Knoten gepeichert werden. Deshalb muss hier eine
Balance zwischen Suchzeit und Speicherverbrauch gefunden werden.
Bereichssuche
Im Gegensatz zu vielen anderen Netzwerktopologien ist es durch die Grundordnung im SkipGraph möglich Bereichsanfragen zu stellen. Sind in den Knoten z.B. die Domainpfade als
224
M. Borowski
Schlüsselwerte abgelegt, so ist z.B. eine Suche nach allen Schlüsseln unterhalb der Domaine
de.upb möglich. Hierbei wird zunächst nach einem Knoten des Bereichs gesucht, der die
Suche anschließend in seiner Umgebung broadcastet.
3.2 Einfügen neuer Peers
Eine Grundvoraussetzung für P2P Netzwerke ist, dass neue Peers mind. einen Peer des
existierenden Netzwerkes kennen müssen. Ist dies der Fall, kann der neue Peer dort mit
einer Suche nach sich selbst starten und damit seinen Vorgänger und Nachfolger in der
Liste der Ebene 0 finden.
Abb. 7. Ein neuer Peer stellt zunächst eine Suchanfrage nach sich selbst um seine Nachbarn auf Ebene 0
zu finden.
Nachdem sich der neue Peer in die Liste eingefügt hat, sucht er auf Ebene 0 anhand des
Mitgliedvektors nach beiden Seiten nach seinem Nachbarn auf höheren Ebenen und fügt
sich ebenfalls in diese Listen ein.
Lemma 3. Ohne gleichzeitigen Zugriff benötigt das Einfügen einen Knoten in einem SkipGraphen S mit n Knoten O(log n) Nachrichten und O(log n) Zeit.
Beweis. Bei einem festen Alphabet mit p = |Σ| Elementen verwendet das Einfügen auf
Ebene 0 eine Such-Operation nach 2 O(log n) Nachrichten und Zeit. Bei der Suche der Nachbarn für jede andere Ebene werden durchschnittlich p1 Knoten durchlaufen. Die Anzahl der
Ebenen im Skip-Graphen ist O(log n). Damit ergibt sich eine erwartete Anzahl benötigter
Nachrichten:
log
Xn 1 1
O(log n) +
O
= O(log n + log n)
(2)
p
p
0
= O(log n)
(3)
P2P: Skip-Graph
225
Abb. 8. Der eingefügte Knoten sucht durch Vergleichen des Mitgliedschaftsvektors seiner Nachbarn, seine
Nachbarn auf höherer Ebene.
3.3 Entfernen von Peers
Das Löschen von Knoten ist eine einfache und schnelle Operation. Zunächst entfernt sich
der Peer von allen Listen der Ebenen gößer 0 - dies kann parallel erfolgen. Anschließend
entfernt er sich auch aus der Liste von Ebene 0.
Listing 2. Suchen in einem Skip-Graphen
1
l ö s c h e ( Knoten u )
2
3
4
Für a l l e Ebenen > 0
Lösche u aus d e r L i s t e
5
6
Lösche u aus d e r L i s t e a u f Ebene 0
Lemma 4. Ohne gleichzeitigen Zugriff benötigt die Lösch-Operation in einem Skip-Graphen
O(log n) Nachrichtne und O(1) Zeit.
Beweis. Wir nehmen an, dass die Lösch-Operation in einer verketteten Liste O(1) Nachrichten und Zeit braucht. Da dies in allen Liste bis auf Ebene 0 parallel geschehen kann,
benötigen wir nur O(1) Zeit. Bei der Anzahl der Nachrichten müssen wir die Anzahl der
Listen, die gleich der Höhe des Skip-Graphen ist, berücksichtigen:
log
Xn
0
O(1) = O(log n)
(4)
226
M. Borowski
3.4 Operationen bei mehrfachem gleichzeitigen Zugriff
Da jeder Peer sich selbst verwaltet, ist ein kontrollierter Zugriff von mehreren Peers auf den
Skip-Graphen nicht möglich.
Die vorgestellten Algorithmen stellen jedoch sicher, dass zu jedem Zeitpunkt die Liste auf
Ebene 0 korrekt ist. Damit ist gegeben, dass auch mehrfache gleichzeitige Operationen
korrekt durchgeführt werden. Die Listen höherer Ebenen dienen nur zur effizienteren Suche
der Knoten und beeinträchtigen deshalb die Funktionalität des Skip-Graphen nicht.
4 Qualitätsanalyse
Im vorherigen Kapitel wird die Effizienz und Korrektheit der Operationen auf einem
Skip-Graphen gezeigt. Entwickelt wurde diese Datenstruktur für den Aufbau eines P2PNetzwerkes.
Hier ergeben sich jedoch viele Fehlerquellen, die die Qualität des Netzes beeinträchtigen. Im
folgenden wird deshalb die Güte eines Skip-Graphen mit dem Alphabet {0, 1} für P2P-Netze
untersucht.
4.1 Fehlertoleranz
Eine große Herausforderung beim Design eines P2P-Netzes ist die Eigenschaft, dass sich die
Topologie durch das Hinzufügen und Entfernen von Peers ständig ändern kann. Es kann
nicht davon ausgegangen werden, dass jeder Peer, der das Netzwerk verlässt, vorher ordnungsgemäß die Lösch-Operation ausführt. Die Robustheit des Skip-Graphen ergibt sich
deshalb aus dem Verhältnis von ausgefallenen Peers zu denen, die dadurch den Zusammenhang zum Netzwerk verloren haben.
Randomisierter Ausfall von Peers
Zunächst nehmen wir an, dass jeder Knoten mit der gleichen Wahrscheinlichkeit ausfallen
kann. [AspnesS2003] zeigen in ihren Simulationen, dass bis du einer Ausfallwahrscheinlichkeit von 60% fast alle Knoten in der großen Zusammenhangskomponente verbleiben. Erst
bei größeren Werten werden viele Knoten isoliert, wenn ihre gesamte Nachbarschaft ausfällt. Dies bedeutet, dass ein P2P Netz, dass auf einem Skip-Graphen aufbaut, sehr robust
gegenüber zufälligen Fehlern ist.
Ungünstige Ausfälle von Peers
Neben dem Zufälligen und damit gleichmäßig verteilten Ausfall von Peers interessiert bei der
Robustheit von Skip-Graphen auch der Ausfall größerer benachbarter Bereiche. Aufgrund
der Sortierung der Peers im Skip-Graphen kann der Ausfall eines Rechners oder physikalischen Netzes den Ausfall großer benachbarter Knoten zur Folge haben. Im folgenden
P2P: Skip-Graph
227
versuchen wir deshalb eine Kombination von Peers zufinden, deren Ausfall den Zusammenhang zerstört.
Hierzu untersuchen wir den Expansionsgrad vom Skip-Graphen G. Der Expansionsgrad von
einer Menge Knoten A ⊆ G ist definiert als |δA|/|A|, wobei |δA| die Anzahl der Knoten ist,
die zu A benachbart, aber selbst nicht in A enthalten sind.
Abb. 9. Beispiel für ein Set A und der damit erzeugten Menge δA
Der Expansionsgrad des Graphen G ist der minimale Expansionsgrad aller Teilmengen
A mit 1 ≤ |A| ≤ n2 . Fallen alle Knoten von A aus, haben alle Knoten von δA fehlerhafte
Kanten. Im Folgenden wird deshalb eine untere Schranke für den Expansionsgrad bestimmt.
Die Menge δ` A ⊂ G enthält alle Knoten, die nicht in A liegen, aber durch eine Kante auf
Ebene ` mit einem Knoten aus A benachbart sind. Damit gilt:
[
δA =
δ` A
(5)
`
|δA| ≥ max` |δ` A|
(6)
Lemma
5.Die Anzahl
der Sets A mit |A| = m < n und |δ0 A| < s ist kleiner als:
Ps−1 m+1
n−m−1
r=1
r
r−1
Beweis. Zuerst werden alle Knoten von 1 bis n durchnummeriert und ein Bit-Vektor x =
x1 x2 . . . xn defininert, wobei gilt:
(
1, falls Knoten i ∈ A
xi =
0, sonst
Damit sind alle Knoten, die durch eine 0 repräsentiert werden und zu einer 1 benachbart
sind, in δA enthalten. Um sicher zu stellen, dass der Bit-Vektor immer mit einer 1 sowohl
beginnt als auch aufhört, wird ein weiterer Vektor x0 = 1x1 definiert. Dieser Vektor besteht
alternierend aus Einser- und Nuller-Folgen, wobei die Anzahl der Nuller-Folgen r um eins
kleiner als die der Einser-Folgen (r + 1) ist. Da A eine echte Teilmenge ist (A ⊂ G), ist
228
M. Borowski
Abb. 10. Beispiel für ein Set A und der dazugehörigen Teilmenge δ0 A mit |δ0 A| = 2 und r = 2
mind. eine 0 im Bit-Vektor enthalten. Jede Nuller-Folge enthält einen oder zwei Knoten aus
δA:
r ≤ |δ0 A| ≤ 2r
(7)
0
Nun Summieren wir die Anzahl der Bit-Vektoren
x auf, die n − m Nullen enthalten und
n−m−1
aus r Nuller-Intervallen bestehen. Es gibt
Möglichkeiten n − m Nullen auf die r
r−1
Nuller-Intervalle zu verteilen. Für die m + 2 Einser gibt es m+2−1
r+1−1 Möglichkeiten sie auf
r +1 Intervalle verteilt zu werden. Beide Verteilungen sind voneinander unabhängig, deshalb
ergibt sich als obere Schranke:
s−1 X
m+2−1 n−m−1
r=1
r+1−1
r−1
=
s−1 X
m+1 n−m−1
r=1
r−1
r
(8)
Nun können wir mit hoher Wahrscheinlichkeit zeigen, dass für alle Ebenen ` > 0 |δ` A|
selten klein sein wird.
Lemma 6. Sei A eine Teilmenge mit m ≤ n/2 Knoten in einem Skip-Graph S mit n
m
` Knoten. Dann gilt für jede Ebene ` > 0: P [|δ` A| ≤ 31 · 2` ] < 2 b 22·2` c 32
3
Beweis. Wenn für ein b ∈ Σ ` ein Knoten u ⊂ S existiert, sodass auch ein Knoten v ⊂ S −A
mit b = m(u)|h = m(v)|h existiert, dann gibt es ein Knotenpaar v 0 ∈ A und v 0 ∈ S − A,
die benachbart sind. Da diese Paare verschieden für unterschiedliche b sind, können wir eine
untere Schranke für δ` A berechnen. Sei T (A) die Menge von bs, für die A einen Knoten aus
Sb enthalten, Dann gilt:
X
2 `
P [T (A) ⊆ B]
P |T (A)| < · 2 ≤
3
2 `
B⊂S,|B|=b 3 ·2 c
≤
2`
b 23 · 2` c
|A|
2
3
(9)
P2P: Skip-Graph
229
und für die restliche Menge S − A:
|S−A|
2
2`
2
P |T (S − A)| < · 2` ≤
3
b 23 · 2` c
3
(10)
Da beide Mengen T (A) und T (S − A) mind. zwei Drittel aller b enthalten, muss die Schnittmenge mind. ein Drittel der b enthalten:
|A| |S−A| !
2`
2
1 `
2
≤
P |T (A) ∩ T (S − A)| < · 2
+
2
`
3
b3 · 2 c
3
3
`
|A|
≤ 2 b 22·2` c 23
(11)
3
Damit gibt es nicht genug Teilmengen A ⊂ G mit kleinem |δ0 A|, damit die Wahrscheinlichkeit, dass eine Teilmenge auch ein kleines |δ` A| hat, groß genug ist.
4.2 Auslastung der Peers
Bei einem Skip-Graph kann gezeigt werden, dass die Auslastung von Peers bei einer hohen
Last Suchanfragen an ein bestimmtes Element mit der Distanz stark abnimmt.
Die Wahrscheinlichkeit, dass die Suche einen bestimmten Knoten zwischen den Startknoten
und dem Zielknoten benutzt, ist umgekehrt proportional zur Distanz des Knotens zum Ziel.
Hierbei ist jedoch die Gleichverteilung des Mitgliedsvektors entscheident. Unglücklicherweise
kann es sein, dass ein Knoten durch ungünstige Mitgliedsvektoren immer schnell zu einen
Suchpfad führt, der einen Knoten in der Nähe eines sehr populären Knoten beinhaltet.
Zudem wird für den Startknoten angenommen, dass er immer einen zufälligen Mitgliedvektor
hat.
Theorem 1. Gegeben sei ein Skip Graph S mit dem Alphabet {0, 1}. Bei einer Suche von
s nach t ist die Wahrscheinlichkeit für einen Knoten u mit s < u < t und dem Abstand d
2
nach t, dass der Suchpfad u durchläuft kleiner als d+1
.
Beweis. u íst im Suchpfad von s nach t enthalten, wenn es keinen Knoten zwischen u und
t gibt, der in einer höheren Ebene in einer gemeinsammen Liste mit s enthalten ist. Es
existieren d + 1 Knoten in diesen Interval. Sei T eine Zufallsvariable, die alle Knoten der
höchsten Ebene enthält.
230
M. Borowski
Abb. 11. u ist im Suchpfad von s1 nach t enthalten. Im Suchpfad von s2 nach t nicht.
P (u ∈ T ) =
d+1
X
k=1
P (|T | = k)
k
d+1
(12)
E(|T |)
d+1 

|T |−1 X n
1
|T | +
E(k) /(d + 1)
= |T |
k
2 −1
k=1


|T |−1 X n
1
n
|T | +
= |T |
E(1) + 2
P (k) /(d + 1)
1
k
2 −1
k=2


|T |−1 X
n
1
2 n P (1) + 2
P (k) /(d + 1)
= |T |
1
k
2 −1
=
(13)
(14)
(15)
(16)
k=2
|T |−1 X n
2
= |T |
P (k)/(d + 1)
2 − 1 k=1 k
(17)
= 2P (|T |)/(d + 1)
2
≤
d+1
Der letzte Schritt ergibt sich, da P (n) mit P (0) = 0, P (1) = 1 und P (n) =
kein Wert größer 1 ist. (18)
(19)
1
2n −1
Pn−1
k=1
n
k
P (k)
5 Varianten und Erweiterungen
Von der in den vorigen Kapiteln vorgestellten Datenstruktur Skip-Graph gibt es einige
Variationen, die im folgenden vorgestellt werden.
P2P: Skip-Graph
231
Abb. 12. Erwartete und simulierte Nachrichtenlast in einen Skip-Graph mit 131072 Knoten und den
Zielknoten 76539 (aus [AspnesShah])
5.1 Mehrere Nachfolger
James Aspnes zeigt in seiner Ausarbeitung [AspnesShah], dass es sinnvoll sein kann, statt
nur eines Nachbarn in jeder Ebene mehrere Nachfolger zu speichern. Bei einer Ausfall-
Abb. 13. Anzahl der fehlgeschlagenen Suchläufe in einen Skip-Graph mit 131072 Knoten und 10000 Nachrichten. Jeder Knoten hat bis zu 5 Nachfolger auf jeder Ebene (aus [AspnesShah])
wahrscheinlichkeit von 60% für jeden Knoten ist eine Suche im vorgestellten Skip-Graphen
praktisch nicht mehr möglich. Speichert man aber zusätzlich immer die nächsten 5 Nachfol-
232
M. Borowski
ger auf jeder Ebene, so ist eine Suche in mehr als 23 der Fälle weiterhin erfolgreich möglich.
Der Speicherbedarf ändert sich hierbei nur um einen konstanten Faktor (siehe Abbildung
13).
5.2 SkipNet
An der Universität von Washington in Seattle und bei Microsoft wurde unabhängig von der
Entwicklung des Skip-Graphen eine sehr ähnliche Struktur für P2P-Netzwerke entwickelt.
Harvey et al. [Harvey03] beschreibt eine Datenstruktur, die auf einfach, zirkular verketteten
Listen aufbaut. Die Operationen sind wie beim Skip-Graphen implementiert, nur dass im
Abb. 14. Aufbau eines SkipNet nach [Harvey03]
SkipNet die Rechner einer Domain als ein Knoten auftauchen. Die einzelnen Daten werden
innerhalb einer Domain wieder mittels der verteilten Hashtabelle aufgeteilt. Der Vorteil der
zirkulären Listen ist die gleichmäßigere Auslaustung der Peers. [AspnesShah] zeigt jedoch
auf, dass es bei Linkfehlern sehr schwer ist, die Struktur wieder zu reparieren.
5.3 Expander Graphen in Skip-Graphen
J. Aspnes und U. Wieder [AspnesWieder2005] zeigen, dass in einen Skip-Graph mit hoher
Wahrscheinlichkeit ein 4-regulärer Expander enthalten ist. Dies führt zu den Ergebnis, dass
der Expansiongrad nicht wie vorher gezeigt Ω(1/ log n), sondern sogar Ω(1) ist und damit
jede Teilmenge, die weniger als die Hälfte der Knoten (m < n/2) enthält Ω(m) Nachbarn
hat. Damit ist die Fehlertoleranz besser als zuvor angenommen. Es kann gezeigt werden,
dass bei einem Ausfall einer konstanten Anzahl von Knoten immer noch eine konstante
Anzahl in einem Graphen verbleibt.
P2P: Skip-Graph
233
6 Zusammenfassung und Fazit
In dieser Ausarbeitung wurde die Datenstruktur des Skip-Graphen und einige Variationen
vorgestellt. Sie ermöglicht die verteilte Datenspeicherung und bietet gegenüber dem gebräuchlichen DHT-Verfahren einige wichtige Vorteile.
Im Vergleich mit CAN und Chord wird eine bessere Performance erreicht. Die Laufzeiten
für das Erreichen von Knoten ist gleich, jedoch benötigt das Einfügen neuer Knoten mit
O(log2 n) mehr Zeit als im Skip-Graphen mit O(log n). Zudem sind Skip-Graphen auch
robuster, da sie im Gegensatz zu verteilten Hashtabellen auch bei gezieltem ungünstigen
Löschen von Knoten nur begrenzt Schaden nehmen. Ein weiterer großer Vorteil von SkipGraphen ist aufgrund ihrer Sortierung die Möglichkeit einfach Bereichsanfragen zu stellen.
Es existiert aber derzeit noch kein in der Praxis verwendetes P2P-Netz, das auf einem SkipGraph aufbaut. Alle getroffenen Annahmen sind aufgrund von Simulationen entstanden.
Es wird sich deshalb noch zeigen müssen, ob sich P2P-Netze basierend auf Skip-Graphen
durchsetzen können.
Literaturverzeichnis
AspnesS2003. J. Aspnes and G. Shah 2003. Skip graphs. Fourteenth Annual ACM-SIAM Symposium on
Discrete Algorithms, Jan 2003, 384-393
AspnesShah. J. Aspnes and G. Shah. Skip graphs. ACM Journal
AspnesWieder2005. J. Aspnes and U. Wieder 2005. The expansion and mixing time of skip graphs
with applications. SPAA ’05: Proceedings of the seventeenth annual ACM symposium on Parallelism
in algorithms and architectures, 2005, 126-134
Harvey03. J.A. Harvey, M.B. Jones, S. Saroiu, M. Theimer and Alec Wolman SkipNet: A Scalable
Overlay Network with Practical Locality Properties
NaorWieder06. M. Naor and U. Wieder. Novel Architectures for P2P Applications: the Continuous.Discrete Approach
MahlSchindel07. Peter Mahlmann und Christian Schindelhauer Peer-T to-Peer-Netzwerke: Algorithmen und Methoden. Springer-Verlag Berlin, 1. auflage, Jul.2007, ISBN 3540339914
PUGH90. Pugh, W. 1990. Skip Lists: A Probabilistic Alternative to Balanced Trees. Communications of
the ACM 33,6 (June), 668-676
Groli07. Dominik Grolimund. 2007. P2P Online Storage Web 2.0 Expo Berlin, 2007
Rat00. S. Ratnasamy, P. Francis, M. Handley, R. Karp and S. Shenker. A Scalable ContentAddressable Network. Proceedings of ACM SIGCOMM 2001, 161-172
Schoder02. Detlef Schoder, Kai FischbachPeer-to-Peer(2002) Springer Verlag
SMK01. Stoica, Morris, Karger, Kasshoek, Balakrishnan Chord: A scalable Peer-To-Peer lookup
service for internet applications. Proceesings of the 2001 ACM SIGCOMM Conference, 2001, 149-160
OReilly01. Peer to Peer oder das Netz als Computer
Ein Kommentar von Tim O’Reilly 2001 O’Reilly verlag
Napster. @web(1999-2008) Napster - P2P Filesharing - MP3 Suche ohne Suchmaschinen
Freenet. @web(1999-2008)
Freenet - statt Suchmaschinen - p2p Filesharing
Gnutella. @web(1999-2008)
Gnutella - P2P Filesharing - MP3 Suche ohne Suchmaschinen
Wuala. @web(2006-2008)
Wua.la - Ihre kostenlose Online-Festplatte
Herwig. Björn A.Herwig, Seminar Internet Computing
Peer-to-Peer Networking
PCWELT0803. PC-WELT : Peer-to-Peer-Netze (27. AUGUST 2003)
Kinetische Datenstrukturen für zweidimensionale Probleme
Sabine Naewe
Universität Paderborn [email protected]
Zusammenfassung. In meiner Seminararbeit werde ich mich mit kinetischen Datenstrukturen für zweidimensionale Probleme beschäftigen. Das Vorgehen hierbei werde ich am Beispiel zweier grundlegender
Probleme erläutern, welche repräsentative Beispiele für Bewegungsprozesse sind. Das Problem der konvexen
bzw. oberen Hülle von n Punkten gehört zur Kategorie der Umfangsprobleme, während das Problem des
dichtesten Paares zur Kategorie der Nähe- und Schnittprobleme gehört. Für beide Probleme werden als
erstes kinetische Datenstrukturen entwickelt und diese dann für die Bewegung der Elemente modifiziert.
1
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
2
Die konvexe Hülle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
2.1
2.2
2.3
2.4
Berechnung der oberen Hülle zweier Ketten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Analyse des Beweisschemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
Aktualisierung der konvexen Hülle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
Divide and Conquer Algorithmus für die obere Hülle . . . . . . . . . . . . . . . . . . . . . . . . . 241
3
Dichtestes Paar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
3.1 Statischer Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
3.2 Die Bewegung der Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
4
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
1 Einführung
In meiner Seminararbeit werde ich die Idee einer kinetischen Datenstruktur für zwei zweidimensionale Probleme vorstellen. Kinestische Datenstrukturen sind ein Konzept zur Berechung bestimmter Attribute von kontinuierlichen Modellen, wobei sie diese während der
betrachteten Zeitspanne aufrechterhalten. Eine Einführung in dieses Thema liefert [5].
Die Arbeit gliedert sich in zwei nicht aufeinander aufbauende Abschnitte. Der erste
Abschnitt erläutert eine kinetische Datenstruktur für das Problem der konvexen Hülle einer
zweidimensionalen Punktmenge. Im zweiten Abschnitt wird dann eine Datenstruktur für
das Problem des dichtesten Paares einer zweidimensionalen Menge vorgestellt.
236
Sabine Naewe
2 Die konvexe Hülle
In diesem Abschnitt betrachtet wir nun das Problem der konvexen Hülle. Gegeben seien n
Punkte im zweidimensionalen Raum. Gesucht ist nun die konvexe Hülle dieser n Punkte.
Definition 1. Die konvexe Hülle einer n−elementigen Menge ist definiert als die kleineste
konvexe Menge, welche die n Punkte enthält. Dabei heißt eine Menge M konvex, falls gilt:
∀ a, b ∈ M : ∀ t ∈ [0, 1] : ta + (1 − t)b ∈ M
Anschaulich enthält eine konvexe Menge M für jedes Paar von Elementen aus M auch die
Strecke zwischen diesen beiden Punkten. Sie wird durch ihre Eckpunkte beschreiben. Eine
konvexe Hülle kann man in obere und untere Hülle aufteilen. Um die obere Hülle zu
berechnen, werden als erstes alle Punkte nach ihrer x-Koordinate lexikographisch sortiert.
Danach durchläuft man die Punkte im mathematisch positiven Sinne und verbindet alle
geordneten Punkte. Ergibt sicht dabei eine Einbuchtung nach innen, werden die inneren
Punkte entfernt. Eine innere Einbuchtung wird hierbei durch einen Winkel repräsentiert,
welcher kleiner als 180 ist. Die untere Hülle erhält man analog.
Um nun die konvexen Hülle zu berechnen, benutzt man einen Divide and Conquer Ansatz. Dabei wird zufällig unsere Ausgangsmenge in etwa zwei gleich große Untermengen
geteilt, von denen man nun rekursiv die konvexe Hülle berechnet. Anschließend mischen
wir diese beiden Ergebnisse, um die konvexe Hülle der gesammten Menge zu bekommen.
Bei diesem Vorgang betrachtet man die parallelen Tangenten der beiden Hüllen um die
endgültige Menge zu bekommen.
In dieser Arbeit berechnen wir nur die obere konvexe Hülle und benutzten die duale
Transformation um einem Punkt (p, q) die Linie y = px + q zuzuordnen, da es einfacher
ist den Algorithmus für Linien zu beschreiben. Im dualen Raum ist es nun das Ziel, die
obere Hülle einer Familie von Linien zu erhalten. Dabei können sich die Parameter der
Linien kontinuierlich aber vorhersehbar ändern. Um dieser Bewegung Rechnung zu tragen,
wird der Divide and Conquer Algorithmus modifiziert, indem man die obere konvexe Hülle
der Untermengen berechnet. Der entscheidene Punkt ist hierbei die Berechnung der oberen
Hülle aus den oberen Hüllen von zwei Untermengen. Dafür betrachten wir die Linien als
konvexe, stückweise definierte lineare Funktionen.
2.1 Berechnung der oberen Hülle zweier Ketten
Im Folgenden befinden wir uns im Dualen und betrachten die duale Tranformation der
Ausgangsmenge. Wir definieren in unserem Algorithmus eine konvexe, stückweise definiert
lineare Funktion als doppeltverkettete Liste mit Ecken und Kanten, welche von von links
nach rechts geordnet ist. Diese Darstellung nennen wir eine Kette. In diesem Abschnitt
betrachen wir nun zwei Untermengen als blaue und rote Kette und erläutern eine kinetische
Datenstruktur, um die lila Menge zu erhalten, welche die obere Hülle der roten und blauen
Kette darstellt.
Um den Algorithmus darstellen zu können, definieren wir im nächsten Absatz hierfür
wichtige Mengen und Begriffe. Da wir bei diesem Problem die Hauptaufmerksamkeit auf
die Kanten richten werden , bezeichen wir die Kanten mit Kleinbuchstaben und nennen
die Ecke zwischen den Kanten a und b die Ecke ab. Eine Konfiguration bezeichnet nun
Kinetische Datenstrukturen für zweidimensionale Probleme
237
eine Darstellung aller Ecken und Kanten, so dass beide Ketten konvex sind. Für eine Ecke
ab bezeichnen wir die Kante der anderen Kette, welche darüber oder darunter liegt, als
rivalisierende Kante (engl.: contender edge ) und kennzeichnen sie mit ce(ab). Jeder
Knoten hat dann einen Zeiger auf die rivalisierende Kante. Wir kennzeichnen mit χ( )
die Farbe (rot oder blau) einer Ecke oder Kante. Schließlich bezeichnen wir mit ab.prev
bzw. ab.next die blaue oder rote Ecke, welche auf der linken bzw. rechten Seite von ab am
nächsten bei ab liegt. Diese Ecke kann leicht durch das Vergleichen der x-Koordinaten der
benachbarten Ecke in der Kette von ab mit einer der Eckpunkte der rivalisierenden Kante
von ab berechnet werden.
Um die rote und blaue Kette in einem Mischdurchlauf miteinander vergleichen zu können,
benötigen wir zwei verschiedene Typen von Zertifikaten: Die x-Zertifikate definieren die
horizontale Ordnung der Ecken, während die y-Zertifikate die vertikale Ordnung in Hinsicht
auf die rivalisierende Kante untersucht. Wir bezeichnen diese mit <x bzw. <y . Wenn wir alle
diese Vergleiche aber als Zertifikate behandeln, ist die erhaltende kinetische Datenstruktur
nicht mehr lokal, da eine gegebene Kante die rivalisierende Kante von O(n) vielen Ecken der
anderen Hülle sein kann. Deswegen definieren wir eine alternative Menge von Zertifikaten,
welche auch Vergleiche zwischen Linienpaaren bzgl. der Steigung, mit <s gekennzeichnet,
enthalten. Dadurch kann dann überprüft werden, ob der Winkel zwischen zwei Linien kleiner
als 180 ist. Mit diesen drei Arten von Zertifikaten kann die Anzahl der Zertifikate erheblich
einschränkt werden.
Name
x[ab]
Vergleich
[ab <x cd]
Bedingung
cd = ab.next
χ(ab) 6= χ(cd)
yli[ab] [ab <y or >y ce(ab)]
b ∩ ce(ab) 6= ∅
yri[ab] [ab <y or >y ce(ab)] a ∩ ce(ab) 6= ∅
yt[ab]
[ce(ab) <y ab]
a <s ce(ab) <s b
slt[ab]
[a <s ce(ab)
ce(ab) <y ab
srt[ab]
[ce(ab) <s b]
sl[ab]
[b <s ce(ab)]
b <s ce(ab)
ab <y ce(ab)
χ(ab) 6= χ(ab.next)
sr[ab]
[ce(a) <s a]
ce(ab) <s a
ab <y ce(ab)
χ(ab) 6= χ(ab.prev)
Tabelle 1. Zertifikate für die obere Hülle zweier Ketten
In Tabelle 2.1 werden die modifizierten Zertifikate definiert. Die erste Spalte enthält den
Namen der Zertifikate, die zweite enthält den Vergleich, welchen dieses Zertifikat garantiert
und die dritte Spalte enthält zusätzliche Bedingungen für das Zertifikat, damit es in der
kinetischen Datenstruktur enthalten ist. Die erste Zeile definiert ein Zertifikat mit Namen
x[ab]. Dieses existiert nur in der Datenstruktur, wenn ab und cd Nachbarn sind und in unterschiedlichen Ketten liegen (Bedingung). Um dies zu überprüfen, müssen die x-Koordinate
der Ecken ab und cd miteinander verglichen werden. Die Ungleichung muss nun nach t gelöst werden, um den ersten Zeitpunkt zu berechnen, an dem das Zertifikat seine Gültigkeit
verliert, also der Knoten cd nicht mehr der rechte Nachbar von ab ist.
238
Sabine Naewe
Das Zertifikat x[..] definiert die exakte x-Ordnung der Knoten, während die Zertifikate yli[..] und yri[..] den Schnitt zweier Kanten in verschiedenen Ketten darstellt. Wenn
eine Kante nicht in der oberen Hülle liegt, ordnen die Zertifikate seine Steigung in die
Folge aller Kantensteigungen ein. Entweder geschieht dies mit den drei tangetialen Zertifikaten yt[..], slt[..] und srt[..] oder das Zertifikat sl[..] bzw. sein symmetrisches Zertifikat
sr[..] zeigt, dass keine Tangente vorhanden ist. Abhängig von den Positionen der roten und
blauen konvexen Ketten werden in Abbildung 1 verschiedene Zertifikate benutzt um die
Überschneidungsstruktur (oberer Fall) oder das Nichtüberschneiden (mittlerer und unterer
Fall) zu zertifizieren. Die Pfeile zeigen dabei die Vergleiche zwischen Ecken oder Kanten an.
Schließlich benötigen wir noch Abstandszertifikate zwischen den beide Kanten am linken
bzw. rechten Rand der Kette.
Abb. 1. Darstellung der modifizierten Zertifikate
2.2 Analyse des Beweisschemas
In diesem Abschnitt beweisen wir die Lokaltität des Beweisschemas und ihre korrekte Berechnung der oberen Hülle.
Lemma 1. Die Lokaltität des obrigen Beweisschemas hat Komplexität O(1).
Beweis. Sei a eine beliebige Kante. Wir müssen nun die Anzahl der Zertifikate berechnen, in
denen a im Gültigkeitsbeweis des Schemas vorkommt. Ohne Beschränkung der Allgemeinheit kommt a in einem Zertifikat vor, da einer der Eckpunkte in einem Zertifkat vorhanden
ist. Jede Ecke kann höchsten in zwei x[..] Zertifikaten vorkommen, da jede Ecke jeweils
Kinetische Datenstrukturen für zweidimensionale Probleme
239
nur einen rechten und linken Nachbarn besitzt. Außerdem kann er nur in jeweils einem der
anderen Zertifikattypen vorkommen. Deswegen müssen wir nur die Anzahl der Zertifikate
berechnen, in denen a als rivalisierende Kante vorkommt.
Wenn a im Schnitt mit der anderen Kette liegt, kann die Kante als rivalisierene Kante
in den Zertifikaten yli[..] und yri[..] liegen. Diese Konstellation kann nur zweimal auftreten,
da a nach Definition der oberen Hülle höchstens zweimal von der anderen Kette geschnitten
werden kann.
Wenn a nicht von der anderen Kette geschnitten wird, kann a in höchstens zwei Dreiergruppen der tangentialen Zertifikate vorkommen. Das eine Zertifikat gilt, wenn a über
einem Teil der andere Kette liegt und das andere, wenn sie unter einem Teil der anderen
Kette liegt.
Schließlich nehmen wir an, dass a die rivalisierene Kante von vielen Ecken ist. Dann
haben diese Knoten alle die gleiche Farbe. Damit können nur der linkeste und der rechteste
Knoten a als rivalisierende Kante in sl[..] oder sr[..] enthalten. So besitzt die Lokalität des
Beweisschemas Komplexität O(1).
t
u
Lemma 2. Die Menge der obigen Zertifikate beschreiben die obere Hülle.
Beweis. Sei Π ein Konfiguration mit der Zertifikatenmenge L und Π 0 ein andere Konfiguration, in der diese Zertifikate gültig sind. Wir zeigen, dass die obere Hülle von Π 0 die gleichen
Ecken enthält wie die obere Hülle von Π.
Die x-Zertifikate beweisen die Korrektheit der Zeiger der rivalisierenden Kanten. Jeder
Knoten, welcher in einem y-Zertifikat in L enthalten ist, befindet sich nach Voraussetzung
auch in Π 0 und in Π. Es bleibt zu zeigen, dass Ecken ohne y-Zertifikate nicht nur in Π 0
oder Π liegen.
Sei S eine maximale Menge von benachbarten Ecken ohne y-Zertifikate in L. Ohne Beschränkung der Allgemeinheit nehmen wir an, dass die rote Kette in diesem Teilabschnitt
von Π unter der blauen Kette liegt. Sei 4(x) die Differenz zwischen der roten und blauen
Steigung bei x in Π. Diese Funktion steigt bei roten Ecken und fällt bei blauen Ecken. Sie
ändert nicht ihr Vorzeichen bei einer roten Ecke von S, da dies ein yt[..] Zertifikat in L
bedeuten würde.
So ist 4(x) in dem Intervall von S positiv bis zu einer bestimmten blauen Ecke und ab
dann negativ. Wenn nun a die rivalisierende Kante dieser Ecke ist, existieren sl[..] Zertifikate
zu der linken Kante des linken Endpunktes von a und sr[..] Zertifikate zu der rechten Kante
des rechten Endpunktes von a. Diese Zertifikate garantieren, dass die rote Kette auf dem
Interval von S über der blauen Kette bleibt.
t
u
2.3 Aktualisierung der konvexen Hülle
Das letzte Lemma zeigt, dass die obrige Liste der Zertifikate ausreichend ist, um die obere
Hülle zu erhalten. Um eine kinetische Datenstruktur zu erhalten, speichern wir alle Zertifikate in einer globalen Queue, in der diese nach ihrem Fälligkeitsdatum gespeichert sind.
Wenn das erste Ereignis in der Queue eintritt, müssen wir die Liste der Zertifikate aktualisieren. Die Algorithmen für diese Veränderungen sind für jeden Ereignistyp im Folgenden
dargestellt. Die graphische Darstellung einer Veränderungen wird in Abbildung 2 gezeigt.
240
Sabine Naewe
Dabei fehlen drei Fälle. Es fehlen die gespiegelten Fälle von Fall 1 und Fall 3, und die
Ereignisse, welche von den x-Zertifikaten abhängen.
Abb. 2. Darstellung einiger Ereignisse
Algorithmus 22 Ereignis: Ungültigkeit von yli[ab]
1: Lösche yri[ab.next], yli[ab];
2: if ∃ yri[ab] then
3:
Lösche yli[ab.prev], yri[ab];
4:
Erzeuge slt[ab], srt[ab], yt[ab];
5:
Hole ce(ab) von der Ausgabe;
6: else
7:
Erzeuge yri[ab], yli[ab.prev];
8:
Füge a hinzu oder hole b aus der Ausgabe;
Als Beispiel betrachten wir den Fall, dass das Zertifikat yt[ab], welches dem Fall 4 in
Abbildung 2 entspricht, nicht mehr gültig ist. In diesem Fall bewegt sich eine rote Kante
über eine blaue Ecke. Als erstes löschen wir die drei Zertifikate, welche beweisen, dass die
rote Kante über der blauen liegt (letzter Fall in Abbildung 1). Dann fügen wir die Zertifikate
Kinetische Datenstrukturen für zweidimensionale Probleme
241
Algorithmus 23 Ereignis: Ungültigkeit von yt[ab]
1:
2:
3:
4:
Lösche yt[abt], slt[ab], srt[ab];
Erzeuge yt[ab], yri[ab.next];
Erzeuge yri[ab], yli[ab.prev];
Füge ce(ab) zur Ausgabe hinzu;
Algorithmus 24 Ereignis: Ungültigkeit von slt[ab]
1:
2:
3:
4:
5:
6:
Lösche slt[ab], srt[ab], yt[ab];
cd ← ab.prev;
if d = a then
Erzeuge slt[cd], srt[cd], yt[cd]; {z.B. gleiche Farbe}
else
Erzeuge sl[cd];
Algorithmus 25 Ereignis: Ungültigkeit von sl[ab]
1:
2:
3:
4:
5:
6:
7:
Lösche sl[ab];
cd ← ab.prev;
if χ(cd) 6= χ(ab) then
Erzeuge slt[cd], srt[cd], yt[cd];
else
if ce(cd) 6= cd(ab) then
Erzeuge sr[cd];
hinzu, welche die zwei neuen Schnitte darstellen. Schließlich fügen wir die neue Kante der
oberen Hülle zur Ausgabe hinzu.
Die zu den Zertifikaten yri[ab], sr[ab] und srt[ab] symmetrischen Ereignisse sind die
Zertifikaten yli[ab], sl[ab] und slt[ab].
Im Allgemeinen muss die Ausgabe geändert werden, falls sich ein y-Zertifikat ändert.
Dabei werden entweder zwei Nachbarecken zu einer einzigen oder eine Ecke wird umgekehrt
zu zwei verschiedenen Ecken, welche nun benachbart sind. Um dies rekuriv zu konstruieren,
benötigen wir eine Möglichkeit lokale Strukturveränderungen in der Eingabe behandeln zu
können. Damit erreichen wir, dass wir nur lokale Veränderungen vornehmen müssen und
verringern die Laufzeit. Wenn nun zum Beispiel die Kante b zwischen den Kanten a und c
verschwindet, existieren die Ecken ab und bc nicht mehr. Dafür entsteht nun die Ecke ac.
Kurz bevor dieser Fall eintritt, kann b keine rivalisierende Kante zu einem anderen Knoten
sein. Damit muss nur eine konstante Menge von Zertifikaten verändert oder gelöscht werden.
Diese enthalten in der Klammer ihres Namens ab oder bc und enthalten nun stattdessen ac.
Im umgekehrten Fall erscheint eine Kante b und teilt damit eine Ecke ac in zwei Ecken ab
und bc. Damit müssen nur die Zertifikate mit ac im Namen geändert werden. Ein Steigungsvergleich zwischen b und der rivalisierenden Ecke von ac erfordert die Entscheidung, welcher
der neuen Knoten die, falls vorhandenen, tangentialen Zertifikate erhalten muss.
2.4 Divide and Conquer Algorithmus für die obere Hülle
In diesem Abschnitt wollen wir nun eine Struktur vorstellen, die eine Punktmenge und
ihre Teilmengen verwaltet, um optimal die konvexe Hülle der Gesamtmenge berechnen zu
können. Um diesen Divide and Conquer Ansatz umzusetzten, betrachten wir als erstes
einen binären Baum. Ein Knoten ist nun dafür verantwortlich, die obere konvexe Hülle
242
Sabine Naewe
Algorithmus 26 Ereignis: Ungültigkeit von x[ab, cd]
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
Lösche x[ab, cd];
Erzeuge x[cd, ab];
if ∃ x[cd, cd.next] then
Lösche x[ab.prev, ab];
else
Erzeuge x[ab.prev, cd];
if ∃ x[cd, cd.next] then
Lösche x[cd, cd.next];
else
Erzeuge x[ab, cd.next];
cd.prev ← ab.prev;
ab.next ← cd.next;
cd.next ← ab;
ab.prev ← cd;
ce(ab) ← d;
ce(cd) ← a;
/* Aktualisierung der Überschneidungszertifikate /*
if ∃ yri[ab] then
Lösche yri[ab];
Erzeuge yri[cd];
if ∃ yli[cd] then
Lösche yli[cd];
Erzeuge yli[ab];
/* Aktualisierung der Steigungszertifikate, wenn ab unter cd ist /*
if ab <y d then
if ∃ yt[cd] then
Lösche slt[cd], srt[cd], yt[cd]
if ∃ sl[ab] then
Lösche sl[ab];
if χ(ab) 6= χ(cd) & b <s d then
Erzeuge sl[ab];
if χ(cd.prev) 6= χ(cd) & cd.prev <y ce(cd.prev) & a <s c then
Erzeuge sl[cd.prev];
else
if ∃ sr[ab] then
if a <s d then
Lösche sl[cd.prev];
Erzeuge slt[cd], srt[cd], yt[cd];
else
Aktualisiere sr[ab] mit dem Punkt des neuen cd(ab);
/* Analog für cd liegt unter ab/*
der beiden Untermengen, die sich in den Kinderknoten befinden, zu berechnen. Wenn sich
in einem der Kinderknoten etwas ändert, muss auch der Elternknoten neue Berechnungen
durchführen und gibt wiederum seine neue Ausgabe an seinen Elternknoten weiter. So erhält
man schließlich in der Wurzel die obere konvexe Hülle der Gesamtmenge. Diese Struktur
besitzt Lokalität O(log n) und Antwortzeit O(log2 n).
Analog zur Tournament Datenstruktur in [5] anaysieren wir die Effizienz unser Datenstruktur, indem wir die Zeit als eine zusätzliche statische Dimension betrachten. Dann betrachten wir jedes Ereignis als Element einer drei-dimensionalen Struktur mit bekannter
worst-case Komplexität. Die erste Version unseres Problems ist für diesen Analyseansatz
schlecht geeignet, da die statische Struktur der konvexen Hülle während der Berechnung
Kinetische Datenstrukturen für zweidimensionale Probleme
243
nicht der konvexen Hülle der Trajektorien der eigentlichen Punkte entspricht. Andererseits
entspricht die obere Hülle unser betrachteten Struktur genau der oberen Hülle der Fläche der eigentlichen Linien. Deswegen können wir auf bereits bewiesene Resultate für die
obere Hülle von algebraischen Flächen zurückgreifen [1]. Sie liefern eine nahezu quadratische Komplexität. Agarwal, Schwarzkopf und Sharir haben bewiesen, dass die Oberfläche
der Projektionen von zwei oberen Hüllen nahezu quadratische Komplexität hat [1]. Damit
erhält man eine scharfe Grenze für die Anzahl der Ereignisse infolge von x-Zertifikaten.
Theorem 1. Die kinetische Datenstruktur zur Erhaltung der konvexen Hülle besitzt O(n2+ε )
Effizienz für jedes ε > 0 in einem (δ, n)-Szenario. Dabei hängt die Konstante in der ONotation von δ und ε ab.
Beweis. Ein (δ, n)-Szenario ist ein Szenario mit n Elementen, bei dem die Trajektorie eines
Objektes ein Vektor von Polynomen in t mit Grad kleiner δ bildet [5].
Sei n die Anzahl der roten und blauen Linien in dem Berechnungsbaum. Als erstes betrachtet man die Ereignisse, welche mit einem speziellen Knoten des Berechnungsbaumes
verknüpft sind. Dabei sei die Zeit die statische dritte Dimension. Dann beschreibt eine Linie, deren Parameter polynomiale Funktionen abhängig von der Zeit sind, eine algebraische
Fläche im Dreidimenisionalen. Die Familie der blauen (bzw. roten) Linien wird dann als
Familie von bivariaten algebraischen Funktionen betrachtet. Wenn man nun die beiden oberen Hüllen und ihre gemeinsame Hülle betrachtet, sieht man, dass ein violetter Knoten in
dem zugeordneten Maximierungsdiagramm einem Vorzeichenwechsel in einem y-Zertifikat
entspricht. Ein monochromatischer Knoten entspricht dann dem Erscheinen bzw. Verschwinden einer Kante, was durch einen Nachfahren ausgelöst wird. Da unsere Flächen algebraisch
einen begrenzeten Grad haben, besitzt ihr Maximierungsdiagramm Komplexität O(n2+ε )
für jedes ε > 0 (Theorem 2.7 [1]). Damit wird die Anzahl der Ereignisse abhängig von dem
Vorzeichenwechsel der y-Zertifikate durch diese Schranke begrenzt.
Nun betrachten wir die Ereignisse, die von der Neuordnung der x−Koordinaten von zwei
Knoten mit verschiedenen Farben abhängen. Wir nennen diese im folgenden x-Ereignisse.
Im dreidimensionalen wird dann ein blauer Hüllenknoten zu einer Kante des blauen Maximierungsdiagramms. Damit entspricht ein x-Ereignis einem Punkt (x, t), über dem sich
eine Kante befindet, die sowohl in der blauen als auch in der roten Hülle enthalten ist. Das
heißt, jedes x-Ereignis ist mit einem bichromatischen Knoten auf der Oberfläche des Maximierungsdiagramms der roten und blauen oberen Familie verbunden. Wenn wir n bivariate
algebraische Flächen mit begrenzeten Grad haben, ist die Komplexität also O(n2+ε ) für
jedes ε > 0 (Theorem 2.8) [1]. Damit haben wir höchstens so viele x-Ereignisse.
Schließlich liegt jedes Paar von Linien für eine konstante Anzahl von Zeitpunkten parallel zueinander. Damit ergeben sich O(n2 ) Steigungs-Ereignisse, welche mit dem bis jetzt
betrachteten Knoten verknüft sind. Wenn wir nun wieder den gesamten Berechnunsbaum
betrachten, erhalten wir zusammenfassend die Ereignisanzahl C(n). Diese erfüllt die Rekurrenzgleichung C(n) = 2C( n2 ) + O(n2+ε ). Damit ergibt sich C(n) = O(n2+ε ).
t
u
Im schlimmsten Fall ändert sich die konvexe Hülle von n Punkten mit linearem oder
höherem Grad Ω(n2 ) Mal; damit ist diese kinetische Datenstruktur effizient.
Insgesamt ist diese Datenstruktur für die konvexe Hülle nicht sehr hilfreich, solange man
keine Datenstruktur für die Anfragen benutzt. Diese kann man aber leicht erhalten, indem
244
Sabine Naewe
man die gegebenen Ecken und Kanten nicht in einer doppelt verketteten Liste sondern in
einem dynamischen binären Baum speichert. Dadurch wird die Effizienz nicht verändert,
aber die Anfragen nach der Lage eines Punktes verbessert sich.
3 Dichtestes Paar
Als nächstes betrachten wie das Problem des dichesten Paares. Bei diesem Problem ist
wieder eine Menge M mit n Punkte gegeben. Gesucht wird nun ein Paar von Punkten
x, y ∈ M mit:
∀ a, b ∈ M : |x − y| ≤ |a − b|.
Es ist ziemlich einfach eine kinetische Datenstruktur zu finden, welche dieses Problem
löst. Man erzeugt eine Prioritätsschlange, welche alle möglichen Abstände zwischen je zwei
Punkten aus M enthält. Das Problem hierbei ist, dass diese kinetische Datenstruktur weder
lokal noch kompakt ist, da jeder Punkt in O(n) vielen Zertifikaten enthalten ist.
Um nun eine kompakte kinetische Datenstruktur zu erhalten, betrachten wir als erstes
einen effizienten Algorithmus, welcher das dichteste Paar einer Punktemenge berechnet. Ein
klassischer Divide and Conquer Algorithmus hierfür ist der von Shamos [4]:
Man teilt die Menge der Punkte in zwei annähernd gleich große Mengen und berechnet
rekurisiv die kleinsten Abstände δL und δR . Dann betrachtet man alle Paare von Punkten,
welche einen Abstand kleiner oder gleich δ = min(δL , δR ) von der vertikalten Linie x = x0
zwischen den beiden Teilmengen besitzen (Abbildung 3). Wenn man nun zulässt, dass sich
die Punkte auch bewegen können, benötigt man für jeden Punkte p auf der linken Seite
ein Zertifikat der Form [xp < x0 − δ] oder umgekehrt. Wenn dann ein Punktepaar δ viele
Veränderungen durchführen würde, müssten alle Zertifikate der obrigen Form aktualisiert
werden und das können O(n) viele sein. Deswegen hätte die daraus resultierende kinetische
Datenstruktur eine so große Antwortzeit, so dass sie in diesem Fall nicht sinnvoll ist.
Abb. 3. Algorithmus für das dichteste Paar
Dieses Beispiel zeigt, dass nicht alle Algorithmen auf die Möglichkeit der Bewegung
erweitert werden können. Bis jetzt wurde für keinen bekannten Algorithmus für das dichteste
Paar eine Erweiterung auf die Bewegung der Elemente gefunden.
In diesem Abschnitt erläutern wir nun einen neuen statischen Algorithmus für die Berechnung des dichtesten Paares einer Menge von Punkten in der Ebene. Er basiert auf dem
Kinetische Datenstrukturen für zweidimensionale Probleme
245
plane sweep paradigm bzw. ebenen Durchlaufmodell. Dannach betrachten wir die Erweiterung für sich bewegende Punkte. Jedes Element besitzt dann eine Position, welche eine
kontinuierliche Funktion in Abhängigkeit von der Zeit ist. Dann benötigen wir einige Datenstrukturen um den Verlauf zu speichern. Für diese Datenstrukturen zeigen wir dann, dass
sie während der Bewegung der Elemente aufrechterhalten werden können. Damit erhalten
wir einen Algorithmus, welcher unsere Anforderungen erfüllt.
3.1 Statischer Algorithmus
Der statische Algorithmus für das Problem des dichtesten Paares basiert auf der Idee der
Teilung des Raumes um einen Punkt in sechs 60 Gebiete. Trivialerweise ist der nächste
Nachbar jedes Punktes der nächste der nächsten Nachbarn in den sechs Gebieten. Wir
werden zeigen, dass eine auf eindimensionalen Projektionen basierende approximative Definition des nächsten Nachbarn in jedem Gebiet ausreichend ist, um das dichteste Paar zu
finden. Mit dieser Definition können wir dann die Nachbarn effizient berechnen und später
die Bewegung der Objekte in den Algorithmus einbringen.
In diesem Abschnitt betrachten wir eine Menge S von Elementen in einer festen Konfiguration. Um die Notation zu vereinfachen, unterscheidet man nicht zwischen den Elementen
und ihrer Position in der Konfiguration. Wir bezeichen den Abstand zwischen zwei Punkten
p und q mit d(p, q). Nun definieren wir drei verschiedene Ordnungen auf S. Für die erste Ordnung projektieren wir die Punkte orthogonal auf die x−Achse. Die hierauf geltende
Ordnung bezeichnen wir als die x-Ordnung. Für die zweite Ordnung projektieren wir die
Punkte orthogonal auf eine orientierte Linie, welche mit der x-Achse einen 60 Winkel bildet. Wir definieren als die +60 Ordnung die Ordnung der orthogonalen Projektion auf ihrer
Position auf einer orientierten Linie. Analog definieren wir die −60 Ordnung. Für diese drei
Ordnungen schreiben wir <0 , <+ , <− .
Die Annahme einer beliebigen Lage bedeutet, dass kein Element bezüglich dieser drei
Ordnungen gleich einem anderen Element ist und dass keine zwei Paare von Elementen die
gleiche Distanz besitzten. Mit diesen Annahmen sind diese Strukturen und das dichteste
Paar eindeutig definiert.
Im Folgenden leiten wir nun eine notwendige und hinreichende Bedingung für das dichteste Paar her. Dafür benötigen wir im Folgenden einige Sätze und Definitionen.
Lemma 3. Sei T ein gleichseitigen Dreieck, u einer der Begrenzungsknoten und v ein Punkte auf der Begrenzungskante gegenüber von u. Dann gilt für jeden Punkt w im Inneren von
T:
d(w, v) < d(u, v)
Beweis. Sei a die Länge einer Seite von T und b = d(u, v). Die Begrenzungskante, welche
v enthält, besitzt zwei Endknoten. Sei z der Knoten, welcher von den beiden weiter von v
entfernt liegt. Dann können wir schreiben d(v, z) = a2 + c für ein c mit 0 ≤ c ≤ a2 . Mit dem
Satz von Pythagoras gilt b2 = c2 + 34 a2 und damit:
a
a
a2
(b − (c + ))(b + (c + )) = b2 − c2 − ac −
2
2
4
a2
=
− ac
2
≥0
246
Sabine Naewe
Dann gilt b ≥ c + a2 . Der Kreis mit dem Mittelpunkt v und dem Radius d(u, v) enthält alle
drei Knoten der Begrenzung von T und damit alle alle inneren Punkte von T .
t
u
Wir definieren den dominierenden Keil eines Elements p als den nach rechts erweiterten Keil, welcher durch die Linien durch p, die mit der x− Achse einen 30 bzw. −30 Winkel
bilden, begrenzt wird. Wir bezeichnen ihn mit Dom(p). Ein Element q liegt in Dom(p),
genau dann wenn p <− q und p <+ q gelten.
Mit der Bedeckung eines Elementes q bezeichnen wir das am weitesten rechts liegende
Element, welches q in seinem dominierenden Keil enthält und bezeichnen sie als Cover(q).
Damit die Bedeckung immer definiert ist, fügen wir ein Element (−∞, 0) hinzu.
Die Kandidatenmenge eines Elementes p, bezeichnet mit Cands(p), bezeichne die
Menge von Elementen, dessen Bedeckung p ist und das von diesen am weitesten links liegende Element, bezeichnet mit lcand(p), nennen wir den linken Kandidaten von p. Ein
Paar (p, lcand(p)) heißt ein Kandidatenmenge. Sie werden in Abbildung 4 dargestellt.
Abb. 4. Darstellung von U pT arget(p), lcand(p), Cands(p), M axima(p)
Lemma 4. Sei S eine Menge von Elementen in beliebiger Lage. Wenn (p, q) das dichteste
Paar in S ist und q ∈ Dom(p) gilt, ist q der linke Kandidat von p.
Beweis. Den Beweis führen wir indirekt.
Als erstes nehmen wir an, dass p nicht die Bedeckung von q sein. Das bedeutet, dass
eine anderes Element r ∈ S rechts von p liegt und damit q ∈ Dom(r) gilt. In diesem Fall
liegt r im Inneren eines gleichseitigen Dreiecks. Dieses Dreieck hat q als rechte Ecke und
p liegt auf der linken Begrenzungslinie (Abbildung 5 a). Lemma 3 widerspricht dann der
Annahme, dass (p, q) das dichsteste Paar ist. Also gilt p = cover(q).
Nun nehmen wir an, dass ein Punkt q 0 ∈ S ∩ Dom(p) existiert, welcher links von q liegt.
Dann liegt q 0 in Inneren eines gleichseitigen Dreiecks mit p als linker Ecke und q liegt auf der
rechten Begrenzungslinie. Dann gilt mit Lemma 3, dass d(q, q 0 ) < d(p, q). Das widerspricht
wieder (p, q) als dichtestes Paar.
Damit ist q der linke Kandidat von p (Abbildung 5 b).
t
u
Nun haben wir nur noch n Kandidatenpaare für eine Menge mit n Elementen. Wir
bezeichnen diese Elementenpaare verbunden der 0 Richtung. Um nun das dichteste Paar
zu finden, definieren wir analog die obrigen Definitionen für die Richtungen +60 und −60.
Dabei ist der dominierende Keil verbunden mit einem der Winkel 4 einfach der Keil, welchen
man nach den obrigen Definitionen erhält, wenn wir die Fläche mit −4 um den Ursprung
drehen.
Kinetische Datenstrukturen für zweidimensionale Probleme
247
Abb. 5. Wenn (p, q) das dichteste Paar ist und q ∈ Dom(p), dann ist p die Bedeckung von q (a); q der linke
Kandidat von p (b).
Korollar 1. Das dichteste Paar einer n−elementigen Menge S in beliebiger Lage ist eines
der höchstens 3n Kandidatenpaare, welche mit den drei Richtungen 0, +60, −60 verbunden
sind.
Beweis. Sei (p, q) das dichteste Paar der Menge S, wobei p links von q liegt. Die drei dominierenden Keile von p spannen die ganze rechte Halbebene von der Vertikalen durch p auf.
Damit liegt q in einem dieser Keile. Mit dem Lemma 4 folgt, dass (p, q) ein Kandidatenpaar
für diese Richtung ist.
t
u
Für ein gegebenes Element p bezeichnen wir nun mit Sp die Menge aller Elemente
zu seiner rechten Seite. Die Elemente aus Sp , dessen Bedeckung nicht in Sp liegt, wird
mit Maxima(p) bezeichnet. Diese Menge wird in Abbildung 4 dargestellt.
Proposition 1. Wenn q, r ∈ Cands(p), dann gilt:
q <+ r ⇔ r <− q ⇔ q <y r
Beweis. Nach Voraussetzung liegen q und r nicht im dominierenden Keil des anderen. Damit
liegt r entweder unter oder über dem doppelten Keil, welcher durch die 30 und −30 Linien
durch p begrenzt wird. Falls ein Punkt über oder unter einem anderen liegt, sind die Ordnung
<+ und <− die entgegengesetze Ordnung der anderen. Damit ist die Ordnung <+ die gleiche
wie die y-Ordnung.
u
t
Der dominierende Keil von p teilt M axima(p) in drei Mengen. Die zentrale Menge in
dem dominierenden Keil enthält die Kandidaten von p. Das niedrigste Element in der Menge
über Dom(p) wird als oberes Ziel von p mit U pT arget(p) bezeichnet. Analog bezeichnet
man das größte Element in der Menge unter Dom(p) als unteres Ziel mit LowT arget(p)
bezeichnet. Das obere Ziel ist genau der linke Kandidat von p in Richtung +60 (Abbildung 4). Widerum fügt man Markierungen für −∞ und +∞ hinzu, damit die beiden Ziele
wohldefiniert sind.
Proposition 2. Wenn U pT arget(q) = U pT arget(r) und q <0 r gilt, folgt q <− r. Wenn
LowT arget(q) = LowT arget(r) und q <0 n r, gilt q <+ r.
Beweis. Wir beweisen nur die erste Behauptung. Die zweite Behauptung folgt dann analog.
Sei P das gemeinsame obere Ziel von q und r. Wir nehmen an, dass q links von r liegt.
Wenn r <− q, dann liegt r über dem dominierenden Keil von q. Da aber r unter p liegt,
kann p nicht oberes Ziel von q sein. Das ist ein Widerspruch zur Voraussetzung. Also gilt
q <− r.
t
u
248
Sabine Naewe
Nun skizzieren wir den statischen Algorithmus zur Berechnung aller Kandidatenpaare
in Richtung 0 aus der Menge S. Dabei fügen wir die Elemente von rechts nach links ein
und speichern die Menge M axima(p) in einem binären Baum Maxima. Dabei sortieren wir
die Elemente nach der ansteigenden y-Koordinate bzw. äquivalenterweise durch die 60 oder
−60 Ordnung. Dieser Baum wird für jedem Knoten mit einem Feld erweitert. Dieses enthält
das linkeste Element in dem Unterbaum, welcher diesen Knoten als Wurzel hat. Dieses Feld
wird später für die Bewegung benötigt. Im statischen Fall ändert sich die Laufzeit nicht
wesentlich ohne dieses Feld, da man auch alle Elemente aus Cands(p) betrachten kann. Der
dazu gehörige Algorithmus wird unten dargestellt.
Algorithmus 27 Berechnung aller Kandidatenpaare in 0 Richtung
1:
2:
3:
4:
5:
6:
Initialisiere Maxima mit ∅
Für jeden Punkte p ∈ S von rechts nach links:
(a) Finde U pT arget(p) und LowT arget(p) in Maxima
(b) Setze Cands(p) = M axima ∩ Dom(p)
(c) Setze lcand(p) als das linkeste Element von Cands(p)
(d) Ersetze die Elemente aus Cands(p) durch p in Maxima
Man sieht, dass dieser plane sweep Algorithmus mit Laufzeit O(n log n) implementiert
werden kann. Das Sortieren zur Vorbereitung des Durchlaufs benötigt O(n log n). Man
speichert Maxima in einer erweiterten balancierten binären Baumstruktur, welche Einfügen, Suchen, Löschen, Trennen und Verbinden in logarithmischer Zeit unterstützt [1]. Die
Berechnung von Cands(p) erfordert zwei O(log n) Suchen in Maxima, falls Cands(p) eine
fortlaufende Untermenge von Maxima ist. Das Herausnehmen von Cands(p) aus Maxima
und Einfügen von p auf diese Plätze benötigt O(log n) für jedes Element p. Dabei muss das
Feld des linkesten Elements aktualisiert werden. Insgesamt beträgt die Laufzeit O(n log n).
Der gleichen Algorithmus wird dann für die Flächen rotiert um 60 und −60 verwendet
um alle Kandidatenpaare aus Korollar 1 zu bekommen. Aus diesen Paaren kann man in
linearer Zeit das dichsteste Paar berechnen. So erhält man das dichteste Paar mit worstcase Laufzeit O(n log n).
Der Algorithmus zur Berechnung der Kandidatenpaare benötigt nur Vergleiche in den
drei Richtungen 0, 60 und −60. Damit sind die Bedeckung, das Ziel und der linke Kandidat
für jeden Punkt durch die Ordnung entlang dieser drei Richtungen definiert. Wir sprechen
von allen diesen Attributen als die Kegelstruktur von S.
Proposition 3. Die folgende Menge von Zertifikaten auf einer Menge S reicht aus um die
Kegelstruktur und das dichsteste Paar von S zertifizieren.
1. Zertifikate zur Bestätigung der 0 Ordnung auf S
2. Zertifikate zur Bestätigung der 60 Ordnung auf S
3. Zertifikate zur Bestätigung der −60 Ordnung auf S
4. Zertifikate zur Bestätigung der Ordnung der Kandidatenpaaren aus S.
Diese Beweisstruktur hat lineare Größe und O(log n) Lokalität.
Beweis. Die Gültigkeit des Beweises ist durch die Korrektheit des Algorithmus gegeben.
Nun betrachten wir die Lokalität. Jedes Element kommt höchstens in zwei Zertifikaten in
der geordneten Liste vor. Außerdem ist jedes Element für jede Richtung in höchstens zwei
Kinetische Datenstrukturen für zweidimensionale Probleme
249
Kandidatenpaaren enthalten. Das eine Paar enthält noch seinen linken Kandidaten. Das
anderen enthält zusätzlich das Element zu dem das Ausgangselement der linke Kandidat
ist. Daher erscheint ein Element in der Kanditatenpaarordnung in O(1) Blättern und in
O(log n) inneren Knoten. Damit hat die Beweisstruktur O(log n) Lokalität.
t
u
3.2 Die Bewegung der Elemente
Im vorherigen Abschnitt haben wir uns mit einer Struktur beschäftigt, welche das dichteste
Paar einer Menge berechnet. Im folgenden betrachten wir nun, wie sich die Struktur ändern
muss, wenn ein Zertifikat verfällt und zählen dabei die worst case Anzahl von Ereignissen,
die in unserem polynomiellen Bewegungsmodell auftreten können.
Im [5] wurde die Aktualisierung des Wettbewerbes zwischen Kandidatenpaaren betrachtet.
Nun müssen wir die Kegelstruktur aktualisieren, wenn sich die Ordnung zweier Elemente auf
einer der drei betrachteten Richtungen ändert. Wenn zwei Elemente ihre Plätze tauschen,
kann dies höchstens eine Veränderung in der Bedeckung von O(n) vielen Elementen ändern.
Genauso kann eine Veränderung in der 60 Ordnung höchstens linear viele Veränderungen
von Zielen mit sich bringen.
Um nun eine ansprechbare kinetische Datenstruktur zu bekommen, stellt man die Ziele
und Bedeckungen implizit in drei verschiedenen Binärbäumen dar.
1. Cands(p) enthält alle Kandidaten von p. Diese werden nach ihrer y−Ordnung sortiert.
Die Folge dieser Elemente wird nun in einem balancierten Binärbaum gespeichert. Dieser
unterstützt Suchen und Aktualisieren. Zusätzlich bekommt jeder Knoten einen Zeiger
auf seinen Elternknoten in dem Baum und auf die Wurzel dieses Baumes. Damit kann
man für jedes Element q ∈ S seine Bedeckung in O(log n) finden. Außerdem kennt jeder
Knoten seinen in x-Ordnung in seinem Unterbaum am weitesten links liegendes Element.
Damit speichert die Wurzel von Cands(p) lands(p). Die Korrektheit des Elternzeigers
kann in einer Standardbaumaktualisierungsoperation mit dem gleichen asymptotischen
Aufwand wie das Feld des linkesten Kandidaten erhalten bleiben. Dieses Feld muss
immer überprüft werden, falls sich die x-Ordnung ändert.
2. Hitsu (p) enthält alle Elemente, welche p als ein oberes Ziel besitzten. Sie werden nach der
−60 Ordnung sortiert und in einem balancierten Binärbaum gespeichert. Dabei besitzt
jeder Knoten einen Zeiger auf seinen Elternknoten und auf p in der Wurzel, so dass für
jedes Element das obere Ziel in logarithmischer Zeit gefunden werden kann.
3. Analog enhält Hitsl (p) alle Elemente, für die p ein unters Ziel ist.
Mit diesen Datenstrukturen kann nun die Bewegung der Elemente simuliert werden,
wobei wir die Maxima Datenstruktur selbst nicht mehr benutzen. Der statische Algorithmus
ist nützlich, um diese Datenstrukturen nach dem Verfall eines Ereignisses in O(n log n) zu
erzeugen, wobei die beiden Hits Strukturen taktweise nach jedem gefundenen Ziel aufgebaut
werden können.
Um nun die Arbeitsweise dieser Datenstrukturen zu verdeutlichen, betrachten wir als erstes den Algorithmus, welcher Cands(), Hits() und lands() aktualisiert, wenn zwei Elemente
p und q bzgl. der x-Ordnung ihre Positionen tauschen. Ohne Beschränkung der Allgemeinheit liegt p links von q und im Augenblick des Wechsels unter q.
250
Sabine Naewe
1: /*Schritt 1*/
2: if q = U pT arget(p) then
3:
(a) Hole aus Cands(q) die Elemente von Dom(p) und füge sie zur Spitze von Cands(p) hinzu.
4:
(b) Sei w = LowT arget(q). Lösche q aus Hitsl (w) und füge es in Hitsl (p) hinzu.
5:
(c) Sei v, falls vorhanden, das neue Bodenelement von Cands(q) oder sonst das obere Ziel von q.
Lösche p aus Hitsu (q) und füge es in Hitsu (v) ein.
6: /*Schritt 2*/
7: Sei p0 = Cover(p) und q 0 = cover(q).
8: if p0 = q 0 then
9:
Aktualisiere lcand(p0 ) beginnend beim gemeinsamen Vorgänger von p und q im Baum für Cands(p0 ).
Abb. 6. Ein x-Ereignis und die Veränderung von Cands
Abbildung 6 verdeutlicht diesen Algorithmus. Dabei gilt, dass sich die Kegelstruktur
ändert, falls q ein Ziel von p ist und sich ihre x-Koordinaten vertauschen. Dabei werden die
Elemente aus Maxima(q) in Dom(q) ∩ Dom(p) von Cands(q) nach Cands(p) verschoben.
Das Element p bekommt ein neues Ziel; der neue Punkt der Linie zwischen dem Abschnitt
von p und seinem Ziel liegt in Dom(q). Ebenfalls bekommt q p als ein Ziel. Diese Veränderung
geschieht in Schritt 1.
Wir defininieren nun das Maximumdiagramm alsSdie Vereinigung aller Punkte, welche
auf dem Rand von Dom(p) liegen und die nicht in q∈M axima(p) Dom(q) vorhanden sind.
Die einzigen sich ändernden Kanten im Maximumdiagramm sind dann die, welche sich rechts
von p und q erstrecken. Für Elemente rechts oder links von p, q ändert sich kein Ziel. Damit
aktualisiert Schritt 1 auch das Maximumdiagramm.
Wenn weder p noch q Ziel des anderen sind, ändert sich das Maximumdiagramm nicht
und Cands() und Hits() Felder müssen nicht verändert werden.
Ein lcand() Feld muss hingegen immer verändert werden. Falls p, q ∈ Cands(u) für ein
u, muss sichergestellt werden, dass das Feld für den linkesten Kandidaten im Binärbaum
für Cands(u) aktualisiert wird. Dafür wird jeder Vergleich von p und q in diesem Baum neu
bewertet. Dadurch kann sich lcand(u) verändern. Dies geschied in Schritt 2.
Jeder Schnitt des Algorithmus kann in logarithmischer Zeit durchgeführt werden. Dies
gilt auch für Schritt 1(a), da Cands(q) nach der −60 Ordnung sortiert ist. Die Neuterminierung der modifizierten Zertifikate für die geänderte Ordnung benötigt ebenfalls logarithmische Zeit.
Der folgende Pseudoalgorithmus aktualisiert das zugehörige Feld, wenn zwei Elemente p
und q ihre Positionen in der +60 Ordnung von S wechseln. Während dieses Wechsels bildet
die Linie durch p und q einen −30 Winkel mit der x-Achse.
Ohne Beschränkung der Allgemeinheit nehmen wir an, dass p links und überhalb von q
liegt. Dann können zwei verschiedene Fälle auftreten. Entweder kommt q zu Dom(p) dazu
oder q verlässt diese Menge.
Kinetische Datenstrukturen für zweidimensionale Probleme
251
Im ersten Fall kommt q zur Menge Dom(p) dazu. Dann wird die Datenstruktur wir folgt
aktualisiert:
1: if q = LowT arget(p) then
2:
(a) Sei v = Cover(q). Lösche q aus Cands(v) und füge es in Cands(p) ein.
3:
(b) Sei t das linkeste Element in Hitsu (q), welches rechts von p liegt. Falls nicht vorhanden, setzte t
gleich dem linkestes Ziel von q. Lösches p aus Hitsl (q) und füge p zu Hitsl (t) hinzu.
4:
(c) Lösche die Untermenge aus Hitsu (q), dessen Elemente links von t (somit auch links von p) liegen
füge sie an das Ende von Hitsu (p).
Im zweiten Fall verlässt q die Menge Dom(p). Der hierzu gehörige Pseudocode vertauscht
nur die Aktionen des ersten Falles:
1: if q ∈ Cands(p) then
2:
(a) Sei t = LowT arget(q). Lösche p aus Hitsl (t) und füge es in Hitsl (q) ein.
3:
(b) Lösche aus Hitsu (p) die Elemente kleiner als q bzgl. <− und füge sie am Anfgang von Hitsu (q)
ein.
4:
(c) Sei v das neue rechteste Element von Hitsu (p). Falls Hitsu (p) leer ist, sei v die Bedeckung von
p. Lösche q aus Cands(p) und füge q zu Cands(v) hinzu.
Diese Fälle werden in Abbildung 7 dargestellt. Von (a) nach (b) verdeutlicht den ersten
Fall, während (b) nach (a) darstellt.
Abb. 7. Ein 60 Ereignis
Im ersten Fall kommt q zur Menge Dom(p) hinzu. Wenn q nicht das kleinste Ziel von p
ist, gilt q 6∈ M axima(p) und damit verändert der Wechsel von p und q in der +60 Ordnung
die Kegelstruktur nicht. Somit muss die Datenstruktur nicht verändert werden. Falls aber
q das kleinste Ziel von p ist, verändert sich die Kegelstruktur. Dies geschieht aber nur in
der Nähe von p und q. Ihr Wechsel verändert nicht die Ziele der Elemente rechts von p, nur
das kleinste Ziel von p muss aktualisiert werden. Dies geschied in Schritt (b). Die Elemente
links von p, welche q als ihr oberes Ziel haben, müssen p als ihr neues Ziel speichern. Diese
Elemente liegen alle in Hitsu (q). Diese Aktualisierung geschied in Schritt (c). Von den
Mengen Cands() änderts dich nur die Menge Cands(p), da q zu dieser Menge hinzukommt
(Schritt (a)). Die Felder für die linkesten Elemente werden während den Veränderungen
in den binären Bäumen der Mengen Cands() aktualisiert und bleiben damit korrekt. Die
Listen der Mengen Cands() und Hits() reichen aus um die kombinatorische Struktur des
Maximumdiagramms darzustellen. Damit ist dieses korrekt, solange die Mengen korrekt
sind.
252
Sabine Naewe
Im zweiten Fall sind die Wechsel im Maximumdiagramm genau umgekehrt zu denen im
ersten Fall. Die Aktualisierung geschied genau umgekehrt zu der ersten Prozedur.
Die hierbei benutzten Operationen sind alle in logarithmischer Zeit möglich. Dies gilt
auch für den Schritt (b) im ersten Fall, da die Elmente aus Hitsu (q) in der x-Ordnung
geordnet sind. Die Anzahl sich hierbei wechselnder Zertifikate beträgt O(1). Sie können in
logarithmischer Zeit in der Ereignisschlange aktualisiert werden. Somit kann das gesuchte
Element in logarithmischer Zeit gefunden werden.
Das letzte Element unserer kinetischen Datenstruktur ist der kinetische Wettbewerb der
3n vielen Abständen, welche zu den (p, lcand(p)) Paaren gehören. Damit bekommen wir
3n zusätzliche Zertifikate zu unserer Datenstruktur. Die Wurzel unseren Baumes für diesen
Wettbewerb enthält zu jeder Zeit das dichteste Paar. Dabei muss man beachten, dass wenn
sich lcand(p) ändert, dies zu einer Unstetigkeit des zugehörigen Abstandes im kinetischen
Wettbewerb führt. Insgesamt bekommen wir nun eine Datenstruktur, welche auf einem
dynamischen Szenario arbeitet.
Theorem 2. Die kinetische Datenstruktur für das dichteste Paar hat eine Effizienz von
O(nλ2δ+2 (n) log2 n) in einem dynamischen (δ, n, m) Szenario.
Beweis. Ein (δ, n, m) Szenario ist ein dynmisches Szenario, bei dem maximal n Objekte
gleichzeitig sichtbar sein können und es m verschiedene Bewegungsabschnitte gibt. Auf
diesen sind die Trajektorien wieder Polynome in t vom Grad kleiner als δ [5].
Ein Ereignis in der Kegelstruktur ist der Wechsel der Ordnung zweier Elemente entlang
einer der drei Ordnungen. Ein Paar von Elementen kann seine Ordnung höchstens δ mal
wechseln. Es gibt O(n2 ) solcher Ereignisse, welche wie vorher gesehen in O(log n) ablaufen.
Das Quadrat des Abstandes zweier Elemente ist eine ganzrationale Funktion mit Grad 2δ.
Damit ist das für den kinestischen Wettbewerb erzeugte Szenario ein dynamisches (2δ, n, n2 )
Szenario und hat damit Effizienz O(nλ2δ+2 (n) log2 n) (Lemma 3.8) [1].
t
u
Damit haben wir eine kinetische Datenstruktur für das dichsteste Paar. Sie ist linear,
hat konstante Lokalität und O(log2 n) Antwortzeit, und fast optimale Effizienz und erfüllt
damit unsere gewünschten Eigenschaften.
4 Zusammenfassung
In diesem Kapitel haben wir nun am Beispiel der kinetischen Datenstruktur für die konvexe
Hülle und die des dichstesten Paares einer Menge kinetische Datenstrukturen für zweidimensionale Probleme betrachtet. Das Vorgehen und die Analyse dieser beiden wichtigen
geometrischen Probleme lässt sich nun auf andere Problem übertragen und anwenden. Mit
ihnen lassen sich auch effiziente Algorithmen für Probleme in höheren Dimensionen finden.
Somit stellen die kinetischen Datenstrukturen ein vielseitiges Hilfsmittel für viele Basisprobleme dar.
Literaturverzeichnis
1. Julien Basch, 1999, Kinetic Data Structures, Seite 41-62
Kinetische Datenstrukturen für zweidimensionale Probleme
253
2. Dietrich Travkin, 2003, Kinetische Datenstrukturen, Seite 1-10
3. Leonidas J. Guibas, 1997, Kinetic Data Structures: A State of the Art Report, Seite 7-8
4. F. P. Preparata und M. I. Shamos, 1985, Computational Geometry: An Indroduction, Springer-Verlag,
1st ed. 1985. Corr. 5th printing edition (August 6, 1993), New York, NY
5. Peter Kling, 2007, Eine Einführung in kinetische Datenstrukturen, Technical report, University of
Paderborn
Dynamische Steinerbäume
Holger Hagedorn
Universität Paderborn, [email protected]
Zusammenfassung. Diese Ausarbeitung beschreibt das Problem Dynamic Steiner Tree (DST). Praktische
Anwendungen finden sich in Netzwerken, in denen sich die Menge der über Router zu verbindenden Rechner
im Laufe der Zeit verändern. Im Teilproblem DST-N dürfen keine existierenden Verbindungen verändert
werden. Hierfür zeigen wir, dass die Worst-Case Performanz für jeden Algorithmus mindestens 21 log n mal
die Kosten einer optimalen Lösung beträgt mit n als Anzahl der Rechner. Weiterhin präsentieren wir einen
Greedy-Algorithmus, der maximal die zweifachen Kosten dieser Schranke verursacht. Letztlich wird noch
ein Ausblick auf Ergebnisse für das Teilproblem DST-R gegeben, in dem Veränderungen an bestehenden
Verbindungen erlaubt sind.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
1.2 Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
1.3 Kompetitive Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
2
DST-N . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
2.1 Add Requests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
2.2 Dynamischer Greedy-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
2.3 Remove Requests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
3
DST-R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
4
Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
1 Einleitung
1.1 Motivation
Stellen wir uns ein Netzwerk von Rechnern vor. Ein paar Arbeitsrechner sind dafür vorgesehen miteinander verbunden zu werden und Daten auszutauschen. Unser Ziel ist es die
Arbeitsrechner so miteinander zu verbinden, dass die zu übertragenden Daten möglichst
schnell übermittelt werden. Dazu können die restlichen Rechner im Netzwerk als Router
benutzt werden. Überträgt man dieses Problem auf einen gewichteten Graphen als das
Netzwerk, so hat man eine gewisse Teilmenge der Knoten gegeben, die man mit einem
Baum verbinden möchte. Dies könnte man über einen Spannbaum lösen, wie in Abbildung
256
Holger Hagedorn
1 (a) für drei Knoten gezeigt. Allerdings kann es eine günstigere Verbindung geben, sofern man noch andere Knoten des Graphen mit einbezieht. Der entstehende Baum wird
Steinerbaum genannt und ist in Abbildung 1 (b) dargestellt. Ein Steinerbaum ist also eine
Verallgemeinerung des Spannbaums.
In vielen Netzwerken sind aber die Arbeitsrechner nicht statisch, sondern es werden
immer wieder welche hinzugefügt und entfernt. Wir befinden uns damit also im Gebiet der
Online-Algorithmen. Dieses sogenannte Dynamic Steiner Tree (DST) Problem wird von
Imase und Waxman [1] vorgestellt. Dabei gibt es zwei verschiedene Teilprobleme. Im ersten
Fall können beim Hinzufügen und Entfernen von Knoten die bestehenden Verbindungen
nicht geändert werden. Im zweiten Fall sind solche Veränderungen erlaubt, allerdings wird
die Anzahl derer beschränkt.
Wir werden in diesem Abschnitt zunächst die beiden Teilprobleme formal definieren und
daraufhin die kompetitiven Analyse als Technik vorstellen, mit der wir die Performanz von
Online-Algorithmen analysieren können. In Abschnitt 2 befassen wir uns mit dem ersten
Teilproblem. Dort zeigen wir erst eine untere Schranke für alle Algorithmen die nur Knoten
ins Netzwerk hinzufügen. Dann stellen wir einen Greedy-Algorithmus für das Problem vor
und beweisen seine Performanz. Zuletzt zeigen wir noch, dass im Fall wo auch Knoten aus
dem Netzwerk entfernt werden können, keine obere Schranke existiert. In Abschnitt 3 geben
wir einen kurzen Überblick über die Ergebnisse zum Teilproblem in dem Veränderungen
zugelassen sind.
1.2 Definitionen
Wir bezeichnen mit G = (V, E) einen ungerichteten und zusammenhängenden Graphen.
Dabei steht V (G) für die Knotenmenge und E(G) für die Kantenmenge. Der Grad deg(v)
eines Knoten v ist definiert als die Anzahl inzidenter Kanten. Ein Teilgraph G0 von G wird
mit G0 ⊆ G notiert bzw. mit G0 ⊂ G für einen echten Teilgraphen. Ein einfacher Pfad in
einem Graphen ist ein Pfad in dem jeder Knoten nur einmal vorkommt. Mit dist : V × V →
R+ wird ein kürzester Weg zwischen zwei Knoten bezeichnet. Weiterhin gibt es zu jedem
Graphen eine Kostenfunktion cost : E → R+ . Eine Instanz I des Problems DST besteht aus
einem Graphen G, der Kostenfunktion cost und einer Folge von Anfragen σ = {σ0 , . . . , σK }
mit σi = (vi , ρi ) wobei vi ∈ V und ρi ∈ {add, remove}.
Definition 1 (Steinerbaum). Gegeben ein zusammenhängender, ungerichteter Graph G =
(V, E), eine Gewichtsfunktion cost : E → N+ und eine Menge von Terminalen S ⊆ V . Ein
Steinerbaum T = (V 0 , E 0 ) ist ein zusammenhängender Teilbaum von G, in dem S ⊆ V 0 gilt.
(a)
(b)
Abb. 1. Beispiel für (a) einen Spannbaum auf drei Knoten und (b) einen Steinerbaum auf denselben Knoten
Dynamische Steinerbäume
257
Bei einem minimalen
P Steinerbaum (man spricht auch von dem Steinerbaum-Problem ST)
gilt zusätzlich, dass e∈E 0 cost(e) minimal ist. Bei dem korrespondierenden Online-Problem
Dynamic Steiner Tree verändert sich die Menge der Terminale. Si beschreibt dabei die
Terminale zum Zeitpunkt i. Wir definieren nun die beiden Ausprägungen dieses Problems.
Definition 2 (DST-N). Gegeben sei eine Instanz I = (G, cost, σ). Das Problem DST-N
(Nonrearrangeable Dynamic Steiner Tree) besteht darin, eine Folge von Bäumen (Ti )0≤i≤K
zu finden, so dass
P eine Funktion cost(Ti ) für alle 0 ≤ i ≤ K minimiert wird. In diesem Fall
ist cost(Ti ) = e∈E(Ti ) cost(e). Dabei müssen folgende Bedingungen eingehalten werden:
1. Jeder Baum Ti ist ein Steinerbaum auf Si .
2. Falls σi eine add-Anfrage ist, dann muss Ti−1 ⊆ Ti gelten.
3. Falls σi eine remove-Anfrage ist, dann muss Ti ⊆ Ti−1 gelten.
Definition 3 (DST-R). Gegeben sei eine Instanz I = (G, cost, σ). Das Problem DST-R
(Rearrangable Dynamic Steiner Tree) besteht darin, eine Folge von Bäumen (Ti )0≤i≤K zu
finden, so dass eine Funktion cost(Ti ) für alle 0 ≤ i ≤ K minimiert wird. Dabei müssen die
folgenden Bedingungen eingehalten werden:
1. Jeder Baum Ti ist ein Steinerbaum auf Si .
2. Die Anzahl der Änderungen dürfen eine obere Schranke B nicht überschreiten.
Offensichtlich ist in der letzteren Version die Einschränkungen um Ti aus Ti−1 zu konstruieren relaxiert. Zusätzlich sind allerdings die Anzahl der Veränderungen um von Ti−1 nach
Ti zu gelangen beschränkt. Die Anzahl der Änderungen im Schritt i werden mit αi bezeichnet und entsprechen der Anzahl der Zusammenhangskomponenten in Ti−1 ∩ Ti abzüglich
eins.
1.3 Kompetitive Analyse
Wir führen in diesem Kapitel eine Analysetechnik für Online-Algorithmen ein, die Optimierungsprobleme lösen (vgl. [3]). In unserem Fall haben wir ein Minimierungsproblem
vorliegen, denn wir wollen mit Hilfe eines Algorithmus A einen Steinerbaum für eine gegebene Instanz I = (G, cost, σ) von DST erzeugen, der möglichst geringe Kosten hat. Wir
bezeichnen dabei mit A(Si ) die Kosten cost(Ti ) des Baumes, den A für Si generiert hat.
Weiterhin bezeichne OP T (Si ) die Kosten eines minimalen Steiner-Baumes auf Si .
Im allgemeineren Fall sprechen wir von einem unter Betrachtung stehenden OnlineAlgorithmus A und einem optimalen Offline-Algorithmus OP T . Optimal bedeutet, dass
er unter allen möglichen Instanzen I eine der Lösungen liefert, die geringstmögliche Kosten
verursacht. Im Vergleich zu Offline-Algorithmen, wo die Eingabegröße bekannt ist, sind bei
Online-Algorithmen zu Beginn des Berechnungsvorgangs nicht alle Eingabedaten verfügbar.
Die Eingabedaten werden vielmehr zur Laufzeit ergänzt. Dies ist durch die Eingabefolge σ
ausgedrückt. Berechnungen von A dürfen zum Zeitpunkt i immer nur von der Anfrage σi
abhängen.
Es stellt sich nun die Frage, wie wir die Güte solcher Online-Algorithmen analysieren
können. Die klassische Worst-Case Analyse mit dem O-Kalkül versagt an dieser Stelle, da
die Eingabegröße nicht verfügbar ist. Daher hat sich eine Analysetechnik durchgesetzt, die
kompetitive Analyse genannt wird. Die Idee dahinter ist, dass man einen Online-Algorithmus
258
Holger Hagedorn
A gegen einen Gegner antreten lässt (daher kompetitiv). Der Gegner stellt Anfragen σi immer gerade so, dass die Lösung die A produziert möglichst hohe Kosten hat. Das Verhältnis,
wie schlecht A dabei abschneidet, wird gemessen indem man die Lösung von A der Lösung
von OP T gegenüber stellt.
Definition 4 (c-Kompetitivität). Sei A ein Online-Algorithmus und OP T ein optimaler
Offline-Algorithmus. A ist c-kompetitiv, genau dann wenn gilt:
∃a ≥ 0 : ∀0 ≤ i ≤ K : A(σi ) ≤ c · OP T (σi ) + a
c wird hierbei kompetitiver Faktor genannt. Wenn a = 0 dann ist der Algorithmus strikt
c-kompetitiv.
Eine alternative (vielleicht intuitivere) Definition des kompetitiven Faktors die sich auch oft
in der Literatur wiederfindet ist
c = max
0≤i≤K
A(σi )
.
OP T (σi )
(1)
Angewendet auf das Problem DST-N lässt sich dies auch formulieren als
A(I) = max
0<i≤K
A(Si )
.
OP T (Si )
(2)
Die Worst-Case Performance Ratio von A für alle Instanzen I (mit |I| als maximaler Größe
des Terminal-Sets) beträgt
CA (n) = sup {A(I) | I ist Instanz mit |I| = n} .
2 DST-N
In diesem Abschnitt betrachten wir das Problem DST-N, also den Fall ohne Änderungen
an bestehenden Verbindungen. Wir konzentrieren uns zunächst nur auf add -Anfragen und
zeigen hierfür eine untere Schranke. Danach geben wir den Greedy-Algorithmus DGA an
und beweisen seine Kompetitivität. Zum Schluss betrachten wir den allgemeinen Fall in dem
auch remove-Anfragen zugelassen sind. Hierfür wird gezeigt, dass es keine obere Schranke
für beliebige Algorithmen gibt.
2.1 Add Requests
Dieser Unterabschnitt behandelt DST-N ausschließlich für add -Anfragen. Um eine untere
Schranke für diesen Fall herzuleiten, definieren wir zunächst eine spezielle Form von Graphen.
Definition 5 (P-Graph). Ein P-Graph Gk = (Vk , Ek ) mit k ∈ N und einer konstanten
Kostenfunktion ck : Ek → R+ ist wie folgt rekursiv definiert:
1. G0 enthält zwei Knoten v0 , v1 ∈ V0 (Level 0 Knoten) die über eine Kante verbunden sind
und es gilt c0 = 1.
Dynamische Steinerbäume
259
2. ∀0 < i ≤ k : Für alle Kanten (u, v) ∈ E(Gi−1 ) wird ein eindeutiges Paar von Knoten
α, β (Level i Schwestern) eingeführt. Die Kante (u, v) wird durch die zwei Pfade (u, α, v)
und (u, β, v) ersetzt. Der resultierende Graph ist Gi . Jede Kante von Gi besitzt Gewicht
ci = 2−i .
Abbildung 2 verdeutlicht die rekursive Konstruktion für die Graphen G0 , . . . , G3 . In
G1 sind exemplarisch die hinzugefügten Knoten α und β benannt. Man beachte auch die
sich mit jedem Schritt halbierende Kostenfunktion. Eine wichtige Beobachtung ist, dass die
Kosten eines einfachen Pfades von v0 nach v1 immer 1 betragen.
Auf einem P-Graph kann weiterhin eine spezielle Form der Adjazenz definiert werden.
Definition 6 (i-Adjazenz). Zwei Knoten u, v ∈ Vk eines P-Graphen Gk sind i-adjazent,
0 ≤ i ≤ k, wenn es einen Pfad von u nach v gibt, so dass gilt:
1. Level von u und v ist höchstens i.
2. Auf dem Pfad gibt es nur Verbindungsknoten mit Level echt größer als i.
Ein Beispiel für i-Adjazenz in einem G3 ist in Abbildung 3 gegeben. Exemplarisch sind
hier je ein Pfad für 1-, 2- und 3-adjazente Knoten eingezeichnet. Man erkennt weiterhin, dass
es nur beschränkte Möglichkeiten für i-adjazente Knoten gibt. In diesem Graphen können
1-adjazente Knoten nur von Level 1 nach 0, 2-adjazente nur von Level 2 nach 1 oder 0,
und 3-adjazente nur von Level 3 nach 2, 1 oder 0 verbunden werden. Die einzigen Knoten
die 0-adjazent sein können sind v0 und v1 . Überdies folgt aus der Definition sofort, dass
i-adjazente Knoten in einem P-Graphen Gk mit k > i im P-Graphen Gi adjazent sind.
Lemma 1. Für alle P-Graphen Gi mit i ≥ 2 gilt:
1. Jeder Knoten x auf Level i ist adjazent zu genau zwei Knoten, nämlich Knoten v auf
Level i − 1 und Knoten u auf Level j mit 0 ≤ j < i − 1. Weiterhin hat x einen Schwesterknoten y auf Level i der ebenfalls zu u und v adjazent ist.
2. Für alle Knoten v auf Level i−1 gilt, dass sie immer adjazent sind zu genau vier Knoten
auf Level i die aus zwei Schwesterpaaren bestehen.
Level
v0
0
3
2
3
α
β
1
3
2
3
0
v1
G0
c0 = 1
G1
c1 =
G2
1
2
c2 =
G3
1
4
Abb. 2. Beispiel für P-Graphen
c3 =
1
8
260
Holger Hagedorn
Level
v0
0
1-adjazent
3
2-adjazent
2
3-adjazent
3
1
3
2
3
0
v1
G3 , c3 =
1
8
Abb. 3. Beispiel für i-Adjazenz
Daraus folgt, dass für Graphen Gk mit k ≥ i die Bedingungen 1 und 2 erhalten bleiben,
wenn man das Wort adjazent durch i-adjazent ersetzt.
Beweis. Das Lemma kann leicht per vollständiger Induktion bewiesen werden. Induktionsanfang ist bei i = 2. Für einen G2 stimmt die Behauptung, was sich leicht anhand Abbildung
2 nachprüfen lässt. Nehmen wir nun an, die Behauptung gelte für i. Wir zeigen, dass die
Behauptung dann auch für i + 1 gilt. In Abbildung 4 sehen wir auf der linken Seite einen
Ausschnitt aus einem Graphen Gi . Der Knoten x auf Level i hat genau wie verlangt einen
Schwesterknoten y und zwei adjazente Knoten u und v. Per Definition eines P-Graphen
werden nun um Gi+1 zu erzeugen für jede Kante zwei Knoten α und β eingefügt. Diese
befinden sich auf Level i + 1. Diese Transformation ist auf der rechten Seite in Abbildung 4
Level
u
u
α = x0
y
x
y0 = β
v0 = x
j (0 ≤ j < i − 1)
i+1
i
i+1
i−1
v
Schritt i
Schritt i + 1
Abb. 4. Induktionsschritt
Dynamische Steinerbäume
261
zu sehen. Wenn wir uns nun wieder einen Knoten als neues x0 herausnehmen (im Beispiel
α), dann hat dieser wiederum einen Schwesterknoten y 0 (im Beispiel β) und ist zu zwei Knoten u0 und v 0 verbunden. Im Beispiel gilt u0 = u und der Knoten liegt damit zwangsläufig
auf Level j mit 0 ≤ j < (i + 1) − 1. Weiterhin wird aus dem alten x das neue v 0 , welches
auf Level i = (i + 1) − 1 liegt. Damit gilt Behauptung 1 des Lemmas. Behauptung 2 gilt
ebenfalls, da v 0 zu genau vier Level i = (i + 1) − 1 Knoten adjazent ist, von denen je zwei
Geschwister sind. Anhand der Abbildung lässt sich erkennen, dass alle Eigenschaften nicht
nur für die betrachteten x0 und y 0 gelten, sondern für alle neu eingeführten Knoten α und
β.
t
u
Definition 7 (k-Sequenz). Für einen P-Graphen Gk wird eine Folge N = (N0 , . . . , Nk )
k-Sequenz genannt, wenn es einen Pfad p gibt der v0 und v1 verbindet und für alle 0 ≤ i ≤ k
gilt:
Ni = {v ∈ V (p) | v ist auf Level i}
Als Beispiel für eine k-Sequenz nehmen wir einen P-Graphen G3 an und es sei ein Pfad
gegeben als (v0 , a, b, c, d, e, f, g, v1 ). Dann ist die korrespondierende 3-Sequenz dazu:
N = ({v0 , v1 }, {d}, {b, f }, {a, c, e, g})
An diesem Beispiel lässt sich auch leicht erkennen, dass für i ≥ 1 immer |Ni | = 2i−1 gilt.
Eine weitere Folgerung aus der Definition ist, dass der von N induzierte Pfad immer die
Kosten 1 hat.
Definition 8 (Minimale Baum-Sequenz). Gegeben sei eine k-Sequenz N für einen PGraphen Gk . Eine Folge T̂ = (T̂0 , . . . , T̂k ) wird minimale Baum-Sequenz genannt und induktiv definiert wie folgt:
1. T̂0 ist ein beliebiger Steinerbaum für N0 und kein T̂00 ⊂ T̂0 ist Steinerbaum für N0 .
2. ∀0 < i ≤ k : T̂i−1 ⊆ T̂i und T̂i ist Steinerbaum für Ni und kein T̂i0 ⊂ T̂i ist Steinerbaum
für Ni .
Offensichtlich ist T̂0 immer ein einfacher Pfad zwischen v0 und v1 . Mithilfe dieser und der
vorherigen Definition können wir jetzt ein Lemma formulieren, welches eine untere Schranke
für Algorithmen angibt, die minimale Baum-Sequenzen erzeugen. Ein beliebiger Algorithmus
A erzeugt T̂i immer basierende auf dem Wissen über T̂i−1 und Ni . Es kann gezeigt werden,
dass Knotenmengen Ni existieren, die immer die Kosten von A mindestens auf die Größe
der unteren Schranke treiben. Wegen der Restriktion von σ auf eine k-Sequenz existiert
immer ein minimaler Steinerbaum mit Kosten 1, nämlich ein einfacher Pfad von v0 nach v1 .
Lemma 2. Sei A ein Algorithmus für DST-N, der für alle Instanzen I = (Gk , cost, σ) eine
minimale Baum-Sequenz T̂ konstruiert. Dann existiert eine Folge von Anfragen auf Gk , die
einer k-Sequenz N entspricht, so dass für alle 0 ≤ i ≤ k gilt:
1
cost(T̂i ) ≥ 1 + i .
2
(3)
262
Holger Hagedorn
Beweis. Das Lemma wird per vollständiger Induktion über i für alle T̂i mit 0 ≤ i ≤ k
bewiesen. Wir konstruieren dazu eine Eingabe σ, die einer k-Sequenz N entspricht, so dass
Ungleichung (3) gilt.
Der Induktionsanfang ist bei i = 0 und i = 1. Für i = 0 gilt die Behauptung, da N0
nach Definition nur die Knoten v0 und v1 beinhaltet, die über einen einfachen Pfad T̂0 mit
Kosten 1 im Graphen Gk verbunden werden können (vgl. Abbildung 2). N0 bildet somit den
Präfix einer k-Sequenz und Ungleichung (3) gilt. Für N1 bleiben uns nun zwei Knoten auf
Level 1 zur Auswahl. Wenn wir den Knoten nehmen, der nicht auf dem Pfad T̂0 liegt, dann
ergibt sich für T̂1 ein Baum mit Kosten cost(T̂1 ) ≥ 1, 5 und Ungleichung (3) gilt. Natürlich
existiert auch ein Pfad mit Kosten 1 über den neuen Knoten, aber da per Definition T̂0 ⊆ T̂1
gelten muss, kann dieser von A nicht gewählt werden. Da der Pfad mit Kosten 1 für N0 und
N1 existiert (unabhängig von T̂0 und T̂1 ), bilden (N0 , N1 ) einen Präfix einer k-Sequenz.
Als Induktionsvoraussetzung nehmen wir an, dass Ungleichung (3) für alle j mit 0 ≤ j ≤
i − 1 gilt und (N0 , . . . , Ni−1 ) der Prefix einer k-Sequenz ist.
Der Induktionsschritt geht nun von i − 1 nach i. Wieder wird ein Gegner angenommen,
der immer unter Erhalt einer k-Sequenz auf den Algorithmus A reagiert und Knoten so
setzt, dass die gewünschten Kosten verursacht werden. Der Algorithmus A hat also einen
Baum T̂i−1 erzeugt, der Gegner wählt nun eine Folge von Anfragen Ni gerade so, dass
A nur einen Baum T̂i erzeugen kann, der mindestens die gewünschten Kosten hat. Per
Widerspruch können wir beweisen, dass zu jedem Knoten v ∈ Ni−1 nur höchstens ein
Knoten pro i-adjazentem Schwester-Paar in T̂i−1 enthalten ist. Dazu betrachten wir einen
Knoten v ∈ Ni−1 . Dieser ist nach Lemma 1 (2) i-adjazent zu genau vier Knoten auf Level
i, aufgeteilt auf zwei Schwesterpaare. Angenommen T̂i−1 würde beide Knoten eines Level i
Schwesterpaares enthalten. Dann müsste T̂i−1 entweder einen Zyklus enthalten, was aber der
Minimalität dieses Steinerbaums widersprechen würde. Oder aber es gäbe einen Blattknoten
z ∈ T̂i−1 , der sich auf einem Level größer als i − 1 befinden würde. Da Nj (0 ≤ j ≤ i − 1)
nach Definition nur Knoten der Level 0 bis i − 1 enthält, gilt z 6∈ Nj . D.h. z könnte auch
weggelassen werden, also ist wiederum die Minimalitätsbedingung verletzt. Damit kann es
in T̂i−1 zu jedem Knoten v ∈ Ni−1 nur höchstens einen Knoten pro i-adjazentem SchwesterPaar geben.
Um die Anfrage Ni zu bilden, wählen wir nun für jedes v ∈ Ni−1 jeweils einen der noch
nicht in T̂i−1 enthaltenen i-adjazenten Schwesterknoten x aus (vgl. Abbildung 5). Nach I.V.
gibt es einen Pfad mit Kosten 1, der alle Knoten aus jedem Nj , 0 ≤ j ≤ i − 1 enthält. In der
Abbildung würde dieser Pfad durch u und v verlaufen. Also existiert auch ein Pfad über
x, da alle weiteren Knoten die zwischen u und v liegen einen Level größer als i besitzen
und also nicht aus (N0 , . . . , Ni−1 ) stammen. Damit gilt die k-Sequenz Eigenschaft auch mit
dem neuen Knoten x ∈ Ni . Nach Lemma 1 (1) ist jeder Level i Knoten i-adjazent zu einem
Knoten auf Level i − 1. Daraus folgt, dass in Ni alle Knoten des Levels i auf diesem Pfad
enthalten sind. Somit ist auch (N0 , . . . , Ni−1 , Ni ) Präfix einer k-Sequenz.
Kommen wir nun zu den Kosten des von A generierten Baumes T̂i . Die Anzahl der Knoten
in Ni−1 beträgt genau 2i−2 . Da zu jedem dieser Knoten zwei Knoten auf Level i verbunden werden, sind insgesamt genau 2i−1 Knoten in Ni enthalten. Die kürzeste Verbindung
dieser Knoten aus Ni mit den Knoten aus T̂i−1 entspricht einer Kante im Gi bzw. einem
korrespondierenden Pfad im Gk . Per Definition des P-Graphen hat eine solche Verbindung
Kosten 2−i .
Dynamische Steinerbäume
263
···
v ∈ Ni−1
Level i − 1
···
..
.
..
.
Level > i
···
T̂i−1 63 x
y ∈ T̂i−1
Level i
···
..
.
..
.
Level > i
···
Level j, 0 ≤ j < i − 1
u
···
Abb. 5. Ausschnitt des Induktionsschritts
=⇒
I.V.
1
1 1
cost(T̂i ) ≥ cost(T̂i−1 ) + (2i−1 · 2−i ) ≥ 1 + (i − 1) + = 1 + i
2 2
2
Damit ist insgesamt das Lemma bewiesen.
t
u
Theorem 1. Sei A ein beliebiger Algorithmus für DST-N. Dann existiert eine Instanz I =
(G, cost, σ), so dass gilt
∀0 < i ≤ K :
A(Si )
1
≥ 1 + blog(|Si | − 1)c .
OP T (Si )
2
(4)
Diese Schranke gilt insbesondere, wenn wir uns auf das Hinzufügen von Knoten beschränken.
Beweis. Die Idee hinter dem Beweis ist, dass wir uns eine k-Sequenz auf einem P-Graphen
konstruieren, so dass Lemma 2 zur Ungleichung (4) umformuliert werden kann. Wir definieren uns dazu eine Instanz I = (Gk , ck , σ) von DST-N mit σi = (ui , add) für alle
0 ≤ i ≤ K = 2k . Dabei gilt u0 = v0 , u1 = v1 und für i > 1 gilt ui ∈ Nj mit j = dlog ie
für eine k-Sequenz N . Diese entspricht genau der k-Sequenz, die wir als Eingabe für den
Algorithmus A aus Lemma 2 benötigen.
Zuerst verdeutlichen wir warum σ durch diese Definition einer k-Sequenz N entspricht.
Man kann leicht nachrechnen, dass nach allen 2i add -Anfragen die Knoten für Ni vollständig
sind. Insbesondere brauchen wir also K = 2k add -Anfragen um eine k-Sequenz zu erhalten.
σ entspricht also einer k-Sequenz N . Damit gilt auch die Ungleichung (3). Lemma 2 gilt
allerdings nur im Bereich zwischen 0 und k. Darum ersetzen wir das i in (3) durch log(i),
denn log(2k ) = k. Wir runden diesen Wert zusätzlich ab, da wir nach Lemma 2 nur für
eine j-Sequenz mit j = dlog ie die untere Schranke für die Kosten garantieren können. Nun
haben wir immer noch eine Abhängigkeit von i, wir wollen die Ungleichung aber abhängig
machen von der Menge der Terminale Si . Da |Si | − 1 = i, kann dies leicht ersetzt werden.
Damit gilt insgesamt die Ungleichung (4) und das Theorem ist bewiesen.
u
t
264
Holger Hagedorn
Algorithmus 28 DGA
Input: (G, cost, σ)
Output: (Ti )0≤i≤K
1: T0 ← ({v0 }, ∅)
2: S0 ← {v0 }
3: i ← 1
4: for i ≤ K do
5:
if σi is add request then
6:
pi ← Shortest path from vi to Ti−1
7:
Ti ← Ti−1 ∪ pi
8:
Si ← Si−1 ∪ {vi }
9:
else if σi is remove request then
10:
Ti ← Ti−1
11:
Si ← Si−1 \ {vi }
12:
while ∃w ∈ V (Ti ) \ Si : deg(w) = 1 do
13:
Ti ← Ti \ w
2.2 Dynamischer Greedy-Algorithmus
Der Online-Algorithmus DGA (Dynamic Greedy Algorithm) berechnet eine Lösung für das
Problem DST-N mit einem Greedy-Ansatz. Im wesentlichen verbindet er neue Knoten mit
dem nächstgelegenen Knoten des aktuellen Steinerbaumes. Algorithmus 28 beschreibt die
Details in Pseudocode.
Wir zeigen als nächstes, dass DGA strikt dlog |Si |e-kompetitiv ist. Ein wesentlich einfacherer Beweis als der im Paper von Imase und Waxman stammt von Bartal [2].
Theorem 2. Sei I = (G, cost, σ) eine beliebige Instanz des Problems DST-N mit Anfragen
σ = σ0 , . . . , σK und Terminalen Si zum Zeitpunkt i. Wenn alle Anfragen in der Form
σi = (vi , add) sind, dann gilt:
∀1 ≤ i ≤ K :
DGA(Si )
≤ dlog |Si |e
OP T (Si )
(5)
Beweis. Sei I = (G, cost, σ) eine Instanz von DST-N und Ti∗ der minimale Steinerbaum,
der alle Knoten in Si spannt. Weiterhin sei Hi ein minimaler Kreis über alle Knoten in Si .
Abbildung 6 illustriert diesen Zusammenhang. Der Kreis ist von oben beschränkt durch das
zweifache des optimalen Steinerbaumes, also
cost(Hi ) ≤ 2 · cost(Ti∗ ) .
Diese obere Schranke ergibt sich aus dem Kreis der entsteht, wenn man einfach an einem
beliebigen Knoten von Ti∗ startet und einmal aussen an dem ganzen Baum entlanggeht.
Dabei muss jede Kante einmal in Hin- und einmal in Rückrichtung passiert werden, was die
zweifachen Kosten verursacht. Natürlich kann Hi aber auch andere Kanten verwenden und
daher günstiger sein.
Betrachten wir zwei beliebige adjazente Knoten u, v ∈ Hi , wobei v nach u hinzugefügt
wurde. Die Kosten für das Hinzufügen von v sind maximal die Kosten des Pfades zwischen u
und v im Kreis Hi , da alle benachbarten Knoten in Hi durch einen kürzesten Pfad verbunden
sind.
Wir teilen nun alle Knoten entlang des Kreises Hi in b|Si |/2c Paare von adjazenten
Knoten auf (vgl. Abbildung 6). Dabei können die Paare gerade so gewählt werden, dass die
Dynamische Steinerbäume
265
akkumulierten Kosten ihrer verbindenden Kanten nur halb so groß sind wie die des gesamten
Kreises. Daraus folgt, dass die Kosten dieser Paare auch nur maximal so hoch sein können,
wie die von Ti∗ .
Angewendet auf DGA befinden wir uns also in der Situation, in der jeweils genau einer der
Knoten eines solchen Knotenpaares gegeben ist und der zweite als add -Anfrage hinzugefügt
wird. Die Kosten die DGA für diese halbe Menge der Terminale verursacht sind folglich
höchstens so teuer wie die Kosten von Ti∗ , also
DGA(b|Si |/2c) ≤ OP T (Si ) .
Wichtig zu beachten ist dabei, dass diese halbe Menge der Terminale nicht zwingend der
Suffix der Anfragen σ sein muss, sondern nur paarweise die zuletzt hinzugefügten Knoten
betrachtet werden.
Entfernen wir nun diese zuletzt hinzugefügten Knoten, dann können wir die übrig gebliebenen wiederum zu einem minimalen Kreis verbinden und in adjazente Knotenpaare
aufteilen. Die Kosten von DGA entsprechen wiederum maximal den Kosten von Ti∗ . Dies
wird sukzessive so fortgeführt bis nur noch ein Knoten übrig bleibt. Die Frage ist nun also, wie oft wir diese Aufteilung vornehmen müssen – wie oft wir also maximal die Kosten
von Ti∗ beanspruchen. Dazu können wir die obige Ungleichung als eine Rekurrenzgleichung
auffassen. Nach Auflösen ergibt sich, dass wir dlog |Si |e mal die Menge der Terminale wie
beschrieben aufteilen müssen. Daraus folgt die Ungleichung (5) und das Theorem ist bewiesen.
t
u
2.3 Remove Requests
Bislang haben wir nur add -Anfragen betrachtet. Wenn jetzt noch zusätzlich removeAnfragen hinzukommen, dann kann gezeigt werden, dass im Worst-Case die Kosten eines
Algorithmus A für DST-N unbeschränkt sind. Die Kosten sind dann abhängig von der Anzahl der Terminale.
Theorem 3. Sei A ein Algorithmus für DST-N. Für alle Paare M, l ∈ N+ gibt es eine
Instanz (G, cost, σ) von DST-N und ein j ∈ N+ , so dass
Ti∗
Hi
v
u
Abb. 6. Der minimale Steinerbaum Ti∗ (schwarze Linien), der minimale Kreis Hi (graue Linien) und dessen
Aufteilung in b|Si |/2c Paare von adjazenten Knoten (fett gestrichelte Linien).
266
Holger Hagedorn
1
1
1
1
1
1
1
1
Abb. 7. Spezieller Graph in dem |V | = 2M + 4 gilt, hierbei für M = 6. Die hellen Knoten bilden einen
Kreis C mit M + 2 Knoten.
A(Si ) ≥ M · OP T (Si )
(6)
für alle j < i ≤ j + l unabhängig von der Anzahl der Terminale in Si .
Beweis. Wir betrachten folgenden gewichteten Graphen G = (V, E) mit |V | = 2M + 4.
Hierin befindet sich ein Kreis C mit M + 2 Knoten in dem alle Kanten das Gewicht 1
haben. Die restlichen M + 2 Knoten sind jeweils durch genau eine Kante mit Gewicht zu
einem der Knoten in C verbunden. Ein Beispiel dieses Graphen für M = 6 findet sich in
Abbildung 7.
Für einen Algorithmus A werden nun mit den ersten M + 2 Anfragen die Knoten des
Kreises hinzugefügt. Also gilt für alle 0 ≤ i ≤ M + 1, dass σi = (qi , add). Da immer der
nächstliegende Knoten hinzugefügt wird, ist der vom Algorithmus A erstellte Steinerbaum
TM +1 ein Pfad, der bis auf eine Kante dem Kreis C entspricht. Die Knoten dieses Pfades
seien der Reihe nach durchnummeriert mit q0 , . . . , qM +1 . Die Kosten entsprechen genau
cost(TM +1 ) = M + 1.
In den nächsten M Schritten wird immer wieder ein Knoten mit Kantengrad zwei aus
dem Kreis entfernt. Formal gilt also für alle M +2 ≤ i ≤ 2M +2, dass σi = (vi , remove) und
deg(vi ) = 2. Der Algorithmus A wird die aus der Menge der Terminale entfernten Knoten
trotzdem weiter benutzen, da er nach Definition von DST-N nur Kanten löschen, aber keine
neuen einfügen darf. Daraus folgt, dass TM +1 = TM +2 = . . . = T2M +1 . Nach entfernen
der Knoten sind nur noch gerade die zwei Knoten in der Menge der Terminale übrig, die
zuvor die Start- und Endknoten des Pfades TM +1 waren, also S2M +1 = {q0 , qM +1 }. Da
TM +1 = T2M +1 ist, gilt cost(T2M +1 ) = M + 1. Allerdings wäre ein optimaler Steinerbaum
lediglich die Verbindung der zwei Knoten q0 und qM +1 durch deren verbindende Kante und
somit OP T (S2M +1 ) = 1. An dieser Stelle gilt also die Ungleichung (6).
Um diese Eigenschaft aufrecht zu erhalten, werden nun für alle σi mit i > 2M + 2 immer
alternierend ein Knoten hinzugefügt und entfernt. Dieser Knoten ist genau einer der Knoten,
die durch eine Kante mit Gewicht mit q0 , qM +1 ∈ T2M +1 verbunden sind. Der Wert von kann beliebig klein gemacht werden, so dass
M + 1 + ≥ M · (1 + )
gilt. Somit gilt nach jedem Schritt die Ungleichung 6 und das Theorem ist bewiesen.
t
u
Dynamische Steinerbäume
267
3 DST-R
In diesem Abschnitt werden wir aus Platzgründen nur einen kurzen Überblick über die
Ergebnisse in [1] zum Problem DST-R geben. Zur Erinnerung, der Unterschied zu DSTN war, dass nun Änderungen in existierenden Verbindungen zulässig sind. Die Anzahl der
Änderungen ist aber beschränkt. Falls die Anzahl nicht beschränkt ist, dann ist das Problem
in jedem Schritt äquivalent zum statischen Steinerbaum-Problem ST. Für DST-R gibt es
eine Klasse von Algorithmen, die δ-Kanten-beschränkte Algorithmen genannt werden. Jeder
spezifische Algorithmus (EBA(δ)) ist bestimmt durch eine positive reelle Zahl δ ≥ 1. Doch
bevor wir etwas über diese Algorithmen aussagen können, benötigen wir die folgenden zwei
Definitionen.
Definition 9 (δ-Kanten-beschränkt). Seien u, v ∈ T und T ist ein Baum. Falls u und
v die folgende Bedingung erfüllen, werden sie als δ-Kanten-beschränktes Paar bezeichnet.
Für ein beliebiges e ∈ p(u, v, T ) gelte
cost(e) ≤ δ · dist(u, v)
(7)
mit p(u, v, T ) als Menge von Kanten auf dem Pfad zwischen u und v in T . Weiterhin wird
T als δ-Kanten-beschränkter Baum bezeichnet, wenn jedes Knotenpaar in T δ-Kantenbeschränkt ist.
Definition 10 (Erweiterungsbaum). Für eine Knotenmenge S wird ein Baum T als
Erweiterungsbaum bezeichnet, falls er die folgenden Eigenschaften erfüllt:
• S ⊆V.
• Für einen beliebigen Knoten x ∈ V \ S ist deg(x) > 2 in T .
Der Algorithmus EBA(δ) basiert auf dem Algorithmus M ST A [4], der einen minimalen Spannbaum approximiert. Er liefert für eine gegebene Knotenmenge einen Spannbaum,
der nie höhere Kosten hat als das Zweifache vom Optimum. Für DST-R jedoch verursacht
er unter Umständen sehr viele Änderungen von Verbindungen. Die von M ST A generierten Spannbäume sind 1-Kanten-beschränkte Bäume, daher kann ein δ-Kanten-beschränkter
Baum als eine Generalisierung davon verstanden werden.
Die nun folgenden Theoreme sind Folgerungen aus Lemmas, die diese Schranken für
δ-Kanten-beschränkte Bäume und Erweiterungsbäume zeigen. Da EBA(δ) solche Erweiterungsbäume für jedes Si berechnet, gelten die Schranken auch für die von diesem Algorithmus erzeugten Lösungen.
Theorem 4. Für einen beliebigen von EBA(δ) erstellten Baum Ti gilt, dass er ein δKanten-beschränkter Erweiterungsbaum für Si ist und für alle 0 ≤ i ≤ K gilt weiterhin
cost(Ti ) ≤ 2δ · M ST A(Si ) ≤ 4δ · OP T (Si ) .
(8)
Theorem 5. Falls alle σi auf add-Anfragen beschränkt sind, dann genügt jeder von EBA(δ)
erzeugte Baum Ti der folgenden Ungleichung:
cost(Ti ) ≤ δ · M ST A(Si ) ≤ 2δ · OP T (Si ) .
(9)
268
Holger Hagedorn
Als letztes stellen wir noch eine obere Schranke für die Gesamtanzahl von Änderungen
für EBA(δ) vor. Dabei bezeichne Ka die Anzahl add -Anfragen und Kr die Anzahl removeAnfragen.
Theorem 6. Sei I = (G, cost, σ) eine beliebige Instanz. Falls δ ≥ 2, dann ist die obere
Schranke für die totale Anzahl an Änderungen die von EBA(δ) benötigt werden gegeben
durch
K
X
p
1
αi ≤ Ka ( 4Ka − 3 − 3) + Kr .
(10)
2
i=0
4 Fazit
In dieser Ausarbeitung haben wir zwei Ausprägungen des Problems Dynamic Steiner Tree
vorgestellt. Für DST-N konnten wir zeigen, dass es im allgemeinen Fall unbeschränkt ist.
Lässt man jedoch nur das Hinzufügen von Knoten zu, so gibt es eine obere Schranke. Wir
haben den Greedy-Algorithmus DGA vorgestellt, dessen Worst-Case Performanz innerhalb
dem zweifachen des optimalen Falles liegt. Weiterhin haben wir für DST-R den Algorithmus
EBA(2) vorgestellt, dessen Performanz im achtfachen des Optimums liegt.
Literaturverzeichnis
1. Imase M, Waxman BM (1991) Dynamic Steiner Tree Problem. SIAM J. Disc. Math. Vol. 4 No. 3:369–
384
2. Bartal Y (1994) Competitive Analysis of Distributed On-line Problems – Distributed Paging. Ph.D.
Thesis, Tel-Aviv University, Tel-Aviv
3. Borodin A, El-Yaniv R (1998) Online Computation and Competitive Analysis. Cambridge University
Press, New York
4. Kou L, Markowsky G, Berman L (1977) A fast algorithm on Steiner trees. Acta Inform. 3:141–145
Approximationen und Alternativen für Aspektgraphen
David Schmelter
Universität Paderborn
Zusammenfassung. Ein wesentliches Problem bei der Verwendung von Aspektgraphen ist ihre Komplexität, sowohl was die Größe, als auch den Konstruktionsaufwand betrifft. Dies macht eine praktische
Verwendung bereits für 3D Szenen mit wenigen hundert Polygonen unmöglich. In dieser Arbeit werden daher sowohl Approximationen (im Wesentlichen der Finite-Resolution Aspect Graph) als auch Alternativen
(im Wesentlichen das Visibility Skeleton) für Aspektgraphen betrachtet, denen eine gewisse Praxisrelevanz
zugeschrieben werden kann. Der Finite-Resolution Aspect Graph bietet für den Fall der orthografischen Projektion ein Verfahren, das einen Aspektgraphen mit geringerer Komplexität im Vergleich zum klassischen
Aspektgraphen ermöglicht. Allerdings leidet dieses Verfahren unter einem hohen Konstruktionsaufwand,
was eine praktische Verwendung bereits für einfache Szenen verwehrt. Mit dem Visibility Skeleton existiert
eine interessante Alternative für Aspektgraphen, mit der eine Reihe unterschiedlicher Anfragen auch für
nicht-triviale 3D Szenen effizient beantwortet werden können.
1
Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
1.1 Approximationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
1.2 Alternativen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
1.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
2
Finite-Resolution Aspect Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
2.1
2.2
2.3
2.4
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Konstruktion des Finite-Resolution Aspect Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
3
Visibility Skeleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
3.1
3.2
3.3
3.4
3.5
3.6
Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Datenstruktur des Visibility Skeletons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Konstruktion des Visibility Skeletons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
4
Zusammenfassung und Diskussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
270
David Schmelter
1 Einleitung
Viele Verfahren in der Computergrafik (beispielsweise globale Beleuchtungsverfahren wie
Radiosity) benötigen detaillierte Information über globale Sichtbarkeiten von Objekten.
Mit Aspektgraphen [8] existiert eine Datenstruktur, mit der diese Informationen exakt für
jeden Punkt einer dreidimensionalen Szene gespeichert und abgefragt werden können.
Die Kosten für die Erzeugung machen eine praktische Verwendung des Aspektgraphen
bereits für Szenen mit wenigen hundert Polygonen allerdings unmöglich (unter Annahme
perspektivischer Projektion ist die maximale Größe des Aspektgraphen für n Polygone
O(n9 ), die Konstruktionszeit beträgt O(n9 log n)). Es gibt unterschiedliche Ansätze, um
diesem Problem zu begegnen. Zum einen wurden Approximationen für Aspektgraphen entwickelt. Darüber hinaus gibt es alternative Verfahren, die sich auf eine etwas andere Weise
dem Sichtbarkeitsproblem nähern.
In dieser Arbeit werden sowohl unterschiedliche Approximationen (Finite-Resolution
Aspect Graphs, Scale Space Aspect Graphs und Weighted Aspect Graphs) als auch alternative Verfahren (das Visibility Skeleton und der 3D Visibility Complex) vorgestellt und untersucht. Der Schwerpunkt soll hierbei auf Verfahren mit einer gewissen Praxisrelevanz liegen.
Wir werden sehen, dass hierfür Aspektgraphen mit endlicher Auflösung (Finite-Resolution
Aspect Graphs) und das Visibility Skeleton in Frage kommen.
1.1 Approximationen
In diesem Abschnitt wird zunächst ein kurzer Überblick über die im vorherigen Abschnitt
bereits erwähnten Approximationen für Aspektgraphen gegeben.
Finite-Resolution Aspect Graphs
Bei der Konstruktion von Aspektgraphen wurde bisher eine Kamera bzw. Projektion mit
unendlicher Auflösung angenommen. Typischerweise besitzt eine reale Kamera aber nur
eine endliche Auflösung. Daraus resultiert, dass in einem Aspektgraphen Details berücksichtigt werden, die vom Betrachter gar nicht unterschieden werden können. Abbildung 1
verdeutlicht dies an einem Beispiel: Auf der linken Seite der Abbildung ist eine Kante und
ein Vertex in einer Projektion mit unendlicher Auflösung dargestellt. In diesem Fall ist der
Abstand beider Elemente erkennbar. Auf der rechten Seite der Abbildung ist die gleiche
Projektion mit endlicher Auflösung dargestellt. In diesem Fall scheinen sich beide Elemente
zu berühren, der Abstand ist für einen Betrachter nicht erkennbar.
Abb. 1. Projektion mit unendlicher Auflösung (links) und endlicher Auflösung (rechts). Nach [11]
Approximationen und Alternativen für Aspektgraphen
271
Shimshoni und Ponce haben in [11] einen Algorithmus zur Konstruktion eines Aspektgraphen für den Fall einer orthografischen Projektion vorgestellt, der die Einschränkung endlicher Auflösung einer realen Kamera berücksichtigt. Dieser Aspektgraph speichert Aspekte
eines Objekts mit endlicher anstatt unendlicher Auflösung. Shimshoni und Ponce gehen
davon aus, dass ein solcher Aspektgraph eine relativ geringe Komplexität besitzt und die
entsprechenden Aspekte dennoch genug Details, z.B. zur Objekterkennung, enthalten.
Hierzu wurde der Schwellenwert eingeführt. Beispielsweise können zwei Vertexe unterschieden werden, wenn sie in einer Projektion mit endlicher Auflösung mindestens um den
Wert voneinander entfernt sind.
Da der Algorithmus zur Konstruktion des Finite-Resolution Aspect Graphs vollständig
implementiert wurde, wird dieses Verfahren in dieser Arbeit in Kapitel 2 näher untersucht.
Scale Space Aspect Graphs
Der von Eggert et al. in [6] vorgestellte Scale Space Aspect Graph kann in gewissem Sinne als
eine Verallgemeinerung des Finite-Resolution Aspect Graphs aufgefasst werden. Man kann
sich vorstellen, dass die Komplexität eines Aspektgraphen mit endlicher Auflösung immer
mehr abnimmt, je größer der Schwellenwert gewählt wird. Die Idee ist, durch den ScaleParameter σ mit einem stetigen Wertebereich zu ersetzen um so einen Aspektgraphen mit
beliebig anpassbarer Komplexität zu erhalten. Für σ = 0 entspricht der Finite-Resolution
Aspect Graph einem klassischen Aspektgraphen mit unendlicher Auflösung. Wird σ stetig
erhöht erhält man schließlich einen Aspektgraphen mit nur einem Aspekt. In [6] geht es in
erster Linie darum, unterschiedliche Interpretationen von Scale-Parametern zu identifizieren
und zu untersuchen. Die Arbeit liefert allerdings keinen Algorithmus zur Konstruktion des
Scale Space Aspect Graphs, bleibt also auf theoretischer Ebene und wird daher im Kontext
dieser Ausarbeitung nicht weiter betrachtet.
Weighted Aspect Graphs
Arie stellt in [1] eine weitere Möglichkeit vor, um Aspektgraphen zu vereinfachen bzw. zu
approximieren. Er gibt eine Wahrscheinlichkeit (bzw. das Gewicht) für ein Element eines
Objektes an, mit der dieses Element im Bildraum sichtbar ist. Abbildung 2 zeigt zur Verdeutlichung einen Würfel unter orthografischer Projektion. Die markierte Fläche a ist exakt
in der oberen Halbkugel von S 2 sichtbar. Somit ist das Gewicht dieser Fläche 12 .
Die Idee von Arie ist, für jeden Knoten des Aspektgraphen ein solches Gewicht zu berechnen. Aspekte mit einem relativ niedrigen Gewicht können als unwichtig aufgefasst und aus
dem Aspektgraphen entfernt werden. Auch diese Arbeit bleibt allerdings auf theoretischer
Ebene.
1.2 Alternativen
In diesem Abschnitt wird ein kurzer Überblick über alternative Verfahren bzw. Datenstrukturen, die Informationen über globale Sichtbarkeiten zur Verfügung stellen, gegeben.
272
David Schmelter
a
Abb. 2. Würfel unter orthografischer Projektion
Visibility Skeleton
Das Visibility Skeleton [5] ist eine im Jahr 1997 von Frédo Durand, George Drettakis und
Claude Puech vorgestellte Datenstruktur, die exakte, globale Sichtbarkeitsinformationen
einer 3D Szene in Form einer Graphstruktur enthält. Verschiedene Verfahren, die Informationen über globale Sichtbarkeiten benötigen (z.B. Verfahren zum Occlusion Culling oder
globale Beleuchtungsverfahren wie Radiosity) können diese Informationen effizient über das
Visibility Skeleton abfragen. Da das Visibility Skeleton für unterschiedliche Anwendungen
genutzt werden kann, wird es von den Autoren auch als multi-purpose Tool beworben. Das
Visibility Skeleton enthält im Gegensatz zu Aspektgraphen allerdings keine Informationen
über die unterschiedlichen Aspekte eines Objekts, eignet sich also nicht zur Objekterkennung.
Wie auch der Finite-Resolution Aspect Graph wurde das Visibility Skeleton vollständig
implementiert und wird in Kapitel 3 näher betrachtet.
3D Visibility Complex
Der 3D Visibility Complex [3] ist eine im Jahr 1996 ebenfalls von Frédo Durand, George
Drettakis und Claude Puech vorgestellte Datenstruktur die, ebenso wie das Visibility Skeleton, alle globalen Sichtbarkeitsinformationen einer 3D Szene enthält. Die nulldimensionalen
und eindimensionalen Elemente des 3D Visibility Complex1 , sind die gleichen wie die des
Visibility Skeletons (Hierdurch erklärt sich auch der Name Visibility Skeleton: Das Visibility
Skeleton ist gewissermaßen das Skelett des 3D Visibility Komplex). Darüber hinaus enthält
der 3D Visibility Complex Elemente mit zwei, drei und vier Dimensionen. Diese höher dimensionalen Elemente können für einige spezifische Berechnungen, z.B. zur Berechnung von
Aspekten oder dynamische Updates, verwendet werden. Darüber hinaus macht die Verwendung des 3D Visibility Complex für spezielle Szenen Sinn, in denen Gitter hintereinander
ausgerichtet und leicht gedreht sind (also viele Sichtbarkeitswechsel vorliegen).
Im Gegensatz zum Visibility Skeleton ist der 3D Visibiliy Complex kompliziert zu implementieren und zu verwenden, da eine vierdimensionale Aufteilung der 3D Szene konstruiert werden muss. Tatsächlich wurden die in [3] vorgestellten Konzepte zum Zeitpunkt
1
Diese Elemente werden ausführlich in Abschnitt 3.1 vorgestellt
Approximationen und Alternativen für Aspektgraphen
273
der Veröffentlichung noch nicht implementiert. Aus diesem Grund wird auch der 3D Visibility Complex mit Bezug zu praxisrelevanten Arbeiten in dieser Ausarbeitung nicht näher
betrachtet.
1.3 Zusammenfassung
Es gibt sowohl eine Reihe von Approximationen für Aspektgraphen, als auch alternative
Verfahren, die sich auf eine etwas andere Art und Weise dem Problem der globalen Sichtbarkeit nähern. Wirkliche Praxisrelevanz haben von den vorgestellten Ansätzen aber nur
Aspektgraphen mit endlicher Auflösung (Finite-Resolution Aspect Graphs) und das Visibility Skeleton. Aus diesem Grund werden diese beiden Arbeiten in dieser Ausarbeitung näher
betrachtet.
2 Finite-Resolution Aspect Graphs
Der Finite-Resolution Aspect Graph wurde 1997 von Shimshoni und Ponce in [11] vorgestellt
und ist ein Aspektgraph für den Fall einer orthografischen Projektion, dem ein Bildbereich
mit endlicher Auflösung zugrunde liegt. Mit dem Finite-Resolution Aspect Graph sollen die
folgenden beiden Probleme gelöst werden:
1. Ein wesentliches Problem von Aspektgraphen ist ihre Komplexität: Für eine Szene mit n
Polygonen besitzt ein Aspektgraph unter Annahme einer orthografischen Projektion eine
Größe von O(n6 ) (vgl. [8]). Aus diesem Grund können Aspektgraphen mit unendlicher
Auflösung nur bei sehr einfachen Objekten verwendet werden. Die Idee ist, durch Annahme einer Kamera mit endlicher Auflösung einen Aspektgraphen mit relativ geringer
Komplexität zu erhalten.
2. In einem klassischen Aspektgraphen mit unendlicher Auflösung werden keine Aspekte
gespeichert, die exakt an einem Sichtbarkeitswechsel auftreten, da diese Bereiche in der
Theorie im VSP unendlich klein sind. In der Praxis treten diese Situationen allerdings
häufig auf, da unterschiedliche Details eines Objekts aufgrund einer realen Kamera mit
endlicher Auflösung im Bildbereich häufig verwaschen. Abbildung 3 zeigt hierfür ein
Beispiel.
Die grundsätzliche Idee ist, Aspekte dahingehend zu vereinfachen, dass unterschiedliche
Details (z.B. Vertexe, Kanten, etc.), die im Bildraum weniger als um den Schwellenwert voneinander entfernt sind, vereinigt werden (vgl. Abbildung 3). Die Hoffnung liegt in der
Entstehung eines Aspektgraphen mit relativ geringer Komplexität. Hierzu ist es notwendig,
einige Besonderheiten bzgl. der Sichtbarkeitswechsel zu betrachten, wie wir im nächsten
Abschnitt sehen werden.
<ε
Abb. 3. Links: Aspekt eines Objekts unter Annahme unendlicher Auflösung. Rechts: Der gleiche Aspekt
unter Annahme endlicher Auflösung.
274
David Schmelter
Die Autoren stellen in [11] einen vollständig implementierten Algorithmus zur Konstruktion des Finite-Resolution Aspect Graphs vor. Die Konstruktion erfolgt im Wesentlichen
mit den folgenden Schritten:
1. Zunächst werden die kritischen Kurven (engl.: critical curves, vgl. [11]) berechnet, die
aufgrund von Sichtbarkeitswechseln bei Annahme einer orthografischen Projektion entstehen. Diese Sichtbarkeitswechsel unterscheiden sich von denen klassischer Aspektgraphen, wie wir im folgenden Abschnitt sehen werden.
2. Im Anschluss daran werden die Schnittpunkte dieser kritischen Kurven berechnet.
3. Die kritischen Kurven und ihre Schnittpunkte werden im nächsten Schritt als Eingabe für
einen Plane-Sweep Algorithmus benötigt, der den Sichtraum in nicht-kritische Regionen,
also einen VSP, unterteilt. Das Resultat ist ein Aspektgraph bzw. VSP mit zunächst
unendlicher Auflösung.
4. Jede dieser berechneten Regionen bzw. Aspekte wird nun vereinfacht, indem verschiedene Details (Vertexe, Kanten, etc.) die weniger als voneinander entfernt sind, vereinigt
werden.
5. Dadurch, dass die einzelnen Aspekte vereinfacht werden, kann es passieren, dass adjazente Aspekte isomorph sind. Aus diesem Grund ist es notwendig, in einem dritten und
letzten Schritt isomorphe Aspekte zu vereinigen.
Wir werden sehen, dass der entstandene Finite-Resolution Aspect Graph eine geringere
Größe als sein Pendant mit unendlicher Auflösung haben kann. Das große Problem ist allerdings, dass der Konstruktionsaufwand bereits für sehr einfache Objekte unter Umständen
derart groß ist, dass die Konstruktion eines Aspektgraphen mit endlicher Auflösung nicht
immer möglich ist.
Im nächsten Abschnitt werden zunächst einige Grundlagen erläutert, die zum Verständnis des Algorithmus erforderlich sind. Hierzu gehören insbesondere einige Besonderheiten
bzgl. der Sichtbarkeitswechsel, die bei Annahme einer Kamera mit endlicher Auflösung beachtet werden müssen.
2.1 Grundlagen
In diesem Abschnitt werden einige Grundlagen, insbesondere zu Sichtbarkeitswechseln im
Falle endlicher Auflösung, vermittelt. Insgesamt werden bei einer orthografischen Projektion
unter Annahme endlicher Auflösung drei Arten von Sichtbarkeitswechseln unterschieden:
VV, EV und EEE Sichtbarkeits-Ereignisse. Diese Ereignisse unterscheiden sich von denen
im Falle unendlicher Auflösung, vereinfacht gesagt führen sie zu zusätzlichen kritischen
Kurven im Sichtraum.
Dies wird am Beispiel eines VV Sichtbarkeitswechsels verdeutlicht. Ein VV Ereignis
tritt ein, sobald zwei Vertexe p und q exakt um den Wert voneinander entfernt sind
(siehe Abbildung 4 (a)). Diese Bedingung führt zu exakt zwei gegenüberliegenden kritischen
Kreisen im Sichtraum (vgl. Abbildung 4 (b)).
Zur späteren Berechnung des VSPs ist eine explizite Darstellung dieser kritischen Kreise
erforderlich. Am Beispiel des VV Sichtbarkeitswechsels wird diese Darstellung exemplarisch
betrachtet: Sei v die Blickrichtung des Betrachters und p sowie q = p+u1 die beiden Vertexe,
die ein VV Ereignis hervorrufen. Das Ereignis tritt genau dann ein, wenn θ = arcsin( |u1 | )
gilt. In diesem Fall ist der erste kritische Kreis, abhängig vom Winkel α, durch v(α) =
Approximationen und Alternativen für Aspektgraphen
p
275
p
q
q
ε
(a)
(b)
u3
d
v
θ
p
u1
α
•
q=p+u1
u2
(c)
Abb. 4. VV Sichtbarkeitswechsel unter Annahme endlicher Auflösung
u1 +d(cos αu2 +sin αu3 ), α ∈ [0, 2π] gegeben (vgl. Abbildung 4 (c)), mit d = |u1 | tan θ. u1 , u2
und u3 bilden eine orthonormale Basis des R3 . Der entgegengesetzte Kreis ist entsprechend
durch −v(α) gegeben.
Ähnliche kritische Kurven existieren für VE und EEE Ereignisse. Abbildung 5 (a) zeigt
ein Beispiel für ein VE Ereignis unter Annahme endlicher Auflösung. Der Sichtbarkeitswechsel tritt ein, sobald der Vertex v auf dem abgerundeten Rechteck liegt, das die Kante e
in einem Abstand von umschließt. (b) zeigt ein Beispiel für ein EEE Ereignis. Es tritt ein,
wenn der Abstand der beiden Schnittpunkte zwischen den Kanten e1 und e3 sowie e2 und
e3 exakt beträgt. In [11] werden, ähnlich zu VV Sichtbarkeitswechseln, explizite Darstellungen der entsprechenden kritischen Kurven für VE und EEE Ereignisse eingeführt. Auf
eine detaillierte Beschreibung dieser Darstellungen wird aus Gründen der Übersichtlichkeit
an dieser Stelle verzichtet.
e1
v
ε
ε
e
ε
(a)
e3
e2
(b)
Abb. 5. Beispiele für Sichtbarkeitswechsel unter Annahme endlicher Auflösung. (a) VE Ereignis (b) EEE
Ereignis
276
David Schmelter
2.2 Konstruktion des Finite-Resolution Aspect Graphs
322
In diesem Abschnitt wird die Konstruktion des Finite-Resolution Aspect Graphs am Beispiel des in Abbildung 6 (a) dargestellten L-förmigen Objekts betrachtet. (c) zeigt die durch
die im vorigen Abschnitt vorgestellten Sichtbarkeitswechsel unter Annahme endlicher Auflösung induzierten kritischen Kurven dieses Objekts. Anstatt einer Kugel mit unendlichem
Radius wird ein Würfel zur Repräsentation des Sichtraums verwendet. Dies ermöglicht die
Konstruktion eines VSPs mit Hilfe eines Plane-Sweep Algorithmus. (d) zeigt schließlich den
fertigen Finite-Resolution Aspect Graph. Teil (b) der Abbildung zeigt der Vollständigkeit
halber die induzierten kritischen Kurven unter Annahme unendlicher Auflösung. Hierbei
fällt auf, dass im Falle endlicher Auflösung wesentlich mehr kritische Kurven existieren,
was, wie wir später sehenIEEE
werden,
ein wesentliches Problem dieses Verfahrens ist.
TRANSACTIONS ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE, VOL. 19, NO. 4, APRIL
(a)
(b)
(c)
1997
(d)
Abb. 6. Beispielszene: (a) L-förmiges Objekt (b) die entsprechenden kritischen Kurven im Falle unendlicher
Fig. 18. An L-shaped object and its aspect graph. (a) The object. (b) The infinite-resolution visual event curves. (c) The finite-resolution visual
(c)
kritische Kurven
im Falle endlicher Auflösung (d) Aspektgraph mit endlicher Auflösung.
event Auflösung
curves. (d) The
finite-resolution
aspect graph.
Quelle: [11]
Berechnung der kritischen Kurven und ihrer Schnittpunkte
Mit Hilfe der in Abschnitt 2.1 vorgestellten parametrisierten Darstellung der VV, VE und
EEE Sichtbarkeitswechsel werden zunächst die kritischen Kurven und ihre Schnittpunkte
berechnet. Die Berechnung der Schnittpunkte erfolgt mittels homotopischer Fortsetzung
[7]. Abbildung 6 (c) zeigt eine Projektion der kritischen Kurven für das in (a) dargestellte
Objekt.
VSP Konstruktion mit Plane-Sweep Algorithmus
Die zuvor berechneten kritischen Kurven und ihre Schnittpunkte dienen als Eingabe für
einen Plane-Sweep Algorithmus. Abbildung 7 dient zur Illustration und zeigt ein einfaches
Fig. 19.
A series offür
aspects
obtained
sweeping
through adjacent
views
in the aspect graph.
Beispiel
eine
Seiteby des
Würfels,
der den
Sichtraum
repräsentiert: Dargestellt sind drei
kritische
Kurven
in
Form
von
durchgezogenen,
schwarzen
Linien.
Dielines.
Schnittpunkte
die-shown
as heavy
The aspect graph
to [8]). For the finite-resolution aspect graph we have cho- curves are shown
Kurven
grün
hervorgehoben,
orange.
Zusätzlich zu Schnitt- und
Fig. 20c contains
357 regions.
to be
smaller sind
than the
length
of edges of the ihre
object.Endpunkte
sen eser
One
of the
problems with aspect
is that as
The visual
event curves
of the
finite-resolution
aspect graph
Endpunkten
sind
ihre
Extremal-Punkte
in Bezug
auf
die main
Sweep-Richtung
blau graphs
markiert.
are shown in Fig. 18c. These curves bound 377 different re- the object gets more complex the aspect graph itself beSchnitt-, End- und Extremal-Punkte werden im Folgenden als kritische Punkte bezeichnet.
gions. The aspect graph is shown in Fig. 18d: Adjacent re- comes unmanageably complex. At the resolution used in
kritischen
werden
anhandand
dertheSweep-Richtung
und von
oben nach
untenbysorFig. 18, this problem
is certainly
not solved
our apgionsDie
yielding
the samePunkte
aspect have
been merged,
proach,werden
since the
finite-resolution
is larger
resulting
regions
are shown in different
shades
of gray. Punkt
tiert117und
abgearbeitet.
An jedem
kritischen
vertikale
Linien aspect
zu dengraph
beiden
Fig. 19 shows the qualitatively different aspects obtained
by making a continuous sweep across some of the regions
of the aspect graph. This sweep is indicated by the black
diagonal line in Fig. 18d. The viewing direction corresponding to each aspect is indicated by a small circle. The
aspects in Fig. 19 have been rendered by merging features
than the infinite-resolution one. As e grows larger, or object
features get smaller, some of the aspect graph features disappear: Fig. 21 shows the finite-resolution visual event
curves of an object and the aspect graph for which some of
the edges are shorter than e. The aspect graph is considerably more simple than the previous one; in fact, the features
Approximationen und Alternativen für Aspektgraphen
277
entsprechenden kritischen Kurven berechnet (in der Abbildung als gepunktete vertikale Linien dargestellt). Zusammen mit den kritischen Kurven induzieren diese vertikalen Linien
Regionen. Zwei Regionen, deren gemeinsame Grenze eine vertikale Linie ist, gehören zur
gleichen nicht-kritischen Region des VSPs, repräsentieren also einen Aspekt (an dieser Stelle noch mit unendlicher Auflösung). In Abbildung 7 sind die entsprechenden Aspekte durch
unterschiedliche Grautöne hervorgehoben. Zusätzlich liefert der Plane-Sweep Algorithmus
eine Blickrichtung für jede dieser Regionen. Die so berechneten nicht-kritischen Regionen
bzw. Aspekte mit unendlicher Auflösung und ihre entsprechenden Blickrichtungen dienen
als Eingabe für Schritt 4 des Algorithmus zur Konstruktion des Finite-Resolution Aspect
Graphs.
Sweep Richtung
Abb. 7. Beispiel zur Verdeutlichung des Plane-Sweep Algorithmus zur Konstruktion des VSPs mit unendlicher Auflösung
Vereinfachung der Aspekte
Im nächsten Schritt wird jeder der zuvor berechneten Aspekte vereinfacht. Hierzu wird ein
Aspekt mit Hilfe der zuvor berechneten Blickrichtung in den Sichtraum projeziert. Details
(z.B. Vertexe), die weniger als voneinander entfernt sind, werden vereinigt. Das Resultat
dieses Schritts ist ein Aspektgraph, der Aspekte mit endlicher Auflösung enthält.
Vereinigung von isomorphen Aspekten
Unter Umständen ist es möglich, dass nach dem vorigen Schritt einige adjazente Aspekte
isomorph sind. Dies kann passieren, wenn unterschiedliche Ereignisse den gleichen vereinfachenden Effekt auf zwei adjazente Aspekte bewirken. Abbildung 8 zeigt hierfür ein Beispiel.
Auf der linken Seite der Abbildung ist zunächst ein Aspekt mit unendlicher Auflösung dargestellt. Die obere und untere Kante der Vertexe p und q sind weniger als voneinander
entfernt. Der entsprechende Aspekt mit endlicher Auflösung ist rechts dargestellt. In der
Mitte der Abbildung ist ein weiterer Aspekt mit unendlicher Auflösung dargestellt. In diesem Fall sind die Vertexe p und q selbst weniger als voneinander entfernt, was den gleichen
Aspekt mit endlicher Auflösung impliziert.
Im letzten Schritt zur Konstruktion des Finite-Resolution Aspect Graphs werden daher adjazente Aspekte, die isomorph sind, vereinigt. Das Resultat ist der fertige FiniteResolution Aspect Graph (vgl. Abbildung 6 (d)).
278
David Schmelter
Laut Shimshoni und Ponce trägt dieser letzte Schritt im Wesentlichen zur geringeren
Komplexität eines Aspektgraphen mit endlicher Auflösung gegenüber einem Aspektgraphen
mit unendlicher Auflösung bei.
q
<ε
q
p
<ε
p
Abb. 8. Unterschiedliche Ereignisse bewirken auf zwei adjazente Aspekte den gleichen vereinfachenden
Effekt. Quelle: [11]
Laufzeit und Komplexität
Für eine Szene mit n Polygonen wird die Größe des Finite-Resolution Aspect Graphs in [11]
mit O(n8 ) angegeben. Der Konstruktionsaufwand für einen Aspektgraphen der Größe m,
der im Wesentlichen durch den letzten Schritt, also die Vereinigung isomorpher, adjazenter
Aspekte entsteht, beträgt O(m · n4 ), insgesamt also O(n12 ) (vgl. [9]).
2.3 Anwendungen
In diesem Abschnitt werden einige Beispielszenen vorgestellt und diskutiert, die in [11]
untersucht wurden.
Die erste Szene haben wir in Abbildung 6 bereits kennen gelernt. Das erste wesentliche
Ziel von Shimshoni und Ponce war es, die Komplexität von klassischen Aspektgraphen in
den Griff zu bekommen. Für die in Abbildung 6 verwendete Szene und Auflösung konnte
dieses Problem nicht gelöst werden, der entstandene Finite-Resolution Aspect Graph ist
komplexer als sein klassisches Gegenstück.
Abbildung 9 zeigt eine weitere Beispielszene mit einem Objekt, das aus drei orthogonalen „Streben“ besteht. In diesem Fall wurde die Auflösung so gewählt, dass sich der Aspekt
des dargestellten Objekts zu drei Linien vereinfacht (vgl. (b)). Der in (c) gezeigte klassische
Aspektgraph besteht aus 120 Regionen. Für den Fall endlicher Auflösung existieren 5060
Regionen, die in (d) dargestellt sind. Nachdem adjazente, isomorphe Aspekte vereinigt wurden, ergibt sich der in (e) dargestellt Finite-Resolution Aspect Graph, der aus lediglich 20
Regionen besteht.
324
IEEE TRANSACTIONS ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE, VOL. 19, NO. 4, APRIL 1997
(a)
(b)
(c)
(d)
(e)
Abb. legs
9. Eine
Beispielszene.
[11]
Fig. 22. An object consisting of three orthogonal
and itsweitere
aspect graph.
(a) The object. Quelle:
(b) Its finite-resolution
aspect. (c) The infinite-resolution
visual event curves. (d) The finite-resolution visual event curves. (e) The finite-resolution aspect graph.
(a)
(b)
(c)
Approximationen und Alternativen für Aspektgraphen
279
Abbildung 10 (a) zeigt eine Szene mit einem einfachen nicht konvexen Objekt, (b) die
kritischen Kurven bei unendlicher Auflösung. In diesem Fall war es aufgrund des hohen
Konstruktionsaufwands nicht möglich, die für den Algorithmus zur Erstellung des FiniteResolution Aspect Graphs benötigten kritischen Kurven unter Annahme endlicher Auflösung zu generieren.
an diesem Ansatz:
(d)Dieses Beispiel verdeutlicht das wesentliche Problem
(e)
Die
Komplexität
eines
Finite-Resolution
Aspect
Graphs
mag
in
der
Tat
geringer sein als
Fig. 23. All qualitatively different finite-resolution aspects of an object consisting of three orthogonal legs. (a) All three legs are visible in the finiteresolution aspect.
(b) One
of the legs isGegenstücks.
foreshortened to Die
a point
in the finite-resolution
aspect.sind
(c) Two
legsUmständen
appear as one aber
line in the finitedie seines
klassischen
Kosten
zur Berechnung
unter
resolution aspect. (d) Two legs are close to each other but the width of the combined feature is more than e and therefore they appear as a region
bereits
für
Szenen
mit
wenigen
Polygonen
derart
hoch,
dass
ein
Aspektgraph
mit
endlicher
in the finite-resolution aspect. (e) One of the legs is close to the other two legs but they are not close to each other causing all three of them to
appear as aAuflösung
region in the finite-resolution
aspect.
erst gar nicht
generiert werden kann.
(a)
(b)
Fig. 24. A very non-convex object
and its10.
infinite-resolution
event curves.
(a) The object.
(b) The
infinite-resolution
visual event curves.
Abb.
Beispielszenevisual
mit einem
nicht konvexen
Objekt.
Quelle:
[11]
2.4 Zusammenfassung
Das wesentliche Problem von klassischen Aspektgraphen ist ihre Größe, die eine praktische
Verwendung unmöglich macht. Mit dem Finite-Resolution Aspect Graph existiert eine Approximation, die dieses Problem teilweise löst. Das Problem bei dem Ansatz von Shimonshi
und Ponce liegt allerdings in der aufwendigen Konstruktion, die bereits für relativ einfache
Szenen fehlschlägt (vgl. Abbildung 10).
3 Visibility Skeleton
Das Visibility Skeleton ist eine im Jahr 1997 von Frédo Durand, George Drettakis und
Claude Puech vorgestellte Datenstruktur, die exakte globale Sichtbarkeitsinformationen einer 3D Szene enthält. Verschiedene Verfahren, die Informationen über globale Sichtbarkeiten
benötigen (z.B. Verfahren zum Occlusion Culling oder globale Beleuchtungsverfahren wie
Radiosity) können diese Informationen effizient über das Visibility Skeleton abfragen. Da
das Visibility Skeleton für unterschiedliche Anwendungen genutzt werden kann, wird es
von den Autoren auch als multi-purpose Tool beworben. Es zeichnet sich im Gegensatz
zu klassischen Aspektgraphen durch eine gewisse Praxisrelevanz aus: In [5] wird gezeigt,
dass die Komplexität des Visibility Skeletons für Testszenen mit etwas über 1000 Polygonen beherrschbar bleibt, sowohl was die Konstruktionszeit als auch die Größe des Visibility
Skeletons angeht.
280
David Schmelter
Um Informationen über globale Sichtbarkeiten effizient abfragen zu können, werden im
Visibility Skeleton alle Sichtbarkeitswechsel einer 3D Szene gespeichert. Ein Sichtbarkeitswechsel (auch Line Swath) ist über eine dreidimensionale Fläche definiert, die durch exakt
drei Polygonkanten gebildet wird (man spricht hier auch von Generator-Kanten). Die direkte
Konstruktion dieser Sichtbarkeitswechsel ist allerdings sehr aufwendig. Aus diesem Grund
betrachtet man Schnitte von Line Swaths, also Linien im dreidimensionalen Raum. Diese
Linien werden maximal freie Liniensegmente oder auch MFLs (engl. Extremal Stabbing Line) genannt und sind durch exakt vier Generator-Kanten definiert. Das Visibility Skeleton
einer 3D-Szene ist ein aus diesen maximal freien Liniensegmenten und Sichtbarkeitswechseln
aufgebauter Graph.
Zum besseren Verständnis werden die zentralen Elemente des Visibility Skeletons - maximal freie Liniensegmente und Sichtbarkeitswechsel - im Folgenden anhand von einigen
Beispielen verdeutlicht um im Anschluss daran zu einer präzisen Definition dieser zentralen
Elemente und des Visibility Skeletons zu kommen.
3.1 Grundlagen
Abbildung 11 zeigt ein Beispiel für einen sogenannten EV Sichtbarkeitswechsel. Bewegt sich
der Standpunkt des Betrachters von links nach rechts (verdeutlicht durch den oberen Teil
der Abbildung), erscheint der Vertex v nicht länger über dem Boden, sondern über einem
Polygon, das von der Kante e begrenzt wird. Es tritt also eine Änderung in der Topologie
der Sichtbarkeit ein. Die Topologie ändert sich im Beispiel immer dann, wenn v und e auf
einer Sichtlinie des Betrachters liegen. Die Menge aller Sichtlinien, die v und e schneiden,
bildet den in der Abbildung blau dargestellten ev Line Swath mit einem Freiheitsgrad über
die Kante e. ev ist also eine eindimensionale Fläche2 (auch: 1D Element), die durch drei
Generator-Kanten gebildet wird: Die beiden Polygonkanten des Vertex v und die Kante e.
Abbildung 12 zeigt einen Sichtbarkeitswechsel, der aus drei unabhängigen GeneratorKanten gebildet wird, also einen EEE Line Swath. Wie zu erkennen ist, ist die durch einen
Sichtbarkeitswechsel gebildete Fläche nicht notwendigerweise eben.
v
e1
e2
e3
e
ev
Abb. 11. EV Line Swath. Quelle:
[5]
2
e1e2e3
Abb. 12. EEE Line Swath. Quelle:
[5]
Die Dimension bezieht sich hierbei auf den Freiheitsgrad über die Kante e
Approximationen und Alternativen für Aspektgraphen
281
Neben EV und EEE Line Swaths können noch Fv (für Face Vertex) und Fe (für Face
Edge) Sichtbarkeitswechsel unterschieden werden. Tabelle 1 gibt eine Übersicht über die
unterschiedlichen Ausprägungen von Sichtbarkeitswechseln und ihrer Generator-Elemente.
Bezeichnung
EV
EEE
Fv
Fe
Generator-Elemente
Eine Kante, ein Vertex
Drei Kanten
Erläuterung
Ein Vertex wird durch zwei Kanten definiert
(siehe Abbildung 11)
Entspricht der Definition eines Sichtbarkeitswechsels (siehe Abbildung 12)
Ein Polygon (Face), Ein Polygon wird durch mind. zwei Kanten
ein Vertex
definiert, der entsprechende Vertex dieses Polygons durch eine weitere Kante.
Eine Polygon, eine Ähnlich zu Fv: Ein Polygon wird durch mind.
Kante
zwei Kanten definiert, die dritte Kante stammt
von einem anderen Polygon.
Tabelle 1. Übersicht der möglichen Sichtbarkeitswechsel (nach [10])
Abbildung 13 zeigt ein Beispiel für ein VEE MFL. e1 e2 v (in der Abbildung rot dargestellt) wird durch den Schnitt der beiden EV Line Swaths e1 v und e2 v gebildet, also
insgesamt durch vier Generator-Kanten (e1 e2 v ist somit zu e1 v und e2 v adjazent). Ein MFL
ist somit eindeutig definiert und besitzt keinen Freiheitsgrad. Es besitzt also keine Dimensionen und wird im Folgenden als 0D Element bezeichnet.
Abbildung 14 zeigt ein E4 MFL, das durch die vier voneinander unabhängigen Kanten
e1 , e2 , e3 und e4 gebildet wird.
e1
v
e1
e2
e1e2v
e2v e1v
Abb. 13. VEE Extremal Stabbing
Line. Quelle: [5]
e2
e3
e4
Abb. 14. E4 Extremal Stabbing
Line. Quelle: [5]
Neben VEE und E4 Extremal Stabbing Lines existieren noch eine Reihe weiterer Ausprägungen. Tabelle 2 gibt eine Übersicht über die möglichen Ausprägungen von maximal
freien Liniensegmenten und ihrer Generator-Elemente.
Das Visibility Skeleton ist ein durch MFLs und Line Swaths aufgebauter Graph. Die
Knoten dieses Graphen sind die maximal freien Liniensegmente. Eine Kante im Graphen ist
ein Sichtbarkeitswechsel, der adjazent zu den beiden entsprechenden Knoten ist. Abbildung
15 zeigt zur Verdeutlichung einen Ausschnitt des Visibility Skeletons für das bereits aus
Abbildung 13 bekannte Beispiel mit dem MFL e1 e2 v. Teil (a) der Grafik zeigt den Knoten
282
David Schmelter
Bezeichnung
VV
VEE
EVE
Fvv
FvE
FEE
EFE
FF
E4
Generator-Elemente
zwei Vertexe, die
nicht zum selben
Polygon gehören
ein Vertex, zwei Kanten
ein Vertex, zwei Kanten
zwei Vertexe eines
Polygons, die keine
gemeinsame Kante
besitzen
ein Vertex eines Polygons und eine Kante,
die die Ebene des Polygons schneidet
1 Polygon und zwei
Kanten,
die
die
Ebene des Polygons
schneiden
1 Polygon und zwei
Kanten,
die
die
Ebene des Polygons
schneiden
zwei Polygone, wobei
sich die Ebenen der
Polygone gegenseitig
schneiden
vier Kanten
Erläuterung
Ein Vertex wird durch jeweils zwei Kanten definiert
Vgl. Abbildung 13
Analog zu VEE, allerdings schneidet das MFL
die Generator Kanten in der Reihenfolge EVE
Das MFL ist eine Diagonale des Polygons
MFL liegt in der Ebene des Polygons und
schneidet ein Vertex des Polygons sowie eine
Kante
MFL liegt in der Ebene des Polygons und
schneidet zwei Kanten
Analog zu FEE, allerdings schneidet das MFL
die Generator Kanten in der Reihenfolge EFE
Das MFL ist die durch die Ebenen der beiden
Polygone gebildete Schnittgerade
Vgl. Abbildung 14
Tabelle 2. Übersicht der möglichen maximal freien Liniensegmente (nach [10])
e1 e2 v des Visibility Skeletons, der dem MFL e1 e2 v entspricht. Er ist adjazent zu den Kanten
e1 v und e2 v, die den zu dem MFL adjazenten Sichtbarkeitswechseln e1 v und e2 v entsprechen.
Der Übersichtlichkeit halber sind nicht alle adjazenten Sichtbarkeitswechsel dargestellt. Teil
(b) zeigt den Knoten e1 e2 v mit den vollständigen adjazenten Sichtbarkeitswechseln:
• e01 v entsteht durch die Sichtlinien, die auf das durch die Kante e2 begrenzte Polygon
treffen.
• e3 e1 e2 und e4 e1 e2 sind die durch die Generator Kanten e1 und e2 sowie e3 bzw. e4
induzierten Sichtbarkeitswechsel.
Bisher wurde lediglich die Konstruktion von Sichtbarkeitswechseln beschrieben. Die eigentlich wichtigste Information, nämlich die Sichtbarkeit welcher Extremal-Elemente durch
einen Sichtbarkeitswechsel beschrieben wird, wurde noch nicht betrachtet. Abbildung 16
verdeutlicht, was unter einem Extremal-Element verstanden wird. Dargestellt sind die beiden rot hervorgehobenen MFLs Nstart und Nend . Nstart ist durch die Generator-Elemente v,
e1 und e3 definiert, Nend durch v, e1 und e2 . Die beiden MFLs definieren somit den Sichtbarkeitswechsel ve1 . Die Extremal-Elemente eines Sichtbarkeitswechsel sind die Elemente einer
Szene, die als nächstes „vor“ der ersten bzw. als nächstes „hinter“ der letzten GeneratorKante geschnitten werden. Im Beispiel sind dies für den Sichtbarkeitswechsel ve1 also die
Polygone Fup und Fdown . Da Sichtbarkeitswechsel durch MFLs begrenzt werden, können
2
1
e
e2v
e1
e2
e1
e1'v
3
e1'v
e4
v
e3
e1e2v
e2v
e 1v
e2
e1
e4
v
e1v
e
e1e2v
283
e
Approximationen und Alternativen für Aspektgraphen
e 3e 1e 2
e1v
e
e
v
e 2v
1 2
e4e1e2
e2
e1e2v
e v e1v
2
(a)
(b)
Abb. 15. (a) Das Beispiel aus Abbildung 13 mit entsprechendem Knoten des Visibility Skeletons (Sichtbarkeitswechsel unvollständig). (b) Das gleiche Beispiel mit vollständigen Sichtbarkeitswechseln. Nach [5]
die Extremal-Elemente eines Sichtbarkeitswechsel direkt aus den Extremal-Elementen der
begrenzenden MFLs abgelesen werden. Dadurch, dass MFLs Linien im dreidimensionalen
Raum sind, ist die Berechnung ihrer Extremal-Elemente leicht mit Ray-Casting Verfahren
möglich.
Fup
v
Nend
Nstart
e2
e1
e3
Fdown
Abb. 16. Extremal-Elemente Fup und Fdown der MFLs Nstart und Nend . Quelle: [5]
Aus diesen Überlegungen folgt die grundsätzliche Idee des Visibility Skeletons: Durch
Berechnung aller MFLs inkl. ihrer Extremal-Elemente und Zuordnung der adjazenten Sichtbarkeitswechsel können alle Sichtbarkeitsbeziehungen in einer 3D-Szene mit Hilfe einer Graphstruktur beschrieben werden.
3.2 Definitionen
Nachdem eine kurze Übersicht über den Aufbau des Visibility Skeletons und seiner Bausteine (maximal freie Liniensegmente und Sichtbarkeitswechsel) gegeben wurde, werden die
folgenden Definitionen deutlich:
284
David Schmelter
Definition 1 (Maximal freies Liniensegment). Gegeben seien vier Polygonkanten e1
bis e4 . Ein maximal freies Liniensegment ist definiert als die Linie, die jede dieser Vier
Kanten schneidet.
Ein maximal freies Liniensegment ist somit eine Linie ohne Freiheitsgrade, also ein Element mit 0 Dimensionen (auch 0D Element).
Definition 2 (Sichtbarkeitswechsel). Gegeben sei ein maximal freies Liniensegment l.
Ein Sichtbarkeitswechsel ist definiert durch die Oberfläche, die durch die Menge aller Schnittlinien dreier Polygonkanten ei von l aufgespannt wird, sofern die Schnittbedingung exakt
einer Kante von l aufgehoben ist.
Ein Sichtbarkeitswechsel ist also durch eine Oberfläche mit einem Freiheitsgrad über eine
Kante eines maximal freien Liniensegments definiert. Er besitzt somit einen Freiheitsgrad,
entspricht also einem Element mit 1 Dimension (auch 1D Element).
Definition 3 (Visibility Skeleton). Das Visibility Skeleton ist ein ungerichteter Graph.
Die Knoten dieses Graphen entsprechen maximal freien Liniensegmenten, eine Kante zwischen zwei Knoten entspricht einem zu beiden Knoten adjazenten Sichtbarkeitswechsel.
3.3 Datenstruktur des Visibility Skeletons
Nachdem Sichtbarkeitswechsel und maximal freie Liniensegmente im Kontext des Visibility
Skeletons definiert wurden, werden Ausschnitte einer möglichen (vereinfachten) Datenstruktur zur Implementierung des Visibility Skeletons betrachtet.
Listing 1 zeigt die Klasse N ode, die einen Knoten im Graphen des Visibility Skeletons
darstellt und einem MFL entspricht. In einem Knoten werden die folgenden Informationen gespeichert: Eine Liste der zu diesem MFL adjazenten Sichtbarkeitswechsel (Paramter
adjacentArcs) sowie die beiden Extremal-Elemente, die dieses MFL begrenzen (Parameter
Fup und Fdown ).
Listing 2 zeigt die Klasse Arc, die eine Kante im Visibility Skeleton repräsentiert und
einem Sichtbarkeitswechsel entspricht. In einer Kante werden die folgenden Informationen
gespeichert: Der Start- und Endknoten, also die beiden MFLs, die diesen Sichtbarkeitswechsel begrenzen (Parameter Nstart und Nend ) sowie wiederum die beiden Extremal-Elemente
dieses Sichtbarkeitswechsels (Parameter Fup und Fdown , vgl. auch Abbildung 16).
Für jede Ausprägung von Sichtbarkeitswechseln (EV, EEE, Fv und Fe) existieren entsprechende Klassen, die die Klasse Arc erweitern. Listing 3 zeigt ein Beispiel für einen EV Sichtbarkeitswechsel. Zusätzlich zu den Start- und Endknoten sowie den Extremal-Elementen
werden in der Klasse EV die Generator-Elemente des Sichtbarkeitswechsels gespeichert, im
Beispiel also die Kante e und der Vertex v.
Listing 4 zeigt die Klasse V isibilitySkeleton, die das eigentliche Visibility Skeleton repräsentiert. Für jede Ausprägung von Sichtbarkeitswechseln (EV, EEE, Fv und Fe) existiert
ein zweidiemensionales Array von binären Suchbäumen. Im Beispiel sind die beiden Arrays
für EV und EEE Sichtbarkeitswechsel dargestellt. Das Array eines Sichtbarkeitswechsels
wird über die beiden Extremal-Elemente indiziert. Somit existiert für jede Kombination
von Extremal-Elementen genau ein binärer Suchbaum. Auf diese Art und Weise sind die
Sichtbarkeitsinformationen einer 3D Szene für eine Kombination von Extremal-Elementen
effizient abrufbar.
Approximationen und Alternativen für Aspektgraphen
1
2
3
4
c l a s s Node {
L i s t <Arcs> a d j a c e n t A r c s
Face Fup , Fdown
}
1
2
3
4
Listing 1. Klasse Node
2
3
4
c l a s s EV : c h i l d o f Arc {
Edge e
Vertex v
}
Listing 3. Klasse EV
c l a s s Arc {
Node N s t a r t , Nend
Face Fup , Fdown
}
Listing 2. Klasse Arc
1
1
285
2
3
4
5
class VisibilitySkeleton {
t r e e <EV>ev [ Fup ] [ Fdown ]
t r e e <EEE>e e e [ Fup ] [ Fdown ]
...
}
Listing 4. Klasse VisibilitySkeleton
3.4 Konstruktion des Visibility Skeletons
Nachdem das Visibility Skeleton und seine Elemente definiert und eine Datenstruktur vorgestellt wurde, wird seine Konstruktion betrachtet. Algorithmus 29 verdeutlicht die prinzipielle Konstruktion. Der Algorithmus ist anhand von Definition 1 aufgebaut und betrachtet
der Übersichtlichkeit halber keine Sonderfälle wie VV, VEE o.a. MFLs. Die Konstruktion
ist prinzipiell einfach: In einer äußeren Schleife werden zunächst alle Knoten des Visibility
Skeletons erzeugt. Für jede Kombination G von vier Kanten der Szene wird überprüft, ob
diese Kanten ein gültiges MFL bilden (Zeilen 1 und 2). Vier Kanten bilden ein gültiges
MFL, wenn eine Linie l exisitiert, die diese Kanten schneidet und l zwischen der ersten und
letzten Kante keine weiteren Elemente der Szene schneidet. Diese Überprüfung kann durch
einfache Ray-Casting Abfragen erfolgen. Wurde ein gültiges MFL gefunden, werden die entsprechenden Extremal-Elemente berechnet und ein neuer Knoten in das Visibility Skeleton
eingefügt (Zeilen 3 und 4). Die Erzeugung aller adjazenten Sichtbarkeitswechsel eines MFLs
L erfolgt direkt nach dessen Erzeugung (Zeile 5): Für jede dreielementige Teilmenge A ⊂ L,
die einen zu L adjazenten Sichtbarkeitswechsel definiert, wird überprüft, ob im Visibility
Skeleton bereits ein Sichtbarkeitswechsel A0 mit den gleichen Extremal-Elemente wie A vorhanden ist (Zeile 6). Ist dies der Fall, wird der bestehende Sichtbarkeitswechsel A0 mit A
verschmolzen (Zeile 7). Ansonsten wird eine neue Kante in das Visibility Skeleton eingefügt
(Zeile 9).
Algorithmus 29 Konstruktion des Visibility Skeletons
1: for all Kombinationen von Generator-Kanten G = {g0 , g1 , g2 , g3 } do
2:
if G bildet ein gültiges maximal freies Liniensegment L then
3:
Berechne Extremal-Elemente von L
4:
Füge L in Visibility Skeleton ein
5:
for all Sichtbarkeitswechsel A = {gi0 , gi1 , gi2 } adjazent zu L do
6:
if Visibility Skeleton enthält Sichtbarkeitswechsel A’ mit denselben Generator-Kanten wie A
then
7:
Verschmelze A mit A’
8:
else
9:
Füge A in das Visibility Skeleton ein
286
David Schmelter
Abbildung 17 veranschaulicht die Konstruktion an einem Beispiel. In einem ersten Schritt
seien die Kanten der Vertexe v und ve als mögliche Generator-Kanten eines MFLs ausgewählt worden. Diese Kanten bilden das gültige MFL vve ; vve wird somit in das Visibility
Skeleton eingefügt. Ein möglicher adjazenter Sichtbarkeitswechsel ve ist durch den Vertex
v und die Kante e definiert. Im Visibility Skeleton ist zu diesem Zeitpunk noch kein Sichtbarkeitswechsel mit den gleichen Generator-Kanten vorhanden. Aus diesem Grund wird ve
einfach zum Visibility Skeleton hinzugefügt, das nun die Struktur wie in Abbildung 17 (a)
besitzt. Die weiteren zu vve adjazenten Sichtbarkeitswechsel werden der Übersichtlichkeit
halber an dieser Stelle nicht weiter betrachtet.
Als nächstes seien die Generator-Kanten des Vertex v, Polygons f und e ausgewählt
worden. Diese Kanten bilden das gültige MFL f ve, das somit in das Visibility Skeleton
eingefügt wird. Ein möglicher adjazenter Sichtbarkeitswechsel von f ve ist wiederum ve. Da
im Visibility Skeleton bereits ein Sichtbarkeitswechsel enthalten ist, wird f ve über ve mit
vve verbunden. Das Visibility Skeleton hat nun die in Abbildung 17 (b) gezeigte Struktur.
Nun seien die Generator-Kanten des Vertex v sowie e3 und e ausgewählt worden. Diese
Kanten bilden das gültige MFL ve3 e, das in das Visibility Skeleton eingefügt wird. Erneut ist
ve ein zu ve3 e adjazenter Sichtbarkeitswechsel. Da im Visibility Skeleton sowohl der Startals auch der Endknoten von ve bereits gesetzt ist, wird ve gesplittet. Der Zielknoten von
vve ist zunächst undefiniert, ve verbindet die beiden MFLs ve3 e und f ve (vgl. Abbildung
17 (c)).
Im letzten Schritt seien die Generator-Kanten des Vertex v sowie e2 und e ausgewählt
worden. Diese Kanten bilden das gültige MFL ve2 e. Erneut ist ve adjazent zu ve2 e. ve2 e
wird über ve mit vve verbunden. Das Visibility Skeleton besitzt nun die in Abbildung 17
(d) dargestellte Struktur.
Insgesamt können also die folgenden Operationen beim Einfügen von Sichtbarkeitswechseln in das Visibility Skeleton unterschieden werden (Zeilen 7 und 9 in Algorithmus 29):
• Add: Ein neuer Sichtbarkeitswechsel wird in das Visibility Skeleton eingefügt (vgl. Abbildung 17 (a)).
• Merge: Ein bestehender Sichtbarkeitswechsel wird mit einem neuen vereinigt (vgl. Abbildung 17 (b)).
• Split: Ein bestehender Sichtbarkeitswechsel wird gesplittet (vgl. Abbildung 17 (c)).
Zum Schluss dieses Abschnitts wird die Laufzeit des vorgestellten Algorithmus und die
Komplexität des Visibility Skeletons untersucht.
Behauptung (Größe des Visibiliy Skeletons). Für eine Szene mit n Polygonen beträgt die
theoretische Größe des Visibility Skeletons im Worst-Case O(n4 ).
Beweis. Der Beweis ist recht trivial: Jedes Quadrupel von Kanten kann theoretisch ein
gültiges MFL bilden.
Behauptung (Konstruktionszeit des Visibiliy Skeletons). Für eine Szene mit n Polygonen
beträgt die theoretische Konstruktionszeit des Visibility Skeletons im Worst-Case O(n5 ).
Beweis. Auch dieser Beweis ist einfach: Es existieren O(n4 ) Kombinationen von Kanten, die
potentiell ein gültiges MFL bilden können. Für jede dieser Kombinationen muss überprüft
werden, ob sie eine gültige MFL bildet. Hierzu muss die gesamt Szene mittels Ray-Casting
Approximationen und Alternativen für Aspektgraphen
v
v
f
e
e
ve
ve
?
?
ve
vve
?
?
??
v
f
f
e2 e3
e
ve
ve
?
? ?
ve
fve
(b)
e
vve
ve
?
v
?
? ?
vve
?
?
(a)
e3
287
?
ve3e
?
?
(c)
?
? ?
ve
fve
??
?
?
? ?
vve
ve ve e
?
?
? ?
ve3e
2
? ?
?
ve
? ?
fve
??
(d)
Abb. 17. Erzeugung der Kanten des Visibility Skeletons. Quelle: [5]
Verfahren auf Verdeckungen überprüft werden. Somit ergibt sich eine Komplexität von
O(n5 ).
Laut Durand, Drettakis und Puech werden diese Worst-Cases allerdings nur in bestimmten Szenen erreicht. Für die in [5] untersuchten Testszenen ergab sich eine durchschnittliche
Konstruktionszeit von O(n2.4 ).
3.5 Anwendungen
Nachdem die Konstruktion des Visibiltiy Skeletons vorgestellt wurde, werden einige Anwendungen betrachtet, für die das Visibility Skeleton eine effiziente Datenstruktur zur Verfügung
stellt.
In [5] werden im Wesentlichen drei Anwendungen vorgestellt:
• Bei globalen Beleuchtungsverfahren wie Radiosity wird zur Berechnung der FormFaktoren häufig die Information benötigt, welche Teile einer Fläche von einem bestimm-
288
David Schmelter
ten Punkt einer 3D Szene aus gesehen sichtbar sind. Diese Information kann mittels dem
Visibility Skeleton effizient abgefragt werden.
• Eine weitere Anwendung des Visibility Skeletons ist die Berechnung von sogenannten
Discontinuity Meshes, die zur Berechnung von Schatten und Halbschatten eingesetzt
werden können. Zur Berechnung von Discontinuity Meshes ist allerdings eine kleine Erweiterung am Visibility Skeletons nötig. Hierbei handelt es sich um das Array DM (i, j),
in dem alle Sichtbarkeitswechsel zwischen zwei Polygonen fi und fj abgelegt werden. Die
Verwaltung dieses Arrays ist in konstanter Zeit möglich.
• Als dritte und letzte Anwendung wird die Berechnung von exakten Blockern vorgestellt.
Eine Liste von exakten Blockern enthält die exakte Menge von Objekten, die eine Fläche
von einer bestimmten Betrachterposition aus gesehen verdecken. Auch zur Berechnung
von exakten Blockern wird das Array DM (i, j) verwendet.
In dieser Arbeit geht es in erster Linie darum, die vielfältigen Einsatzmöglichkeiten des
Visibility Skeletons zu motivieren und weniger darum, diese Anwendungen sehr detailliert zu
betrachten. Aus diesem Grund wird im Folgenden exemplarisch vorgestellt, wie mit Hilfe des
Visibility Skeletons berechnet werden kann, welche Teile einer Fläche von einer bestimmten
Betrachterposition sichtbar sind. Auf Details zur Berechnung von Discontinuity Meshes oder
exakten Blockerlisten wird verzichtet und auf [5] verwiesen.
Abbildung 18 zeigt hierfür ein Beispiel. (a) zeigt eine Stadtszene. Die blau umrandeten
Flächen des grünen Untergrunds sind vom dem gelben Vertex des dargestellten Flugzeugs
nicht sichtbar. (b) zeigt ein Zimmer. Die blau umrandeten Flächen des Fußbodens sind vom
gelben Vertex der dargestellten Lampe ebenfalls nicht sichtbar.
Diese Informationen können mit dem Visibility Skeleton wie folgt berechnet werden:
Um die globale Sichtbarkeit eines Vertex v in Bezug zu einer Fläche f zu bestimmen,
werden zunächst alle EV Sichtbarkeitswechsel berechnet, die zu f in Beziehung stehen.
Diese Abfrage kann erfolgen, indem die entsprechenden Suchbäume des Visiblity Skeletons
mit f als Extremal-Element abgefragt werden. Für jeden dieser Sichtbarkeitswechsel wird
überprüft, ob er mit dem Vertex v in Beziehung steht. Die Menge der so erhaltenen EV
Sichtbarkeitswechsel sind exakt diejenigen, die die Sichtbarkeitsgrenzen von f , ausgehend
von v, definieren.
Die Abfragezeiten für die dargestellten Szenen betrugen für Abbildung 18 (a) 1.2 ms
(312 Polygone) und für Abbildung 18 (b) 1.5 ms (1488 Polygone). Somit eignet sich das
Visibility Skeleton also durchaus für Echtzeitanwendungen in diesem Anwendungsbereich.
3.6 Zusammenfassung
Das Visibility Skeleton ist eine interessante Alternative zu Aspektgraphen, mit dem eine
Reihe von Anwendungen, die Informationen über globale Sichtbarkeiten benötigen, effizient realisiert werden können. Es besticht durch seine Einfachheit: Zur Konstruktion werden
nur Standard-Verfahren aus der Computergrafik, beispielsweise Ray-Casting, benötigt. Das
Visibility Skeleton wurde vollständig implementiert und konnte für die in [5] untersuchten Testszenen trotz seiner zunächst eher schlechten Worst-Case Komplexität erfolgreich
eingesetzt werden. Im Gegensatz zu klassischen Aspektgraphen ist es also auch für relativ
komplexe Szenen praktisch einsetzbar.
Approximationen und Alternativen für Aspektgraphen
(a)
289
(b)
Abb. 18. (a) Teile des Untergrunds, die von dem gelben Vertex des Flugzeugs aus sichtbar sind (b) Teile
des Fußbodens, die von dem gelben Vertex einer Lampe aus sichtbar sind. Quelle: [5]
4 Zusammenfassung und Diskussion
In dieser Arbeit wurden sowohl Approximationen (im Wesentlichen der Finite-Resolution
Aspect Graph) als auch Alternativen für Aspektgraphen (im Wesentlichen das Visibility
Skeleton) vorgestellt und untersucht.
Für den Fall einer orthografischen Projektion existiert mit dem Finite-Resolution Aspect
Graph eine Approximation für Aspektgraphen, die vollständig implementiert wurde. Obwohl
die Größe eines Aspektgraphen mit endlicher Auflösung je nach Auflösung drastisch kleiner
als im unendlichen Fall sein kann, muss die praktische Relevanz dieses Verfahrens bezweifelt
werden:
• Einerseits funktioniert das vorgestellte Verfahren nur für den Fall einer orthografischen
Projektion.
• Andererseits versagt es bereits für relativ einfache Szenen aufgrund des hohen Konstruktionsaufwands.
Mit dem Visibility Skeleton existiert eine interessante (und vollständig implementierte) Alternative zu Aspektgraphen, mit der eine Reihe unterschiedlicher Anfragen an eine
3D Szene beantwortet werden können. Im Gegensatz zum Finite-Resolution Aspect Graph
wurde gezeigt, dass es auch für nicht triviale Szenen mit mehreren tausend Polygonen erfolgreich eingesetzt werden kann. Eine Objekterkennung wie mit Aspektgraphen ist mit dem
Visibility Skeleton allerdings nicht möglich.
Literaturverzeichnis
1. Arie, Jezekiel Ben (1990) Probabilistic Models of Observed Features and Aspects with Application to
Weighted Aspect Graphs. Pattern Recognition Letters, Volume 11, Issue 6
2. Durand, Frédo; Drettakis, George; Puech, Claude (1999) Fast and Accurate Hierarchical Radiosity
Using Global Visibility. ACM Transactions on Graphics (TOG), Volume 18, Issue 2, S. 128–170
3. Durand, Frédo; Drettakis, George; Puech, Claude (1996) The 3D visibility complex: a new approach to
the problems of accurate visibility. Proceedings of the eurographics workshop on Rendering techniques
’96, S. 245–256
4. Durand, Frédo; Drettakis, George; Puech, Claude (2002) The 3D Visibility Complex. ACM Transactions
on Graphics (TOG), Volume 21, Issue 2, S. 176–206
290
David Schmelter
5. Durand, Frédo; Drettakis, George; Puech, Claude (1997) The Visibility Skeleton: A Powerful And Efficient Multi-Purpose Global Visibility Tool. SIGGRAPH ’97: Proceedings of the 24th annual conference
on Computer graphics and interactive techniques, S. 89–100
6. Eggert, D. W.; Bowyer, K. W.; Dyer, C. R.; Christensen, H. I.; Goldgof, D. B. (1993) The Scale Space
Aspect Graph. IEEE Transactions on Pattern Analysis and Machine Intelligence, Volume 15, Issue 11,
S. 1114–1130
7. Morgan, A. P. (1987) Solving Polynomial Systems Using Continuation for Scientific and Engineering
Problems. Prentice-Hall, Englewood Cliff, NJ
8. Plantinga, Harry; Dyer, Charles R. (1990) Visibility, Occlusion, and the Aspect Graph. International
Journal of Computer Vision, Volume 5, Issue 2, S. 137–160
9. Schiffenbauer, Robert D. (2001) A Survey of Aspect Graphs. Polytechnic University of Brooklyn
10. Schröder, Axel (2003) Globale Sichtbarkeitsalgorithmen. Dissertation, Philipps-Universität Marburg
11. Shimshoni, Ilan; Ponce, Jean (1997) Finite-Resolution Aspect Graphs of Polyhedral Objects. IEEE
Transactions on Pattern Analysis and Machine Intelligence, Volume 19, Issue 4, S. 315–327