Algorithmen der Computergraphik

Universität Paderborn
Sommersemester 2009
S KRIPT ZUR VORLESUNG
Algorithmen der Computergraphik
Dozent: Dr. Matthias Fischer
Christian Heinzemann
15. Dezember 2009
Inhaltsverzeichnis
1 Walkthrough-Problem
1.1 Rendering Pipeline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Z-Buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3 Walkthrough-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 Trees
2.1 kd-Bäume . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Konstruktion . . . . . . . . . . . . . . . . .
2.1.2 Bereichsanfragen . . . . . . . . . . . . . . .
2.1.3 Zusammenfassung der Eigenschaften . . . .
2.2 BSP-Bäume . . . . . . . . . . . . . . . . . . . . . .
2.2.1 Grundidee . . . . . . . . . . . . . . . . . . .
2.2.2 Anwendungsbeispiel: Painter’s Algorithmus
2.2.3 Konstruktion - 2D . . . . . . . . . . . . . .
2.2.4 Konstruktion - 3D . . . . . . . . . . . . . .
2.3 Quadtrees und Octrees . . . . . . . . . . . . . . . .
2.3.1 Speichern von Elementen . . . . . . . . . .
2.3.2 Aufbau . . . . . . . . . . . . . . . . . . . .
2.3.3 Suche im Quadtree . . . . . . . . . . . . . .
2.3.4 Balancierte Quadtrees . . . . . . . . . . . .
2.4 Loose Octrees . . . . . . . . . . . . . . . . . . . . .
2.4.1 Konstruktion . . . . . . . . . . . . . . . . .
2.4.2 Nutzen . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Visibility Culling
3.1 Potentially Visible Sets . . . . . . . . . . . . . . . . . . . .
3.2 Occlusion Culling mit Potentially Visible Sets . . . . . . . .
3.2.1 Idee der Methode . . . . . . . . . . . . . . . . . . .
3.2.2 Berechnung des Adjazenzgraphen . . . . . . . . . .
3.2.3 Berechnung der Cell-to-Cell Visibility . . . . . . . .
3.2.4 Berechnung der Eye-to-Cell Visibility . . . . . . . .
3.2.5 Objekte in Räumen . . . . . . . . . . . . . . . . . .
3.3 Dynamische Berechnung von Potentially Visible Sets (PVS)
3.4 Hierarchischer Z-Buffer . . . . . . . . . . . . . . . . . . . .
3.4.1 Grundideen . . . . . . . . . . . . . . . . . . . . . .
3.4.2 Z-Pyramide . . . . . . . . . . . . . . . . . . . . . .
I
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
4
6
10
10
10
11
13
16
19
20
21
23
23
29
30
33
.
.
.
.
.
.
.
.
.
.
.
35
37
38
38
39
40
41
43
43
45
45
46
Inhaltsverzeichnis
3.5
3.6
3.4.3 Verwendung der Z-Pyramide . . . . . . . . .
3.4.4 Rendering mit dem Hierarchischen Z-Buffer
3.4.5 Hardwareunterstützung . . . . . . . . . . . .
Hierarchical Occlusion Maps (HOM) . . . . . . . .
3.5.1 Der HOM-Algorithmus . . . . . . . . . . . .
3.5.2 Betrachtung der Teilschritte . . . . . . . . .
3.5.3 Approximatives Visibility Culling . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . .
4 Replacement
4.1 Rendering mit Color-Cubes . . . . . . .
4.1.1 Datenstruktur . . . . . . . . . .
4.1.2 Rendering . . . . . . . . . . . .
4.1.3 Aufbau der Hierarchie . . . . .
4.1.4 Aufwandsabschätzung . . . . .
4.1.5 Bildqualität . . . . . . . . . . .
4.2 Hierarchical Image Caching . . . . . .
4.2.1 Erster Rendering Durchlauf . .
4.2.2 Zweiter Rendering Durchlauf .
4.2.3 Partitionierung der Szene . . . .
4.2.4 Berechnung der Splittingebenen
4.2.5 Fehlermetrik . . . . . . . . . .
4.2.6 Artefakte . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
47
49
50
50
51
52
55
55
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
56
56
56
57
57
59
60
62
63
64
64
66
67
68
5 Paralleles Rendering
5.1 Paralelles Rendering als Sortierproblem . . . . . . .
5.1.1 Sort-First . . . . . . . . . . . . . . . . . . .
5.1.2 Sort-Middle . . . . . . . . . . . . . . . . . .
5.1.3 Sort-Last . . . . . . . . . . . . . . . . . . .
5.2 Hybrides Sort-First / Sort-Last Rendering . . . . . .
5.2.1 Grundidee der Partitionierung . . . . . . . .
5.2.2 Ablauf des Rendering . . . . . . . . . . . .
5.2.3 Partitionierungs-Algorithmus . . . . . . . .
5.2.4 Abschätzung des Kommunikations-Overhead
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
69
70
70
71
72
74
74
75
76
77
6 Level of Detail
6.1 Arten des Level of Detail . . . . . . . . .
6.1.1 Discrete Level of Detail . . . . .
6.1.2 Continuous Level of Detail . . . .
6.1.3 View-Dependent Level Of Detail .
6.2 LOD - Hierarchie . . . . . . . . . . . . .
6.3 Automatische Frameratenregulierung . .
6.4 Vereinfachung von Polygonmodellen . . .
6.4.1 Decimation . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
79
80
80
80
80
80
81
82
82
AlgoCG 09
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
II
Inhaltsverzeichnis
.
.
.
.
.
.
.
.
.
83
84
84
85
85
86
87
87
88
7 Aspect Graph und Viewpoint Space Partition
7.1 Viewpoint Space Partition . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.2 Aspect Graph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
89
89
91
AlgoCG 09
III
6.5
6.4.2 Sampling . . . . . . . . . . . . . . . . . .
6.4.3 Vertex Merging . . . . . . . . . . . . . . .
6.4.4 Adaptive Subdivision . . . . . . . . . . . .
Schrittweise Verfeinerung mit Progressive Meshes .
6.5.1 Vergröberung . . . . . . . . . . . . . . . .
6.5.2 Verfeinerung . . . . . . . . . . . . . . . .
6.5.3 Messung der Qualität . . . . . . . . . . . .
6.5.4 Verfeinerungsalgorithmus . . . . . . . . .
6.5.5 Anwendungen . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1 Walkthrough-Problem
Das Ziel ist die effiziente Berechnung von 3D-Ansichten in einem Walkthrough-System, d.h.
die Ansicht wird durch die Bewegung des Anwenders bestimmt und kann nicht im Voraus
berechnet werden, wie dies bei Animationsfilmen möglich ist. Die Berechnung muss deshalb
in Echtzeit erfolgen, wodurch besondere Anforderungen an die Effizienz der verwendeten
Algorithmen entstehen. Die einzelnen Algorithmen sind in einer sogenannten RenderingPipeline angeordnet und werden nacheinander ausgeführt.
1.1 Rendering Pipeline
Das Rendering ist der Vorgang zum Erstellen von 2D Bildern aus einer 3D-Szene zum Anzeigen auf einem Display. Die Rendering Pipeline in Abbildung 1.1 beschreibt die Anordnung
der dafür notwendigen Algorithmen.
3D-Modell erstellen
(Modellierung)
3D → 2D
Transformation
Versteckte Kanten
entfernen
(Culling, Z-Buffer)
Rasterung,
Anti-Aliasing
Beleuchtung
Abbildung 1.1: Rendering Pipeline.
Zunächst wird ein 3D-Modell der Szene erstellt. Oberflächen werden durch ein feines Zusammensetzen von Polygonen (Dreiecken) modelliert. Dadurch entsteht ein feines Netz von Polygonen. Jedes Dreieck ist durch die 3D-Koordinaten seiner drei Eckpunkte gegeben. Anschließend wird das 3D-Objekt über Geometrietransformationen auf 2DBildschirmkoordinaten abgebildet und dann beleuchted. Danach werden die nicht-sichtbaren
Kanten entfernt und das entstandene Bild wird gerastert, d.h. es wird auf eine 2D-Pixel-Fläche
abgebildet.
Die Rendering-Pipeline nutzt als Primitiven nur Dreiecke, Linien und Punkte. Oberflächen
und Kurven werden über NURBS (Non-Uniform Rational B-Spline) aus den Grundprimitiven
approximiert.
Die auf dem Prozessor ausgeführte Anwendung berechnet die Objekte der Szene über Libraries wie OpenGL oder DirectX, die Grafikkarte übernimmt die Geometrietransformationen
und die Rasterung.
1
Kapitel 1. Walkthrough-Problem
1.2 Z-Buffer
Für die Darstellung einer Szene braucht man zwei Puffer: den Z-Buffer und den Framebuffer.
Der Z-Buffer ist ein 2-dimensionales Feld in der Größe der Bildschirmauflösung, dass für
jedes Pixel den Tiefenwert (z-Wert) speichert. Dies ist die Entfernung zum Betrachter.
Der Framebuffer enthält die Pixel der vordersten Oberfläche, je Pixel mindestens einen
Farbwert.
Algorithmus 1 Z-Buffer Algorithmus
1: function Z-B UFFER( )
2:
Setze alle Einträge im z-Buffer auf Hintergrundentfernung
3:
Setze alle Einträge im Frame-Buffer auf Hintergrundfarbe
4:
for all Polygone P do
5:
Projiziere Polygon P auf Bildschirmebene
6:
Transformiere Resultat in Rasterkoordinaten (Pixel)
7:
for all Pixel (u, v) des Polygons do
8:
p := z - Koordinate des Polygons im Pixel (u, v)
9:
z := Eintrag im z-Buffer für das Pixel (u, v)
10:
if p < z then
11:
z-Buffer (u, v) := p
12:
Frame-Buffer (u, v) := Farbe(P, u, v)
13:
end if
14:
end for
15:
end for
16:
return success
17: end function
Die äußere For-Schleife für die Geometrietransformation aus, die innere die Rasterung.
Eine Szene, bei der die Geometrietransformation die Laufzeit dominiert, ist eine Szene mit
sehr vielen kleinen Objekten, von denen viele vielleicht gar nicht sichtbar sind. Diese müssen
alle explizit gerendert werden, obwohl sie jeweils nur eine kleine Anzahl von Pixeln haben.
Im Gegensatz dazu ist bei einer großen Fläche der Aufwand für die Geometrietransformation
gering, während viele Pixel gerastert werden müssen.
Vorteile
Nachteile
• einfach, keine Sortierung
• Alle Polygone werden gerendert
• gute Hardware-Unterstützung
• Lineare Laufzeit
• einfach zu parallelisieren
• Keine Zusammenhänge im Objektraum
• Größe der Szene beschränkt (für Echtzeitrendering)
AlgoCG 09
2
Kapitel 1. Walkthrough-Problem
1.3 Walkthrough-Systeme
Zunächst hat man eine 3D-Szene, die aus Objekten besteht, die über Polygone modelliert sind.
In einem Walkthrough-System kann sich der Betrachter frei durch die Szene bewegen. Dazu
werden die Position und die Orientierung der Kamera verändert. Die Bilder können damit
nicht vorberechnet werden, sollen aber dennoch eine hohe Qualität aufweisen. Das Rendering
muss somit in Echtzeit passieren.
Damit eine Bilderzeugung als ruckelfrei empfunden wird, benötigt man mindestens eine
Framerate von 20-30 fps. Werden alle Polygone zur Graphikkarte geschickt, erhält man ab einer bestimmten Anzahl von Polygonen keine akzeptablen Renderingzeiten mehr. Dafür benötigt man Verfahren mit sublinearer Laufzeit. Die Laufzeit soll abhängig von der Bildschirmauflösung, aber unabhängig von der Anzahl der Polygone sein.
Eine Beschleunigung der Laufzeit erreicht man durch:
1. Vermeide alle Polygone an die Graphikkarte zu schicken.
2. Vermeide häufige „Zustandswechsel“ (Farbe, Transformationen, ...)
3. Nutze spezielle CPU/GPU Befehle
Über (1) wird die Größe der darzustellenden Szene reduziert, d.h. es wird nur noch der
relevante Teil gerendert. Über (2) und (3) wird die Anzahl der Rechenschritte reduziert und
beschleunigt, die für die Darstellung eines Polygons notwendig sind.
Damit
verbessern (2) und (3)-die
Konstanten der Laufzeit, (1) hingegen
verbessert
die asymHEINZ NIXDORF
INSTITUT
Walkthrough-Problem
Echtzeit-Rendering
!"#$%&'#()(*+,-%&./&"
ptotische
Laufzeit.
gibt zwei Ansätze, dies zu erreichen:
012/&#(34%"*5"-*6/471%8#()(
Entlastung
der Es
Rendering-Pipeline
• Approximation (Level of Detail)
9:%#*0"')(;%*5"-*<%#'7#%1%
Ein weniger komplexes Modell wird erzeugt, das (fast) genauso gut aussieht wie das
= Approximation
- Level
Detail
ursprüngliche
Modell
(sieheofdazu
auch Kapitel 6).
>(%11%*%#"*:%"#2%&*?/471%8%'*@/-%11*-,&A*-,'*BC,'(D*2%",5'/*25(*,5''#%3(*
:#%*-,'*5&'7&E"21#F3%*@/-%11
• Sichtbarkeitsprüfung
(Visibility Culling)
Schicke
möglichst nur sichtbare
Polygone
zur Rendering Pipeline (siehe dazu auch Ka= Sichtbarkeitsprüfung
- Visibility
Culling
pitel>F3#F?%*4G21#F3'(*"5&*'#F3(.,&%*+/1H2/"%*;5&*I%"-%&#"2*+#7%1#"%
3).
077&/8#4,(#/"
2%/4%(&#'F3%'
JKL@/-%11
0":%"-5"2
I%"-%&%&
+#7%1#"%
<#1-
>#F3(.,&?%#('7&EC5"2
O/&1%'5"2*P012/&#(34%"*#"*-%&*Q/475(%&2&,C#?RA*>>*STTU
@,((3#,'*M#'F3%&
JN
Abbildung 1.2: Entlastung der Rendering Pipeline.
AlgoCG 09
3
2 Trees
Die in diesem Kapitel beschriebenen Datenstrukturen dienen zur effizienten Speicherung von
Punkten. Das Ziel ist es, basierend auf einem sichtbaren Ausschnitt die nicht-sichtbaren Objekte effizient berechnen zu können, um diese nicht zum Rendern an die Grafikkarte schicken
zu müssen.
2.1 kd-Bäume
kd-Bäume dienen zur Sortierung von Objekten bzw. Punkten im k-dimensionalen Raum. Sie
werden für (orthogonale) Bereichsanfragen, d.h. für die Berechnung aller Punkte, die sich
innerhalb eines Rechtecks oder Würfels befinden, eingesetzt. Eine weitere Anwendung sind
Verdeckungsberechnungen. Im Folgenden wird nur der 2D-Fall betrachtet.
Ein Punkt p = (px , py ) im 2-dimensionalen Raum liegt in einem Rechteck [x : x0 ] × [y : y 0 ]
genau dann, wenn px in [x : x0 ] und py in [y : y 0 ] liegt. Es sollen nun wie in Abbildung 2.1
dargestellt alle Punkte bestimmt werden, die im Rechteck liegen.
Abbildung 2.1: Orthogonale Bereichsanfrage: Punkte bestimmen, die im Rechteck liegen.
2.1.1 Konstruktion
Es wird ein Binärbaum aufgebaut, der als Blätter die Objekte bzw. Punkte enthält und als innere Knoten sogenannte Splitting-Geraden. Eine Splitting-Gerade teilt die Menge der Punkte
in zwei gleich große Teile, indem der Median der x-Koordinaten bzw. der y-Koordinaten berechnet wird. Dabei wird abwechselnd in x-Richtung und in y-Richtung unterteilt. Die ent-
4
Kapitel 2. Trees
stehenden Teilmengen werden über das linke bzw. rechte Kind des Baums gespeichert. Ein
Beispiel zeigt Abbildung 2.2.
Abbildung 2.2: Beispiel für einen kd-Baum.
Die Wurzel besitzt Tiefe 0, somit hat der Baum in Tiefe k immer 2k Knoten. Die SplittingGeraden verlaufen achsenparallel zur x- bzw. y-Achse. In einer geraden Baumtiefe wird immer vertikal unterteilt (bzgl. der x-Koordinate), in einer ungeraden Baumtiefe horizontal (bzgl.
der y-Koordinate). Abbildung 2.3 stellt die Unterteilung der Punktemenge dem aufgebauten
Binärbaum gegenüber.
Abbildung 2.3: Zweites Beispiel für einen kd-Baum.
Den Algorithmus zum Aufbau des kd-Baums zeigt Algorithmus 2. Der Algorithmus erhält
als Eingabe eine Menge von Punkten und gibt die Wurzel des kd-Baums als Ergebnis zurück.
Der Aufbau eines kd-Baumes mit n Punkten benötigt Platz O(n). Die Laufzeit eines Aufrufs wird von der Bestimmung der Splitting-Geraden dominiert. Dabei benötigt die Bestim-
AlgoCG 09
5
Kapitel 2. Trees
Algorithmus 2 Algorithmus zum Aufbau eines kd-Baumes
1: function B UILD KDT REE(Set of Points P , depth)
2:
if P enthält nur einen Punkt p then
3:
return Blattknoten, der p speichert
4:
else
5:
if depth gerade then
6:
Teile P mit vertikaler Linie I durch den Median bzgl. x-Koordinate in Mengen
P1 , P2
7:
else
8:
Teile P mit horizontaler Linie I durch den Median bzgl. y-Koordinate in
Mengen P1 , P2
9:
end if
10:
vlef t = BuildKDTree(P1 , depth + 1)
11:
vright = BuildKDTree(P2 , depth + 1)
12:
Erzeuge Knoten v mit linkem Nachfolger vlef t und rechtem Nachfolger vright und
Splittinggerade I
13:
end if
14:
return v
15: end function
mung des Medians Zeit O(n). Da diese Algorithmen kompliziert sind, wird in der Regel der
Punktemenge in zwei Liste (eine für x-Koordinate, eine für y-Koordinate) sortiert. Damit läuft
die Bestimmung des Medians in Zeit O(1), man benötigt aber Zeit O(n) für das Erzeugen der
Teillisten. Der Aufbau kann damit über folgende Rekurrenzgleichung beschrieben werden:
O(1)
,n = 1
T (n) =
n
O(n) + 2T (d 2 e) , n > 1
Da sich Eingabegröße in jedem Schritt halbiert, sind log(n)-Aufrufe notwendig, die jeweils
Laufzeit O(n) besitzen. Damit folgt insgesamt Laufzeit O(n log(n)). Da der Baum aber nur
einmal vor Beginn des Walkthroughs aufgebaut werden muss und dann während des gesamten
Walkthroughs benutzt werden kann, ist dies nicht schlimm. Allgemein benötigt die Konstruktion für k-Dimensionen und n Punkte Zeit O(n(k + log(n))).
2.1.2 Bereichsanfragen
Bereichsanfragen sollen zu einem achsenparallelen Rechteck alle Punkte zurückgeben, die in
dem Rechteck enthalten sind. Dazu wird geprüft, welche Regionen des kd-Baumes in dem
Rechteck enthalten sind oder sich mit diesem schneiden. Eine Region ist die Punktemenge,
die auf mindestens einer Seite durch eine Splittinggerade begrenzt ist. Für einen Knoten v des
Baums sind dies alle Splittinggeraden entlang des Pfads zur Wurzel. Eine Region kann damit
geschlossen (Rechteck) oder an mehreren Seiten offen sein. Abbildung 2.4 zeigt ein Beispiel.
Bei der Berechnung wird nun unterschieden zwischen Regionen, die vollständig im Rechteck enthalten sind, und Regionen, die von dem Rechteck geschnitten werden. Bei ersteren
AlgoCG 09
6
Kapitel 2. Trees
Abbildung 2.4: Regionen in einem kd-Baum.
werden alle Punkte ausgegeben, bei letzteren muss für jeden Punkt geprüft werden, ob er in
dem Rechteck enthalten ist. Abbildung 2.5 zeigt ein Beispiel.
Die türkis umrandete Region ist vollständig im roten Rechteck enthalten. Die im Baum
hellgrau hervorgehobenen Regionen werden durch das Rechteck geschnitten. In diesem Fall
ergibt die Einzelprüfung, dass die Punkte p6 und p11 im Rechteck enthalten sind, die Punkte
p3, p12 und p13 hingegen nicht. Das generelle Vorgehen beschreibt Algorithmus 3.
Die Funktion ReportSubTree(v) gibt den vollständigen Teilbaum mit Wurzel v aus. Die
Funktionen lc(v) bzw. rc(v) geben das linke bzw. rechte Kind des Knotens zurück. Die
Funktion p(v) liefert den Punkt, der in Knoten v gespeichert ist. Die Berechnung der Regionen
kann entweder in einem Preprocessing für alle Knoten durchgeführt werden oder „live“ bei der
Traversierung des Baums, indem die jeweilige Region mit dem Halbraum der Splittinggerade
des aktuellen Knotens ver-∩-det wird.
Um die Laufzeit der Bereichsanfrage zu bestimmen, müssen vorher output-sensitive Algorithmen definiert werden.
Definition 2.1.1 (Output-sensitiv)
Ein Algorithmus ist output-sensitiv, wenn seine Laufzeit von der Größe der Ausgabe abhängt.
Sei nun k die Anzahl aller Punkte im Rechteck [x : x0 ] × [y : y 0 ]. Eine lineare Suche
würde Zeit O(n) benötigen. Dies ist jedoch nicht notwendig. Die Ausgabe wird zum einen
durch die Aufrufe der ReportSubTree() Methode bestimmt und zum anderen durch die Anzahl
der SearchKDTree() Aufrufe für geschnittene Regionen. Die Summe aller ReportSubTree()
Aufrufe ist O(k), da maximal k Knoten ausgegeben werden.
Für die Bestimmung der Anzahl der rekursiven Aufrufe von SearchKDTree muss man wissen, wie viele Regionen das Rechteck schneidet. Das direkte Zählen ist durch die freie Platzierung nicht möglich, stattdessen zählt man, wie viele Regionen eine unendlich lange Gerade schneidet (stellvertretend für eine Seite des Rechtecks, muss für jede Seite einmal ausgeführt werden um den Gesamtaufwand zu erhalten.) Betrachtet man eine vertikale Gerade
AlgoCG 09
7
Kapitel 2. Trees
Abbildung 2.5: Auswertung von Regionen in einem kd-Baum.
Algorithmus 3 Algorithmus zur Durchführung von Bereichsanfragen auf einem kd-Baum
1: function S EARCH KDT REE(Node v, Range R)
2:
if v ist Blattknoten then
3:
wenn p(v) in R, gib p(v) aus
4:
else
5:
if region(lc(v)) vollständig in R then
6:
ReportSubTree(lc(v))
7:
else
8:
if region(lc(v)) schneidet R then
9:
SearchKDTree(lc(v), R)
10:
end if
11:
end if
12:
if region(rc(v)) vollständig in R then
13:
ReportSubTree(rc(v))
14:
else
15:
if region(rc(v)) schneidet R then
16:
SearchKDTree(rc(v), R)
17:
end if
18:
end if
19:
end if
20: end function
AlgoCG 09
8
Kapitel 2. Trees
und vertikale Splittinggeraden, so kann die Gerade immer nur einen der beiden Halbräume
der Splittinggeraden schneiden, aber nie beide (vgl. auch Abbildung 2.6)!
vertikale Gerade
vertikale Splittinggerade
Abbildung 2.6: Geschnittene Regionen bei vertikaler Gerade und vertikaler Splittinggerade.
Es beschreibt nun T (n) die Anzahl der geschnittenen Regionen eines kd-Baums, dessen
Wurzel eine vertikale Splittinggerade enthält. Da sich eine Rekursionsstufe tiefer eine horizontale Splittinggerade befindet, steigt man immer 2 Rekursionsstufen auf einmal ab, muss
dort aber beide gefundenen Knoten überprüfen wie in Abbildung 2.7 dargestellt. Jede dieser
Regionen enthält nach Konstruktion n4 Punkte.
Abbildung 2.7: Geschnittene Regionen im kd-Baum.
Damit ergibt sich insgesamt für die Anzahl der Aufrufe:
O(1)
,n = 1
T (n) =
2 + 2T (d n4 e) , n > 1
√
Dies ergibt O( n)√Aufrufe der SearchKDTree-Funktion und zusammen mit der Ausgabe
eine Laufzeit von O( n + k).
AlgoCG 09
9
Kapitel 2. Trees
2.1.3 Zusammenfassung der Eigenschaften
kd-Bäume sind Binärbäume, die über die Berechnung von Achsenparallelen Splitting-Geraden
gebildet werden. Die Teilmengen, in die die Objektmenge zerlegt wird, sind ungefähr gleich
groß (Teilung am Median der jeweiligen Schnittrichtung). In gerader Tiefe gibt es vertikale Splitting-Geraden (Unterteilung nach x-Koordinate), in ungerader Tiefe gibt es horizontale Splitting-Geraden (Unterteilung nach y-Koordinate).
Die Konstruktion benötigt Zeit
√
O(n log(n)), eine achsenparallele Bereichsanfrage O( n + k). Die Platzkomplexität beträgt
O(n).
2.2 BSP-Bäume
BSP-Bäume sind eine Form des Preprocessing, die es für statische Szenen erlaubt, den
Painter’s Algorithmus effizient und zur Laufzeit unabhängig vom Standpunkt anzuwenden.
Der Painter’s Algorithmus dient zum Hidden Surface Removal, zur Verdeckungsberechnung
(Occlusion-Culling, Kap. 3) und zur Darstellung transparenter Objekte HEINZ
bzw. NIXDORF
Schatten.
INSTITUT
!"#$!%&'
!"#$%&'#()(*+,-%&./&"
Das
Verfahren
ist
im
Vergleich
zu
anderen
Preprocessingverfahren
Zeitund
speicherinten012/&#(34%"*5"-*6/471%8#()(
!"##
siv. Dafür ist es effizient für statische Szenen und erlaubt das Display in linearer Zeit.
9#&*.%(&,:3(%"*;<+=;)54%*$/"*
2.2.1
Grundidee
> ?#"#%"*#4*@A=B,54
Es wird
eine Paritionierung der Dreiecke in einer Szene durchgeführt, die einer Tiefensortie> A&%#%:C%"*D+/1E2/"%"F*#4*GA=B,54
rung entspricht. Findet man nun eine Gerade oder Ebene, die eine Gruppierung von DreiGrundlegende Idee:
ecken (der Szene) aufteilt, dann weiß man automatisch, dass Elemente auf der gleichen Seite
H#%I%"'/&(#%&5"2*5"-*J&577#%&5"2
wie >dem
Betrachterstandpunkt nicht von Dreiecken auf der anderen Seite verdeckt werden
können.
Umgekehrt
jedoch schon. Dies stellt Abbildung 2.8 dar.
> ;%(&,:3(%*%#"%*<K%"%*,1'*J&577#%&5"2*$/"*?#"#%"LA&%#%:C%"
9%""*%#"%*Gerade/Ebene 2%I5"-%"*M%&-%"*C,""N*-#%*%#"%*J&577#%&5"2*,5I(%#1(*
Abbildung 2.8: Aufteilung einer Gruppierung von Dreiecken durch eine Splittinggerade.
-,""*2#1(O
?#"#%"LA&%#%:C%*,5I*-%&*21%#:3%"*<%#(%*M#%*-%4*;%(&,:3(%&'(,"-75"C(
Durch
die weitere Aufteilung der Gruppen erhält man einen Binärbaum dessen innere KnoM%&-%"*"#:3(*$%&-%:C(*$/"*?#"#%"LA&%#%:C%"*,5I*-%&*,"-%&%"*<%#(%*D542%C%3&(*X,F
ten Splittinggeraden (2D) bzw. -ebenen (3D) sind. Die Blätter entsprechen Regionen im
@R
P,((3#,'*Q#':3%&
S/&1%'5"2*T012/&#(34%"*#"*-%&*U/475(%&2&,I#CVN*<<*@WWR
Raum, die eine vollständige, disjunkte Aufteilung (Partionierung) der Ebene bzw. des Raums
darstellen. Jedes Blatt enthält ein Dreieck bzw. ein Fragment. Abbildung 2.9 zeigt ein Beispiel, in dem die Splittinggeraden durch die Geraden der Szene gelegt wurden, d.h. ein innerer
Knoten kodiert nicht nur die Region sondern speichert auf die Gerade. Alle übrigen Liniensegmente werden in den Blättern gespeichert. Man nennt diesen Vorgang auch Autopartition.
Es bezeichnet h- den linken und h+ den rechten Halbraum der Splittinggerade.
AlgoCG 09
10
F 1%2%"*@#&*G71#((#"22%&,-%"*-5&B3*H#"#%"%1%4%"(%:
1%2%" @#& G71#((#"22%&,-%" -5&B3 H#"#%"%1%4%"(%
F '7%#B3%&"*'#%*#"*#""%&%"*6"/(%":
F 5"-*'7%#B3%&"*&%'(1#B3%*H#"#%"%1%4%"(%*#"*E1)((%&"
5"- '7%#B3%&" &%'(1#B3% H#"#%"%1%4%"(% #" E1)((%&"
Kapitel 2. Trees
39
3;
39
3;
I,((3#,'*J#'B3%&
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,P#>Q:*GG*RSST
KL
Abbildung 2.9: Autopartition einer Menge von Geraden im 2D.
Es ist auch möglich, die Splittinggeraden unabhängig von den Objekten zu legen. Dieses
Verfahren ist jedoch komplizierter, da gute Geraden berechnet werden müssen, die eine kleine
Partitionierung erreichen ohne Dreiecke in Fragmente zu teilen.
2.2.2 Anwendungsbeispiel: Painter’s Algorithmus
Der Painter’s Algorithmus dient zum Zeichnen von Dreiecken. Der naive Algorithmus führt
eine Sortierung der Dreiecke nach ihrer Entfernung vom Betrachter durch (Tiefensortierung).
Anschließend zeichnet er (wie ein Maler) von hinten nach vorne das Bild. Es lassen sich
so jedoch keine zyklischen Überdeckungen auflösen. Diese bedingen, ein Dreieck in zwei
HEINZ NIXDORF INSTITUT
Fragmente zu teilen.
!"#$!%&'
!"#$%&'#()(*+,-%&./&"
zu traversieren und die Dreiecke so von
012/&#(34%"*5"-*6/471%8#()(
"#$"%&"'()$*(+*$,Die Lösung mit dem BSP besteht darin, den Baum
hinten nach vorne zu zeichnen. Der Vorteil gegenüber dem Painters Algorithmus besteht darin,
weiter Versuch dass
einerman
Lösung
nicht9+,#"(%&:'*012/&#(345';
für jeden Frame alle Dreiecke nach Tiefe sortieren muss. Hat man die Dreiecke
in den BSP einsortiert, weiß man für jeden Standpunkt, was vorne und was hinten ist.
=&,$%&'#%&% -%"einmal
=&,$%&'#%&%*-%"*>?+
>?+@>,54
>,54
Der Baum muss nur einmal im Preprocessing für die gesamte Szene aufgebaut werden.
A&%#%BC%*$/"*3#"(%"*",B3*$/&"%*D%#B3"%"
Es bezeichnet nun die Menge S(v) die Fragmente, die im Knoten des BSP-Baums gespeiE
EA&%#%BC%F*CG""%"*,5B3*H&,24%"(%*'%#"I*
2 zuvor ist Ivp der Standort des Betrachters, sowie T- der linke Teilbaum und T+
chert sind. Wie
-#%*$/4*>?+@>,54*2%(%#1(*J5&-%"
der rechte Teilbaum wie in Abbildung 2.10 dargestellt.
()*
=@
KL* H&,24%"(%I*-#%*#4*6"/(%"*-%'
>?+@>,54'*2%'7%#B3%&(*'#"-
+
KL ?(,"-/&(*-%'*>%(&,B3(%&'
KL*
?(,"-/&( -%' >%(&,B3(%&'
-.,$
KL 1#"C%&*.DJN*&%B3(%&*=%#1.,54
3@
3M
=M
$7
?9$;
Abbildung 2.10: Benennung der Elemente des BSP für den Painter’s Algorithmus.
R/&1%'5"2*S012/&#(34%"*#"*-%&*T/475(%&2&,U#CVI*??*WXXY
O,((3#,'*H#'B3%&
PQ
Der Painter’s Algorithmus ist in Algorithmus 4 aufgeführt.
AlgoCG 09
11
Kapitel 2. Trees
Algorithmus 4 Painter’s Algorithmus auf einem BSP-Baum
1: function PAINTERS(Tree T , ViewPoint vp)
2:
Sei v die Wurzel von T .
3:
if v ist Blattknoten then
4:
zeichne die Fragmente S(v) des Knotens v
5:
else
6:
if vp in h+ then
. 1. Fall
7:
Painters(T-, vp)
8:
Fragmente S(v) des Knotens v zeichnen
9:
Painters(T+, vp)
10:
else
11:
if vp in h- then
. 2. Fall, umgekehrt wie 1. Fall
12:
Painters(T+, vp)
13:
Fragmente S(v) des Knotens v zeichnen
14:
Painters(T-, vp)
15:
else
. 3. Fall
16:
Painters(T-, vp)
17:
Fragmente sind von dieser Seite unsichtbar.
18:
Painters(T+, vp)
19:
end if
20:
end if
21:
end if
22: end function
AlgoCG 09
12
Kapitel 2. Trees
Im ersten Fall liegt T- weiter hinten wie die Splittinggerade/-ebene. Da von hinten nach
vorne gezeichnet wird, wird somit zuerst T-, dann das Element im Knoten und zuletzt T+
gezeichnet. Im zweiten Fall liegt der Standort im T-, d.h. um von hinten nach vorne zu
zeichnen muss Fall 1 invertiert werden. Im 3. Fall ist der Standort weder im h+ noch im hder Splittinggerade, d.h. man befindet sich auf der Splittinggerade bzw. -ebene. Die Punkte
bzw. Dreiecke, die direkt auf der Splittinggerade/-ebene liegen sind somit nicht sichtbar.
2.2.3 Konstruktion - 2D
Im 2D Fall wird der BSP-Baum über eine Menge von Liniensegmenten aufgebaut. Eingabe
ist eine Menge von n Segmenten S = {s1 , . . . , sn }. Die Ausgabe ist ein BSP-Baum für S.
Als Splittinggerade wählen wir in jedem Schritt eine unendlich lange Gerade l(s) durch das
Segment s (Autopartition).
Das Vorgehen beschreibt Algorithmus 5.
Algorithmus 5 Aufbau eines BSP-Baums im 2D
1: function 2 D BSP(Segmente S)
2:
if |S| ≤ 1 then
3:
Erzeuge Baum T , der aus einem Blatt besteht, das S enthält.
HEINZ NIXDORF INSTITUT
4:
return T
!"#$%&'#()(*+,-%&./&"
5:
else
. Nehme erstes Segment s1
012/&#(34%"*5"-*6/471%8#()(
'+,-".,/*'
6:
Benutze l(s1 ) als Splittinggerade
7:
S + := {s ∩ l(s1 )+ |∀s ∈ S}; T + := 2dBSP(S + )
dBSP(S)
8:
S − := {s ∩ l(s1 )− |∀s ∈ S}; T − := 2dBSP(S − )
9:
Erzeuge BSP-Baum T mit Wurzel v, linkem Teilbaum T − und rechtem Teilbaum
2%*%#"%"*:,54*0;*-%&*,5'*%#"%4*:1,((*.%'(%3(;*-,'*1
%"(3)1(
+
T
.
0
10:
Speichere im Knoten v S(v) = {s ∈ S|s ⊂ l(s1 )}
%"5(9%"
%"5(9%"*23+
23+54 ,1'*=%&,-%*954*05>(%#1%"
,1'11:
=%&,-%
954
end if 05>(%#1%"?
12: end function
Abbildung 2.11 illustriert die einzelnen Variablen.
2%*%#"%"*:B+C:,54*0 4#(*6"/(%"*6
%" F%#1.,54 07
%"*F%#1.,54*0
3(%"*F%#1.,54*08
+
G3%&% #4 6"/(%" 6
G3%&%*#4*6"/(%"*6
3C
3H
0
23+4
3+4
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,>#EP;*BB*QRRS
AlgoCG 09
KL
I,((3#,'*J#'G3%&
Abbildung 2.11: Aufbau
eines 2D BSP-Baums.
13
Kapitel 2. Trees
2.2.3.1 Größe des BSP-Baums
Durch die Nutzung der Autopartition hängt die Größe des Baumes zum einen von der Reihenfolge der Segmentwahl ab und zum anderen von der Anzahl der aufgeteilten Segmente (je
weniger Segmente zerteilt werden, desto kleiner der Baum).
Definition 2.2.1 (Größe eines BSP-Baums)
Die Größe eines BSP-Baums bemisst sich in der Anzahl aller erzeugten Segmente.
Um einen möglichst kleinen Baum zu erzeugen, wäre eine Möglichkeit, in jedem Schritt
ein Segment zu wählen, dass möglichst wenige andere Segmente schneidet. Dieser Greedy
Ansatz kann große Bäume allerdings nicht verhindern und ist zudem rechenaufwändig. Man
wählt deshalb das Segment zufällig aus (zufällig kann gut sein, wenn die Auswahl schwer
fällt). Man kann nun die Eingabeliste S von Segmenten zuerst zufällig zu S 0 permutieren
und dann Algorithmus 5 unverändert auf der permutierten Liste ausführen. Alternativ kann
man den Algorithmus so verändern, dass in jedem Schritt ein zufälliges Element aus der Liste
genommen wird und nicht immer das erste.
Lemma 2.2.1
Die erwartete Anzahl von Fragmenten, die der Algorithmus 2dRandomBSP(S) berechnet, ist
O(n log n).
Beweis 2.2.1
Bei n Fragmenten gibt es n! viele Permutationen.
HEINZ NIXDORFWähle
INSTITUTsi beliebig aber fest. Analysiere
!%&'
!"#$%&'#()(*+,-%&./&"
nun die erwartete Anzahl von Segmenten, die
von si geschnitten werden, wenn l(si ) als Split012/&#(34%"*5"-*6/471%8#()(
"&"'(&)*'+,-".,/*'
tingsegment gewählt wird wie in Abbildung 2.12 dargestellt.
ein festes Segment !
+0
",1:'#%&%"*
",1:'#%&%"
#%*%&<,&(%(%*0"=,31*$/"*>%24%"(%"?*-#%*
%'@3"#((%"*<%&-%"?
<%""*12+/3 ,1'*>71#((#"2'%24%"(*2%<)31(*<#&-
A
Fragen:
+/
9#%*$#%1%*>%24%"(%*1#%2%"*D$/&E*+/
9,""*<#&-*%#"*>%24%"(*+0 ?*-,''*D$/&E*+/ 1#%2(?*
%'@3"#((%"A
12+/3
Abbildung 2.12: Anzahl zerteilter Segmente bei Wahl von si .
1. Wie viele Segmente liegen „vor“ si ?
Wir definieren zunächst die Distanz eines Segmentes sj zu einem Segment si :
K/&1%'5"2*L012/&#(34%"*#"*-%&*M/475(%&2&,N#OP?*>>*FQQR
G,((3#,'*H#'@3%&
IJ
dist(sj ) := Anzahl Segmente, die l(si ) zwischen si und sj schneiden.
Im Beispiel ist dist(sj ) = 2.
AlgoCG 09
14
Kapitel 2. Trees
2. Wann wird ein Segment sj , dass „vor“ si liegt, tatsächlich geschnitten?
Ein Segment s „schützt“ ein anderes Segment sj , wenn es vor dem Element si als Splittingsegment gewählt wurde. Das Segment sj wird dann nicht geschnitten. Abbildung
2.13 gibt ein Beispiel.
Abbildung 2.13: Ein Splittingsegment schützt ein anderes Segment.
In (a) wird s3 nicht von s2 geschützt, da beide zuvor durch s1 geteilt wurden. In (b) wird
s3 durch s1 geschützt, wenn s2 als Splittingsegment gewählt wird.
3. Wie hoch ist die Wahrscheinlichkeit, dass l(si ) das Segment sj schneidet, wenn si als
Splittingelement gewählt wird?
Es wird nur dann geschnitten, wenn kein Element sk , das sj schützen würde, vorher
gewählt wird. Sei nun k := dist(sj ) und seien sj1 , sj2 , . . . , sjk die Segmente zwischen si
und sj . si muss nun als erstes gewählt werden, da sj sonst geschützt würde. Somit hat
es den kleinsten Index in S. Für die Wahrscheinlichkeit folgt damit:
P r(„l(si ) schneidet sj “) ≤
1
dist(sj ) + 2
dist(sj ) ist die Anzahl der Elemente zwischen si und sj , die 2 sind si und sj selbst.
Wenn keine Elemente zwischen si und sj liegen, beträgt die Wahrscheinlichkeit 21 , da si
nur dann schneidet, wenn es vor sj liegt. Mit jedem Element dazwischen verringert sich
die Wahrscheinlichkeit, dass sj geteilt wird, da die Wahrscheinlichkeit, dass sj geschützt
wird, immer größer wird.
Für ein Segment s ergibt sich die erwartete Anzahl von Schnitten, die s erzeugt, wie
folgt:
P
1
E(„Anzahl der Schnitte erzeugt durch s“) ≤
s0 6=s dists (s0 )+2
P
n−2 1
≤ 2 i=0
i+2
≤ 2 ln n
Es wird die Summe über die Wahrscheinlichkeit eines Schnitts für alle Segmente s0 berechnet. Je nachdem welche Position si in der Permutation einnimmt variiert die Anzahl der möglichen Schnitte, die si vornehmen kann, zwischen 0 und n − 2. Man kann
also auch über alle möglichen Distanzen aufsummieren, da jede mögliche Distanz für
jede Richtung höchstens einmal auftauchen kann. Dabei summiert man in beide Richtungen auf, d.h. links und rechts des betrachteten Segments. Dies ist möglich, da hier
AlgoCG 09
15
Kapitel 2. Trees
nur eine Abschätzung nach oben betrachtet wird. Die entstehende Summe ist eine harmonische Reihe, die nach oben näherungsweise mit ln(n) plus einer kleinen Konstanten
abgeschätzt werden kann.
Die Anzahl der Schnitte für n Elemente fügt zu diesem Wert noch einen Faktor n hinzu,
so dass die gesamte Anzahl von möglichen Schnitten 2n ln(n) beträgt. Zusammen mit
den n als Eingabe gegebenen Segmenten ergibt sich eine erwartete Größe von n +
2n ln(n) = O(n log n) Segmenten für den BSP-Baum.
Es ist wichtig zu beachten, dass es sich hierbei nur um einen Erwartungswert handelt, der
über die Wahrscheinlichkeit eines Schnitts gebildet wird. Es kann somit auch BSP Bäume
geben, in denen eine höhere Anzahl von Segmentierungen passiert.
2.2.3.2 Laufzeit des Konstruktionsalgorithmus
Die Laufzeit für die Konstruktion des BSP-Baums hängt von seiner Größe ab. Die Aufteilung
in S + und S − kostet Zeit O(n), da nie mehr als n Fragemente bei der Aufteilung entstehen
können Die Anzahl der rekursiven Aufrufe ist gleich der Anzahl
der erzeugten Fragmente.
HEINZ NIXDORF INSTITUT
!"#$!%&'
!"#$%&'#()(*+,-%&./&"
Somit ergibt sich zusammen mit der zuvor berechneten erwarteten
Größe des BSP-Baums die
012/&#(34%"*5"-*6/471%8#()(
!"#$!%&'()'(*+(,%&' 2
erwartete Laufzeit O(n log n).
9#%*.%&%:3"%"*;#&*%#"%"*<=+><,54*?@&*A&%#%:B%*C+/1D2/"%E*F
2.2.4 Konstruktion - 3D
Die
besteht hier aus Polygonen (Dreiecken). Für ein Dreieck t beschreibt nun h(t)
=%#*-Eingabe
%#"*A&%#%:BG
./-0Ebene
HI*#'(*-#%*J.%"%G*#"*-%&*-,'*A&%#%:B*die
in der das Dreieck liegt wie in1#%2(
Abbildung 2.14 dargestellt.
3K
-
3>
./-0
L-%%H
Abbildung 2.14: Polygone als Splittingebenen im 3D.
M ;#&*"%34%"*",:3%#","-%&*-#%*A&%#%:B%*N54*05?(%#1%"*-%'*OA>P,54%'
MAnalog
Q%-%'*A&%#%:B*-%?#"#%&(*%#"%*=71#((#"2%.%"%*-%'*<=+><,54'
zu den Geraden im 2D werden nun die Ebenen der Polygone zur Aufteilung des
Raums
verwendet. Jedes Dreieck definiert eine Splittingebene,5"-*.1
die den Raum in zwei HalbM -#%*=71#((#"2%.%"%*(%#1(*-%"*<=+><,54*#"*N;%#*\,1.&)54%*.$
räume h+ und h− aufteilt. Der Algorithmus ist damit sehr ähnlich zum 2D Fall wie AlgorithTU
R,((3#,'*S#':3%&
mus 6 zeigt.
Für den Aufbau kann dieselbe Autopartionsvorschrift kombiniert mit Randomisierung verwendet werden, wie im 2D. Die Analyse der Größe eines 3D BSP-Baums ist bislang unbekannt. Für die weiteren Betrachtungen definieren wir zunächst Free-Splits.
V/&1%'5"2*W012/&#(34%"*#"*-%&*X/475(%&2&,?#BYG*==*ZUU[
Definition 2.2.2 (Free-Split)
Ein Dreieck (Liniensegment), das eine Zelle (Region) in zwei nicht zusammenhängende Teile
aufteilt ist ein Free-Split.
AlgoCG 09
16
Kapitel 2. Trees
Algorithmus 6 Aufbau eines BSP-Baums im 3D
1: function 3 D BSP(Segmente S)
2:
if |S| ≤ 1 then
3:
Erzeuge Baum T , der aus einem Blatt besteht, das S enthält.
4:
return T
5:
else
. Nehme erstes Dreieck t1
6:
Benutze h(t1 ) als Splittingebene
7:
S + := {t ∩ h(t1 )+ |∀t ∈ S}; T + := 3dBSP(S + )
8:
S − := {t ∩ h(t1 )− |∀t ∈ S}; T − := 3dBSP(S − )
−NIXDORF INSTITUT
!"#$!%&'
9:
Erzeuge BSP-Baum T mit Wurzel v, linkem TeilbaumHEINZ
T !"#$%&'#()(*+,-%&./&"
und rechtem Teilbaum
+
012/&#(34%"*5"-*6/471%8#()(
T !"#$!%&'()'(*+(,%&'
.
10:
Speichere im Knoten v S(v) = {t ∈ S|t ⊂ h(t1 )}
Definition:
11:
end if -.//$"01)2
12: end function
9#"*:&%#%;<*=>#"#%"'%24%"(?@*-,'*%#"%*A%11%*=B%2#/"?*#"*CD%#*
"#;3(*C5',44%"3)"2%"-%*E%#1%*,5F(%#1(
Abbildung 2.15 zeigt ein Beispiel für 2D und 3D. Ein Free-Split schneidet die Begrenzung
der Region auf allen Seiten. [TODO:Wieso ist das nicht zusammenhängend?]
F
F&%%*'71#((
1#((
K/&1%'5"2*L012/&#(34%"*#"*-%&*M/475(%&2&,F#<N@*OO*PQQR
G,((3#,'*H#';3%&
IJ
Abbildung 2.15: Beispiele für Free-Splits.
Eine Erweiterung des Algorithmus besteht nun darin, dass man immer einen Free-Split
durchführt, wenn dies möglich ist, und ansonsten ein zufälliges Dreieck als Splittingebene
auswählt. Ein weiterer Unterschied ist, dass alle möglichen (sinnvollen) Teilungen ausgeführt
werden, d.h. h(ti ) wird zum Schnitt aller Zellen verwendet, die es schneiden kann. Bislang
wurde immer nur eine Zelle geschnitten. [TODO:Das ist jetzt wirklich nicht mehr zusammenhängend, aber nicht spezifisch für den Free-Split, oder?]
Dieses Vorgehen kann jetzt nicht mehr rekursiv formuliert werden. Algorithmus 7 fasst das
iterative Vorgehen zusammen.
Die Unterschiede in der Arbeitsweise zeigt Abbildung 2.16.
Es lässt sich nun zeigen, dass für den angegebenen Algorithmus unter Verwendung aller
möglichen Free-Splits die erwartete Anzahl von Fragmenten O(n2 ) ist. Eine Analyse ohne
Free-Splits ist unbekannt. Das folgende Lemma zeigt, dass diese Grenze hart ist.
AlgoCG 09
17
Kapitel 2. Trees
Algorithmus 7 Iterativer Aufbau eines BSP-Baums im 3D mit Free-Splits
1: function 3 D R ANDOM F REE S PLIT BSP(Segmente S)
2:
Erzeuge zufällige Permutation S 0 = t1 , . . . , tn
3:
for i := 1 to n do
4:
Verwende h(ti ) zur Teilung aller Zellen, die h(ti ) schneiden (nur sinnvolle Teilungen)
HEINZ NIXDORF INSTITUT
!"#$!%&'
5:
Verwende alle möglichen Free-Splits
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
6:
end!"#$!%&'()'(*+(,%&'
for
7: end function
!"(%&'93#%-1#93%*0&.%#(':%#'%;
&%<5&'#$%& 012/&#(345'
&%<5&'#$%&*012/&#(345'
#(%&,(#$%& 012/&#(345'
#(%&,(#$%&*012/&#(345'
-/
-.
-*
-.
-/
-*
Abbildung 2.16: Unterschiede in der Arbeitsweise zwischen rekursivem und iterativem
Algorithmus.
=,"*<,""*>%#2%";
K#%*%&:,&(%(%*0">,31*$/"*?&,24%"(%"*#'(*DL&*-%"*&,"-/4#'#%&(%"*012/&#(345'*
Lemma 2.2.2
3dRandomFreeSplitBSP(S) 4#(*?&%%MG71#(*012/3
Es gibt Mengen von n sich nicht überschneidenden Dreiecken im 3D-Raum,
für die jede
Auto@@
=,((3#,'*?#'93%&
2
matische Aufteilung (Autopartition) Ω(n ) Fragmente hat.
A/&1%'5"2*B012/&#(34%"*#"*-%&*C/475(%&2&,D#<EF*GG*HIIJ
Beweis 2.2.2
Wir ordnen eine Menge R1 von n1 Rechtecken parallel zur xy-Ebene und eine Menge R2 von
n2 Rechtecken parallel zur yz-Ebene an (für Dreiecke ebenso möglich) wie in Abbildung 2.17
dargestellt.
Sei nun G(n1 , n2 ) die minimale Größe einer automatischen Aufteilung. Der Beweis erfolgt
durch Induktion über n1 + n2 .
Behauptung: G(n1 , n2 ) = (n1 + 1)(n2 + 1) − 1
Anfang: G(1, 0) = 1, G(0, 1) = 1
Schritt: n1 + n2 > 1
O.B.d.A. wählt die automatische Aufteilung ein Rechteck r aus R1 als Splittingebene.
Dies teilt alle Rechtecke aus R2 . Die entstehenden Teilszenen sehen alle so aus, wie
die Ausgangssituation. Sei nun m die Anzahl der Dreiecke von R1 , die oberhalb von r
liegen. Dann gilt:
G(n1 , n2 ) = 1 + G(m, n2 ) + G(n1 − m − 1, n2 )
= 1 + ((m + 1)(n2 + 1) − 1) + ((n1 − m)(n2 + 1) − 1)
= (n1 + 1)(n2 + 1) − 1
AlgoCG 09
18
Kapitel 2. Trees
Abbildung 2.17: Nachweis einer unteren Schranke für die Anzahl von Fragmenten.
Man kann aber auch zeigen, dass für jede Menge von n sich nicht überschneidenden Dreiecken ein BSP der Größe O(n2 ) existiert.
2.3 Quadtrees und Octrees
Quadtrees und Octrees sind Datenstrukturen, um eine räumliche Sortierung und Bereichsanfragen durchzuführen. Sie werden z.B. bei der Finite Elemente Methode, bei der Berechnung
von Meshes und bei der Verdeckungsberechnung eingesetzt.
Quadtrees werden im 2D eingesetzt. Jeder Knoten entspricht einem Quadrat. Ein innerer
Knoten hat vier Kinder, die einer Aufteilung HEINZ
des Quadrats
vier gleichgroße Quadrate entNIXDORFin
INSTITUT
+%&''(
!"#$%&'#()(*+,-%&./&"
sprechen. Die Quadrate sind entsprechend der Himmelsrichtungen mit NW, NE, SW, SE be012/&#(34%"*5"-*6/471%8#()(
"-.%/'-0'- zeichnet. Alle Quadrate auf einer Ebene des Baums
sind gleich groß. Abbildung 2.18 zeigt
ein Beispiel.
;=
/",1
;<
(%"*@/&&%'7/"-#%&(*4#(*
,-&,(
/(%"*3,.%"*$#%&*6#"-%&
,(%*#"*-%&'%1.%"*<.%"%*
*2&/C
C
D=
D<
Abbildung 2.18: Aufbau eines Quadtrees.
Octrees sind eine analoge Datenstruktur im 3D Raum. Dabei wird ein Würfel in acht gleich
große Würfel unterteilt, so dass jeder Knoten 8 Kinder besitzt. Alle Würfel auf einer Ebene
des Baums sind gleich groß. Abbildung 2.19 zeigt ein Beispiel.
/",1
Die Unterteilung kann so lange fortgesetzt werden, bis entweder eine maximale Tiefe erreicht
(%"
(%"*@/&&%'7/"-#%&(*4#(*
@/&&%'7/"-#%&( wurde
4#( oder bis in einer Box maximal c Elemente enthalten sind. Die Elemente selbst
&H%1
/(%"*3,.%"*,E3(*6#"-%&
AlgoCG 09
19
1*#"*-%&'%1.%"*<.%"%*'#"-*
C
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,H#@PQ*DD*:RRS
I,((3#,'*J#'E3%&
KL
,-&,(%*#"*-%&'%1.%"*<.%"%*
%#E3*2&/C
# 3
C
D=
Kapitel 2. Trees
"'#/",1
6"/(%"
6"/(%"*@/&&%'7/"-#%&(*4#(*
@/&&%'7/"-#%&( 4#(
=G&H%1
6"/(%"*3,.%"*,E3(*6#"-%&
G&H%1*#"*-%&'%1.%"*<.%"%*'#"-*
2&/C
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,H#@PQ*DD*:RRS
Abbildung 2.19: Aufbau
eines Octrees.
I,((3#,'*J#'E3%&
KL
werden in den Blättern gespeichert, bei Speicherung von Dreiecken je nach Implementierung
auch in inneren Knoten. Die Elemente sind damit in der Box, in der sie enthalten sind, gespeichert.
!"#$%&''()*+%&''(
!"#$%&#'()*+,-)+.'#$#%/#)
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
2.3.1 Speichern von Elementen
Praktikable Lösungsansätze
Die Eingabe ist eine Menge von Punkten bzw. Dreiecken. Im Fall von Punkten wird jeder
9 +/1:2/"*,5;(%#1%"
+/1:2/" ,5;(%#1%"
Punkt in genau einem
Quadrat gespeichert, das ein Blatt des Quadtrees ist. Jedes Blatt enthält
!*+/1:2/","<,31*%&3=3(*'#>3
maximal k Punkte. Durch die exakte Aufteilung enthalten innere Knoten nur die geometri9 +/1:2/"*&%-5"-,"(*'7%#>3%&"
schen Informationen
des Quadrats, aber keine Punkte.
!*?%&@,1(5"2',5;@,"-A*-,*"5&*B8*<%#>3"%"*'#""$/11
Das Speichern von Polygonen (Dreiecken) führt häufig dazu, dass Dreiecke die Begren9 +/1:2/"*#"*-%4*6"/(%"*'7%#>3%&"A*;C&*-%"*'#%*"/>3*"#>3(*5"(%&(%#1(*@%&-%"*
zungslinien bzw. 4C''%"
-flächen schneiden. Es gibt drei Möglichkeiten, damit umzugehen, die in
Abbildung 2.20 dargestellt
sind.
!*?#%1%*+/1:2/"%*1#%2%"*3=3%&*#4*D,54A*,1'*%'*#3&%&*E&=F%*%"('7&#>3(
G,((3#,'*H#'>3%&
Abbildung 2.20: Speicherung von Dreiecken in einem Quadtree.
?/&1%'5"2*K012/&#(34%"*#"*-%&*L/475(%&2&,;#MNA*OO*PQQR
IJ
Die erste Variante besteht darin, dass Polygon entlang der Begrenzungslinien in mehrere
Polygone aufzuteilen. Dadurch erhöht sich allerdings die Anzahl der Polygone. Die zweite
Möglichkeit ist, dass Dreieck in jedem Quadrat zu speichern, in dem es enthalten ist. Diese
Redundanz führt jedoch zu zusätzlichem Aufwand beim Zeichnen, da das Dreieck obwohl
mehrfach gespeichert nur einmal gezeichnet werden soll. Die dritte Möglichkeit besteht darin,
das Polygon in einem Knoten zu speichern, für den es nicht unterteilt werden muss. Damit
können auch innere Knoten Dreiecke enthalten. Es passiert so jedoch häufig, dass Dreiecke
weiter oben im Baum liegen, als dies ihrer Größe entspricht. Eine weitere Möglichkeit sind
die in Abschnitt 2.4 beschriebenen Loose Octrees, bei denen die Ebene nur von der Größe
AlgoCG 09
20
Kapitel 2. Trees
des Elements abhängt. Hier entscheidet der Mittelpunkt des Polygons darüber, in welchem
Knoten ein Objekt liegt.
Quadtrees und Octrees sind insbesondere für dynamische Daten geeignet. Durch die dynamische Unterteilung der Quadrate/Würfel können Polygone beliebig ungünstig positioniert
sein, da die Struktur nur bedingt von der Dichte der Objekte abhängig ist.
2.3.2 Aufbau
Der Aufbau eines Quadtrees beginnt mit einem Quadrat, das alle Punkte enthält (BoundingBox von allen Punkten). Dieses Quadrat wird dann in vier gleich große Teile zerteilt und die
Punkte werden aufgeteilt. Punkte, die auf der Trennlinie liegen, werden im dem linken bzw.
unteren Quadrat zugeordnet. Man unterteilt solange, bis maximal k Punkte enthalten sind oder
eine maximale Tiefe erreicht wurde. Algorithmus 8 stellt die Konstruktion für k = 1 dar. Der
Wert für k ist für die Laufzeit entscheidend und liegt deshalb in praktischen Anwendungen in
der Regel über 1.
Algorithmus 8 Aufbau eines Quadtrees
1: function BUILD Q UADTREE(Punkte P )
2:
σ := [xσ : x0σ ] × [yσ : yσ0 ] ist das oberste Quadrat für Punktemenge P
3:
if |P | ≤ 1 then
4:
Erstelle einen Knoten, der σ und P speichert und gibt diesen zurück.
5:
else
. |P | > 1
6:
Es sind σN E , σN W , σ0SE und σSW die vier0 Quadranten von σ.
σ)
σ)
7:
Es gilt xmid := (xσ +x
und ymid := (yσ +y
2
2
8:
PN E := {p ∈ P |px > xmid ∧ py > ymid }
. Berechnung der Punktemengen
9:
PN W := {p ∈ P |px ≤ xmid ∧ py > ymid }
10:
PSE := {p ∈ P |px > xmid ∧ py ≤ ymid }
11:
PSW := {p ∈ P |px ≤ xmid ∧ py ≤ ymid }
12:
Erstelle Knoten v, in dem σ gespeichert ist, die Kinder des Knotens sind PN E ,
PN W , PSE und PSW .
13:
end if
14: end function
2.3.2.1 Tiefe des Quadtrees
Die Größe und Tiefe eines Quadtrees ist nicht über die Anzahl der Punkte beschränkt, da
immer nur in Einheiten fester Größe aufgeteilt wird. Die Tiefe entspricht der Anzahl der
Aufteilungsschritte. Diese ist wiederum abhängig von der Größe s des äußersten Quadrats
und vom geringsten Abstand c zwischen zwei benachbarten Punkten.
Lemma 2.3.1
Die Tiefe eines Quadtrees für eine Punktemenge P in der Ebene ist höchstens log( sc ) + 32 .
AlgoCG 09
21
Kapitel 2. Trees
Beweis 2.3.1
Die Tiefe eines Quadrates in Tiefe i ist 2si wie in Abbildung 2.21 dargestellt. Die maximale mögliche Entfernung zweier Punkte
√ in einem Quadrat dieser Seitenlänge ist entlang
der Hauptdiagonalen und beträgt somit 2 · 2si .
Abbildung 2.21: Größe von Qudraten in Ebene i in einem Quadtree.
Jedes innere Quadrat umfasst mindestens zwei Punkte, die mindestens c voneinander entfernt sind. Für jedes Quadrat auf Tiefe i gilt damit:
√ s
s
1
2 · i ≥ c ⇒ i ≤ log( ) +
2
c
2
Da die Tiefe des Baums aufgrund der Blätter noch um eins Tiefer ist als die maximale Tiefe
eines inneren Knotens, ergibt sich die Schranke.
2.3.2.2 Größe eines Quadtrees
Die Größe des Quadtree ist abhängig von der Tiefe. Durch eine ungeschickte Anordnung von
Punkten kann der Quadtree sehr unbalanciert sein.
Lemma 2.3.2
Ein Quadtree mit n Punkten und Tiefe d hat
1. O((d + 1)n) Knoten und kann in
2. Zeit O((d + 1)n) aufgebaut werden.
Beweis 2.3.2
1. Jeder innere Knoten hat vier Kinder. Damit erhält man die Anzahl der Blätter als 3 ×
Anzahl innerer Knoten + 11 . Jeder innere Knoten umfasst mindestens einen Punkt (in
seinem Quadrat). Die Knoten auf einer Ebene sind aber alle disjunkt und überdecken
alle Knoten. Daraus folgt direkt, dass die Anzahl der inneren Knoten auf einer Ebene
nicht größer als O(n) sein kann. Da dies für alle Ebenen gilt, folgt dass der Baum
O((d + 1)n) Knoten besitzt.
2. In jedem inneren Knoten werden die Punkte auf die vier Kinder verteilt. Dies benötigt
lineare Zeit in Abhängigkeit von der Anzahl der Punkte in jedem Quadrat. Damit kostet
der Aufbau O((d + 1)n) für alle Level.
1
Für einen Binärbaum mit Tiefe d erhält man entsprechend 2d Blätter und 1 × 2d − 1 innere Knoten.
AlgoCG 09
22
%&''(
-%%
dtree
Kapitel 2. Trees
2.3.3 Suche im Quadtree
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Gegeben ist ein Knoten v des Quadtrees und gesucht wird sein nördlicher Nachbar
N ordN achbar(v, T ). Die Idee, diesen zu finden, besteht darin, bis zu einem gemeinsamen
Vorgänger von v und N ordN achbar(v, T ) im Baum hochzugehen. Dieses Vorgehen ist in
Abbildung 2.22 dargestellt. Die farbige Umrandung kennzeichnet jeweils den gemeinsamen
Vorfahren. Die Pfeile kennzeichnen den Knoten bzw. den Nachbarn, die auch einheitlich
farblich gekennzeichnet sind.
"
"*6"/(%"*.
6"/(%" . #4*:5,-(&%%*5"-*
#4 :5,-(&%% 5""=&-1#;3%">*?,;3.,&"*
23
/ +/ $0 1 23
/4-+/*#$0*-1.523
&%%*3/;3*.#'*B5*%#"%4*6"/(%"C*-%&*
3 3 .#
#
6 (
/&A,3&%*$/"*. 5"-*
23 #'(
6"/(%"*.
E,((3#,'*F#';3%&
D/&1%'5"2*H012/&#(34%"*#"*-%&*I/475(%&2&,A#JKC*LL*MNNO
GG
Abbildung 2.22: Nordnachbar eines Knotens v.
Der Algorithmus zur Berechnung des N ordN achbar(v, T ) ist in Algorithmus 9 angegeben.
Die verwendeten Variablen sind in Abbildung 2.23 illustriert.
Satz 2.3.1
Der Nachbar eines Knotens v im Quadtree der Tiefe d wird in Zeit O(d + 1) gefunden.
Man läuft solange in der Hierarchie hoch, bis man einen gemeinsamen Vorfahren gefunden
hat. Dabei kann man maximal bis zur Wurzel hochlaufen und auf der Wurzel nochmal rekursiv
aufrufen. Bei einer maximalen Tiefe d ergibt sich somit die Laufzeit.
2.3.4 Balancierte Quadtrees
Eine ungünstige Anordnung der Punkte kann dazu führen, dass in einem Quadtree ein großes
Quadrat sehr viele kleine Nachbarn besitzt, wie dies in Abbildung 2.24 dargestellt ist.
Definition 2.3.1 (Balancierter Quadtree)
Ein Quadtree ist balanciert, wenn sich zwei benachbarte Quadrate in der Seitenlänge höchstens um einen Faktor zwei unterscheiden.
AlgoCG 09
23
&''(
%%
Kapitel 2. Trees
Algorithmus 9 Berechnung der nördlichen Nachbarn eines Knotens
1: function N ORD NACHBAR(Knoten v, Quadtree T )
2:
if v = root(T ) then
3:
return nil
4:
end if
5:
if v = SW-Kind von Eltern(v) then
6:
return NW-Kind von Eltern(v)
7:
end if
8:
if v = SE-Kind von Eltern(v) then
9:
return NE-Kind von Eltern(v)
10:
end if
11:
µ = NordNachbar(Eltern(v, T ))
12:
if µ = nil oder µ ist Blatt then
13:
return µ
14:
else
15:
if v = NW-Kind von Eltern(v) then
16:
return SW-Kind von µ
17:
else
18:
return SE-Kind von µ
19:
end if
20:
end if
HEINZ NIXDORF INSTITUT
21: end function
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
/(%"*. #"*%#"%4*:5,-(&%%*/
%&*6"/(%"*.0 -%''%"*;#%<%*3=>3'(%"'*'/*(#%<*
*'/-,''*!1.02 A/&-A,>3.,&*$/"*!1.2 #'(D*E,11'*
2#.(C*2#.*"#1*,5'
? @*A/&-A,>3.,&
$/"*34,%-51.2
,#+./#&01234
%"*&%(5&"*"#1
$/"*34,%-51.2 (3%"*&%(5&"*AKL6#"-*$/"*34,%-51.2
!1.2
$/"*34,%-51.2 (3%"*&%(5&"*A9L6#"-*$/"*34,%-51.2
$9*-134,%-51.2 /2
$9*-134,%-51.2:&/2
'(*%#"*Q1,((*
"*?
AKL6#"-*$/"*34,%-51.2
AK 6#"- $/" 34,%-51.2
"*&%(5&"*JKL6#"-*$/"*?
*&%(5&"*J9L6#"-*$/"*?
!;<='5+
34,%-51.2
!3<='5+
Abbildung 2.23: Suche des Nordnachbarn zu einem Knoten v.
"/(%"'*. #4*:5,-(&%%*-%&*;#%<%*+ B#&-*#"*[%#(*>1+?@2 2%<5"-%"
1%'5"2*V012/&#(34%"*#"*-%&*W/475(%&2&,<#FXC*JJ*IYYZ
AlgoCG 09
R,((3#,'*E#'>3%&
ST
24
9 B,'*$%&'(%3%"*C#&*5"(%&*%#"%&*D,1,"A%E
9 B#%*C#&-*%#"%*D,1,"A%*=/"'(&5#%&(E*
Kapitel 2. Trees
3,(*$#%1%*=1%#"%*@,A3.,&"
!"#$%&''()*+%&''(
!"#"$%&'()$*
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
Abbildung 2.24: Unbalancierter Quadtree. 012/&#(34%"*5"-*6/471%8#()(
Definition
J/&1%'5"2*K012/&#(34%"*#"*-%&*L/475(%&2&,M#=NO*??*PQQI
Das bedeutet,
die Nachbarn
eines Quadrates sind höchstens eine Ebene im BaumF,((3#,'*G#'A3%&
höher oder
9#" :5,-(&%% #'( +"#"$%&'(, ;%"" '#<3 =;%# .%",<3.,&(% :5,-&,(%
9#"*:5,-(&%%*#'(*+"#"$%&'(,>*;%""*'#<3*=;%#*.%",<3.,&(%*:5,-&,(%*
tiefer. Abbildung
2.25
zeigt
ein
Beispiel.
#"*-%&*?%#(%"1)"2%*3@<3'(%"'*54*%#"%"*A,B(/&*=;%#*5"(%&'<3%#-%"C
G/&1%'5"2*H012/&#(34%"*#"*-%&*I/475(%&2&,J#BK>*??*LFFM
D,((3#,'*A#'<3%&
EF
Abbildung 2.25: Balancierter Quadtree.
Das Vorgehen zum Aufbau eines balancierten Quadtrees besteht darin, zunächst einen unbalancierten Quadtree aufzubauen und dann alle unbalancierten Blätter solange aufzuteilen,
bis der Baum balanciert ist. Die Details zeigt Algorithmus 10.
Die Aufteilung eines Knotens kann dazu führen, dass jetzt auch ein Nachbarn aufgeteilt
werden muss, obwohl dies vor der Aufteilung nicht notwendig gewesen wäre. Zur Überprüfung, ob ein Knoten aufgeteilt werden muss, kann man den Algorithmus N ordN achbar(v, T )
benutzen.
Ein Knoten v hat einen unbalancierten Nordnachbarn, wenn der Nordnachbar von v ein SWoder SE-Kind hat, dass kein Blatt ist. Diese Situation ist in Abbildung 2.26(a) dargestellt.
Nach dem Aufteilen eines Knotens v muss der Nordnachbar von σ(v) dann aufgeteilt werden, wenn der Nordnachbar vor dem Split schon größer ist als σ(v). In diesem Fall liegen
nach dem Split zwei Baumebenen zwischen den Knoten. Dies zeigt Abbildung 2.26(b)
Satz 2.3.2
Sei T ein Quadtree mit m Knoten. Die balancierte Version T ∗ von T hat O(m) Knoten.
AlgoCG 09
25
HI
Kapitel 2. Trees
Algorithmus 10 Balancieren eines Quadtrees
1: function BALANCE Q UADTREE(Knoten v, Quadtree T )
2:
Füge alle Blätter in eine lineare Liste L.
3:
while L ist nicht leer do
4:
Entferne ein Blatt v aus L HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
5:
if σ(v) muss aufgeteilt werden then
012/&#(34%"*5"-*6/471%8#()(
6:
Ersetze Blatt v als internen Knoten mit vier Kindern
7:
Falls v einen Punkt enthält, füge ihn in das entsprechende Blatt ein
8:
alle vier Kinder von v in L ein.
att aufgeteilt
werdenFüge
muss?
9:
Prüfe ob σ(v) jetzt Nachbarn enthält, die aufzuteilen sind und füge diese in L
ein.
&#(345'
&#(345'*:5&*;,<3.,&'5<3%*
:5& ;,<3.,&'5<3%
10:
end if
11:
end while
12: end function
-",<3.,&"*:5*%#"%4*6"/(%"*1>*9%""*
"*?@A /-%&*?=A6#"-*3,(>*-,''*B%#"*
!014
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
rden muss?
einem Split
p von , die Nachbarn von
.,&'5<3%
.,&'5<3%*
üssen?
&#(345'*:5&*;,<3.,&'5<3%*
%4*6"/(%"*1>*9%""*
"-*3,(>*-,''*B%#"*
(%"*;/&-",<3.,&"*:5*%#"%4*6"/(%"*1>*
!014
&DE%&*#'(*,1'*!014
(a)
*#"*-%&*L/475(%&2&,M#BN>*??*OPPQ
, die Nachbarn
von
Abbildung
2.26: Unbalancierte
!014
0 4
(b)
F,((3#,'*G#'<3%&
HI
Quadtree Situationen. In (a) ist die Ausgangssituation unbalanciert, in (b) entsteht die unbalancierte Situation durch Aufteilung von
σ(v).
.,&'5<3%*
"*:5*%#"%4*6"/(%"*1>*
AlgoCG 09
!014
0 4
F,((3#,'*G#'<3%&
26
HI
Kapitel 2. Trees
Zum Beweis zeigen wir, dass nur O(m) Aufteilungen notwendig sind, um T zu balancieren.
Daraus folgt dann automatisch die Größe von T . Vorher muss folgendes Lemma gezeigt
werden.
Lemma 2.3.3
Seien v1 , v2 , v3 drei benachbarte Knoten auf gleicher Tiefe, wobei v2 , v3 Blätter in T sind. Für
jede beliebige Unterteilung von σ(v1 ) bewirken die balancierenden Aufteilungen durch den
Algorithmus in σ(v2 ) keine Aufteilung in σ(v3 ).
Das bedeutet, wenn der Nachbar eines Knotens v1 unbalanciert ist, dann wirkt sind die Balancierung des Knotens nur auf den direkten Nachbarn aus, aber nicht transitiv auf Nachbarn
des Nachbarn. Damit lässt sich zeigen, dass Balancierungen nur lokal vorgenommen werden
müssen. Abbildung 2.27 illustriert die Ausgangssituation.
Abbildung 2.27: Balancierung eines Quadtree.
Beweis 2.3.3
Der Beweis des Lemmas erfolgt per Induktion über die Tiefe d des Teilbaums unter v1 .
Anfang: Für d = 1 hat σ(v1 ) eine Unterteilung, σ(v2 ) und σ(v3 ) werden nicht unterteilt.
Schritt: Habe jetzt v1 Tiefe d > 1.
– Nach Voraussetzung verursacht die Balancierung im SW-Quadrat von σ(v2 ) (notwendig wegen kleiner SE-Quadrate in σ(v1 )) keine Aufteilung im SE-Quadrat von
σ(v2 ). Dies zeigt Abbildung 2.28.
– Das gleiche gilt nach Voraussetzung auch für das NE-Quadrat von σ(v2 ) bei einer
Balancierung im NE-Quadrat von σ(v1 ).
– ⇒ NE und SE in σ(v2 ) werden nicht aufgeteilt.
– ⇒ σ(v3 ) braucht nicht aufgeteilt zu werden.
Mit dem Lemma kann nun auch Satz 2.3.2 bewiesen werden.
AlgoCG 09
27
Kapitel 2. Trees
Abbildung 2.28: Auswirkung der Balancierung eines SE-Quadrats.
Abbildung 2.29: Auswirkung der Balancierung eines Quadrats auf benachbarte Knoten.
AlgoCG 09
28
Kapitel 2. Trees
Beweis 2.3.4
Die Unterteilung eines Quadrates σ(v) verursacht in anderen Quadraten σ(v 0 ) gleicher Größe
nur dann eine weitere Aufteilung, wenn v 0 eins der 8 benachbarten Quadrate von v ist. (Beweis
siehe Lemma) Abbildung 2.29 illustriert diesen Zusammenhang.
Die alten Quadrate seien die Quadrate von T . Die neuen Quadrate die zusätzlichen Quadrate von T ∗ . Betrachte nun den Split eines Quadrates σ:
• Der Split kostet 4 neue Knoten (die Kinder von σ).
• Eines der umgebenden Quadrate muss ein altes Quadrat σ ∗ sein, das den Split verursacht hat.
• Die Kosten des Splits (4) werden dem alten Quadrat σ ∗ zugewiesen.
⇒ Ein Quadrat kann nur maximal 8-mal (von jedem seiner 8 Nachbarn) Kosten zugewiesen bekommen. Damit ist die Steigerung der Knotenanzahl linear und die Größe des
balancierten Quadtrees folgt.
2.3.4.1 Laufzeit
Zuletzt soll noch die Laufzeit für die Balancierung berechnet werden.
Lemma 2.3.4
Sei T ein Quadtree mit m Knoten. Die balancierte Version kann in Zeit O((d + 1)m) konstruiert werden.
Beweis 2.3.5
Es wird nur eine konstante Anzahl von Nachbarschaftssuchen durchgeführt, weil ein Knoten
nur eine Konstante Anzahl von Nachbarn besitzt. Ein Blatt der Liste L kann damit in Zeit
O(d + 1) behandelt werden. Da es maximal O(m) Knoten gibt, beträgt die Laufzeit O((d +
1)m).
2.4 Loose Octrees
Quadtrees und Octrees führen eine vollständige Partitionierung des Raumes durch, die keine
Redundanz enthält und die Lage der Objekte nicht berücksichtigt. Der Nachteil der Vorgehensweise ist, dass nur Punkte eindeutig einsortiert werden können. Objekte, die eine Ausdehnung besitzen wie z.B. Dreiecke, müssen gesondert behandelt werden (siehe auch Abschnitt 2.3.1). Bevorzugt wird in der Regel die Variante, bei der ein Objekt in die tiefstgelegene Bounding-Box einsortiert wird, in die es vollständig hineinpasst. Falls aber ein sehr
kleines Objekt genau auf der Splittinggerade oder -ebene von zwei großen Boxen liegt, wie
in Abbildung 2.30 dargestellt, dann wird es sehr weit oben im Baum einsortiert. Man spricht
hierbei von sog. „Sticky Planes“. Dies kann durch Loose Octrees vermieden werden. Im folgenden werden alle Abbildungen im 2D gezeigt, da das Verfahren für Loose Quadtrees auf
die gleiche Weise funktioniert.
AlgoCG 09
29
HEINZ NIXDORF INSTITUT
$$
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
(+,-."."/#"'-'#("0(12.-''
Kapitel 2. Trees
"*$/"*9.:%;(%"*-5&<3*%#"%"*9<(&%%
2*-%'*?,54%'*%&>/12(
2 -%' ?,54%' %&>/12(
-5"-,"A%"
-#2
&C<;'#<3(#25"2*,5>*-#%*D,2%*-%&*9.:%;(%
&*9.:%;(%*%#"G
Abbildung 2.30: Objekte, die Splittinggeraden schneiden, liegen in großer Bounding-Box.
Ein Knoten eines Octrees enthält immer den Mittelpunkt der Bounding-Box, Referenzen
auf alle 8 Kinder, sowie einen Vektor mit allen enthaltenen Objekten. Für das Einfügen eines
;(%*1,''%"*'#<3*%#">,<3*5"-*%#"-%5(#2*%#"'/&(#%&%"
Objektes wird zunächst eine Klassifikation durchgeführt, die in Algorithmus 11 dargestellt ist.
;(%*4#(*05'-%3"5"2*'#"-*A5')(A1#<3%*DH'5"2%"*2%>&,2(
2
2 2
2
Algorithmus 11 Klassifikation eines Knotens beim Einfügen in einen Octree
1: function C LASSIFY(Plane p, Volume v)
Lösung
2:
if v ist vollständig hinter p then
3:
return 0;
9.:%;(*'/*(#%>*F#%*4H21#<3*%#"*
4:
else if v ist vollständig vor p then
KL
I,((3#,'*J#'<3%&
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,>#;PQ*RR*LSSK
5:
return 1;
6:
else
. v wird von p durchtrennt
7:
return 2;
8:
end if
9: end function
Die Funktion zum Einfügen eines Objektes prüft nun das Bounding Volume des Objektes
gegen Ebenen durch den Mittelpunkt der Octree-Box, die parallel zur x-Achse, zur y-Achse
und zur z-Achse liegen. Falls das Objekt eine der Ebenen schneidet, wird es im Knoten
gespeichert. Falls nicht, passt es in einen Kindknoten.
2.4.1 Konstruktion
Das Ziel der Loose Octree Konstruktion ist es, dass kleine Objekte nicht mehr auf den StickyPlanes großer Boxen liegen bleiben, sondern tiefer durchfallen. Dies wird durch eine Vergrößerung der Bounding-Boxen erreicht. In einem herkömmlichen Octree gilt für die Größe der
Boxen und die Abstände der Mittelpunkte (in x, y, z Richtung):
L(d) =
W
2d
S(d) =
W
2d
Dabei beschreibt W die Größe der äußersten, alles umschließenden Box, sowie d die Tiefe
des Octree. Das bedeutet, die Seitenlängen der Boxen und die Abstände der Mittelpunkte sind
gleich groß wie in Abbildung 2.31 dargestellt.
In einem Loose-Octree wird die Kantenlänge der Bounding-Box um einen Faktor k vergrößert, ohne jedoch den Abstand zwischen den Boxen anzupassen. Dies führt dazu, dass sich
die Boxen überlappen wie in Abbildung 2.32 dargestellt.
AlgoCG 09
30
HEINZ NIXDORF INSTITUT
"#$%&'()$$
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
#$%&'(%)"#
Kapitel 2. Trees
HEINZ NIXDORF INSTITUT
*3%&:;441#<3%"*=<(&%%*2#1(>
!""#$%&'()$$
!"#$%&'(%)"#
antenlänge
der Octree-Box
Octree Box
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
),-,./0/1/2/3%),-,
Loose Octrees
?
9%&2&:;%&% -%" $/" -%" 6"/(%" .%1%2(%" <,54 #" ,11%"
9%&2&:;%&%*-%"*$/"*-%"*6"/(%"*.%1%2(%"*<,54*#"*,11%"
bstände =#4%"'#/"%"
der Boundingboxen
*8ABACDE#<3(5"2F
%),-,./0/1/2/3
> %),-,
?#&*$%&)"-%&"*-#%*6,"(%"1)"2%*-%&*@A(&%%BC/8%"
*+%),-,./0/(/1/2/3/4%),-,
( DE*%#"*F,G(/&*H*I
HEINZ NIXDORF INSTITUT
$$
-, >H*I#%J%*-%'*=<(&%%
!"#$%&'#()(*+,-%&./&"
G
012/&#(34%"*5"-*6/471%8#()(
Abbildung 2.31: Größe der Bounding-Box
>H*G)"2%*-%&*K/5"-#"2DK/8A*-#%*-#%*$#&(5%11%*?C%"%*54'<31#%L(
> ?#&*1,''%"*-#%*0.'()"-%*21%#A3
%),-,
es
5+%),-,./0/2/3/4
+
.
und Abstand der Mittelpunkte.
%"
%"*$/"*-%"*6"/(%"*.%1%2(%"*<,54*#"*,11%"
$/" -%" 6"/(%" .%1%2(%" <,54 #" ,11%"
> ?#&*1,''%"*J5K*-,''*'#A3*-#%*L//'%BC/5"-#"2./8%"*
-%& 6#"-%& M.%&1,77%"
-%&*6#"-%&*M.%&1,77%"
"-%&"*-#%*6,"(%"1)"2%*-%&*@A(&%%BC/8%"
/(/1/2/3/4%),-, Q/&1%'5"2*R012/&#(34%"*#"*-%&*S/475(%&2&,J#:TA*??*UVVO
F,G(/&*H*I
%"*-#%*0.'()"-%*21%#A3
0/2/3/4%),-,
M,((3#,'*N#'<3%&
9/&1%'5"2*Q012/&#(34%"*#"*-%&*R/475(%&2&,S#GTK*UU*VWWO
Abbildung
%"*J5K*-,''*'#A3*-#%*L//'%BC/5"-#"2./8%"*
%&
%&*M.%&1,77%"
M.%&1,77%"
(a)
OP
(b)
N,((3#,'*F#'A3%&
OP
2.32: Vergrößerte Bounding-Boxen im Loose Octree
Für die Kantenlänge und den Abstand der Mittelpunkte gilt damit:
L(d) = k ·
9/&1%'5"2*Q012/&#(34%"*#"*-%&*R/475(%&2&,S#GTK*UU*VWWO
N,((3#,'*F#'A3%&
W
2dOP
S(d) =
W
2d
Falls ein Objekt im Überlappungsbereich zweier Boxen liegt, entscheidet die Lage des Objektmittelpunktes bezogen auf die ursprünglichen Octree Boxen über die Einordnung. Das
Objekt wird in die Box einsortiert, in der ihr Mittelpunkt liegt. Durch die Redundanz wären
theoretisch auch andere Lösungen denkbar.
Über den Faktor k wird die Größe der Überlappung gesteuert. In der Literatur wird ein Faktor k = 2 als guter Kompromiss beschrieben. Er sorgt dafür, dass kleine Objekte tiefer im Octree durchfallen. Über die tatsächliche Tiefe entscheidet nun die Größe des Objektes und nicht
seine Position bezüglich der Splittingebenen. Abbildung 2.33 zeigt die Überlappungsbereich
ist grau für zwei verschiedene k-Werte.
Lemma 2.4.1
Ein Objekt mit Radius (k−1)· L4 fällt mindestens bis auf Tiefe d, wobei L =
der Octree Bounding-Box ist.
W
2d
die Kantenlänge
Beweis 2.4.1
Die Objekte bleiben nur im grau schraffierten Bereich liegen. Liegt das Objekt komplett im
weißen Bereich, wird es noch eine Ebene tiefer einsortiert. Die Größe des grau schraffierten
AlgoCG 09
31
(
123
%%/)0
E#"*<.=%:(*4#(*F,-#5'*41+56&7&(&8&9 ;)11(*4#"-%'(%"'*.#'*
HEINZ NIXDORF INSTITUT
,5;*@#%;%*'?*>/.%#*(&:&;&8&3' -#%*6,"(%"1)"2%*-%&*
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
<G(&%%HI/5"-#"2./8
<G(&%%
I/5"-#"2./8*#'(
#'(
Kapitel 2. Trees
3"
I%>%#'J
%:(*>%&-%"?*54*,5;*%#"%4*
K <.=%:(%*.1%#.%"*"5&*#4*2&,5*'G3&,;;#%&(%"*I%&%#G3*
=
2
%2%"*B5*.1%#.%"CD
2
1#%2%"
(
123
K 3"&:&174(836&< 4(836&:&41+567&4(836
" : 41 567(89
"&:&41+56
(89
'*41+56&7&(&8&9 ;)11(*4#"-%'(%"'*.#'*
&;&8&3' -#%*6,"(%"1)"2%*-%&*
3"
#'(
1:3
(a)
(b)
"5&*#4*2&,5*'G3&,;;#%&(%"*I%&%#G3*
2
Q/&1%'5"2*R012/&#(34%"*#"*-%&*S/475(%&2&,;#:T?*UU*POOV
L,((3#,'*M#'G3%&
NOP
Abbildung 2.33: Überlappungsbereiche in Abhängigkeit des Parameters k.
36&:&41+567&4(836
Bereichs ist:
1:3
2r = k · L2 − L2 = (k − 1) ·
⇒ r = (k − 1) · L4
L
2
Der grau schraffierte Bereich entspricht dem Überstand der Bounding-Box. Eine original
L
Bounding-Box hat Größe L,((3#,'*M#'G3%&
. MultipliziertNOPman mit k erhält man die neue Größe, subtrahiert
2
L
man dann 2 erhält man nur den Überstand.
Wählt man k < 2 fallen nur ganz kleine Objekte in die nächste Ebene. Für k = 2 passen
alle Objekte, deren Kantenlänge gleich der original Octree Bounding-Box ist, in den entspreHEINZ NIXDORF INSTITUT
""#$%&'()$$ chenden Knoten. Für k > 2 werden die Überlappungen
zu groß.
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
"#$%&'%"&())*%+,-."%%/)0
Ein Nachteil des Loose Octrees ist, dass der Raum, den die Elternknoten inklusive ihrer
vergrößerten Bounding-Box aufspannen, nicht mehr vollständig von den Kindern abgedeckt
Verlust der vollständigen
wird. DieAufteilung
ist in Abbildung 2.34 dargestellt.
2/&#(34%"*#"*-%&*S/475(%&2&,;#:T?*UU*POOV
9 :%&
:%&*2%',4(%*;,54*-%'*<1(%&"="/(%"*
2%',4(% ;,54 -%' <1(%&"="/(%"
123.%"4 >#&-*"#?3(*4%3&*-5&?3*-#%*
@544%*,11%&*6#"-%&*1564'%" ,.2%-%?=(
AB
A<1(%&"
A6#"-%&
A
C,'*4,?3%"*>#&*4#(*D.E%=(%"*,F*-#%*"#?3(*
2&GH%& '#"- ,1' -#% D?(&%%IA/5"-#"2./8
2&GH%&*'#"-*,1'*-#%*D?(&%%
A/5"-#"2./8*1
1
-%&*6#"-%&*1564'%" F*-#%*"#?3(*#"*-%4*
,.2%-%?=(%"*A%&%#?3*1#%2%"J
9 :#
:#%'%*K#"-%"*#"*-%"*6#"-%&"*-%&*
K# - # - 6# L%'?3>#'(%&*-%&*<1(%&"*+1,(M*
NO/5'#"P%Q
D
Abbildung 2.34: Kinder decken den Raum der Eltern nicht mehr vollständig ab.
TUV
B ist die Bounding-Box des Kindes, währendR,((3#,'*S#'?3%&
BL die Bounding-Box
des Elternknotens ist.
BKinder und BEltern bezeichnen jeweils die vergrößerten Bounding-Boxen. Es kann nun Objekte O geben, die innerhalb der Bounding-Box des Elternknotens liegen und von der Größe
her in einen Kindknoten hineinpassen, aber nicht vollständig innerhalb der von den Kindern
W/&1%'5"2*X012/&#(34%"*#"*-%&*O/475(%&2&,K#=YF*@@*ZUU[
AlgoCG 09
32
Kapitel 2. Trees
abgedeckten Fläche liegen. Diese Knoten werden dann in einem Kind eines Geschwisterknotens des Elternknotens gespeichert (Cousin/e). Im Beispiel ist dies ein Kind des linken
Geschwisters von BL.
2.4.1.1 Direkte Platzierung
Die Vergrößerung der Bounding-Boxen um den Faktor k = 2 kann man eine direkte Platzierung der Objekte in Zeit O(1) im Loose Octree durchführen. Eine Traversierung des Baums
ist nicht mehr notwendig.
Wie zuvor gezeigt passen alle Objekte mit einem Radius von weniger 14 der Seitenlänge
(Durchmesser halbe Seitenlänge) der originalen Bounding-Box in den entsprechenden LooseOctree-Knoten. Dies ist unabhängig von der Position, da die Bounding-Box durch den Faktor
k = 2 in alle Richtungen um ein Viertel der orginalen Seitenlänge vergrößert wurde. Ein
Knoten mit Radius von weniger als 18 der Ausgangsbox sollte eine Ebene tiefer gespeichert
werden.
Sei nun Rmax (d) der maximale Objektradius, der in Tiefe d gespeichert werden kann. Es
wird nun von unten nach oben die erste Ebene gesucht, die ein Objekt mit Radius R aufnehmen
kann. Diese Ebene habe Tiefe d(R).
. Damit ergibt sich
Die Kantenlänge einer Box in Tiefe d ist L(d) = 2 · W
2d
1
1W
Rmax (d) = L(d) =
4
2 2d
Damit ein Objekt in eine Ebene passt, muss sein Radius kleiner als der maximal mögliche
Radius sein. Damit ergibt sich:
R ≤ Rmax (d(R))
≤ 12 W
2d
d(R) ≤ log( W
)−1
R
Die direkte Platzierung speichert einen Knoten jedoch nicht immer auf der tiefst möglichen
Ebene. Dies liegt daran, dass abhängig von seiner Position auch ein Knoten mit Durchmesser
L(d) in einer Box gespeichert werden könnte. Dieser wird jedoch höher im Baum abgelegt.
Eine Optimierung ist daher, über die Berechnungsformel die passende Ebene auszurechnen
und dann die Kinder abzutesten, ob diese das Objekt aufnehmen können. Falls ja, wird das
Objekt in den Kindknoten geschoben, sonst bleibt es auf der berechneten Ebene.
2.4.2 Nutzen
Das Frustum Culling funktioniert mit Loose Octrees genauso wie mit normalen Octrees. Dazu
wird der Baum von der Wurzel aus traversiert. Falls ein Knoten nicht sichtbar ist, wird die
Traversierung direkt abgebrochen, ohne die Kinder zu berücksichtigen. Ansonsten werden
die Objekte des Knoten ausgegeben und die Kinder werden betrachtet (bei vollständiger oder
teilweiser Sichtbarkeit).
AlgoCG 09
33
Kapitel 2. Trees
Messungen haben gezeigt, dass durch die Verwendung von Loose Octrees und die damit
verbundene tiefere Einsortierung von kleinen Objekten bei einer Sichtbarkeitsanalyse weniger „möglich sichtbare“ Objekte zurückgegeben werden. Der Nachteil ist, dass durch die vergrößerten Bounding-Boxen mehr Knoten untersucht werden müssen.
AlgoCG 09
34
3 Visibility Culling
HEINZ NIXDORF INSTITUT
Walkthrough-Problem - Echtzeit-Rendering
!"#$%&'#()(*+,-%&./&"
In einer
Szene
sind
nicht
immer
alle
Teile
eines
Objektes
sichtbar.
Man
muss aber jedes
012/&#(34%"*5"-*6/471%8#()(
Visibility Culling
Objekt einmal anfassen und prüfen, ob es sichtbar ist. Der zeitliche Aufwand hängt damit von
allen Objekten ab und nicht nur von den sichtbaren. Dies ist ineffizient. Deshalb möchte man
Lösungsansatz
nicht sichtbare Objekte oder nicht sichtbare Teile von Objekten nicht explizit rendern. Eine
9#& .%&%:3"%"
9#&*.%&%:3"%"*,11%*/-%&*,5:3*"5&*%#"#2%*5"'#:3(.,&%*+/1;2/"%
,11% /-%&
,5:3 "5&
%#"#2%
5"'#:3(.,&%
Übersicht
über mögliche
Verfahren
zeigt
Abbildung
3.1. +/1;2/"%
/.<%:(
7/1;2/"
Frustum Culling
/.<%:(
Backface Culling
Occlusion Culling
Abbildung 3.1: Übersicht über verschiedene Culling Techniken.
= Frustum Culling
>.<%?(%*/-%&*+/1;2/"%*,5@%&3,1.*-%'*A#:3(?%2%1'*B%&-%"*"#:3(*2%C%#:3"%(
Der Sichtkegel des Benutzers wird Frustum genannt. Alles was außerhalb dieses Kegels
= nicht
Backface
Culling
liegt ist
sichtbar
und muss nicht betrachtet werden. Diese Funktion ist in jedem einfa+/1;2/"%D*-#%*$/"*3#"(%"*C5*'%3%"*'#"-D*B%&-%"*"#:3(*2%C%#:3"%(
chen Renderer implementiert und wird auch Clipping genannt. Von einem Polygon können
Occlusion
Culling
einige= Flächen
nur von
hinten betrachtet werden (backfaces). Diese sind dann nicht sichtbar
>.<%?(%D*-#%*#4*A#:3(?%2%1*3#"(%&*,"-%&%"*+/1;2/"%"*$%&-%:?(*1#%2%"D*B%&-%"*
und werden
nicht gezeichnet. Diese Funktion wird typischerweise von der Grafiklibrary oder
Hardware"#:3(*2%C%#:3"%(
unterstützt.Die schwierigste Technik ist das Occlusion Culling. Dabei werden PoGH
E,((3#,'*F#':3%&
I/&1%'5"2*J012/&#(34%"*#"*-%&*K/475(%&2&,L#?MD*AA*NOOP
lygone berechnet, die von anderen Polygonen verdeckt werden. Diese Technik befindet sich
noch in der Erforschung. Man bezeichnet die Techniken des Backface Culling und des Occlusion Culling auch als Hidden Surface Removal, da hier nicht sichtbare Oberflächen entfernt
werden.
Eine Berechnung der Sichtbarkeit für jedes Polygon ist zu aufwändig. Dies kann von der
Rendering Pipeline mit dem Z-Buffer-Algorithmus schneller durchgeführt werden. Der Grund
für den Einsatz von Occlusion Culling ist Effizienz, d.h. man möchte noch schneller sein als
der Z-Buffer. Man benutzt deshalb Datenstrukturen wie die in Kapitel 2 vorgestellten Octrees,
BSP-Trees oder kd-Bäume, die einen schnellen Zugriff auf Teile der Szene erlauben. Sie
erlauben es, schnell große Mengen von Objekten als nicht sichtbar zu klassifizieren.
Ein wichtiges Maß für dafür, ob sich ein Culling lohnt ist die Tiefenkomplexität. Die Tiefenkomplexität beschreibt die Anzahl der verdeckten Dreiecke, die hinter einem sichtbaren
Dreieck liegen. Sie ist standpunktabhängig und fällt für unterschiedliche Szenen unterschiedlich hoch aus. Für eine Wiese ist sie sehr gering, in einer Stadtszene abhängig vom Standpunkt
hoch (vgl. Abbildung 3.2).
35
Kapitel 3. Visibility Culling
Abbildung 3.2: Abhängigkeit der Tiefenkomplexität vom Standpunkt.
AlgoCG 09
36
ility Culling
dbegriffe
Kapitel 3. Visibility Culling
Probleme für das Culling entstehen, wenn nur wenige unsichtbare Dreiecke existieren. In
diesem Fall ist der Aufwand für die Berechnung der unsichtbaren Dreiecke höher als die tatsächliche Einsparung. Falls die Anzahl der unsichtbaren Dreiecke stark schwankt, z.B. die
Kamera fährt dicht hinter einem Pfahl entlang, entstehen ebenfalls Probleme. Der Algorithmus kann dann unter Umständen nicht alle Dreiecke in akzeptabler Zeit klassifizieren. Man
muss somit einen Trade-off zwischen Culling-Test und Renderingzeit finden:
• Eine Szene hat n0 Dreiecke, davon werden n durch den Cullingalgorithmus in Zeit tc (n)
als unsichtbar klassifiziert.
• Das Rendering von n Dreiecken kostet Zeit tr (n), für die restlichen n0 − n Dreiecke
kostet tr (n0 − n).
• Man erhält die Gesamtlaufzeit tges (n) = tr (n0 − n) + tc (n)
Falls tc (n) ≥ tr (n) gilt, dann lohnt sich das Culling offensichtlich nicht, d.h. die auf der
HEINZ
NIXDORF
INSTITUT
CPU durchgeführte
Berechnung der unsichtbaren Polygone darf nicht
länger
dauern
als ihre
Visibility Culling
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
„Darstellung“
durch die Rendering Pipeline.
Grundbegriffe
9%#*O -#%*:%"2%*-%&*;.<%=(%>+&#4#(#$%*#"*-%&*$#&(5%11%"*9?%"%*
@A&*%#"%"*2%2%.%"%"*9(,"-75"=(*'%#B
3.1 Potentially
Visible Sets
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
C S -#%*:%"2%*-%&*'#D3(.,&%"*E%#1%F012/&#(34%"*5"-*6/471%8#()(
Ein Potentially Visible Set (PVS) enthält die Objekte, die wahrscheinlich sichtbar sind. Dies
C keine
U -#%*:%"2%*-%&*5"'#D3(.,&%"*E%#1%G
9
ist jedoch
exakte Sichtbarkeitslösung. Man berechnet schnell!eine konservative
Über-#%*:%"2%*-%&*;.<%=(%>+&#4#(#$%*#"*-%&*$#&(5%11%"*9?%"%*
schätzung der sichtbaren Primitive, das PVS. Die exakte Sichtbarkeit wird durch die Anwen"%"*2%2%.%"%"*9(,"-75"=(*'%#B
HEINZ NIXDORF INSTITUT
dung des
Z-Buffer
Algorithmus auf dem PVS in der Rendering-Pipeline berechnet.
:,"*5"(%&'D3%#-%(*:%(3/-%"*",D3*-%&*0&(F
!"#$%&'#()(*+,-%&./&"
S -#%*:%"2%*-%&*'#D3(.,&%"*E%#1%F
012/&#(34%"*5"-*6/471%8#()(
ManI#%*'#%*-,'*9#D3(.,&=%#('7&/.1%4*1H'%"B
kann
drei
Arten
für eine Menge O von Objekten einer
# # - 9# 3(.von
= #(Sichtbarkeitsberechnungen
.1
1H
U -#%*:%"2%*-%&*5"'#D3(.,&%"*E%#1%G
virtuellenC Szene
durchführen. Für einen!gegebenen
und U
9
9 Standpunkt sind!S die sichtbaren
$%*#"*-%&*$#&(5%11%"*9?%"%*
!"#$%&'()(*(+(%,
die unsichtbaren
Objekte.
Die verschiedenen Ansätze sind in Abbildung 3.3 dargestellt.
-#%*:%"2%*S
2
I#&-*.%&%D3"%(G
#B
5"(%&'D3%#-%(*:%(3/-%"*",D3*-%&*0&(F
C -./)012#%(20&'()(*(+(%,
%F
%*-,'*9#D3(.,&=%#('7&/.1%4*1H'%"B
- 9# 3(. = #(
.1
1H-#%*:%"2%*S 715'*%(I,'*,5'*U I#&-*.%&%D3"%(F
%#1%G
J-%& E%#1 ,5'
J-%&*E%#1*,5'*U
'/11 4H21#D3'( =1%#" '%#"K 9
9 U '/11*4H21#D3'(*=1%#"*'%#"K*
9
!
!
!
!"#$%&'()(*(+(%,
#%*:%"2%*S
2
I#&-*.%&%D3"%(G
C 3441."(5#%(20&'()(*(+(%,
%#"*E%#1*$/"*S 715'*%(I,'*,5'*U I#&-*.%&%D3"%(
%&*0&(F
-./)012#%(20&'()(*(+(%,
(a)
(c)
J-%&*E%#1*,5'*S
'/11*4H21#D3'(*2&/UF* (b)
%"B
#%*:%"2%*S 715'*%(I,'*,5'*U I#&-*.%&%D3"%(F
-%&*E%#1*,5'*U '/11*4H21#D3'(*=1%#"*'%#"K*
-%&*E%#1*,5'*U
-%& E%#1 ,5' U '/11*4H21#D3'(*=1%#"*'%#"K*
'/11 4H21#D3'( =1%#" '%#"K 9
9
!
:,((3#,'*@#'D3%&
Abbildung !
3.3: (a) zeigt
einen exact visibility
Test, (b) einen conservative
Test und (c)LMeinen
N/&1%'5"2*O012/&#(34%"*#"*-%&*P/475(%&2&,Q#=RF*99*SMMT
3441."(5#%(20&'()(*(+(%,
approximative Test.
#"*E%#1*$/"*S 715'*%(I,'*,5'*U I#&-*.%&%D3"%(
-%&*E%#1*,5'*S '/11*4H21#D3'(*2&/UF*
I#&-*.%&%D3"%(F
%&*E%#1*,5'*U '/11*4H21#D3'(*=1%#"*'%#"K*
#" '%#"K
#"*'%#"K*
• Exact! Visibility9
LM
:,((3#,'*@#'D3%&
N/&1%'5"2*O012/&#(34%"*#"*-%&*P/475(%&2&,Q#=RF*99*SMMT
I#&-*.%&%D3"%(
/UF*
"*'%#"K*
Berechne nur die sichtbaren Objekte.
• Conservative Visibility
Berechne die sichtbaren und einen (möglichst kleinen) Teil der unsichtbaren Objekte.
:,((3#,'*@#'D3%&
RF*99*SMMT
AlgoCG 09
LM
37
Kapitel 3. Visibility Culling
• Approximative Visibility
Berechne einen (möglichst großen) Teil der sichtbaren und einen (möglichst kleinen)
Teil der unsichtbaren Objekte.
3.2 Occlusion Culling mit Potentially Visible Sets
Es soll ein Occlusion Culling durchgeführt werden, so dass beim Walkthrough möglichst wenig Objekte gerendert werden müssen. Dazu sollen die architektonischen Eigenschaften der
Szene ausgenutzt werden. Dazu gehören verdeckende Elemente wie Räume, Flüre, Nischen,
Stockwerke (Wände) und nicht verdeckende Elemente wie Durchgänge, offene Türen, sowie
Fenster. Während Menschen eine natürliche Vorstellung davon haben, was eine Tür ist und
was ein Raum, muss dies für einen PC berechnet werden. Es werden daher zwei strukturelle
Elemente eingeführt.
Definition 3.2.1 (Zelle)
Eine Zelle definiert einen „Raum“, der von Wänden und Portalen
umschlossen
ist. Wände
HEINZ NIXDORF
INSTITUT
Occlusion Culling mit Potentially Visible Sets
!"#$%&'#()(*+,-%&./&"
sind grundsätzlich
undurchsichtig.
012/&#(34%"*5"-*6/471%8#()(
Eigenschaften architektonischer Modelle
Definition 3.2.2
(Portal)
!"#$%#"&"'()*'+"&&",'-,.'/0*12&"
Ein Portal definiert einen durchsichtigen oder offenen Teil eines Raums. Portale verbinden die
9%11%"*5"-*+/&(,1%*%"('7&%:3%"*"#:3(*#44%&*5"'%&%&*;/&'(%115"2*$/"*<)54%"*
einzelnen Räume
miteinander.
5"-*=>&%"?
Eine 3D-Szene
besteht nun aus Zellen und Portalen, die wie in Abbildung 3.4 dargestellt
@#%*%&A%""(*5"-*.%&%:3"%(**4,"*<)54%*5"-*=>&%"*B
nicht immer der menschlichen Vorstellung von einem Raum entsprechen.
EF
Abbildung 3.4: Wände (schwarz) und Portale (rot gestrichelt),C,((3#,'*D#':3%&
die verschiedene
Zellen
definieren.
;/&1%'5"2*G012/&#(34%"*#"*-%&*H/475(%&2&,I#AJK*LL*MNNF
3.2.1 Idee der Methode
Die Sichtbarkeitsberechnung wird in zwei Schritte aufgeteilt.
1. Cell-to-Cell Visibility (C2C-Visibility)
Wird im Preprocessing (vor dem Walkthrough) berechnet und umfasst sichtpunktunabhängige Sichtbarkeitsaussagen. Dazu wird ein Adjazenzgraph berechnet, der benachbarte Zellen verbindet.
AlgoCG 09
38
Kapitel 3. Visibility Culling
2. Eye-to-Cell Visibility (E2C-Visibility)
Wird während des Walkthrough berechnet und umfasst sichtpunktabhängige Sichtbarkeitsaussagen. Dazu wird der Adjazenzgraph traviersiert und die Sichtlinien des Beobachters gegen eine Folge von Portalen geprüft. Dadurch erhält man sichbare Zellen.
Die Zellen sind die Grundelemente des PVS über HEINZ
die NIXDORF
der Adjazenzgraph
berechnet wird.
INSTITUT
Occlusion Culling mit Potentially Visible Sets
Während
des Walkthroughs ist eine Zelle nur dann sichtbar, wenn sie durch eine Folge von
Berechnungsbeispiel
Portalen sichtbar ist, wie in Abbildung 3.5 dargestellt.
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
;/*<#%*0*#'(*,5=3*>*%#"*
?,=3.,&*$/"*9
6,"" 4," #" ,11%
6,""*4,"*#"*,11%*
.%",=3.,&(%"*D)54%*
'%3%"E
:
0
9
B
@
A
C
>
0
B
:
A
9
@
C
>
QB#1-%&R*9,$#-*S5%.L%N*!"#$%&'#(T*/K*I#&2#"#,U
I/&1%'5"2*J012/&#(34%"*#"*-%&*A/475(%&2&,K#LMN*;;*GOOP
F,((3#,'*@#'=3%&
GH
Abbildung 3.5: Sichtbarkeit verschiedener Räume mit einem gegebenen Adjazenzgraphen.
Die Sichtbarkeit einer Zelle reduziert sich auf das Testen von Sichtlinien durch eine Folge
von Portalen. Der Adjazenzgraph enthält für jede Zelle einen Zustand und eine Kante zwischen zwei Knoten, wenn die entsprechenden Räume durch ein Portal verbunden sind. Ausgehend von Raum E, in dem der Betrachter steht, sieht der Betrachter natürlich Raum E, aber
auch alle direkt benachbarten Räume durch die Portale in Raum E. Dies sind die Räume D,
F und G. Die zu diesen Räumen adjazenten Räume werden nur gesehen, wenn eine Sichtverbindung durch Portale besteht. Dies ist für Raum A der Fall, für Raum H kreuzen die
Sichtbarkeitslinien undurchsichtige Wände. H ist somit nicht sichtbar.
3.2.2 Berechnung des Adjazenzgraphen
Es wird eine 2D-Projektion eines Gebäudes oder Stockwerks auf die Grundrisse bestehend
aus Wänden und Portalen durchgeführt. Dabei wird eingeschränkt angenommen, dass alle
Wände senkrecht zueinander stehen. Damit sind alle Liniensegmente achsenparallel. Für
das entstehende 2D-Problem wird ein BSP-Baum zur räumlichen Aufteilung berechnet. Die
Blätter des BSP-Baums stellen räumliche Bereiche dar, die die Zellen bilden. Die Wurzel des
BSP ist die Bounding-Box der Eingabe. Abbildung 3.6 zeigt ein Beispiel für die Berechnung
des Adjazengraphen.
Die Elemente der Szene werden als Splittinggeraden gewählt. Dabei wird zunächst auf
die Existenz von spanning faces geprüft. Diese teilen eine Zelle ohne andere Segmente zu
AlgoCG 09
39
@ >%-%'*91,((*#'(*%#"*6"/(%"*#4*9,54
@ .%",B3.,&(%*6"/(%"*=%&-%"*-,""*$%&.5"-%"C*=%""*%#"*+/&(,1*
HEINZ NIXDORF INSTITUT
%8#'(#%&(
mit Potentially Visible
Sets
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Kapitel 3. Visibility Culling
%"*;#"#%"'%24%"(%"*%#"%"*<=>
:%&-%"*,1'*B71#((#"22%&,-%"
B71#((#"22%&,-%"@
(a)
*C,E%'D*%8#'(#%&%"G*-,""*:)31%*
C
D # (#
)31
%&%*B%24%"(
Abbildung 3.6:
'7,""#"2 C,E%
'7,""#"2*C,E%
(b)
A%11%"*4#(*0->,?%"?2&,73
Für einen Grundriss zeigt (a) eine spanning face und (b) die Zellen mit dem
FG
D,((3#,'*E#'B3%&
Adjazenzgraphen.
H/&1%'5"2*I012/&#(34%"*#"*-%&*J/475(%&2&,K#<LC*::*GMMN
E%*(%#1(*%#"%*H%11%G*/3"%*,"-%&%*
( #1( # H 11
3
E3"%#-%"*JC&%%*'71#(KL
N
<
schneiden (Free-Split!).
Falls mehrere existieren, wird die mittlere ausgewählt. Ansonsten
<
wird das Segment verwendet, das möglichst wenige andere Segmente schneidet. Falls mehrere
%"(G*-,'*4O21#E3'(*:%"#2*,"-%&%* N
zur Auswahl stehen, wird das mittlere verwendet.
%#-%(P
N Q
N Q Q N Q einer
Q Q NZelle und wird somit zu einem Knoten des AdjazenzJedes Blatt des BSP
entspricht
I,31*:)31%*-,'*4#((1%&%*B%24%"(
graphen. Banachbarte Knoten werden dann verbunden, wenn ein Portal existiert. Dazu muss
es möglich sein, Nachbarn zu
identifizierenTQund die Portale der Szene zu enumerieren.
R,((3#,'*S#'E3%&
Der Algorithmus führt eine Klassifikation der Eingabesegmente durch.
012/&#(34%"*#"*-%&*W/475(%&2&,C#XYG*BB*<NNZ
• disjunkt: Segment hat keinen Schnitt mit der (Wurzel-)Zelle
• spanning: Ein Segment F partitioniert die Zelle in Komponenten, die sich nur an den
Rändern schneiden.
• covering: Ein Segment F liegt auf dem Rand einer Zelle.
• incident: sonst
Falls eine Zelle keine inzidenten Segmente hat und somit leer ist, wird die rekursive Berechnung abgebrochen.
3.2.3 Berechnung der Cell-to-Cell Visibility
Es wird an Hand des Adjazenzgraphen für eine Zelle C eine Berechnung der direkt oder
indirekt von C aus sichtbaren Zellen durchgeführt. Dabei ist der Standpunkt innerhalb von
C egal. Die Berechnung wird über einen Stabtree durchgeführt. Jeder Knoten im Stabtree
entspricht einer von C aus sichtbaren Zelle. Die Knoten werden im Stabtree mit einer Kante
verbunden, wenn sie durch ein Portal direkt benachbart sind und die Sichtlinie durch dieses
Portal verläuft. Ein Beispiel für einen Stabtree zu einer Szene zeigt Abbildung 3.7.
Die Räume F, H und G, sowie die Räume D und A sind über direkte Sichtlinien von E
aus zu sehen. Die konkrete Position des Beobachters in E wird dabei in diesem Schritt nicht
berücksichtigt. Die Räume B und C sind nicht sichtbar.
Die Berechnung des Stabtrees wird nun über eine Tiefensuche im Adjanzenzgraphen durchgeführt. Für jedes gefundene Portal werden die Endpunkte des Portals in einer Menge Lp für
die linken und Rp für die rechten Endpunkte gespeichert. Eine Sichtlinie kann die Folge von
AlgoCG 09
40
HEINZ NIXDORF INSTITUT
Occlusion Culling mit Potentially Visible Sets
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Cell-to-Cell Visibility - 2
Kapitel 3. Visibility Culling
!"#$%#"&'()*+,*-""
:
:
9
9
;
<
=
HEINZ NIXDORF INSTITUT
Occlusion Culling mit Potentially Visible Sets
Cell-to-Cell Visibility - 3
;
<
!"#$%&'#()(*+,-%&./&"
>012/&#(34%"*5"-*6/471%8#()(
0
!"#"$%&'&()*"#)+,$%-.,&,"&)*'#$%)",&")/0.(")10&)
=#%*@%11%"*?*5"-*>*AB""%"*$/"*A%#"%&*
+/'#(#/"*#"*9*%#"2%'%3%"*C%&-%"
20#-3."&
=
0
?
9 %#"%*:/12%*$/"*+/&(,1%"*%"('(%3(*-5&;3*(&,$%&'#%&%"*
Abbildung 3.7: Stabtree
zu einer Menge von Zellen.
HEINZ NIXDORF INSTITUT
ulling -%'*0-<,=%"=2&,73%"
mit Potentially Visible Sets
!"#$%&'#()(*+,-%&./&"
D,((3#,'*:#'E3%&
H/&1%'5"2*I012/&#(34%"*#"*-%&*>/475(%&2&,J#AKL*MM*NOOP
sibility - 3
FG
012/&#(34%"*5"-*6/471%8#()(
Portalen nur durchstechen, wenn Lp und Rp linear trennbar sind, d.h. es existiert eine Gerade
9 >?&*<%-%'*(&,$%&'#%&(%*+/&(,1*'7%#;3%&"*@#&*-#%*
S
für die gilt
A"-75"B(%*-%'*+/&(,1'*#"*%#"%&*C%"2%*D
7 5"-*E7
)*"#)+,$%-.,&,"&)*'#$%)",&")/0.(")10&)
S · L ≥ 0, ∀L ∈ Lp
S · R ≤ 0, ∀R ∈ Rp
D
HEINZ NIXDORF INSTITUT
Visible
Sets
!"#$%&'#()(*+,-%&./&"
2%*$/"*+/&(,1%"*%"('(%3(*-5&;3*(&,$%&'#%&%"*
A#"%*F#;3(1#"#%*B,""*-#%*:/12%*$/"*+/&(,1%"*"5&*
Ein Beispiel für
eine solche lineare Trennung zeigt Abbildung 3.8. Für eineD Menge von m
012/&#(34%"*5"-*6/471%8#()(
D
=%"=2&,73%"
-5&;3'(%;3%"G*@%""*D
5"-*E
'#"-G*-H3H*%'*mit 2m Randbedingungen,
7
7 linear
Portalen ist dies ein Problem
der trennbar
linearen Programmierung
dass in
E
E
%8#'(#%&(*%#"%*I%&,-%*FG*'/*-,''*2#1(J
Zeit
O(m)
für
eine
Linie
lösbar
ist.
Für
die
Berechnung
des
Stabtree
muss
dieses
Problem
*(&,$%&'#%&(%*+/&(,1*'7%#;3%&"*@#&*-#%*
&")/0.(")10&)also mehrfach gelöst werden.
B(%*-%'*+/&(,1'*#"*%#"%&*C%"2%*D
7 5"-*E7
E
5&;3*(&,$%&'#%&%"*
%*B,""*-#%*:/12%*$/"*+/&(,1%"*"5&*
"G*@%""*D7 5"-*E7 linear trennbar '#"-G*-H3H*%'*
%&"*@#&*-#%*
*I%&,-%*FG*'/*-,''*2#1(J
"2%*D7 5"-*E7
D
(a)
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,>#BPG*FF*QRRS
D
D
E E
D D
E
(b)
D
D D
E E
E
(c)
C,((3#,'*:#';3%&
KL
,1%"*"5&*
Abbildung 3.8: Für den Grundriss
in (a) zeigtD(b)
D D
D eine existierende lineare Trennung und (c)
ennbar '#"-G*-H3H*%'*
RS
eine
E Ezweite.
E E
E
Das Vorgehen fasst Algorithmus
12 zusammen.
E
Der Algorithmus Stabbing_Line(P ) berechnet,
ob für eine gegebene
Folge von Portalen
KL
C,((3#,'*:#';3%&
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,>#BPG*FF*QRRS
eine Sichtlinie existiert, die Dalle Portale durchquert. Falls diese existiert, wird versucht, eine
weitere Zelle anzufügen.
D
D
E E
3.2.4 Berechnung der Eye-to-Cell Visibility
E
Mit dem berechneten
Stabtree für dieKL Zelle, in der der Beobachter steht, müssen nur die von
C,((3#,'*:#';3%&
dort aus sichtbaren Zellen gerendert werden. Dies entspricht jedoch einer 360 Grad Sicht
AlgoCG 09
41
Kapitel 3. Visibility Culling
Algorithmus 12 Algorithmus zum Berechnen eines Stabtree
1: function F IND _V ISIBLE _C ELLS(Cell C, Portal-Sequenz P , Visible-Cell-Set V )
2:
V := V + C
3:
for each Nachbar N von C do
4:
for each Portal p, das C und N verbindet do
5:
Orientiere p von C nach N
6:
P0 = P ◦ p
7:
if Stabbing_Line(P 0 ) exists then
8:
Find_Visible_Cells(N , P 0 , V )
9:
end if
10:
end for
11:
end for
12: end function
von allen möglichen Standorten innerhalb der Zelle ausgehend. Dies lässt sich jedoch weiter
optimieren, indem man zusätzlich den Sichtkegel (Frustum) des Beobachters mit in Betracht
zieht.
Es gibt vier Verfahren, um den Standpunkt und den Sichtkegel des Beobachters auszunutzen. Die Verfahren steigen in Effektivität und Komplexität von oben nach unten an. Sei im
Folgenden S der Stabtree und C das Frustum des Beobachters. Wir schneiden nun das Frustum gegen den Stabtree und rendern nur die Zellen, die der Beobachter wirklich sehen kann.
1. Zellentest mit Frustum
Prüfe für jede Zelle den Schnitt mit dem Frustum wie in Abbildung 3.9 (a) dargestellt.
Der Schnitt mit dem Frustum ergibt die Zellen O, G und H, von denen G und H jedoch
unsichtbar sind. Die übrigen Zellen fallen weg. Die Laufzeit dieser Methode ist O(|V |),
wobei V die Menge der Zellen ist.
2. Tiefensuche mit Zellentest
Führe eine Tiefensuche von O in S durch mit der Abbruchbedingung, dass alle traversierten Zellen im Frustum liegen. Ist eine Zelle nicht sichtbar, wird die Suche an dieser Stelle abgebrochen. Das Beispiel in Abbildung 3.9(b) zeigt, dass F, G, H und O zurückgegeben werden, obwohl G und H unsichtbar sind. Die Laufzeit dieser Methode ist
O(|S|), d.h. die Laufzeit ist linear in der Größe des Stabtrees. Diese ist abhängig von
der Anzahl der Pfade, die jedoch größer als die Anzahl der Knoten sein kann.
3. Tiefensuche mit Portaltest
Suche von O aus alle Zellen in S, die über Portale erreichbar sind und im Frustum liegen.
Damit fällt in Abbildung 3.9(c) die Zelle G weg, die Zelle H bleibt jedoch erhalten,
obwohl sie unsichtbar ist. Die Laufzeit dieser Methode ist O(|S|), wobei S wiederum
die Größe des Stabtree ist.
4. Exakte Eye-To-Cell Visibility
Prüfe für die erreichbaren Portalsequenzen, ob eine im Frustum liegende Sichtlinie vom
Beobachter existiert. Damit fällt in 3.9(c) die Zelle H auch weg. Die Laufzeit dieser
AlgoCG 09
42
HEINZ NIXDORF INSTITUT
Occlusion Culling mit Potentially Visible Sets
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
Occlusion
Culling mit Potentially Visible Sets
012/&#(34%"*5"-*6/471%8#()(
Eye-to-Cell Visibility - 3
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Eye-to-Cell Visibility - 4
9%1:3%*;%11%"*-%'*<(,.(&%%*'#"-*'#:3(.,&=
C
>%&':3#%-%"% ?@21#:3A%#(%"B
>%&':3#%-%"%*?@21#:3A%#(%"B
Kapitel 3. Visibility Culling
!"#$#%&'()#*+",*-./,01,#&,
9
?
'5:3% $/" ; #" < -#% =%11%" -#% >.%& +/&(,1%
E'5:3%*$/"*;*#"*<*-#%*=%11%"@*-#%*>.%&*+/&(,1%*
%&&%#:3.,&*'#"-*5"-*#4*A&5'(54*1#%2%"
F
C
G
D
Methode ist O(|V | · |S|),9 wobei
V Länge der Portalsequenzen beschreibtB (maximal
alle
A
B@*C*D,11%"*#"*EFG*H%(I(*IJ,&*J%2@*
S
Zellen
hintereinander)
undO,.%&*C*.1%#.(*#"*E?G@*/.J/31*5"'#:3(.,&
S Visible
dieQ Anzahl
Stabtree.
HEINZim
NIXDORF
INSTITUT
7&HI%*J%-%*%#"K%1"%*;%11%*4#(*<:3"#((*-%'*F&5'(54
Occlusion
Culling mit Potentially
Sets der Pfade
G
!"#$%&'#()(*+,-%&./&"
Visibility - 4
L" MCN I,11%" OP FP Q R%2 Eye-to-Cell
L"*MCN*I,11%"*OP*FP*Q*R%2
012/&#(34%"*5"-*6/471%8#()(
!"##"$%"&% '(% )*+&%+'
!"##"$%"&%,'(%,)*+&%+'
ially Visible Sets
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
K
2 3,
2603,#*#7#8,.8(#11*4"&"51",7
,
11 4" "51",
G DP*E*.1%#.%"*/.R/31*'#%*5"'#:3(.,&*'#"!"#$#%&'()#*+",*-./,01,#&,
'#:3(.,&=
9
7&>D%*D>&*-#%*%&&%#:3.,&%"*+/&(,1'%M5%"I%"@*/.*
?
T
9 '5:3%*$/"*;*#"*<*-#%*=%11%"@*-#%*>.%&*+/&(,1%*
'5:3% $/" ; #" < -#% =%11%" -#%%#"%*<#:3(1#"#%*$/4*N%(&,:3(%&*%8#'(#%&(
>.%& +/&(,1%
C
%&&%#:3.,&*'#"-*5"-*#4*A&5'(54*1#%2%"
-("."$&+/0",'(%,!"##"$%"&%
C
E
E
9 C*D)11(*#"*E?G*H%(I(*,5:3*J%2
A
F
F
9 D B@*C*D,11%"*#"*EFG*H%(I(*IJ,&*J%2@*
B
D
G IH3&%*U#%I%"'5:3% $/"*S*#"*<*-5&:3
,.%&*C*.1%#.(*#"*E?G@*/.J/31*5"'#:3(.,&
G 4#(*-%&*0..&5:3.%-#"25"2P*-,''*,11%*(&,$%&'#%&(%"*
;
S
S
K
O
O
*<:3"#((*-%'*F&5'(54
;%11%"*#4*F&5'(54*1#%2%"
Q
L
Q
2 3,
2603,#*#7#8,.8(#11*4"&"51",7
,
11 4" "51",
D*5"-*E*I,11%"*#"*MCN*,5:3*R%2P
(a)
(b)
,.%&*DP*E*.1%#.(*#"*MTN*/.R/31*5"'#:3(.,&
:3(.,&*'#"9 7&>D%*D>&*-#%*%&&%#:3.,&%"*+/&(,1'%M5%"I%"@*/.*
?,((3#,'*F#':3%&
>/&1%'5"2*X012/&#(34%"*#"*-%&*Y/475(%&2&,I#AZP*<<*TWW[
%#"%*<#:3(1#"#%*$/4*N%(&,:3(%&*%8#'(#%&(
T
G
<*-5&:3
-,''*,11%*(&,$%&'#%&(%"*
%2P
31*5"'#:3(.,&
2&,I#AZP*<<*TWW[
;
O
C
B
A
K
(c)
VW
L
L
(d)
O
P,((3#,'*A#':3%&
C
3.9: Vier Methoden für die Berechnung
der Eye-to-cell visibility.
9 Abbildung
C*D)11(*#"*E?G*H%(I(*,5:3*J%2
R/&1%'5"2*S012/&#(34%"*#"*-%&*T/475(%&2&,D#UV@*<<*FWWX
B
E
;
OQ
A
F
D
;
K
In praktischen Anwendungen wird man sich wahrscheinlich
L für Variante 2 oder 3 entscheiS
O
Q
den, da hier das
Verhältnis von Laufzeit zu Nutzen am besten ist. Bei sehr komplexer Geometrie in jedem Raum kann sich der zusätzliche Aufwand für die exakte Eye-To-Cell Visibility
Bestimmung jedoch auszahlen.
?,((3#,'*F#':3%&
R/&1%'5"2*S012/&#(34%"*#"*-%&*T/475(%&2&,D#UV@*<<*FWWX
VW
P,((3#,'*A#':3%&
OQ
3.2.5 Objekte in Räumen
Die Einrichtung einer Zelle (z.B. Stühle, Tische, Schränke, etc.) wird zusammen mit der Zelle
gerendert und geht nicht in die Sichtbarkeitsberechnung mit ein.
3.3 Dynamische Berechnung von Potentially Visible
Sets (PVS)
Das Ziel ist eine dynamische, sichtpunktabhängige Berechnung der PVS zur Laufzeit während
des Walkthrough. Dadurch wird es möglich, durchsichtige Bereiche während des Walkthrough
zu verschieben. Für die Berechnung wird zunächst eine räumliche Aufteilung mit einem BSPBaum in Zellen und Portale durchgeführt und anschließend eine sichtpunktabhängige Berechnung der PVS durchgeführt.
Die Idee besteht darin, die Zelle des Betrachters zu rendern und von dort ausgehend nur
doch die Zellen, die durch Portale zu sehen sind. Algorithmus 13 beschreibt das Vorgehen zur
Berechnung der PVS. Abbildung 3.10 zeigt ein Beispiel.
Die rote Cullbox geht vom Standpunkt des Beobachters aus. In dieser Box liegen nur die
Portale zu den Zellen C und F, d.h. D wird nicht gerendert. Der Schnitt der Cullbox mit
den Portalen ergibt die blauen Cullboxen. Innerhalb dieser Boxen liegt nur das Portal zu H,
weshalb die Boxen B und G unsichtbar sind. Der nächste Schnitt des blauen Kegels mit dem
Portal F-H erzeugt die grüne Cullbox.
AlgoCG 09
43
Kapitel 3. Visibility Culling
Algorithmus 13 Algorithmus zur dynamischen PVS Berechnung
1: function DYN PVS
2:
Bestimme die Zelle V des Betrachters
3:
Initialisiere eine 2-dimensionale Boundingbox P in der Größe des Bildschirms.
4:
Rendere die Geometrie der Zelle V , führe dabei Frustum Culling durch, wobei die
Spitze des Frustum vom Betrachter zum Rechteck P geht.
5:
Verfahre rekursiv für alle Nachbarn der Zelle V .
6:
for all Portal der aktuellen Zelle V do
7:
Projiziere das Portal auf den Schirm und bestimme die Boundingbox BB der Projektion.
8:
Bestimme die Schnittmenge von P und BB.
9:
for all Schnittmenge von P und BB. do
10:
if Schnittmenge leer then
11:
Benachbartes Portal unsichtbar
12:
else
13:
Führe Culling der Nachbarzelle mit Frustum durch, das durch die Schnittmenge begrenzt ist.
14:
end if
15:
Falls die Schnittmenge nicht leer war, können die Nachbarn sichtbar sein.
Setze P := Schnittmenge von P und BB und fahre rekursiv in Schritt 3 fort.
16:
end for
17:
end for
18: end function
HEINZ NIXDORF INSTITUT
Dynamische Berechnung von PVS
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Berechnungsbeispiel - 6
!"#$%#"&
9 - : 11. ; < # = - 3
9"*-%&*:511./8*;?<*#'(*=%-/@3*
-,'*+/&(,1*A5*>*A5*'%3%"B
<
;
>
C
D,&54*E#&-*F%11%*>*2%&%"-%&(
:
D
0
G
Abbildung 3.10: Dynamische Berechnung der PVS.
K/&1%'5"2*L012/&#(34%"*#"*-%&*:/475(%&2&,M#NOP*QQ*RSSJ
AlgoCG 09
H,((3#,'*<#'@3%&
IJ
44
Kapitel 3. Visibility Culling
3.4 Hierarchischer Z-Buffer
Die bisher vorgestellten Occlusion Techniken über PVS eignen sich gut für Szenen in Gebäuden. Für Waldszenen, sich bewegende Menschmassen oder anderes, offenes Gelände eignen
sie sich jedoch nicht. Unter den Annahme, dass Zweige, Blätter und Nadeln der Bäume ausmodelliert sind, erhält man einen großen Occluder, der aus sehr vielen kleinen, jeweils wenig verdeckenden Objekten besteht. Man spricht dabei auch von aggregierter Verdeckung.
Hier lassen sich Zellen mit beschränkter Sichtbarkeit nur sehr schlecht bilden und der Stabtree
würde sehr groß.
Der hierarchische Z-Buffer ist ein weiterer Occlusion Culling Algorithmus. Die Idee ist,
von vorne nach hinten zu rendern und alles was verdeckt ist, nicht zu zeichnen. Dabei geht das
Verfahren konservativ vor, d.h. jedes sichtbare Dreieck wird auch garantiert gezeichnet. Das
Ziel ist, die Redundanzen bei der Sichtbarkeitsabfrage (Abfrage der Z-Werte) zu reduzieren
und die Redundanzen bei der Darstellung von HEINZ
verdeckten
Dreiecken
NIXDORF
INSTITUT zu reduzieren.
rchischer Z-Buffer
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
3.4.1 Grundideen
%"&'$%()**"&+,--".&/)(&01($%2,%(".3
Im klassischen Z-Buffer Algorithmus wird die Sichtbarkeit für jeweils ein Pixel gelöst. Dabei
5'
5'*:%(&,;3(%&'#;3(*$/"*$/&"%*",;3*3#"(%"*&%"-%&"=
:%(&,;3(%&'#;3(
$/" $/&"%
",;3
3#"(%"
werden
auch die
Pixel
von &%"-%&"
Objekten bzw. Gruppen von Objekten betrachtet, die vollständig
hinter einem anderen Objekt liegen. In Abbildung 3.11 werden die Smileys komplett von
%&%;3"%"=*?@,""*%#"*A.B%C(*$%&-%;C(*#'(D=
dem Zylinder verdeckt, da der tiefste Z-Wert des Zylinders näher am Betrachter liegt als der
"%*%#"F#2%
"%
%#"F#2% 0.G&,2%*GH&*4I21#;3'(
0.G&,2%
GH& 4I21#;3'(
A.B%C(%
A.B%C(%*
naheste
Z-Wert der$#%1%
Smileys.
5&;3GH3&%"
.%&%#('
2%F%#;3"%(
2
.B%C(*#'(*2%",5*-,""*$%&-%;C(=*@%""*'%#"*4#"#4,1%&*
(*2&IN%&*#'(*,1'*-%&*4,8#4,1%*KLM%&(*.%&%#('*
;3"%(%&*A.B%C(%
B
"/;3*F5
F%#;3"%"
F4,8*
P
Q
4,8 OOKP1#"-%&Q
F4#"*OY4#1%P2&577%Q
U/&1%'5"2*V012/&#(34%"*#"*-%&*W/475(%&2&,G#CX=*YY*>ZZ[
R,((3#,'*S#';3%&
TE
Abbildung 3.11: Vollständige Verdeckung von Objekten durch ein größeres Objekt.
Man rendert nun von vorne nach hinten um schnell abfragen zu können, ob Objekte von bereits gezeichneten Objekten verdeckt werden. Ein Objekt ist genau dann verdeckt, wenn sein
minimaler Z-Wert größer ist als der maximale Z-Wert bereits gezeichneter Objekte. Um die
Berechnung effizienter als den normalen Z-Buffer Algorithmus zu machen, wird eine solche
Abfrage immer für eine Menge von Objekten auf einmal durchgeführt. Dazu wird ein Octree
AlgoCG 09
45
Kapitel 3. Visibility Culling
HEINZ NIXDORF INSTITUT
rchischer Z-Buffer
!"#$%&'#()(*+,-%&./&"
est
für die Szene aufgebaut, der die einzelnen Dreiecke enthält.
Ein Dreieck wird so tief wie mög012/&#(34%"*5"-*6/471%8#()(
lich einsortiert. Das Vorgehen im Paper speichert kleine Dreiecke, die auf den Sticky-Planes
zwischen großen Oktanten hängen bleiben, mehrfach in allen geschnitteten Oktanten. Dabei
%&$'&
enthält eine Octree-Box höchstens k Dreiecke. Passt ein Dreieck nicht in eines der 8 Kinder,
wird es im Elternknoten gespeichert.
Anstatt die Sichtbarkeit einzelner Dreiecke zu testen wird immer die ganze Box auf ihre
3&%"*%#"%*%1%4%"(,&%*<%'(/7%&,(#/"*%#"=
Sichtbarkeits geprüft. Dazu werden die Flächen der BoundingBox genutzt. Falls die Box unist, sind auch alleA/5"-#"2./8
Objekte in der Box und in allen Kindern unsichtbar. Der entschei?%2%.%" #'( sichtbar
?%2%.%"*#'(*%#"%*,@3'%"7,&,11%1%*A/5"-#"2./8*
%#"% ,@3'%"7,&,11%1%
dende
Faktor
für
die
Laufzeit
ist die Anzahl der Elemente, die unterhalb einer Box im OcBAA/8C
tree hängen. Der Test
Boundingbox
darf nicht länger dauern als das Rendern der Objekte
HEINZ der
NIXDORF
INSTITUT
!"#$%&'#()(*+,-%&./&"
+&;:%*#4*A#1-&,54D*/.*<%#1%*-%&*A/8*'#@3(.,&*'#"unterhalb der Box. 012/&#(34%"*5"-*6/471%8#()(
Sonst
würde sich der Test nicht mehr lohnen.
Die Testoperation prüft für eine achsenparallele Boundingbox, ob Teile von ihr im Bildraum
sichtbar sind wie in Abbildung 3.12 dargestellt.
$Funktion !"%&'(&)(*$!!"%$++,
f
*++$-)($-.$!-#/012.$)-34(+10,
%'(/7%&,(#/"*%#"=
0&(20'$(02&
'%"7,&,11%1%
'%"7,&,11%1%*A/5"-#"2./8*
A/5"-#"2./8
lse
*<%#1%*-%&*A/8*'#@3(.,&*'#"0&(20'$51#)&
(a)
)(*$!!"%$++,
(b)
012.$)-34(+10,
Abbildung 3.12: Prüfe für eine achsenparallele Boundingbox ob Teile von ihr unsichtbar sind.
E,((3#,'*F#'@3%&
I/&1%'5"2*J012/&#(34%"*#"*-%&*K/475(%&2&,:#LMD*NN*OPPH
GH
Mögliche Verfahren zur Durchführung des Boxentests sind die folgenden:
• Die Boundingbox kann aus 6 × 2 Dreiecken modelliert werden (2 Dreiecke pro Seite).
Man kann nun die Boundingbox in einem extra Puffer rendern und prüfen, wie viele
Pixel sichtbar sind.
E,((3#,'*F#'@3%&
K/475(%&2&,:#LMD*NN*OPPH
GH
• Projiziere die 8 Eckpunkte der Boundingbox in den Bildraum und berechne davon im
Bildraum die 2D Boundingbox.
• Unterstütze die Operation in spezieller Hardware.
Man prüft dann Pixelweise für die Z-Werte der Boundingbox gegen den Z-Buffer. Falls
alle Werte des Z-Buffers größer sind, ist die Box unsichtbar. Der Nachteil dieses Verfahrens
ist, dass Kosten in Größe der projizierten Box entstehen (in Anzahl der Pixel). Dies ist insbesondere für große Boxen ineffizient. Man verwendet daher die im nachfolgenden Abschnitt
vorgestellte Z-Pyramide.
3.4.2 Z-Pyramide
Die Z-Pyramide bildet eine Hierarchie von Z-Werten. Auf der untersten Ebene hat man die
Werte des normalen Z-Buffers. Für die nächst höhere Ebene werden jeweils vier benachbarte
AlgoCG 09
46
HEINZ NIXDORF INSTITUT
Hierarchischer Z-Buffer
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Aufbau der Z-Pyramide
Kapitel 3. Visibility Culling
!"#$%&'()*
9 :#&**.#1-%"*%#"%*;#%&,&<3#%*$/"*=C>%&(%"*?,4*.%'(%"*'#"-*@%&*+/(%"A%"B
:#& .#1-%" %#"% ;#%&,&<3#% $/" = >%&(%" ?,4 .%'(%" '#"- @%& +/(%"A%"B
HEINZ NIXDORF INSTITUT
Hierarchischer Z-Buffer
Z-Werte zu einem neuen, gröberen Quadranten zusammengefasst wie in einem regelmäßig
9 ,"*-%&*D7#(A%*-%&*;#%&,&<3#%*'(%3(*%#"*%#"A#2%&*=C>%&(
aufgebauten Quadtree. Abbildung 3.13(a) zeigt ein Beispiel. Dies wird solange fortgesetzt
!"#$%&'()*
#" -%" E1)((%&" '#"- -#% >%&(% -%' =CE5FF%&'
#"*-%"*E1)((%&"*'#"-*-#%*>%&(%*-%'*=CE5FF%&'
bis,
wie in Abbildung 3.13(b) dargestellt,9 nur
noch ein Wert an der Spitze der Pyramide steht.
9 :%;%#1'*$#%&*.%",<3.,&(%*=B>%&(%*-%'*=B?5@@%&'*;%&-%"*A5*%#"%4*"%5%"*
:%;%#1' $#%& .%",<3.,&(% = >%&(% -%' = ?5@@%&' ;%&-%" A5 %#"%4 "%5%"
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Aufbau der Z-Pyramide
2&C.%&%"*D5,-&,"(%"*A5',44%"2%@,''(
9 -#%*0&(*-%&*=5',44%"@,''5"2*%&@/12(*;#%*#"*%#"%4*&%2%14)E#2*,5@2%.,5(%"*
D5,-(&%%
=CE5FF%&:%&(%
Hierarchischer Z-Buffer
Aufbau der(a)
Z-Pyramide
F,((3#,'*G#'<3%&
J/&1%'5"2*K012/&#(34%"*#"*-%&*L/475(%&2&,@#MNO*PP*IQQR
!"#$%&'()*
U*05F1T'5"2
V*>%&(
S*05F1T'5"2HEINZ
NIXDORF INSTITUT
G,((3#,'*H#'<3%&
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
K/&1%'5"2*L012/&#(34%"*#"*-%&*M/475(%&2&,F#NOP*DD*@QQR
HI
(b)
Abbildung 3.13: Aufbau der Z-Pyramide.
+*,-.*% +*%/ 0/*./ (1 )*' 2%34*%*1 56&)%&1/*17
+*,-.*%8+*%/80/*./8(18)*'82%34*%*1856&)%&1/*17
In einem höheren
Quadrat steht jeweils der maximale Z-Wert aller seiner Kinder, d.h. der
9 #44%&*-%&*:;<%&(=*-%&*,4*>%#(%'(%"*$/4*?%(&,@3(%&*%"(A%&"(*#'(=*-B3B
-,'*C,8#454*-%&*$#%&*6#"-%&
Z-Wert, der am weitesten vom Betrachter entfernt ist. Lediglich im Z-Buffer selbst, d.h. der
9 "5&*#4*:;?5AA%&*D5"(%&'(%*E.%"%F*'(%3(*-%&*:;<%&(=*-%'*,4*")@3'(%"*
untersten Ebene
der Pyramide, steht der Wert des am nahegelegendsten Pixels. Abbildung
'(%3%"-%"*G&%#%@H'I
3.14 zeigt ein Beispiel für die hierarchische Propagierung der Z-Werte.
9
9
9
9
9
9
9
!
9
9
:
9
9
9
!
!
9
9
9
9
;
9
!
!
9
9
9
;
;
9
!
9
9
;
;
:
:
;
!
;
;
9
:
:
!
!
!
:
:
!
!
:
:
:
9
9
9
!
!
9
;
;
!
;
!
!
!
;
:
!
!
!
:
!
!
!
:
!
:
:
!
:
:
:
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,A#HP=*QQ*RSST
!
C,((3#,'*J#'@3%&
KL
Abbildung 3.14: Propagierung der Z-Werte in der Pyramide.
Ändert sich ein Wert im Z-Buffer, wird die Änderung solange nach oben propagiert, bis sich
der Wert des höheren Quadrats nicht mehr ändert.
3.4.3 Verwendung der Z-Pyramide
Für eine Seite der Boundingbox BBox des zu testenten Oktanten soll die Sichtbarkeit geprüft
werden. Jede der 6 Seiten wird als PolyBBoxi mit i = 1, . . . , 6 bezeichnet. Die 2DBBox
ist die 2D Boundingbox der PolyBBoxi im Bildraum. Dann ist Min(PolyBBoxi ) der kleinste
(näheste) Z-Wert einer Seite PolyBBoxi der Octreebox. Nun wird der feinste Level in der
Pyramide gesucht, in dem die 2D Box gerade noch vollständig in einen Quadranten passt. Sei
ZP.z der Z-Wert dieses Quadranten. Falls nun Min(PolyBBoxi ) ≥ ZP.z gilt, dann ist die Box
AlgoCG 09
47
IJ
9 :#&*;<""%"*"5&*-%"*=>?%&(*-%&*2&<.'(%"*@%$%1*#"*-%
HEINZ NIXDORF INSTITUT
Hierarchischer Z-Buffer
Kapitel
3.- Visibility
9 -#
-#%'*#'(*"#B3(*.%'/"-%&'*:#&;',4C*-,*%'*"5&*-%"*:%#
# ( # 3(
.
# ; Culling
#
2%&%"-%&(%&*D.E%;(%*1#%F%&(*
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Verwendung der Z-Pyramide
!"#$%#&'#()#($'"&$)"#$*+,-&./")#0
vollständig
verdeckt.
In Abbildung
3.15 wird
der
9 '5:3%
'5:3%*-%"*;%#"'(%"*<%$%1*#"*-%&*=B+>&,4#-%C*#"*-%"*-#%*?@AA/8*2%&,-%*
-%"
;%#"'(%" <%$%1
#" -%& = +>&,4#-%
#" -%" -#% ?@AA/8
2%&,-%
"/:3*&%#"*7,''(D*=+DE
'%#*-%&*-,E52%3F&#2%*=BG%&(
umrandet.
ausgewählte Quadrant für ein Dreieck in rot
9 H,11'*I#"JPolyBBoxiK*!*=+DE #'(*-,'*+/1>2/"*-%&*AA/8*$%&-%:L(
I,((3#,'*H#':3%&
O/&1%'5"2*P012/&#(34%"*#"*-%&*Q/475(%&2&,;#LRC*SS*?TTU
(a)
MN
J/&1%'5"2*K012/&#(34%"*#"*-%&*L/475(%&2&,F#;MC*NN*OPPQ
(b)
Abbildung 3.15: Prüfung der Sichtbarkeit von Dreiecken auf dem gröbsten möglichen Level.
Hierarchischer Z-Buffer
Verwendung der Z-Pyramide
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Das beschriebene Vorgehen funktioniert schlecht für Dreiecke, die genau in der Mitte des
Bildes liegen. Diese
schneiden die Quadranten der Pyramide häufig schon sehr früh, so dass
!"#$%&'(%)(*%&(+,-./01%*&
9 2%3%*:54*");3'(*<%#"%&%"*=%$%1*#"*-%&*>@+?&,4#-%
2%3%
:54 ");3'(
=%$%1 #"zum
-%& > +?&,4#-%
man nur den gröbsten
Level
der <%#"%&%"
Pyramide
Vergleich nehmen kann. Dies ist nicht sehr
7&A<%B*/.*-,'*+/1?2/"*#"*,11%"*CA.%&';3"%#-%"-%"D*E5,-&,"(%"*$%&-%;F(*#'(
effektiv, da es nur 9den
weitesten Z-Wert aller bereits gezeichneten Objekte enthält. Fällt der
9 '%(:%*0.'(#%2*&%F5&'#$*</&(*.#'*!"'#;3(.,&F%#(*<A&*,11%*E5,-&,"(%"*2%:%#2(*#'(B*
'%(:%die
0.'(#%2
&%F5&'#$ </&( .#' !"'#;3(.,&F%#(
<A& ,11%gezeigt
E5,-&,"(%"
2%:%#2( #'( dann wird in der ZTest negativ aus, d.h.
Unsichtbarkeit
kann nicht
werden,
/-%&*.#'*4,"*,5<*-%4*<%#"'(%"*=%$%1*'#;3(.,&%*+#8%1*2%<5"-%"*3,(*
Pyramide auf den nächst feineren Level abgestiegen wie in Abbildung 3.16 gezeigt.
K/&1%'5"2*L012/&#(34%"*#"*-%&*M/475(%&2&,<#FNB*OO*PQQJ
G,((3#,'*H#';3%&
IJ
Abbildung 3.16: Abstieg in der Z-Pyramide zur Auflösung kleiner Elemente, die große Boxen
schneiden.
Prüfe für alle überschneidenden Quadranten, ob das Polygon darin verdeckt ist. Falls dies
nicht der Fall ist, setzt man den Abstieg rekursiv für die Quadranten fort, in denen die Unsichtbarkeit nicht gezeigt werden konnte. Auf dem untersten Level wird ganz normal Pixel für Pixel der Z-Wert bestimmt und über den Z-Buffer-Algorithmus eingetragen. Ein Problem dieser
Vorgehensweise ist, dass der minimale Z-Wert für einen Teil des Polygons schwer zu bestimmen ist. Stattdessen verwendet man den Z-Wert des gesamten Polygons für alle Teile. Dies
geht wesentlich schneller, ist aber auch ungenauer, so dass nicht mehr alle Unsichtbarkeiten
gefunden werden können.
AlgoCG 09
48
Kapitel 3. Visibility Culling
3.4.4 Rendering mit dem Hierarchischen Z-Buffer
Beim Rendering wird der Octree von vorne nach hinten durchlaufen (front-to-back traversal).
Für jede Box wird mit Hilfe der Z-Pyramide die Sichtbarkeit geprüft. Falls die Box nicht
unsichtbar ist, werden alle enthaltenen Objekte gerendert und dann die Kinder traversiert. Das
Vorgehen fasst Algorithmus 14 zusammen.
Algorithmus 14 Rendering mit dem Hierarchischen Z-Buffer
1: function R ENDERO CTREE(OctreeNode N )
2:
if N ist außerhalb des Frustum then
3:
return
4:
end if
5:
if IsOccluded(N , Zp) then
6:
return
7:
end if
8:
for all Objekte o in OctreeBBox N do
9:
Rendere Objekt o
10:
Aktualisiere Z-Pyramide Zp
11:
end for
12:
for all Kinder C von N in front-to-back order do
13:
RenderOctree(C)
14:
end for
15: end function
. Zelle nicht im Sichtkegel
. Zelle ist verdeckt
Der hierarchische Z-Buffer versucht, drei Kohärenzen auszunutzen, die in einer 3D Szene
vorkommen können. Diese sind:
• Objektraumkohärenz (object space coherence)
Polygone in der Nähe eines verdeckten Polygons sind wahrscheinlich auch verdeckt.
Dies lässt sich über die Octree Traversierung ausnutzen, da dicht beieinanderliegende
Polygone in der gleichen Box sind, die dann mit hoher Wahrscheinlichkeit komplett
verdeckt ist.
• Bildraumkohärenz (image space coherence)
Ein Polygon mit einem verdeckten Pixel hat wahrscheinlich auch benachbarte Pixel, die
verdeckt sind. Durch die Hierarchie der Pyramide können viele Pixel auf einmal getestet
werden.
• Zeitliche Kohärenz (temporal coherence)
Falls ein Objekt in einem Frame sichtbar ist, ist es mit hoher Wahrscheinlichkeit auch
im nächsten Frame noch sichtbar.
Der Algorithmus wird wahrscheinlich am besten laufen, wenn für eine gegebene Position
die Z-Pyramide einmal aufgebaut wurde. Man führt eine Liste von Octree Boundingboxen,
die im letzten Frame sichtbar waren. Vor der Traversierung rendert man zuerst alle Boxen, die
im letzten Frame sichtbaren gewesen sind. Dabei werden nicht mehr sichtbare Boxen aus der
Liste entfernt und neu sichtbare Boxen in die Liste eingefügt.
AlgoCG 09
49
Kapitel 3. Visibility Culling
3.4.5 Hardwareunterstützung
Die Evaluierung des Algorithmus hat gezeigt, dass er ohne eine Hardwareunterstützung kaum
wirksam ist, da die Testoperationen zu teuer sind. Das Problem ist, dass sich Z-Pyramiden aufgrund der Hierarchie nur schlecht in Hardware implementieren lassen. Zudem führt die unterschiedlich lange Berechnungszeit für den Boxentest zu einem Abriss in der Pipeline. Stattdessen wurde ein einfacher Boxentest in Hardware implementiert. Dieser ist nicht blockierend
und erlaubt das gleichzeitige Rendern weiterer Geometrie. Die Methode gibt die Anzahl der
sichtbaren Pixel zurück.
HEINZ NIXDORF INSTITUT
Hierarchical Occlusion Maps
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Beobachtung und Ausgangspunkt
!"#$%&$#'"&()
3.5 Hierarchical
Occlusion Maps (HOM)B511#"2*
9 2&/:%*;<<15-%&*1,''%"*'#<3*25(*$%&=%"-%">*54*%??#@#%"(*;<<15'#/"
2&/:% ;<<15-%& 1,''%" '#<3 25( $%&=%"-%"> 54 %??#@#%"( ;<<15'#/"AB511#"2
-5&<3@5?C3&%"
Die Ausgangsidee 9 besteht
darin, dass sich große Occluder gut dazu verwenden lassen, um
D1%#"%*;<<15-%&*$%&-%<D%"*E@5*=%"#2F*5"-*%#2"%"*'#<3*-,3%&*=%"#2%&
effizient Occlusion Culling durchzuführen, da diese große Teile der Szene verdecken. Kleine
Occluder eignen sich dafür nicht so gut wie Abbildung 3.17 zeigt.
Abbildung 3.17: Verdeckungspotential verschieden großer Occluder.
HEINZ NIXDORF INSTITUT
Occlusion Maps nutzt
man aus, dass viele kleine Occluder zusammen
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
einen großen Occluder ergeben, der sich für
das Culling eignet. Es wird deshalb aus einer
Menge von Occludern ein sogenannter aggregierter Occluder gebildet, der wie in Abbildung
!"#$%&'()&"*'+,'-+.*/0(1%2&#3.18 dargestellt mehr
verdeckt als die einzelnen Occluder separat verdecken können.
95',44%"'%(:5"2 %#"%& ;<&577%=*,5'*>1%#"%"*
95',44%"'%(:5"2*%#"%&*;<&577%
,5' >1%#"%"
Hierarchical Occlusion
Für die Maps
Hierarchical
L/&1%'5"2*M012/&#(34%"*#"*-%&*B/475(%&2&,?#DN>*OO*PJJQ
G,((3#,'*H#'<3%&
IJK
Idee
?@@15-%&"A*-#%*#"*B)3%*:5%#","-%&*'(%3%"
?@@15-%%
344*#,'(+5#-106
C D%&%#"#25"2*%#"%&*?@@15-%&4%"2%
C %'*%"('(%3(*%#"*,22&%2#%&(%&*?@@15-%&
C %#"*,22&%2#%&(%&*?@@15-%&*$%&-%@>(*4%3&A*,1'*-#%*
%#":%1"%"*>1%#"%"*?@@15-%&*'%7,&,(*$%&-%@>%"*
>E""%"
,22&%2#%&(%&*?@@15-%&
.**/'&'16/7*%1/)'1%
C >%#"%*'7%:#%11%"*F(&5>(5&%"*GH#%*.%#*+DFI*#4*
Abbildung 3.18:
J/-%11*"/(H%"-#2
Verdeckungspotential eines aggregierten Occluders.
C >%#"%*K%'(&#>(#/"%"*,"*-#%*?@@15-%&(V7%"
>%#"% K%'(&#>(#/"%" ," -#% ?@@1 -%&( 7%"
Die Hierarchical Occlusion Maps stellen dabei im Gegensatz zu PVS keine Anforderungen
Form der Occludertypen. Sie eignen sich daher sehr gut für
MNO
J,((3#,'*L#'@3%&
CAD- und Outdoor Szenen.
C -,3%&*25(*2%%#2"%(*RW&*Q0XY
an die Struktur5"-*?5(-//&YF:%"%"
der Szene oder die
D/&1%'5"2*P012/&#(34%"*#"*-%&*Q/475(%&2&,R#>SA*FF*TNNU
AlgoCG 09
50
Kapitel 3. Visibility Culling
HEINZ NIXDORF INSTITUT
Hierarchical Occlusion Maps
3.5.1 Der
HOM-Algorithmus
HOM-Algorithmus
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Der Algorithmus
baut zunächst im Preprocessing eine Occluder-Datenbank auf. Diese ent!"#$%&'()*+,-./
hält eine 9%&*012/&#(345'*,&.%#(%(*#"*:;%#*<=3&#((%">*
Menge
von
Occludern.
Anschließend werden online für jeden Frame zwei
9%& 012/&#(345'guten
,&.%#(%(
#" :;%# <=3&#((%">
Berechnungsschritte
durchgeführt:
-#%*.%#-%"*<=3&#((%*;%&-%"*?@&*A%-%'
B&,4%*.%&%=3"%(C
DE F%&%=3"5"2*-%&*G==15'#/"HI,7*J#%&,&=3#%
1. Berechnung der Occlusion-Map-Hierarchie
KE L#'#.#1#(M*N511#"2*5"-*O%"-%&#"2
2. Visibility Culling und Rendering
JGI*P*J#%&,&=3#=,1*G==15'#/"*I,7'
Die dazu
notwendigen Schritte fast das Ablaufdiagramm in Abbildung 3.19 zusammen.
G==15-%&
9,(%".,"Q
L#%;HB&5'(54
N511#"2
G==15-%&
05';,31
G==15-%&
O%"-%&#"2
F%&%=3"5"2*G==15'#/"H
I,7*J#%&,&=3#%
R9H<:%"%
9,(%".,"Q
L#%;HB&5'(54
N511#"2
L/&1%'5"2*U012/&#(34%"*#"*-%&*N/475(%&2&,?#QVW*<<*KSST
O%"-%&#"2
R9H<:%"%
JGIHN511#"2
I,((3#,'*B#'=3%&
DST
Abbildung 3.19: Ablauf des Rendering unter Verwendung von HOM Culling.
3.5.1.1 Aufbau der Hierarchie
Zunächst wird die 3D-Szene in Form einer Bounding-Volume Hierarchie repräsentiert. Dies
ist vermutlich ein Octree. Anschließend wird daraus eine Occluder-Datenbank mit einer
Menge von Occludern abgeleitet. Diese Schritte werden im Preprocessing durchgeführt. Um
einen Frame zu rendern wird eine Teilmenge der Occluder aus der Datenbank genommen, die
im View-Frustum enthalten ist. Es werden jedoch nicht alle möglichen Occluder ausgewählt,
da das anschließende Rendern dieser Objekte nicht lange dauern soll. Die Objekte werden aus
diesem Grund als weiße Objekte (schwarz-weiß Bild) in den Framebuffer gerendert. Das entstandene Bild wird dann aus dem Framebuffer zurückgelesen und bildet den Ausgangspunkt
für die Berechnung der Occlusion-Map Hierarchie. In einem Zwischenschritt wird ein Tiefenpuffer zur Tiefenabschätzung der Occluder berechnet. Das aus dem Framebuffer gelesene
Bild ist die feinste Auflösung für die Occlusion-Map Hierarchie. Die Hierarchie entsteht ähnlich zum Hierarchischen Z-Buffer dadurch, dass immer Quadranten von 4 Pixeln zu einem Pixel zusammengefasst werden. Dabei erhält das gröbere Pixel als Wert das arithmetische Mittel
der 4 Einzelwerte. Auf der feinsten Ebene ist ein Wert 1, wenn das Pixel von den Occludern
abgedeckt ist, und 0, wenn nicht. In der Praxis wird der Mittelwert als bilineare Interpolation
durch die Graphik-Hardware mit Texture-Mapping-Unterstützung berechnet. Abbildung 3.20
zeigt ein Beispiel für eine solche Hierarchie von Occlusion Maps (HOM).
Das Rendern über den Texture-Mapper funktioniert so, dass eine Occlusion Map der Größe
2N × 2N in den Framebuffer gerendert wird. Anschließend wird das Bild in den Texturspeicher geladen und auf ein Rechteck mit halber Seitenlänge gerendert. Dies wird solange
durchgeführt, bis eine vordefinierte gröbste Auflösung erreicht wurde.
AlgoCG 09
51
Kapitel 3. Visibility Culling
Abbildung 3.20: Occlusion-Map Hierarchie.
3.5.1.2 Visibility Culling und Rendering mit HOM
Für das Rendering der Szene wird zunächst ein normales Frustum Culling durchgeführt. Anschließend wird über den Tiefenpuffer getestet, ob das Objekt hinter den Occludern liegt. Falls
nicht, muss es gezeichnet werden. Ansonsten wird im dritten Schritt die 2D Projektion des
Objektes für den Überlappungstest berechnet. Dabei wird die Occlusion-Map Hierarchie von
oben nach unten durchgegangen und jeweils geprüft, ob der Occludee durch undurchsichtige
Teile der Occlusion-Map verdeckt wird.
3.5.2 Betrachtung der Teilschritte
3.5.2.1 Überlappungstest
Das Objekt wird konservativ in den Bildraum projiziert. Dazu werden die Eckpunkte der
3D-Boundingbox in den Bildraum projiziert und anschließend die 2D-Boundingbox der Projektion betrachtet. Anschließend wird eine Map verwendet, deren Pixelgröße der Größe der
Box entspricht. Danach wird für jedes Pixel, dass die Boundingbox schneidet, geprüft, ob es
sichtbar ist oder nicht. Falls das Pixel das Objekt nicht vollständig verdeckt, werden die Pixel
rekursiv ausgewertet. Falls alle geprüften Pixel undurchsichtig (Schwellwert = 1) sind, wird
das Objekt potentiell vollständig von den Occludern verdeckt. Gewissheit darüber erhält man
durch den zusätzlichen, in Abschnitt 3.5.2.4 beschriebenen Tiefentest.
AlgoCG 09
52
Kapitel 3. Visibility Culling
3.5.2.2 Occluderauswahl im Preprocessing
Im Preprocessing werden alle Objekte der 3D-Datenbank untersucht. Als Occluder eignen
sich Objekte, die
• nicht zu klein sind, da sich kleine Objekte nur schlecht als Occluder eignen
• nicht redundant zu anderen Occludern sind (z.B. ist eine Uhr an einer Wand redundant
zu der Wand, die einen besseren Occluder darstellt).
• nicht zu komplex sind, da die Occluder schnell gerendert werden müssen und komplexe
Objekte zuviel Zeit in Ansprucht nehmen.
3.5.2.3 Occluderauswahl zur Laufzeit
Zur Laufzeit wird eine Menge von Occludern aus der Occluder-Datenbank ausgewählt. Dazu
werden zunächst alle Occluder des Frustums bestimmt und dann nach Entfernung sortiert
(3D-BBox Mittelpunkt). Als Occluder eignen sich vor allem solche, die nah an der Kamera
stehen und wenige Polygone haben. Entsprechend werden startend von der Kameraposition
sukzessive Occluder ausgewählt, bis eine maximale Polygonkomplexität erreicht wurde. Die
Polygonkomplexität ist die Summe der enthaltenen Polygone.
3.5.2.4 Tiefentest
Nachdem festgestellt wurde, dass sich ein Objekt mit der Occlusion Map vollständig überlappt, muss festgestellt werden, ob es auch hinter dem aggregierten Occluder liegt. Dafür gibt
es zwei Varianten.
Variante 1 Für die Occlusion Map wird ein z-Wert einer z-Ebene gespeichert, die die aggregierten Occluder von möglichen Occludees trennt. Der gewählte z-Wert ist der z-Wert des
am weitesten entfernten Occluders (bzw. der weitest entfernte Eckpunkt dieses Occluders).
Alle Objekte, die vollständig hinter dieser z-Ebene liegen, werden vollständig verdeckt wie in
Abbildung 3.21(a) dargestellt.
Variante 2 Bei dieser Variante werden mehrere z-Ebenen verwaltet. Dazu wird der 2DBildraum z.B. in 64 × 64 gleichgroße Kacheln partitioniert, um einen Tiefenpuffer zu erhalten. Für jede Kachel wird ein Tiefenwert gespeichert. Dieser entspricht dem z-Wert des am
weitesten entfernten Occluders, der auf diese Kachel projiziert wird. Abbildung 3.21(b) zeigt
dieses Vorgehen.
Für den Aufbau des Tiefenpuffers werden die Ecken aller 3D-Boundingboxen der Occluder
in den 2D-Bildraum projiziert. Aus diesen wird die 2D-Boundingbox berechnet. Der z-Wert
entspricht dem größten z-Wert unter allen 3D-Eckpunkten der 3D-Boundingbox. Man aktualisiert nun die Tiefenwerte aller Kacheln, die von der 2D-Boundingbox geschnitten werden.
AlgoCG 09
53
HEINZ NIXDORF INSTITUT
Hierarchical Occlusion Maps
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
HEINZ NIXDORF INSTITUT
l Occlusion Maps
Tiefentest - 2
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Kapitel 3. Visibility Culling
!"#$"%&'()
%#'()*+#,&#'(-"&(.#/()0012'"3%4567
9%&:%#"%&% -#% ;-%% 4#( %#"%& <
9%&:%#"%&%*-#%*;-%%*4#(*%#"%&
<=>.%"%
>.%"%*5"-*$%&?%"-%*
5"- $%&?%"-%
(2%'(%11(
(2%'(%11(*<5&-%=*-,''*'#:3*%#"*>.?%@(*4#(*-%&*
<5&-%= -,'' '#:3 %#" >.?%@( 4#( -%&
4%3&%&% <=>.%"%"
,7*$/11'()"-#2*C.%&1,77(=*4C''%"*<#&*7&C;%"=*/.*%'*
2&%2#%&(%"*>::15-%&" 1#%2(
*$'+'%,-++'#
3%&"*;C&*-#%*>::15'#/"AB,7*-%"*EAF%&(*%#"%&*EA
@ ?#&*7,&(#(#/"#%&%"*-%"*AB=C#1-&,54
#%*-#%*>::15-%&*$/"*4H21#:3%"*>::15-%%'*(&%""(
D.'7? #" EF8EF 21%#G3 2&/H% 6,G3%1"I
D.'7?J*#"*EF8EF*21%#G3*2&/H%*6,G3%1"I
-%&*EAG.%"%*#'(*-%&*EAF%&(*-%'*,4*<%#(%'(%"*
@ .#1-%*:K&*L%-%*6,G3%1*-%'*M#%:%"75::%&'*%#"%*<=>.%"%
"*>::15-%&'*
EAG.%"%
JJ*-%&*<%#(%'(%*G:@75"@(*-%&*K/5"-#"2./8L
-%& <%#(%'(% G:@75"@( -%& K/5"-#"2./8L
@ L%-%
L%-%*6,G3%1*%"(3)1(*-%"*<=N%&(*-%'*,4*?%#(%'(%"*
6,G3%1 %"(3)1( -%" <=N%&( -%' ,4 ?%#(%'(%"
%"(:%&"(%"*OGG15-%&'P*-%&*#"*-#%'%*6,G3%1*7&/L#<#%&(*?#&-
,22&%2#%&(%*>::15-%&*
#
> 1 N#%*.%&%G3%"*?#&*-%"*M#%:%"75::%&Q
-%&*>::15'#/"AB,7
<=>.%"%"*+,&(#(#/"%"
#4*AB=C#1-&,54
>::15-%%
N#%*?#&-*%&*$%&?%"-%(Q
B,((3#,'*M#':3%&
Q/&1%'5"2*R012/&#(34%"*#"*-%&*S/475(%&2&,;#@T=*UU*OVVW
(a)
NOP
TAE
Abbildung 3.21: Tiefentest der überlappenden Occludees,HEINZ
(a) zeigt
die Variante mit einer zNIXDORF INSTITUT
Hierarchical Occlusion Maps
!"#$%&'#()(*+,-%&./&"
Ebene, (b) zeigt die Variante mit mehreren 012/&#(34%"*5"-*6/471%8#()(
z-Partitionen.
Tiefentest - 4
!"#$"%&'()(
9%&:%"-5"2*-%'*;#%<%"75<<%&
9%&:%"-5"2
-%' ;#%<%"75<<%&
=>??15-%%@;%'(A
B :#&*7&/C#D#%&%"*-#%*E?F%"*-%&*GH@I./8*-%'*D5*
(%'(%"-%"*>.C%F(%'*#"*-%"*JH@I#1-&,54
HEINZ NIXDORF INSTITUT
clusion MapsB $/"
$/"*-%"*E?F%"*.#1-%"*:#&*-#%*JH@I./8
-%" E?F%" .#1-%" :#& -#% JH
I./8
!"#$%&'#()(*+,-%&./&"
;#%<%"75<<%&
(b)
R,((3#,'*S#'G3%&
9/&1%'5"2*U012/&#(34%"*#"*-%&*V/475(%&2&,:#WXP*YY*AZZ[
D5*(%'(%"-%'*>.C%F(
C
012/&#(34%"*5"-*6/471%8#()(
B :#&*.%&%?3"%"*-%"*")?3'(%"*K@L%&( ,11%&*
E?F%"*-%&*GH@I./8*
")?3'(%& K@L%&(
")?3'(%&*K@L%&(
B :#&*7&M<%"*-#%'%"*L%&(*4#(*,11%"*E#"(&)2%"*-%'*
;#%<%"75<<%&'N*-#%*$/"*-%&*JH@I./8*
2%'?3"#((%" :%&-%"
2%'?3"#((%"*:%&-%"*
*-#%*E?F%"*-%&*GH@I./8*-%'*D5*
%F(%'*#"*-%"*JH@I#1-&,54
D5*(%'(%"-%'*>.C%F(
C
"*.#1-%"*:#&*-#%*JH@I./8
" .#1-%" :#& -#% JH I./8
"*-%"*")?3'(%"*K@L%&( ,11%&*
@I./8*
O,((3#,'*P#'?3%&
(a)
(b)
9/&1%'5"2*S012/&#(34%"*#"*-%&*T/475(%&2&,<#FUN*VV*JWWX
'%"*L%&(*4#(*,11%"*E#"(&)2%"*-%'*
Abbildung 3.22:
*-#%*$/"*-%&*JH@I./8*
%&-%"*
%&-%"
'5"2*S012/&#(34%"*#"*-%&*T/475(%&2&,<#FUN*VV*JWWX
AlgoCG 09
")?3'(%& K@L%&(
")?3'(%&*K@L%&(
QJR
Ausführung des Tiefentests, (a) zeigt die 2D Projektion von Occluder und
Occludee, (b) zeigt eine 3D Übersicht mit eingezeichneten z-Ebenen.
O,((3#,'*P#'?3%&
QJR
54
Kapitel 3. Visibility Culling
Für den in Abbildung 3.22 illustrierten Tiefentest wird die 3D-Boundingbox des Occludees
in den Bildraum projiziert. Anschließend wird der am nahesten zur Beobachterposition gelegene z-Wert der Boundingbox verwendet. Dieser z-Wert wird gegen alle Kacheln des Tiefenpuffers geprüft, die von der projizierten 2D-Boudingsbox des Objektes geschnitten werden.
3.5.3 Approximatives Visibility Culling
Das bisher betrachtete exakte Culling betrachtet ein Pixel der Occlusion Map nur dann als undurchsichtig, wenn es den Wert 1 hat. Bei einem approximativen Culling betrachtet man auch
Pixel mit einem Wert < 1 als undurchsichtig. Damit betrachtet man kleine Löcher als undurchsichtig und kann mehr Objekte verwerfen, die jedoch durch die kleinen Löcher sichtbar
sind. Die Motivation, es trotzdem zu tun, ist, dass die kleinen Löcher in der Darstellung kaum
auffallen und das Rendering beschleunigt werden kann. Je kleiner man den Schwellwert setzt,
desto größer sind die zugelassenen Löcher und damit die zugelassenen Bildfehler. Man muss
nun für jede Ebene in der Occlusion-Map Hierarchie einen solchen Schwellwert berechnen.
Betrachtet man als Beispiel eine Auflösung von 1024 × 1024 Pixeln und eine OcclusionMap von 64 × 64 Pixeln, dann entspricht jedes Pixel der Occlusion-Map 16 × 16 gerenderten
Pixeln im Bild. Möchte man auf dieser Fläche maximal ein Loch von 25 Pixeln zulassen,
25
≈ 0.9 setzen.
muss man den Schwellwert auf 1 − 16·16
Nummeriert man die Ebenen durch, kann man eine allgemeingültige Formel angeben. Dabei entspricht Ebene 0 der nativen Auflösung und somit der feinsten Occlusion Map. Möchte
man n fehlerhafte Pixel unter insgesamt m Pixeln einer Kachel auf Ebene k zulassen, dann
n
. Auf der nächsthöheren Ebene k + 1 erhält man
ergibt sich als Schwellwert Ok = 1 − m
die vierfache Menge an Pixeln, da jeweils 4 Pixel zu einem Pixel zusammengefasst werden.
Damit erhält man
n
1 − Ok
3 + Ok
Ok+1 = 1 −
=1−
=
4m
4
4
Beim Überlappungstest wird die Überprüfung abgebrochen, sobald der Undurchsichtigkeitswert eines überprüften Pixels oberhalb des Schwellwertes liegt. Man betrachtet das Objekt als vollständig verdeckt.
3.6 Zusammenfassung
Die bislang vorgestellten Techniken haben die folgenden Einsatzbereiche:
• Effizientes Frustum Culling wird mit räumlichen Datenstrukturen (Octrees oder Loose
Octrees durchgeführt)
• Effizientes Occlusion Culling für Indoor Szenen berechnen wir über Potentially Visible
Sets (PVS).
• Effizientes Occlusion Culling für Outdoor Szenen oder dynamische Szenen berechnen
wir über einen hierarchischen Z-Buffer oder über Hierarchical Occlusion Maps.
AlgoCG 09
55
4 Replacement
Es kann passieren, dass eine Szene zu viele Artefakte enthält, um sie zeichnen zu können. Die
in diesem Kapitel vorgestellten Techniken sollen das Zeichnen unter der in Kaufnahme von
Qualitätsverlusten trotzdem ermöglichen.
4.1 Rendering mit Color-Cubes
Große Szenen enthalten oft zuviele Objekte, um sie zeichnen zu können. Mit Occlusion Culling (siehe Kapitel 3) und den in Kapitel 6 vorgestellten Level of Detail Techniken kann die
NIXDORF INSTITUT
Color-Cubes
Anzahl der Objekte
in der Szene reduziert werden. Dafür gibt HEINZ
es aber
Grenzen, denn beim
!"#$%&#'()#('
Level of Detail ist ein Dreieck die untere Grenze und auch für dieses entstehen Renderingkosten. Beim Rendering
mit
Color-Cubes werden in einer solchen Situation ganze Gruppen von
Zentrale
Idee
Objekten zusammengefasst
und
9 (
9&'%(<%*%#"%"*$/11'()"-#2%"*:%&%#=3*%#"%&*$#&(5%11%*;<%"%*-5&=3*%#"%"*
#
11 () durch
-#
: eine
# 3 #Ersatzrepräsentation
# ( 11 ;
- 3 # ersetzt. Man ersetzt einen
2%>)&.(%"*?@&>%1*-%&*54'=31#%A%"-%"*:/5"-#"2./8
vollständigen Bereich der virtuelle Szene durch einen gefärbten Würfel der umschließenden
Boundingbox wie in Abbildung 4.1 dargestellt.
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Abbildung 4.1: Generelle Idee der Color-Cubes.
E/&1%'5"2*F012/&#(34%"*#"*-%&*G/475(%&2&,>#HIJ*;;*KLLM
B,((3#,'*C#'=3%&
DD
4.1.1 Datenstruktur
Die Szene wird über einen 3D-Octree repräsentiert, der alle Dreiecke in den Blättern abspeichert. Dreiecke, die die Kanten der Octreeboxen schneiden, werden mehrfach gespeichert.
Um sie nicht mehrfach zu zeichnen, wird ein Flag gesetzt, das angibt, ob das Dreieck bereits
gezeichnet wurde. Zu jeder Octreebox wird ein Würfel (Color-Cube) gespeichert, der genauso
groß ist wie die Zelle. Jede der sechs Seiten des Würfels hat einen Farbwert und einen Undurchsichtigkeitswert (Transparenz), dabei ist 1.0 undurchsichtig und 0.0 vollständig transparent. Der Farbwert und der Transparenzwert approximieren die orthogonale Sicht auf die
Geometrie der Zelle. Dies wird im Preprocessing berechnet. Abbildung 4.2 zeigt ein Beispiel
für einen Color-Cube.
56
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
"#$%&#'()#('
Wie berechnen wir die Ersetzungen?
Kapitel 4. Replacement
= 9#
9#&*'7%#>3%&"*4#(*:%-%&*;>(&%%?<%11%*%#"%"*
# 3
#( : - ; (
< 11 #
9@&A%1*B*+,+'-*(.$CD*-%&*2%",5'/*2&/E*#'(*F#%*
-#%*<%11%
= :%-%&*-%&*G*H%#(%"*3,(*%#"%"*I,&.F%&(*5"-*%#"%"*
J!"-5&>3'#>3(#2K%#('F%&(L*BM&,"'7,&%"NC
BOPQR!"-5&>3'#>3(#2D*
QPQR$/11'()"-#2*(&,"'7,&%"(C
Abbildung 4.2: Ein Color-Cube mit unterschiedlichen Seitenfarben, die die unterschiedlichen
orthogonalen Aufsichten approximieren
Color-Cubes
U/&1%'5"2*V012/&#(34%"*#"*-%&*W/475(%&2&,A#KXD*HH*YQQZ
4.1.2 Rendering
!"#$"%&#'
S,((3#,'*I#'>3%&
HEINZ NIXDORF INSTITUT
OT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Wie
Szene gerendert?
Fürwird
alledieOctree-Zellen,
deren
projizierte Größe kleiner als ein Schwellwert ε ist, wird der
Color-Cube
gezeichnet.
Ein7möglicher
Wert ist ε gleich ein Pixel zu setzen. Für alle Octree9 :;&*,11%*<=(&%%>?%11%"@*-%&%"*7&/A#B#%&(%*C&DE%*F1%#"%&*,1'*%#"*:%'(%&*
@
A
G=3H%11H%&(*!*#'(*IBJKJ*%#"*+#8%1L@*B%#=3"%*-%"*M/1/&>M5.%*I.1,5%*?%11%"L
Zellen, deren Projektion größer ist als ε wird die Geometrie gerendert. Das Vorgehen wird
von
Algorithmus 15 zusammengefasst und von Abbildung 4.3 graphisch illustriert.
9 :;&*,11%*<=(&%%>?%11%"@*-%&%"*7&/A#B#%&(%*C&DE%*2&DE%&*#'(@*B%#=3"%*-#%*
%"(3,1(%"% C%/4%(&#% I2&;"% ?%11%"L
%"(3,1(%"%*C%/4%(&#%*I2&;"%*?%11%"L
R/&1%'5"2*S012/&#(34%"*#"*-%&*M/475(%&2&,:#FT@*GG*UVVW
N,((3#,'*O#'=3%&
PQ
Abbildung 4.3: Rendering mit Color-Cubes. Für die grünen Zellen wird die Geometrie gerendert, für die blauen der Color-Cube gezeichnet und die roten liegen außerhalb
des Frustums.
4.1.3 Aufbau der Hierarchie
Der Aufbau der Color-Cube Hierarchie geschieht in drei Schritten:
1. Aufbau eines Octree und Verteilung der Dreiecke
2. Berechnung der Color-Cubes für die Blätter (initial)
AlgoCG 09
57
Kapitel 4. Replacement
Algorithmus 15 Rendering mit Color-Cubes
1: function R ENDER(Octreecell)
2:
if kein Teil der Octree-Zelle überlappt das Frustum then
3:
return
4:
end if
5:
if projizierte Größe der Octree-Zelle < ε then
6:
Rendere den Color-Cube der Octree-Zelle
7:
else if Octree-Zelle ist ein Blatt then
8:
Rendere die Geometrie der Zelle
9:
else
10:
for all Kinder der Octree-Zelle (in back-to-front-order) do
11:
Render(Kind)
12:
end for
13:
end if
14: end function
3. Berechnung der Color-Cubes für innere Knoten
Die Schritte 2 und 3 werden in einem Post-Order Durchlauf durch den Octree berechnet,
d.h. erst werden die Color-Cubes für die Kinder berechnet und dann der ColorCube für die
Eltern.
HEINZ NIXDORF INSTITUT
Color-Cubes
In Schritt
1 startet man mit einer Wurzelzelle, die die gesamte Geometrie
umfasst. An!"#$%&'#()(*+,-%&./&"
!"#$%"&'()&*+()%),-+(
schließend
werden die Dreiecke solange rekursiv auf die Kinder aufgeteilt,012/&#(34%"*5"-*6/471%8#()(
bis die Anzahl der
Dreiecke pro Zelle genügend klein ist. Die Anzahl ist genügend klein, wenn die RenderingBerechnung der Color-Cubes für die Blätter (initial)
zeit der Geometrie kleiner ist als die Renderingzeit der Color-Cubes aller Kinder. Diese Zeit
kann man experimentell bestimmen oder an Hand der Dreiecke abschätzen.
9:&*,11%*;*<%#(%"*-%&*=>(&%%?@%11%A
.%&%>3"%*%#"*D#1-*$/"*-%4*@%11%"#"3,1(*#"*/&(3/2&,73#'>3%&*+&/E%F(#/"*
4.1.3.1 BC
Berechnung
der initialen Farbwerte
G0 H1I' "2 J J +# %1 /-%& 2&IK%&L
G05H1I'5"2*J8J*+#8%1*/-%&*2&IK%&L
Die Berechnung wird für alle 6 Seiten der Octree-Zelle durchgeführt. Im ersten Schritt wird
MC .%&%>3"%*-%"*N5&>3'>3"#((*-%&*9,&.O%&(%*,11%&*2%&,'(%&(%"*+#8%1*-%'*D#1-%'
eine orthographische Projektion des Zelleninhalts auf eine Auflösung von 4 × 4 Pixel berechP ist .%&%>3"%*%#"%"*S!"'#>3(.,&F%#('O%&(
.%&%>3"%
%#"%" !"'#>3(.,&F%#('O%&(QA
-%&Durchschnitt
2#.( ," O#% $#%1
-%& +#8%1
net (mehrPC
auch möglich).
Anschließend wird A*-%&*2#.(*,"*O#%*$#%1*+&/R%"(*-%&*+#8%1*
der
der+&/R%"(
Farbwerte
aller gera-%&*<%#(%"H1)>3%*4#(*T%/4%(&#%*.%-%>F(*#'(
sterten Pixel des Bildes berechnet, sowie ein Unsichtbarkeitswert, der angibt, wie viel Prozent der Pixel
der Seitenfläche von Geometrie bedeckt sind. Dieser Wert wird als α-Wert des
JC '7%#>3%&%*-%"*U%&(*#4*0173,?U%&(*-%'*9,&.O%&('*GVTD0W*X&,"'7,&%"RL
Farbwertes für die Seitenfläche gespeichert. Abbildung 4.4 illustriert dieses Vorgehen.
Z/&1%'5"2*[012/&#(34%"*#"*-%&*\/475(%&2&,H#F]W*<<*M^^_
Y,((3#,'*9#'>3%&
MB
Abbildung 4.4: Berechnung des initialen Farbwerts eines Color-Cubes.
AlgoCG 09
58
Kapitel 4. Replacement
4.1.3.2 Berechnung der Farbwerte für innere Knoten
Der Farbwert des Color-Cubes für einen inneren Knoten wird aus den Farbwerten der ColorCubes der Kinder berechnet. Dazu betrachtet man auf jeder Seite der Octree-Zelle die entHEINZ NIXDORF INSTITUT
sprechenden Color-Cubes
Seiten der Color-Cubes der Kinder aus derselben Blickrichtung
(8 Farbwerte).
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$%"&'()&*+()%),-+(
Dabei wird von der vorne liegenden Box nach hinten durchgesehen und der Farbwert des vorderen Color-Cube
wird mit
direkt dahinterliegenden
Color-Cube gemittelt. Dabei muss
Berechnung
derdem
Color-Cubes
für interne Octree-Zellen
der Transparenzwert
α berücksichtigt werden. Die Farbe ergibt sich dann als
9:& ,11% ; <%#(%" -%& =>(&%%?@%11%A
9:&*,11%*;*<%#(%"*-%&*=>(&%%?@%11%A
BC
4#((1%*D%E%#1'*7,,&E%#'%*-%"*9,&.E%&(*-%&*$/&-%&%"*<%#(%*-%'*$/&"%*1#%2%"-%"*
c = α · cf g + (1 − α) · cbg
F/1/&?F5.%'*4#(*-%4*9,&.E%&(*-%&*<%#(%*-%'*-,3#"(%&1#%2%"-%"*F/1/&?F5.%'C*
wobei cf g die Farbe
des vorderen Würfels ist und cbg die Farbe des hinteren Würfels. Dieser
GC .%&:>H'#>3(#2%*-,.%#*-%"*I&,"'7,&%"JE%&(*!&A
.'7ECA*,.,
1&234genannt.
!50,$/ .JEC*>/47/'#(%*K/$%&L*",>3*M+/&(%&NO5PP*BQRST
Schritt wird auch „composite
over“
Aus den auf diese Weise ermittelten vier Farb#/ 0&!
werten wird dann
der- Durchschnitt
um1 die( P:Farbe
U wie
UC
. zuvor
.%&%>3"%*,5'*-%"*S*9,&.E%&(%"*-%"*9,&.4#((%1E%&(*P:&*-#%*<%#(%*-%'*J5*
3
S9 .
( berechnet
- 9 . #((
-# <für
#( die
- entsprechende
.%&%>3"%"-%"*F/1/&?F5.%'
Seite des Color-Cubes
zu erhalten. Abbildung 4.5 illustriert diesen Vorgang.
A
B
C
D
E
F
G
H
AE BF
CG DH
>/47/'#(%*K/$%&L
W/&1%'5"2*X012/&#(34%"*#"*-%&*F/475(%&2&,P#HYN*<<*GZZQ
O5&>3'>3"#((*:.%&*,11%*$#%&*+#8%1
V,((3#,'*9#'>3%&
GU
Abbildung 4.5: Berechnung des Farbwerts eines Color-Cubes für einen inneren Knoten.
4.1.4 Aufwandsabschätzung
Der Rendering Algorithmus benötigt Zeit O(log(n)). Für den Nachweis werden die beiden
folgenden, verfeinfachenden Annahmen getroffen:
1. Die Tiefe d des Octree ist d = O(log(n)), wobei n die Anzahl der Dreiecke ist.
2. Die maximale Anzahl geometrischer Primitive pro Blattzelle ist konstant.
Die Szene wird dann, wie in Abbildung 4.6 dargestellt, in einen Nahbereich und einen Weitbereich aufgeteilt. Im Nahbereich wird die vollständige Geometrie gerendert, im Weitbereich
nur Color-Cubes. Im Weitbereich erhält man mehrere Subfrusta i, die jeweils einer Ebene i
des Octrees entsprechen, deren projizierte Größe kleiner als ε ist. Die Color-Cubes können
unterschiedlich großen Bounding-Boxen entsprechen, je nachdem wie weit die Box entfernt
ist.
Da die Tiefe des Octree maximal O(log(n)) ist, erhält man auch nur maximal O(log(n))
Subfrusta im Weitbereich; eines für jeden Level des Octree. Die Anzahl der Zellen ist für
einen festen Level konstant und die Zeit für das Rendering eines Color-Cube ist ebenfalls
konstant. Damit erfolgt das Rendering aller Weitbereichszellen in O(log(n)). Die Anzahl der
Zellen ist konstant, da ein Octreeknoten immer eine feste Anzahl von Nachfolgern besitzt.
AlgoCG 09
59
bereich<*3#%&*=%&-%"*"5&*?/1/&@?5.%'*2%&%"-%&(
rustum i<*
Kapitel 4. Replacement
%&*B%&%#C3D*#"*-%4*"5&*E%11%"*-%'*?/1/&@?5.%'*$/"*FC(&%%@G.%"%*#*2%&%"-%&(*
%&-%"
%&%"*7&/H#I#%&(%*>&JK%*#'(
%#"%&*,1'*!*MINBN*O*+#8%1P
-
S,3.%&%#C3
Z
-@O
-@Q
-@R
9%#(.%&%#C3
3
V/&1%'5"2*W012/&#(34%"*#"*-%&*?/475(%&2&,;#LXD*YY*QZZ[
Q3
\3
]3
T,((3#,'*:#'C3%&
QU
Abbildung 4.6: Aufteilung in Nah- und Weitbereich für das Rendern der Szene.
Im Nahbereich ist die Anzahl der Blattzellen konstant. Zusammen mit der Annahme, dass
die Anzahl der Dreiecke in einer Zelle konstant ist, ergibt sich eine konstante Renderingzeit
von O(1) für den Nahbereich.
Der dritte Faktor sind die rekursiven Tests der Octree-Boxen gegen das View-Frustum. Sei
nun Fk der Teil des View-Frustum, der den Nahbereich und die Weitbereiche d, d − 1, . . . , k
enthält. Betrachte nun die 8 Geschwisterzellen auf Level k, die von der Render-Routine untersucht werden. Mindestens eines davon muss in Fk liegen. Sonst wäre die Elternzelle entweder gecullt worden oder ihr Color-Cube wäre gezeichnet worden. Fk enthält aber nur eine
Konstante Anzahl von Level-k Zellen, womit die insgesamt untersuchte Anzahl von Levelk Zellen konstant ist. Zusammen mit der Tiefe O(log(n)) ergeben sich maximal O(log(n))
getestete Zellen und die Gesamtlaufzeit folgt entsprechend.
Mit jedem Subfrustum, das man in Abbildung 4.6 nach rechts geht, verdoppelt sich die
Größe des Color-Cube. Dies liegt daran, dass die entsprechende Octree-Box weiter entfernt
ist und somit bereit die Box eines um 1 höheren Levels kleiner als ist.
4.1.5 Bildqualität
Bei der Verwendung einer sehr feinen Geometrie erscheinen Bilder mit Color-Cubes „glatter“ als vollständig gerenderte. Durch die Filterung der Geometrie auf verschiedenen Stufen
entsteht eine Art Antialiasing Effekt.
Allgemein muss man bei der Bildqualität zwischen „guten Szenen“ und „schlechten Szenen“ für das Rendering mit Color-Cubes unterscheiden. Eine gute Szene hat Primitive, die
im Vergleich zu den Color-Cubes klein sind und zufällig verstreut (unkorreliert) liegen. Bei
einer schlechten Szene hat man große Primitive im Vergleich zur Größe der Color-Cubes und
lange, zusammenhängende Oberflächen. Bei schlechten Szenen können Artefakte entstehen.
Betrachte dazu das Beispiel in Abbildung 4.7.
AlgoCG 09
60
9#:3( $/" /.%";
9#:3(*$/"*</.%"
= >%-%*?%11%*#'(*$/11'()"-#2*5"-5&:3'#:3(#2
@!"-5&:3'#:3(#2A%#(*BCDE
Kapitel 4. Replacement
HEINZ NIXDORF INSTITUT
Color-Cubes
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$%&'#$(
Artefakte
9#:3( $/" 1#";'<
9#:3(*$/"*=1#";'
BCD BCD BCD BCD BCD
> ?5&*@%11%"*4#(*A1,:3%4*?%#25"2'B#";%1*'#"-*$/11'()"-#2*5"-5&:3'#:3(#2
BCD
C!"-5&:3'#:3(#2;%#(*DEFG
BCD
> @%11%"*4#(*'(%#1%4*?%#25"2'B#";%1*'#"-*"5&*7,&(#%11*$%&-%:;(
C!"-5&:3'#:3(#2;%#(*CFEHI*FEJG
(a)
FEH
FEJ FEJ
FEJ FEJ
J/&1%'5"2*K012/&#(34%"*#"*-%&*L/475(%&2&,M#ANO*99*PDDQ
HI
F,((3#,'*G#':3%&
DEF
DEF
(b)
N/&1%'5"2*O012/&#(34%"*#"*-%&*P/475(%&2&,A#;QI*99*JFFR
HM
K,((3#,'*L#':3%&
Abbildung 4.7: Artefaktbildung bei langen, gekrümmten Oberflächen, in der Aufsicht ((a))
sind die Color-Cubes undurchsichtig, von der Seite ((b)) erscheinen sie teilweise transparent.
In der Aufsicht von oben ist jede Zelle vollständig undurchsichtig,
da sie
vollständig durch
HEINZ NIXDORF
INSTITUT
Color-Cubes
das Dreieck !"#$%&'#$
ausgefüllt wird. Von der Seite sind einige Zellen nicht vollständig durch die
Oberfläche abgedeckt. Die Color-Cube werden deshalb mit einem Undurchsichtigkeitswert
von 0, 2 bis 0,Artefakte
3 belegt und erscheinen transparent. Dadurch kann es passieren, dass der Hin9#:3(
9#:3(*$/"*A':3&)2
$/" ':3&)2;
<=> ?&,-@
tergrund durchscheint.
Bei *<=>*?&,-@
einer
schrägen, seitlichen Sicht ergibt sich das Problem, dass zwei
Problem
Seiten des Color-Cubes zu sehen sind. Davon eine undurchsichtige und eine transparente. Es
CD%# 9%#(%"
CD%#*9%#(%"*-%'*E/1/&FE5.%'*'#"-*C5*'%3%"
-%' E/1/&FE5.%'
'#"-in
C5der
'%3%"
kann passieren,B dass
transparente
Löcher
Oberfläche entstehen, wie in Abbildung 4.8
<%#"%*5"-5&:3'#:3(#2G*%#"%*4#(*H&,"'7,&%"C@
dargestellt. Die Oberfläche wirkt dann an einigen Stellen heller, falls sich die benachbarten
B -#%*(&,"'7,&%"(%"*I.%&1,2%&"*'#:3*"#:3(*$/11'()"-#2
transparenten Color-Cubes nicht genügend überdecken.
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
B 4,"*'#%3(*-5&:3G*%'*%"('(%3%"*JK:3%&
P/&1%'5"2*Q012/&#(34%"*#"*-%&*E/475(%&2&,R#STG*99*UVVW
L,((3#,'*M#':3%&
NO
Abbildung 4.8: Schräge Aufsicht auf gekrümmte Oberfläche aus Color-Cubes kann zu Löchern führen.
Ein weiteres Problem entsteht, wenn undurchsichtige Geometrie und transparente ColorCubes nebeneinander gezeichnet werden, wie dies in Abbildung 4.9 dargestellt ist.
AlgoCG 09
61
re Artefakte
Kapitel 4. Replacement
9,'*7,''#%&(>*?%""*:%/4%(&#%*;5"-5&@3'#@3(#2<*5"-*
9
# (
:
( # ; - 3 # 3(# < ,"'7,&%"(%*A/1/&BA5.%'*"%.%"%#","-%&*2%C%#@3"%(*
?%&-%"D
E%#3%"F/12%*#'(*%"('@3%#-%"-G
!"-5&@3'#@3(#2%*:%/4%(&#%*$%&-%@H(*(&,"'7,&%"(%*
#8%1
em
E%#3%"F/12%*H,""*'#@3*-5&@3*H1%#"%*+/'#(#/"'?%@3'%1*
"-%&"I
"(?%-%&*$%&-%@H(*-#%*:%/4%(&#%*-%"*A/1/&BA5.%*
( - H(Abbildung
-# :
( 4.9:
# - Artefaktbildung
A 1 A .
Geometrie.
/11'()"-#2>
durch benachbarte Zeichnung von Color-Cube und
2
-%&*-%&*A/1/&BA5.%*K.%&1,2%&(*-#%*:%/4%(&#%I
In diesem Fall ist die Reihenfolge entscheidend, da die undurchsichtige Geometrie den
transparenten Pixel verdeckt. Das Problem
ist, dass sich
die Reihenfolge durch einen PoNO
L,((3#,'*M#'@3%&
sitionswechsel ändern kann. Entweder wird der Color-Cube vollständig von der Geometrie
verdeckt, oder der Color-Cube überlagert die Geometrie.
P/&1%'5"2*Q012/&#(34%"*#"*-%&*A/475(%&2&,F#HR>*SS*TUUV
4.2 Hierarchical Image Caching
Bei einem Walkthrough bewegt man sich typischerweise auf einem Pfad durch eine Szene.
Dabei haben die aufeinanderfolgenden Bilder auf diesem Pfad eine hohe zeitliche Kohärenz.
Die Grundidee von Hierarchical Image Caching besteht darin, benachbarte Objekte in eine
Textur zu rendern und diese Textur für die nachfolgenden Bilder zu verwenden. Die Objekte
werden erst dann neu gerendert, wenn sich die Kameraposition zu weit entfernt hat. Abbildung
4.10 illustriert dieses Vorgehen.
An Stelle der Objekte wird die Textur auf ein Rechteck gelegt. Das Rechteck wird dann mittig in die Boundingbox des Knotens in der Hierarchie gesetzt. Bei einer leichten Bewegung
der Kameraposition wird das Rechteck entsprechend mit bewegt. Auf diese Weise lassen sich
Parallaxe Fehler reduzieren, aber nicht vermeiden. Eine Parallaxe ist eine scheinbare Positionsänderung eines Objektes, die durch die Änderung der Position des Beobachters verursacht
wird.
Ein Caching einzelner Objekte wird typischerweise nicht durchgeführt, da die Anzahl der
Objekte und damit die Anzahl der Texturen zu groß wäre. Die Szene wird in Form eines
BSP-Baums aufbereitet, dessen Blätter jeweils eine konvexe Region des Raumes darstellen.
In jedem (inneren) Knoten der Hierarchie kann nun eine Textur gespeichert werden, die einem
Blick auf die im Knoten enthaltenen Objekte entspricht. Das Rendering muss dann in back-tofront-order durchgeführt werden, da sich einzelne Texturen überlappen können und Texturen
teilweise transparent sind.
Das Rendering besteht in jedem Frame aus zwei Durchläufen, die in den folgenden Unterabschnitten beschrieben werden.
AlgoCG 09
62
Hierarchical Image Caching
!"##
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Kapitel 4. Replacement
Idee des Verfahrens
9 &%"-%&%
&%"-%&%*.%",:3.,&(%*;.<%=(%*#"*%#"%*
.%",:3.,&(% ;.<%=(% #" %#"%
>%8(5&
9 $%&?%"-%*-#%*>%8(5&*@A&*",:3@/12%"-%*
B#1-%&
9 &%"-%&%*-#%*;.<%=(%*%&'(*?#%-%&C*?%""*-#%*
6,4%&,7/'#(#/" '#:3 $/" -%&
6,4%&,7/'#(#/"*'#:3*$/"*-%&*
5&'7&A"21#:3%"*+/'#(#/"*D5*?%#(*%"(@%&"(
I/&1%'5"2*J012/&#(34%"*#"*-%&*K/475(%&2&,@#=LC*MM*NOOP
E,((3#,'*F#':3%&
GH
Abbildung 4.10: Objekte werden in eine Textur gerendert und erst bei großer Kameraverschiebung neu gerendert.
4.2.1 Erster Rendering Durchlauf
Im ersten Durchlauf wird ein Culling der Knoten außerhalb des Frustums durchgeführt und
der Image Cache aktualisiert. Dabei werden alle Knoten aktualisiert, für die die Fehler in
der Textur zu groß sind. Diese Überprüfungen werden vom Algorithmus U PDATE C ACHES
ausgeführt.
Die Funktion UpdateNode() berechnet, ob die Geometrie gezeichnet wird oder ob es sich
lohnt, einen Cache anzulegen. Die Geometrie wird immer gezeichnet, wenn der Beobachter
im Knoten steht. Sonst werden die Kosten zum Zeichnen der Geometrie mit den Kosten
zur Erstellung des Caches verglichen. Beide Werte werden experimentell bestimmt (Werte
hängen auch von der konkreten Hardware ab). Die Funktion UpdateNode() beschreibt der
nachfolgende Algorithmus 17.
Die Funktion CreateCache() legt die gecachete Textur an. Dazu wird zunächst die achsenparallele Boundingbox des BSP-Knotens im Bildraum berechnet. Dazu werden wie gehabt
die Eckpunkte der Box in den Bildraum projiziert und die Minima/Maxima betrachtet. Anschließend wird der Knoten gezeichnet. Für ein Blatt wird dazu die Geometrie gezeichnet, für
einen inneren Knoten werden die Kinder gezeichnet. Das Bild wird dann als Textur im Cache
des Knotens gespeichert. Für einen inneren Knoten muss nicht die vollständige Geometrie
gezeichnet werden. Stattdessen können beim Zeichnen auch Texturen der Kinder verwendet
werden.
AlgoCG 09
63
Kapitel 4. Replacement
Algorithmus 16 Aktualisierung des Image Caches
1: function U PDATE C ACHES(node, viewpoint)
2:
if node außerhalb des Frustum then
3:
node.status := CULL
4:
else if node.cache ist für viewpoint noch gut genug then
5:
node.status := DRAWCACHE
6:
else if node ist Blatt then
7:
UpdateNode(node, viewpoint)
8:
else
. Erst Kinder aktualisieren, dann den Knoten selbst
9:
UpdateCaches(node.back, viewpoint)
10:
UpdateCaches(node.front, viewpoint)
11:
UpdateNode(node, viewpoint)
12:
end if
13: end function
4.2.2 Zweiter Rendering Durchlauf
Im zweiten Durchlauf wird der BSP-Baum erneut durchlaufen. Dieses mal jedoch in back-tofront-order. Dabei wird entweder die Geometrie oder die Textur für einen Knoten gezeichnet.
Dabei werden die im ersten Durchlauf vergebenen Zustände verwendet. Das Zeichnen wird
von der Funktion Render ausgeführt, die Algorithmus 18 zusammenfasst.
4.2.3 Partitionierung der Szene
Die Szene wird mit einem 3D BSP-Baum partitioniert. Das Bild für eine Zelle wird als Textur
gespeichert und auf ein Rechteck gerendert. Dabei sind die Ziele der Partitionierung:
1. So wenige Objekte wie möglich zerteilen
Geteilte Objekte werden möglicherweise durch unterschiedliche Texturen dargestellt,
wodurch visuelle Artefakte entstehen können.
2. Die hierarchische Aufteilung bestmöglich balancieren.
Man erhält dadurch eine bessere Performance und ein besseres Frustum Culling.
3. Das Seitenverhältnis jedes Knotens sollte möglichst 1 sein.
Boundingboxen mit ausgewogenem Seitenverhältnis sind länger gültig.
Die Splittingebenen werden zwischen die Objekte gelegt. Dabei sollen möglichst wenige
Objekte geschnitten werden, wie in Abbildung 4.11 dargestellt. Mit den entstandenen Mengen
wird rekursiv weiter verfahren.
Um das Finden der Splittingebenen zu vereinfachen, legt man N Richtungen fest und nutzt
Splittingebenen, die senkrecht zu diesen Richtungen stehen. Ein Möglichkeit besteht darin,
die x-, y- und z-Achse als Richtungen zu nehmen und damit die yz-, die xz und die xy-Ebene
als Splittingebenen zu benutzen. Im Rahmen dieser Vorlesung werden Landschaftsszenen
als Zielszenen betrachtet. Die haben ein großes Oberflächennetz, auf dem die Objekte, z.B.
AlgoCG 09
64
Kapitel 4. Replacement
Algorithmus 17 Aktualisierung eines Knotens
1: function U PDATE N ODE(node, viewpoint)
2:
if viewpoint innerhalb von node then
3:
if node ist Blatt then
4:
node.status := DRAWGEOM
5:
else
6:
node.status := RECURSE
. Rekursiv auf Kindern berechnen
7:
return
8:
end if
9:
end if
10:
k := EstimateCacheLifeSpan(node, viewpoint) . Schätzt die Anzahl der Frames ab,
für die sich das Caching lohnt
11:
amortizedCost := „cost to create cache“ / k + „cost to draw cache“
. amortisierte
Kosten
12:
if amortizedCost < „cost to draw contents“ then
. Caching lohnt sich
13:
CreateCache(node, viewpoint)
14:
node.status := DRAWCACHE
15:
node.drawingCost := „cost to draw cache“ . Kosten für das Zeichnen der Textur
16:
else
. Caching lohnt sich nicht
17:
if node ist Blatt then
18:
node.status := DRAWGEOM
19:
node.drawingCost := „cost to draw geometry“ . Kosten für eigene Geometrie
20:
else
21:
node.status := RECURSE
HEINZ NIXDORF INSTITUT
Hierarchical Image Caching
!"#$%&'#()(*+,-%&./&"
22:
node.drawingCost
:=
node.back.drawingCost
+
node.front.drawingCost
.
012/&#(34%"*5"-*6/471%8#()(
!"#$#%&'('()*(+&,*-./+&.0(&',+11+*."2+*+
Kosten der Kinder
23:
end
if
Wie partitionieren
wir den 3D BSP-Baum?
24:
end if= >#&*1%2%"*-#%*971#((#"2%.%"%"*?>#'@3%"
# 1
-# 9 1#((#
.
# 3 -#%*:.;%<(%
-# :.; <(
25: end function
= 4A21#@3'(*/3"% :.;%<(%*?5*'@3"%#-%"B
= 4#(*-%&*C%"2%*-%&*2%(%#1(%"*:.;%<(%*$%&D,3&%"*>#&*&%<5&'#$
4#( -%& C%"2% -%& 2%(%#1(%" :.;%<(% $%&D,3&%" >#& &%<5&'#$
Abbildung 4.11: Wahl der Splittingebenen.
H/&1%'5"2*I012/&#(34%"*#"*-%&*J/475(%&2&,D#<KL*99*MNNO
AlgoCG 09
C,((3#,'*E#'@3%&
FG
65
Kapitel 4. Replacement
Algorithmus 18 Zeichnen der Geometrie und der Texturen
1: function R ENDER(node, viewpoint)
2:
if node.status == CULL then
3:
return
4:
else if node.status ∈ { DRAWCACHE, DRAWGEOM } then
5:
Draw(node)
6:
else if node ist vor der node.splittingplane then
7:
Render(node.back, viewpoint)
8:
Render(node.front, viewpoint)
9:
else
10:
Render(node.front, viewpoint)
11:
Render(node.back, viewpoint)
12:
end if
13: end function
Bäume oder Häuser, aufgestellt sind. Die Objekte stehen alle auf der xz-Ebene,
allerdings mit
HEINZ NIXDORF INSTITUT
HEINZ NIXDORF INSTITUT
Hierarchical
Image
Caching
HEINZ NIXDORF INSTITUT
ical Image Caching
!"#$%&'#()(*+,-%&./&"
Hierarchical
Image Caching
unterschiedlichen
Höhenwerten.
Damit sind !"#$%&'#()(*+,-%&./&"
alle Splittingebenen senkrecht zur
xz-Ebene (die
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$#%&'('()*(+&,*-./+&.0(&',+11+*."2+*+
012/&#(34%"*5"-*6/471%8#()(
012/&#(34%"*5"-*6/471%8#()(
()*(+&,*-./+&.0(&',+11+*."2+*+
!"#$#%&'('()*(+&,*-./+&.0(&',+11+*."2+*+
verwendeten
Richtungen sind die x- und die
z-Achse. Das Verfahren benötigt
keine Informationen über die semantische Definition von Objekten und ist nicht auf einen bestimmten Typ
Wie
berechnen
wirwir
diedie
Splittingebenen?
Wie
Ebene mit den wenigsten Schnitten?
von
Szene
festgelegt.
der * Richtungen
(bei
uns
2):finden
? #4*9@,"A1#"%A:%&;,3&%"*1,5;%*<%B%#1'*=.%&*%#"%*>#'(%
# 9
1# : ; 3
1 ; <
#1 =.
# ># (
52%*;<%#*'/&(#%&(%*9#'(%"
#
(# ( 9# (
4.2.4
Berechnung
der Splittingebenen
? C)31%*-#%*2%&,-%*2%'@3"#((%"*D.<%E(%*FG*H,E(#$%*D.<%E(%IJ
9,'*7,''#%&(:*;%""*;#&*<%#"%*=71#((#"2%.%"%*>#"-%":*
*'7%#=3%&(*-#%*5"(%&%
>%2&%";5"2*-%'*?.@%A(%'
/3"%*?.@%<(%*A5*'B3"%#-%"C
@ ? .%&%@3"%*,11%*K"(%&$,11%*4#(*-%"*B%"#2'(%"*H,E(#$%"*D.<%E(%"
.%&%@3"%
,11%?.@%A(%'
K"(%&$,11%
4#( -%"
B%"#2'(%"
,E(#$%"
D.<%E(%"I
passieren,
dass keine
Splittingebene
gefunden
werden
kann,
die keine Objekte zerteilt.
<%#(%
<%#(%*'7%#=3%&(*-#%*/.%&%
'7%#=3%&( Es
-#%kann
/.%&%
>%2&%";5"2
>%2&%";5"2*-%'*?.@%A(%'
-%'
Für jede der N Richtungen (in diesem Fall 2 bei der Landschaftsszene) werden 2 sortierte
Listen erzeugt. Eine speichert die untere Begrenzung des Objektes, die andere die obere
L5')(C1#@3 '/11(% -#% 05;(%#15"2 #" CB%# 21%#@3 2&/M% N%"2%" %&;/12%"
L5')(C1#@3*'/11(%*-#%*05;(%#15"2*#"*CB%#*21%#@3*2&/M%*N%"2%"*%&;/12%"
Begrenzung. Abbildung 4.12 zeigt ein Beispiel dafür.
O,' #'( <%-/@3 "#@3( #44%& 4P21#@3Q
O,'*#'(*<%-/@3*"#@3(*#44%&*4P21#@3Q
(a)
(b)
(c)
N,((3#,'*R#'@3%&
:/&1%'5"2*U012/&#(34%"*#"*-%&*V/475(%&2&,;#EWX*99*YZZ[
B,((3#,'*C#'=3%&
ST
DE
FF
D,((3#,'*E#'B3%&
G/&1%'5"2*H012/&#(34%"*#"*-%&*I/475(%&2&,>#<J:*==*KLLM
Abbildung 4.12: Berechnung
der Splittingebenen. (a) zeigt die Ausgangssituation,
(b) die beiden Listeneinträge und (c) den Korridor mit den wenigsten geschnittenen
Objekten.
F/&1%'5"2*G012/&#(34%"*#"*-%&*H/475(%&2&,I#AJK*LL*MNNO
Anschließend wird im Scan-line Verfahren über jeweils eine Liste gegangen. Dabei werden
die gerade geschnittenen Objekte (= aktive Objekte) gezählt. Auf diese Weise werden alle
AlgoCG 09
66
Kapitel 4. Replacement
Intervalle mit den wenigsten geschnittenen Objekten ermittelt. Eine Anforderung war, dass
die Aufteilung möglichst in zwei gleich große Mengen erfolgen soll. Dies ist jedoch nicht
immer möglich. Stattdessen wird eine Funktion aus Anzahl der geschnittenen Objekte und
dem Verhältnis der Aufteilung berechnet. Die Heuristik beschreibt einen Trade-off zwischen
beiden Faktoren, in dem immer der minimale Funktionswert genommen wird.
Über die zusätzliche Heuristik, immer die längere von beiden Seiten zu schneiden, erhält
man zudem ein relativ ausgeglichenes Seitenverhältnis.
4.2.5 Fehlermetrik
Die Fehlermetrik soll zwei Fragen beantworten, die für die Leistungsfähigkeit des Hierarchical
Image Cache von grundlegender Bedeutung sind.
1. Für einen gegebenen Knoten in der Hierarchie und seine Textur im Cache: Ist die Textur
HEINZ NIXDORF INSTITUT
auch Caching
für die aktuelle Kameraposition eine gute Approximation?
Hierarchical Image
!"#$%&'#()(*+,-%&./&"
!"#$"%&"'%()
2. Für einen gegebenen Knoten in der Hierarchie und eine 012/&#(34%"*5"-*6/471%8#()(
Kameraposition: Wie lange
wird eine neu berechnete Textur gültig sein?
9/*1#%2%"*-#%*+5":(%;*-#%*%#"%"*<%31%&*%&=%52%";*-%&*2&>?%&*,1'*
HEINZ NIXDORF INSTITUT
aching
Die Metrik soll einen Unterschied
zwischen der Textur im Cache und der gerenderten Geo!"#$%&'#()(*+,-%&./&"
%#"*@A3B%11B%&(*! #'(C
012/&#(34%"*5"-*6/471%8#()(
metrie quantifizieren. Ist der
Unterschied kleiner als ein Schwellwert ε, dann ist die Textur
noch gültig. Da diese Berechnung zur Laufzeit für sehr viele Texturen ausgeführt wird, muss
sie schnell zu berechnen sein.
+,- 4#''(*-,'*
# (!011%*+5":(%*21%#A3*!
?.%&*,11%
1#%2%"*,5D*=B%#*6&%#'%"*4#(*E,-#5'*%
%'*6"/(%"'*
F
C*****@+&/D%>(#/"*$/"*
,*,5E*-#%*F%8(5&B
!
-%'*6"/(%"'B
5"-*H#((%175":(*+, #'(*
$
G%&*6&%#'*4#(*E,-#5'**
%#"*I%#1*-%&*@#A3%&3%#('=/"%
$G
%.%+,0schnell eine
?
3
&
-
@"%5%*+/'#(#/"B
%+,0E?&*,11%*M*
2A/8 -%'*6"/(%"'
$J
$H*
@+/'#(#/"I*$/"*-%&*F%8(5&
,5E2%"/44%"*J5&-%*B
(a)
-,'
-,'*<,8#454
<,8#454
4%"*#"*-%&*S/475(%&2&,E#>TI*UU*VHHW
,
!
,**@+/'#(#/"*#""%&3,1.*
(b)
Abbildung 4.13: Fehlermetrik für das Hierarchical Image
Caching.
H,((3#,'*<#'A3%&
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,D#:P;*@@*QJJR
<,((3#,'*9#'L3%&
OP
KL
Abbildung 4.13(a) zeigt die Berechnung der Error()-Funktion. Die Textur wurde von der
Position v0 aus gerendert und wird jetzt von v1 aus betrachtet. Der Betrachter sieht in Richtung
des Punktes a innerhalb der Bounding-Box des Knotens. Dieser Punkt a wird jedoch auf den
AlgoCG 09
67
Kapitel 4. Replacement
Punkt ã der Textur abgebildet. Durch entsteht ein Winkel θ um den der Punkt verschoben
wird. Je weiter der Punkt verschoben wird, desto stärker ist der Bildfehler. Die Funktion
Error(v, v0 ) = max θ(a, v, ã)
a
beschreibt nun den maximalen Winkel, den θ nach Betrachtung aller Punkte innerhalb der
Bounding-Box annehmen kann. Um die Berechnung zu Beschleunigen, wird die Funktion
nur für die 8 Eckpunkte berechnet und es wird dann das Maximum dieser 8 Werte betrachtet.
Die Abschätzung der Gültigkeit der Textur erfolgt nun unter der Annahme, dass die Geschwindigkeit und Beschleunigung des Betrachters bekannt sind. Außerdem lässt sich feststellen, dass der Betrachter in kurzen Zeiträumen dann nur kleine Entfernungen zurücklegt. Es
wird nun eine sogenannte Sicherheitszone um eine Position herum definiert, in der der Fehler
kleiner als ε ist. Solange sich der Betrachter innerhalb dieser Sicherheitszone aufhält, ist die
Textur gültig. Die Zone ist definiert als
Saf etyZone(v0 ) ⊆ {v|Error(v, v0 ) ≤ ε}
Je kleiner man nun ε wählt, desto kleinere, abweichende Winkel sind zulässig. Dadurch
ist die Textur näher an der gerenderten Architektur. Zusammen mit der aktuellen Geschwindigkeit und der Beschleunigung der Beobachters und den Maximalwerten für beide Größen
kann man nun die Gültigkeit der Textur daran ausrechnen, wie lange sich der Beobachter in
der Sicherheitszone aufhält. Abbildung 4.13(b) zeigt eine solche Sicherheitszone.
In der Graphik bezeichnet wie zuvor v0 den Standpunkt, von dem aus die Textur berechnet
wurde. Der Punkt a ist ein Punkt aus der Bounding-Box und ã ist die Projektion auf die Textur.
Der Abstand zwischen v0 und a wird mit h bezeichnet. Alle Standpunkte v, von denen der
maximale Winkel ε gilt, liegen auf zwei Kreisen mit Radius
||a − ã||
2 · sin ε
Dabei bezeichnet ||a − ã|| den Abstand zwischen den Punkten a und ã. Man erhält mit
dieser Strecke aus dem Sinussatz den Zusammenhang 2r = ||a−ã||
und damit den Radius der
sin ε
grauen Kreise.
Der weiße Kreis mit Radius d beschreibt nun die Sicherheitszone innerhalb der die Textur
gültig ist. Der Radius d der Sicherheitszone wird über die Strecke d + r berechnet, von der
dann r abgezogen wird. Man erhält damit für d:
√
d = h2 + r2 + 2hr sin ε − r
r=
Der Wert für d wird nun für alle 8 Ecken der Bounding-Box berechnet und für a in die
Gleichungen eingesetzt. Für einen inneren Knoten wird die Sicherheitszone für die BoundingBox des Knoten berechnet und dann gegen die Bounding-Boxen der Kinder geschnitten.
• [TODO:Wie kommt die Formel für d zustande?]
4.2.6 Artefakte
Es kann passieren, dass der Hintergrund durchscheint.
AlgoCG 09
68
HEINZ NIXDORF INSTITUT
Paralleles Rendering als Sortierproblem
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Paralleles Rendering
Renderingprozess besteht aus zwei
Hauptschritten
9 :%/4%(&#%(&,"';/&4,(#/"
5 Paralleles Rendering
9 <,'(%&5"2
Das Rendering besteht aus zwei Hauptschritten: :%/4%(&#%(&,"';/&4,(#/"*=>!?>
der Geometrietransformation und der Rasterung.
Diese
Schritte
zeigt
Abbildung
5.1.
Dabei
ist die Reihenfolge der Polygone bei der
Sequentielle Berechnung
HEINZ NIXDORF INSTITUT
ls Sortierproblem
!"#$%&'#()(*+,-%&./&"
Berechnung beliebig, da das
Ergebnis von der konkreten Reihenfolge unabhängig ist.
012/&#(34%"*5"-*6/471%8#()(
9 <%#3%";/12%*-%&*+/1@2/"%*#'(*;A&*-#%*
B%&%C3"5"2*.%1#%.#2
ht aus zwei
9 D&2%."#'*$/"*-%&*<%#3%";/12%*5",.3)"2#2
D&2%."#' $/" -%& <%#3%";/12% 5",.3)"2#2
/"
g
/"%*#'(*;A&*-#%*
:%/4%(&#%(&,"';/&4,(#/"*=>!?>
<,'(%&5"2
(a)
(b)
HEINZ NIXDORF INSTITUT
Paralleles Rendering als Sortierproblem
!"#$%&'#()(*+,-%&./&"
Abbildung
5.1:
Die
Hauptschritte
des
Rendering.
G
E,((3#,'*F#'C3%&012/&#(34%"*5"-*6/471%8#()(
Paralleles Rendering
H/&1%'5"2*I012/&#(34%"*#"*-%&*J/475(%&2&,;#KLM*NN*?OOP
%";/12%
%";/12%*5",.3)"2#2
5",.3)"2#2
"*-%&*J/475(%&2&,;#KLM*NN*?OOP
Dies
erlaubt
es, die wir
Geometrietransformation
und die Rasterung parallel mit mehreren GeoWas
verstehen
unter parallelen Rendering?
metrieeinheiten bzw. mehreren Rasterungseinheiten auszuführen wie in Abbildung 5.2 darge9 :%/4%(&#%(&,"';/&4,(#/"*<#&-*7,&,11%1*,5'2%;=3&(*
:%/4%(&#%(&,"';/&4,(#/"
<#&- 7,&,11%1
stellt. Dies
nennt man paralleles Rendering.
Da ,5'2%;=3&(
die Reihenfolge, in der die Dreiecke verarbei>4%3&%&%*:%/4%(&#%%#"3%#(%"?
tet werden, in beiden Schritten unabhängig von der Reihenfolge ist und keine Abhängigkei9 @,'(%&5"2*<#&-*7,&,11%1*,5'2%;=3&(*
ten zwischen
den einzelnen
Berechnungen bestehen, ist das ohne Probleme möglich. Unter<,'(%&5"2
>4%3&%&%*@,'(%&5"2'%#"3%#(%"?
schiedliche Z-Werte werden über den Z-Buffer Algorithmus aufgelöst, der auch die unabhängige Verarbeitung der Dreiecke unterstützt.
E,((3#,'*F#'C3%&
G
E/&1%'5"2*F012/&#(34%"*#"*-%&*G/475(%&2&,;#HIJ*KK*LMMN
A,((3#,'*B#'C3%&
Abbildung 5.2: Parallelisierte Rendering Architektur.
69
D
Kapitel 5. Paralleles Rendering
Im Folgenden sollen verschiedene Möglichkeiten vorgestellt werden, diese parallele Berechnung zu organisieren.
5.1 Paralelles Rendering als Sortierproblem
Jeder Prozessor erhält einen Teil der Geometrie und einen Teil der zu rendernden Pixel. Dabei
gibt es folgende Annahmen:
• Vor der Berechnung eines Bildes sind die Objekte beliebig über alle Prozessoren verteilt
gespeichert
• Die Objekte sind ohne Redundanz gespeichert, d.h. jedes Objekt ist auf genau einem
Prozessor.
• Die Objekte sind beliebig im 3D Raum platziert und erscheinen standpunktabhängig an
beliebigen Stellen des Bildschirms.
• Falls die Objekte abstrakt beschrieben sind, müssen sie noch in Dreiecke zerlegt werden
(tesselieren).
Initial muss eine solche Verteilung von Objekten auf Prozessoren jedoch erst einmal berechnet werden. Dabei soll ein Load Balancing zwischen den einzelnen Prozessoren stattfinden, um die Effizienz zu erhöhen. Da Geometrietransformation und Rasterung unabhängig
von einander arbeiten, kann eine Sortierung, d.h. Verteilung oder Zuordnung der Objekte an
die Stelle des Bildschirm, an der sie dargestellt werden, zu drei Zeiten geschehen:
• Sort-First, d.h. vor der Geometrietransformation.
• Sort-Middle, d.h. zwischen Geometrietransformation und Rasterung
• Sort-Last, d.h. nach der Rasterung
5.1.1 Sort-First
Vor der Bildberechnung sind die Objekte beliebig auf Prozessoren verteilt. Sie werden vor der
Geometrietransformation auf die Prozessoren verteilt (sortiert). Damit werden die Objekte im
3D Objektraum verteilt. Dazu wird der Bildschirm in disjunkte Bereiche, „Kacheln“ genannt,
unterteilt. Dabei sind verschiedene Aufteilung möglich, wie in Abbildung 5.3 dargestellt.
Jeder Prozessor ist zuständig für eine Kachel und führt sowohl die Geometrietransformation als auch die Rasterung für diese Kachel durch. Die Objekte werden über das Netzwerk
zu den Prozessoren geschickt. Jeder Prozessor erzeugt dann ein Teilbild für die Kachel für
die er zuständig ist. Für die Darstellung des Bildes im dritten und letzten Schritt müssen die
so entstandenen Einzelbilder dann wieder zusammengefügt werden. Es existieren Hard- und
Softwarelösungen für dieses Problem, das in Abbildung 5.4 dargestellt ist. Bei einer Softwarelösung müssen die Einzelbilder über das Netzwerk an einen Prozessor dargestellt werden,
der das Gesamtbild zusammenstellt.
AlgoCG 09
70
Kapitel 5. Paralleles Rendering
,<3'%"7,&,11%1%*6,<3%1"
Paralleles Rendering als Sortierproblem
Sort-First
@.%1#%.#2%J*6,<3%1"*4K21#<3
HEINZ NIXDORF INSTITUT
P3
P1
Schritt 3: Darstellung des Bildes
P4
9 :5',44%"'%(;5"2*-%&*%#";%1"%"*
2
<%#1.#1-%&*"%.%"%#","-%&
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
P4
P1
P2
P1
P2
P2
P3
P3
9 -,=>&*2#.(*%'*?,&-@,&%A 5"-*
L,((3#,'*M#'<3%&
P/&1%'5"2*Q012/&#(34%"*#"*-%&*R/475(%&2&,:#>SF*EE*TUUV
Sort-First Ansatz.
B/=(@,&%1C'5"2%" Abbildung 5.3: Aufteilung in Kacheln beim P4
9 22='D*4>''%"*-#%*<%#1.#1-%&*E*6,F3%1"*
>.%&*-,'*G%(;@%&H*;5*%#"%4*
+&/;%''/&J*-%&*-,'*I%',4(.#1-*
I
-,&'(%11(J*2%'F3#FH(*@%&-%"*
KB/=(@,&%1C'5"2L
P1
P3
P1
P4
NO
P2
P2
P3
P4
Q/&1%'5"2*R012/&#(34%"*#"*-%&*S/475(%&2&,=#HTJ*BB*UVVW
M,((3#,'*N#'F3%&
OP
Abbildung 5.4: Berechnung und Zusammensetzung der Einzelbilder beim Sort-First Ansatz.
Der Sort-First Ansatz hat jedoch einige Probleme, die in Abbildung 5.5 dargestellt sind.
Die Zuteilung der Polygone auf die Geometrieprozessoren sollte gleichmäßig erfolgen, sonst
laufen einige Prozessoren leer. Dies ist wie in Abbildung 5.5 (a) dargestellt aber je nach Szene
nicht einfach zu erreichen.
Ein größeres Problem sind Polygone, die in mehrere Bildbereiche fallen und somit von
mehreren Prozessoren bearbeitet werden müssen, wie in Abbildung 5.5 (b) dargestellt.
Das dritte Problem besteht darin, dass auch bei einer gleichmäßigen Verteilung von Objekten auf die einzelnen Prozessoren die Last unterschiedlich verteilt sein kann. Dies liegt daran,
dass der Aufwand für Geometrietransformation und Rasterung nicht gleich ist, aber auf dem
gleichen Prozessor ausgeführt wird. Die Last für die Rasterung ist abhängig von der Größe
des Polygons und in Abbildung 5.5 (c) ist die Last somit ungleich verteilt.
5.1.2 Sort-Middle
Vor der Berechnung sind die Polygone wieder beliebig verteilt. Vor Beginn der Geometrietransformation kann zur Lastverteilung eine erste Umverteilung stattfinden. Danach wird die
Geometrietransformation durchgeführt. Nach der Geometrietransformation werden die in den
2D-Bildraum projizierten Polygone wie beim Sort-First auf verschiedene Kacheln aufgeteilt.
Abbildung 5.6 zeigt ein Beispiel. Wie zuvor berechnet nun jeder Prozessor seine Kachel und
AlgoCG 09
71
P1
P2
. #( (
(%#15"2 -%&*+/1;2/"%*,5<*-#%*
-%& +/1;2/"% ,5< -#%$%&,&.%#(%(
%/4%(&#%7&/>%''/&%"*'/11(%*21%#?34)@#2*
9 -#%*D,'( $/"*=%/4%(&#%(&,"'</&4,(#/"*5"-*
&(%#1(
'%#"A*'/"'(*1,5<%"*%#"#2%*HEINZ NIXDORF INSTITUT P3
rproblem
P4
E,'(%&5"2*F,""*5"21%#?3*$%&(%#1(
2
2
'%#"A*-,*
A
!"#$%&'#()(*+,-%&./&"
/>%''/&%" 1%%&
/>%''/&%"*1%%&
012/&#(34%"*5"-*6/471%8#()(
.%#-%'*-%&'%1.%*+&/>%''/&*.%,&.%#(%(
1;2/"%A*-#%*#"*4%3&%&%*B#1-&,54.%&%#?3%*
1%"A*C%&-%"*$/"*4%3&%&%" +&/>%''/&%"*
6/445"#F,(#/"'GH$%&3%,-*2%&#"2A*-,*"5&*
&,&.%#(%(
. #( (
P1
P1
P2
P2
2%/4%(&#'?3%*+&#4#(#$%*$%&'?3#?F(*C%&-%"*
%#?34)@#2*
%*D,'(
$/"*=%/4%(&#%(&,"'</&4,(#/"*5"-*
IF1%#"%*J>%"%"K
*
,'(%&5"2*F,""*5"21%#?3*$%&(%#1(
2
2
'%#"A*-,*
A
P3
P3
P4
P4
=&/@%*J>%"%"W
#-%'*-%&'%1.%*+&/>%''/&*.%,&.%#(%(
P1
P2
Kapitel 5.P3Paralleles Rendering
P4
P1
P2
P3
P4
HEINZ NIXDORF INSTITUT
54.%&%#?3%*
Paralleles Rendering
P/&1%'5"2*Q012/&#(34%"*#"*-%&*R/475(%&2&,<#FSA*JJ*TUUV
!"#$%&'#()(*+,-%&./&"
(a) als Sortierproblem
(b)
(c) L,((3#,'*M#'?3%&
012/&#(34%"*5"-*6/471%8#()(
Sort-Middle
/>%''/&%"*
5"#F,(#/"'GH$%&3%,-*2%&#"2A*-,*"5&*
P1
P2
P1
P2
Abbildung
5.5: Probleme bei der Anwendung
von Sort-First.
Schritt 2: Verteilung - „Sort“
(&#'?3%*+&#4#(#$%*$%&'?3#?F(*C%&-%"*
P1
4,(#/"*5"-*
*J>%"%"K 9 :%&(%#15"2*;</&(#%&5"2=*%&>/12(*
2;
2=
2
P2
( '%#"A*-,*
A
P3
P4
P3
P4
",?3
-%&*@%/4%(&#%(&,"'>/&4,(#/"*$/&
anschließend
wird
das
Gesamtbild
aus
den
einzelnen
Kacheln
zusammengesetzt. Diese Art
J>%"%"W
P3
.%#(%(
-%&*A,'(%&5"2
der Sortierung erlaubt die Verwendung unterschiedlicher Geometrie- und RasterungsprozesNO
L,((3#,'*M#'?3%&P4
P/&1%'5"2*Q012/&#(34%"*#"*-%&*R/475(%&2&,<#FSA*JJ*TUUV
9 $%&(%#1(*B%&-%"*-#%*#"*-%"*CDEF#1-&,54*
$%&(%#1(
B%&-%"
-#% #" -%" CDEF#1-&,54
soren
(Spezialhardware!)
-,*"5&*
%&-%"*
SA*JJ*TUUV
7&/G#H#%&(%"*+/1I2/"%
P1
P2
P1
P4
Wie werden 2D-Polgone verteilt?
P3
P2
P4
P1
9 '/*B#%*.%#*</&(EJ#&'(K*L6,?3%15"2M
9 '(,((*-%&*NDEO.G%P(%*B%&-%"*G%-/?3*
L,((3#,'*M#'?3%&
CDE7&/G#H#%&(%*+/1I2/"%*Q.%&*-,'*
R%(HB%&P*2%'?3#?P(*5"-*#"*6,?3%1"*
2
$%&(%#1(
P2
P3
P3
P4
NO
P1
P3
P1
P4
P2
P2
P3
P4
:/&1%'5"2*U012/&#(34%"*#"*-%&*V/475(%&2&,>#PWX*<<*CYYZ
S,((3#,'*J#'?3%&
CT
Abbildung 5.6: Aufteilung der projizierten 2D-Polygone auf Kacheln.
Die Last der Geometrietransformation kann durch gleichmäßige, nicht unbedingt kachelbezogene Aufteilung der Geometrie auf die einzelnen Prozessoren gut balanciert werden. Für
die Rasterung entstehen jedoch die gleichen Balancierungsprobleme wie beim Sort-First. Ein
weiteres Problem ist, dass die Graphikhardware das Lesen der Daten zwischen Geometrietransformation und Rasterung erlauben muss, was nicht immer möglich ist. Abbildung 5.7
zeigt ein Beispiel für die Balancierungsprobleme bei Sort-Middle.
5.1.3 Sort-Last
Wie zuvor sind vor der Bildberechnung die Objekte beliebig über die Prozessoren verteilt. Vor
der Geometrietransformation kann nun eine Umverteilung der Objekte durchgeführt werden,
um die Last besser zu verteilen. Dann berechnet jeder Prozessor für die ihm übergebenen
Objekte die Geometrietransformation und die Rasterung. Dabei entstehen bei p Prozessoren p
einzelne Bilder, die im Gegensatz zu Sort-First keine Kacheln des Gesamtbildes sind, sondern
AlgoCG 09
72
NO
P3
Probleme von Sort
Sort-Middle
Middle
HEINZ NIXDORF INSTITUT
9 E,&-D,&%*45''*:%'%"*-%&*F,(%"*
ortierproblem
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
CD#'>3%"*;%/4%(&#%(&,"'</&4,(#/"*5"-*
G,'(%&5"2 %&1,5.%"
G,'(%&5"2*%&1,5.%"
;%/4%(&#%(&,"'</&4,(#/"*21%#>34)?#2
9 -,3%&*#4*+HIH15'(%&IJK'(%4*4#(*3%5(#2%&*
$%&(%#1(*!*25(%*@,1,">#%&5"2
J(,"-,&-2&,<#=3,&-D,&%*'>3D#%&#2
4,(#/"
4,(#/"*=,""*
=,""
%&(%#15"2*-%&*
9 .%#*-%&*G,'(%&5"2*-#%'%1.%"*
'/&%"*25(*
P1
@,1,">#%&5"2'7&/.1%4%
P2
P4
D#% .%# J/&(IN#&'(
D#%*.%#*J/&(
N#&'(*
Kapitel 5. Paralleles Rendering
-,",>3*A%&(%#15"2*-%&*7&/L#C#%&(%"*
+/1K2/"%*#4*MFI@#1-&,54*
P3
P2
P3
P4
HEINZ NIXDORF INSTITUT
Paralleles Rendering als Sortierproblem
Sort-Last
P1
!"#$%&'#()(*+,-%&./&"
O,((3#,'*N#'>3%&
012/&#(34%"*5"-*6/471%8#()(
A/&1%'5"2*Q012/&#(34%"*#"*-%&*H/475(%&2&,<#=RS*JJ*MTTU
(a)
(b)
MP
F,(%"*
Schritt 1: Rendering
P1
/&4,(#/"*5"-*
Abbildung 5.7: Vorteil und Problem bei der Anwendung
von Sort-Middle.
9 :%/4%(&#%(&,"';/&4,(#/"*5"<,'(%&5"2*%&;/12%"*,5;*-%4'%1.%"*
-,",>3*A%&(%#15"2*-%&*7&/L#C#%&(%"*
4*4#(*3%5(#2%&* +&/=%''/&
+/1K2/"%*#4*MFI@#1-&,54*
3D#%&#2
"*
P2
P3
der Auflösung des Bildschirms entsprechen. Abbildung 5.8 zeigt die Aufteilung der Objekte
P4
9 =54*>?%@A%*-%&*B,'($%&(%#15"2*
=54
-%&in
B,'($%&(%#15"2
und
das>?%@A%
Rendern
der Bildschirmauflösung.
AC""%"*-#%*D.E%A(%*$/&3%&*22;'F*5"(%&*
P1
P2
-%"*+&/=%''/&%"*54$%&(%#1(*?%&-%"
P3
P1
P2
P4
P3
P1
K/&1%'5"2*L012/&#(34%"*#"*-%&*M/475(%&2&,;#ANO*PP*IQQR
P4
MP
O,((3#,'*N#'>3%&
75(%&2&,<#=RS*JJ*MTTU
P2
P4
P3
G,((3#,'*H#'@3%&
IJ
Abbildung 5.8: Berechnung der Einzelbilder bei Sort-Last.
Das Gesamtbild wird dann als Summe der Einzelbilder berechnet, wie in Abbildung 5.9
dargestellt. Die Verteilung (Sortierung) erfolgt damit erst nach der Rasterung. Er werden die
Pixelfragmente im 2D-Bildraum verteilt. Für die Zusammensetzung der Pixelfragmente zu
einem Gesamtbild müssen die Tiefenwerte bekannt sein, da sich Teile der gerenderten Polygone überlappen können. Man kann zwei Arten der Speicherung der einzelnen Pixelfragmente
unterscheiden. Diese sind:
• SL-sparse:
Jeder Prozessor speichert nur die tatsächlich gerasterten Pixel (in Abbildung 5.9 oben).
• SL-full:
Jeder Prozessor speichert immer die vollständige Bildschirmauflösung (in Abbildung
5.9 unten).
AlgoCG 09
73
9 SL-sparse:* ;#&*'7%#<3%&"*"5&*-#%*(,(')<31#<3*2%&,'(%&(%"*+#8%1
9 SL-full:*
SL full:
;#& '7%#<3%&" #44%& -#% $/11'()"-#2% =#1-'<3#&4,5>1?'5"2
;#&*'7%#<3%&"*#44%&*-#%*$/11'()"-#2%*=#1-'<3#&4,5>1?'5"2
Kapitel 5. Paralleles Rendering
=
P1
+
P2
+
P3
+
P4
=
P1
+
P2
+
P3
+
P4
D/&1%'5"2*E012/&#(34%"*#"*-%&*F/475(%&2&,>#GHI*JJ*BKKC
@,((3#,'*A#'<3%&
BC
Abbildung 5.9: Zusammensetzung der Einzelbilder zu einem Gesamtbild bei Sort-Last.
5.2 Hybrides Sort-First / Sort-Last Rendering
Es wird ein PC-Cluster betrachtet, in dem jeder Knoten aus einem PC besteht, der eine handelsübliche Grafikkarte verwendet. Die PCs sind durch ein Netzwerk verbunden und haben
keine hardwarebeschleunigte Zusammenführung von Bildern.
Sort-Middle ist durch den Bedarf an Spezialhardware nicht umsetzbar, da Standardgrafikkarten keinen direkten Zugriff auf das Ergebnis der Geometrietransformation erlauben. SortFirst erzeugt nur einen geringen Kommunikationsoverhead, benötigt aber eine zusätzliche
Transformation der Grafik-Primitive für die Verteilung. Da sich überlappende Kacheln (oder
auch Buckets genannt) zu einem redundanten Rendering führen, skaliert Sort-First schlecht,
da mit zunehmender Anzahl von Prozessoren die Anzahl der Überlappungen steigt. Sort-Last
skaliert dagegen gut, da sich die einzelnen Buckets nicht überlappen. Dafür müssen zusätzlich
zu den Farbwerten auch Tiefenwerte verschickt werden, was hohe Kommunikationskosten erzeugt.
Das hybride Sort-First/Sort-Last versucht nun, die Vorteile von Sort-First und Sort-Last zu
kombinieren. Der Partitionsalgorithmus ist sichtpunktabhängig und partitioniert dynamisch
zur Laufzeit. Dabei wird der 2D-Bildraum in Buckets partitioniert und der 3D-Objektraum
bestehend aus Polygonen in Gruppen. Die Partitionierung wird durchgeführt, um die Last
der Prozessoren zu balancieren und um die Kommunikationskosten für das Verschicken von
überlappenden Buckets zu minimieren.
5.2.1 Grundidee der Partitionierung
Die 3D-Polygone werden in Gruppen partitioniert. Die 2D-Boundingboxen der Gruppen bilden dann die Buckets. Typischerweise überlappen sich die Buckets. Das Ziel ist nun, die
Gruppen so zu wählen, dass die sich überlappenden Bereiche möglichst klein sind wie in Abbildung 5.10 dargestellt. Die Größe der überlappenden Bereiche ist entscheidend für die Höhe
der Kommunikationskosten.
Die Partitionierung wird zur Laufzeit durchgeführt, um je nach Blickwinkel die überlappenden Bereiche möglichst klein halten zu können.
AlgoCG 09
74
es Sort-First /Sort-Last Rendering
egende Idee Partitionierungs-Algorithmus
HEINZ NIXDORF INSTITUT
Kapitel 5. Paralleles Rendering
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
9#%11/'%*0"/&-"5"2
77#%&%*;<=+/1>2/"%*#"*?&577%"
*@<=A/5"-#"2./8%"*-%&*?&577%"*#4*A#1-&,54*
-%"
-%"*%#"*A5BC%(
%#" A5BC%(
*A5BC%('*D.%&1,77%"*'#B3
31%*-#%*?&577%"*'/F*-,''*-#%*'#B3*D.%&1,77%"-%"*
77
F
77
&%#B3%*-%&*A5BC%('*4G21#B3'(*C1%#" '#"-
H.%&1,775"2'.%&%#B3
I%*-%&*D.%&1,77%"-%"*A%&%#B3%*#'(*%"('B3%#-%"-*
KG3%*-%&*6/445"#C,(#/"'C/'(%"
&)541#B3%*?&577#%&5"2
O/&1%'5"2*P012/&#(34%"*#"*-%&*Q/475(%&2&,J#CRF*SS*@TTN
L,((3#,'*M#'B3%&
;N
Abbildung 5.10: Idee der Partitionierung beim Hybrid-Sort
5.2.2 Ablauf des Rendering
Der Algorithmus arbeitet in drei Phasen, die alle von entsprechenden PCs bearbeitet werden.
Das Gesamtsystem ist damit quasi eine 3-Phasen Pipeline, wie in Abbildung 5.11 dargestellt.
Die Phasen sind im einzelnen:
• Phase 1: Partitionierung
Die Partitionierung wird von einem Client-PC durchgeführt. Dieser teilt die 3DPolygone in N disjunkte Gruppen auf und weist jede Gruppe einem der N Server zu.
Dazu werden zunächst die Überlappungen der Buckets berechnet. Dann werden die Pixel in disjunkte Überlappungsbereiche aus überlappenden und nicht überlappenden Teilen Buckets partitioniert. Diese Überlappungen werden ebenfalls auf die Server verteilt.
• Phase 2: Rendering
Das Rendering wird parallel auf den N Servern ausgeführt. Dabei rendert jeder Server A die im zugewiesene Gruppe in den lokalen Framebuffer. Dann weden die Farbund Tiefenwerte aller Pixel, die in sich überlappenden Bereichen der Buckets liegen,
zurückgelesen. Die überlappenden Bereiche werden dann an die zuständigen Server B
geschickt.
Danach werden die Überlappungsbereiche gerendert. Dabei wird von allen Servern A
ein Teil des Überlappungsbereichs empfangen und die einzelnen Teile werden dann zu
einem Gesamtbild für den Überlappungsbereich zusammengesetzt. Dazu werden die
Farb- und Tiefenwerte aus dem lokalen Frame-Buffer verwendet. Nach dem Rendering
werden die Pixel aller Überlappungsbereiche zurückgelesen und zusammen mit den Pixeln der sich nicht überlappenden Teile der Buckets an den Display-PC geschickt.
AlgoCG 09
75
rt-First /Sort-Last Rendering
setzung
HEINZ NIXDORF INSTITUT
Kapitel 5. Paralleles Rendering
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
(*#"*-%&*;#1-'<3#&4,5:1='5"2*>%-%'*
*2%",5*%#"4,1
7:,"2*$/"*A#%:%"B%&(%"*"/(B%"-#2
D5*-#%*E,<3(%#1%*$/"*F/&(GH,'(G
Abbildung 5.11: Ablauf des Rendering beim Hybrid-Sort
• Phase 3: Bildzusammensetzung
Die Bildzusammensetzung wird von einem Display-PC ausgeführt. Dieser empfängt
die Teilbilder der Überlappungsbereiche und der sich nicht überlappenden Teile der
KL
C/&1%'5"2*M012/&#(34%"*#"*-%&*N/475(%&2&,:#?OP*FF*QRRS
Buckets und setzt alle Teile zu einemI,((3#,'*J#'<3%&
Bild zusammen. Der
Tiefentest ist hier nicht
mehr notwendig, da er bereits bei der Berechnung des Überlappungsbereichs ausgeführt
wurde. Im Vergleich zu normalen Sort-Last Algorithmus wird jedes Pixel nur genau
einmal empfangen, was die Kommunikationskosten senkt.
5.2.3 Partitionierungs-Algorithmus
Die beiden Ziele der Partitionierung sind:
1. Rendering-Last balancieren durch Umverteilung der Objekte in Gruppen
2. Kommunikationsoverhead minimieren indem durch Umverteilung die Überlappungsbereiche klein gehalten werden.
Die Berechnung muss schnell erfolgen, damit der Client nicht zum Bottleneck wird. Dazu
wird eine rekursive, binäre Aufteilung der Gruppen mit zwei aufeinander zulaufenden SweepLines vorgenommen. Abbildung 5.12 zeigt ein Beispiel für die Aufteilung mit Sweep-Lines.
Die linke (rote) Sweep-Line läuft immer nach rechts, die rechte (blaue) Sweep-Line läuft
nach links. Sobald ein Objekt vollständig von einer Sweep-Line überlaufen wurde, wird es
zur Gruppe hinzugefügt. Jeweils zu der Gruppe, die zur Sweep-Line gehört. Die Sweep-Lines
laufen nur so lange, bis alle Objekte verteilt wurden.
Wenn alle Objekte zugeordnet wurden und die Sweep-Lines aneinander vorbei gelaufen
sind, wie in Abbildung 5.12 (d) dargestellt, entstehen Überlappungsbereiche der Buckets.
AlgoCG 09
76
9 -#%*&%@3(%*;<%%7=>#"%*1)5?(*#44%&*",@3*1#":'
-#% &%@3(% ;<%%7 >#"% 1)5?( #44%& ",@3 1#":'
Kapitel 5. Paralleles Rendering
HEINZ NIXDORF INSTITUT
t /Sort-Last9 Rendering
'/.,1- %#" A.B%:( $/11'()"-#2 $/"!"#$%&'#()(*+,-%&./&"
'/.,1-*%#"*A.B%:(*$/11'()"-#2*$/"*-%&*;<%%7=
-%& ;<%%7=
thmus
012/&#(34%"*5"-*6/471%8#()(
>#"%*C.%&1,5?%"*<5&-%D*:/44(*%'*E5&*F&577%
lgorithmus
9 A.B%:(%D*-#%*$/"*-%&*1#":%"*G&%@3(%"H*;<%%7=
>#"%*C.%&1,5?%"*<5&-%"D*:/44%"*E5&*1#":%"*
G
G&%@3(%"H*F&577%
H
77
7=>#"%*1)5?(*#44%&*",@3*&%@3('
%7
%7=>#"%*1)5?(*#44%&*",@3*1#":'
>#"% 1)5?( #44%& ",@3 1#":'
9 -#%*;<%%7=>#"%'*1,5?%"*'/*1,"2%D*.#'*,11%*
2
HEINZ NIXDORF INSTITUT
A.B%:(%*$%&(%#1(*<5&-%"
/Sort-Last
Rendering
Hybrides
Sort-First /Sort-Last Rendering
!"#$%&'#()(*+,-%&./&"
%:(
%:(*$/11'()"-#2*$/"*-%&*;<%%7=
$/11'()"-#2 $/" -%& ;<%%7=
hmus
Partitionierungs-Algorithmus
*<5&-%D*:/44(*%'*E5&*F&577%
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
(a)
(b)
012/&#(34%"*5"-*6/471%8#()(
I,((3#,'*J#'@3%&
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,?#:PD*;;*QRRL
KL
Partitionierungs-Algorithmus
gorithmus
"*-%&*1#":%"*G&%@3(%"H*;<%%7=
*<5&-%"D*:/44%"*E5&*1#":%"*
7>#"%*1)5?(*#44%&*",@3*&%@3('
7%
9 :;
-#% <=%%7
-#%*<=%%7@>#"%'*1,5?%"*'/*1,"2%A*.#'*,11%*
>#"%' 1,5?%" '/ 1,"2% .#' ,11%
7
7=>#"%*1)5?(*#44%&*",@3*1#":'
>#"% 1)5?(9 #44%&
",@3 1#":'
B.C%D(%*$%&(%#1(*=5&-%"
'*1,5?%"*'/*1,"2%D*.#'*,11%*
2
*<5&-%" 9 =%""*,11%*B.C%D(%*E52%/&-"%(*=5&-%"*5"-*-#%*
(*$/11'()"-#2*$/"*-%&*;<%%7=
( $/11'()"-#2 $/" -%& ;<%%7=
(c)
(d)
<=%%7@>#"%'*,"%#","-%&*$/&.%#*2%1,5?%"*'#"-A*
<5&-%D*:/44(*%'*E5&*F&577%
KL
I,((3#,'*J#'@3%&
2/&#(34%"*#"*-%&*O/475(%&2&,?#:PD*;;*QRRL
-,""*%"('(%3%"*-#%*F.%&1,775"2'.%&%#G3%*-%&*
H5GD%('
Abbildung 5.12: Partitionierung der Szene mit Sweep-Lines.
*-%&*1#":%"*G&%@3(%"H*;<%%7=
<5&-%"D*:/44%"*E5&*1#":%"*
Die rekursive Aufteilung wird vorgenommen, in dem ein Bucket jeweils senkrecht zur läng%
sten Achse in zwei Gruppen aufgeteilt wird. Die Aufteilung wird beendet, nachdem bis zu N
gleichmäßige Gruppen entstanden sind. Dabei sollte jede Gruppe die gleiche Rendering-Last
*1,5?%"*'/*1,"2%D*.#'*,11%*
2 erzeugen.
<5&-%"
5.2.4 Abschätzung des Kommunikations-Overhead
KL
I,((3#,'*J#'G3%&
#(34%"*#"*-%&*O/475(%&2&,?#:PD*;;*QLLR
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,?#DPA*<<*QRRS
I,((3#,'*J#'@3%&
KL
Ein Teil des Kommunikations-Overhead entsteht durch das Verschicken der überlappenden
Bereiche der Buckets. Eine exakte Berechnung ist schwierig, da die Breite der Überlappung
schwer abzuschätzen ist. Sie hängt ab vom Aufbau der Szene und vom jeweiligen Sichtpunkt.
Für die Berechnung werden deshalb die folgenden, vereinfachenden Annahmen gemacht:
• Alle Objekte sind gleich verteilt
• Alle Objekte sind im Bildraum (nach der Transformation) als Quadrate gleicher Größe
mit Kantenlänge B abgebildet.
• Der Bildraum besteht aus P Pixeln
• Es gibt N Server
• Jeder Server bekommt ein Bucket mit
P
N
Pixeln und Kantenlänge
√
√P .
N
Ein solches quadratisches Bucket zeigt Abbildung 5.13. Der rote Bereich S ist der Überlappungsbereich, an dem sich die gerenderten Pixel überlappen. Der Bereich ist ein „Streifen“ der Breite B2 , der außen um das Bucket herumliegt. Die Breite kommt zustande, da ein
AlgoCG 09
77
Kapitel 5. Paralleles Rendering
HEINZ NIXDORF INSTITUT
Sort-Last Rendering
ad
!"#$%&'#()(*+,-%&./&"
Objekt, das weiter außen liegt, sonst zuvor
von einer anderen Sweep-Line in einen anderen
012/&#(34%"*5"-*6/471%8#()(
Bucket sortiert worden wäre.
%*=S) -%&*;5<>%('*
'#<3*-#%*2%&%"-%&(%"*
# 3 -#
- (
"*;5<>%(
?
C.D%>(
B/2
B
%#"*E?(&%#F%"G*-%&*
'*;5<>%(
;5<>%(
"',5F:,"-*2#1(K
B
Abbildung 5.13: Illustration der Berechnung der Kommunikations-Overhead
<3#<>(*-%"*;%&%#<3*?*
Jeder Prozessor schickt nur diesen Bereich S zu anderen Prozessoren oder erhält einen
%''/&%"*
solchen Bereich. Die Größe von S setzt sich zusammen aus:
-%&'%1.%"*M&NO%*$/"*
• den vier Ecken, jeweils mit Größe B2 · B2
• den vier Rechtecken entlang der Seiten, jeweils mit Größe
B
2
·
√
√P
N
Die Gesamtgröße von S ergibt sich damit als:
√
B √P
·
+4
2
N
√
P
2B √N
+ B2
P,((3#,'*J#'<3%&
T (n) = 4 ·
4%"*#"*-%&*T/475(%&2&,F#>U@*??*IVVW
=
·
B
2
·
B
2
QQ
Diese Anzahl von Pixeln muss jeder Server in jedem Frame an andere Server verschicken.
AlgoCG 09
78
6 Level of Detail
In einer Szene sind nicht immer alle Objekte mit gleich hohem Detaillierungsgrad erkennbar.
Trotzdem müssen alle Objekte gezeichnet werden, wodurch Rechenzeit verschwendet wird.
Der Ansatz des Level of Detail besteht darin, ein weniger komplexes Modell zu erstellen und
zu rendern, dass (fast) genauso gut aussieht wie das ursprüngliche Modell.
Werden alle Objekte mit hoher Komplexität gerendert erhält man eine hohe Qualität der Bilder, aber eine geringe Framerate. Ab einer bestimmten Anzahl von Objekten ist keine akzeptable Realzeit-Navigation mit mehr als 20 fps mehr möglich. Bei niedriger Komplexität für
alle Objekte erhält man eine niedrige Qualität, aber dafür eine hohe Framerate. Im klassischen
Level of Detail versucht man eine individuelle Steuerung zwischen Komplexität und Performance zu erreichen. Die hohe Komplexität wird nur dort verwendet, wo es optisch wichtig ist.
Die niedrige Komplexität dort, wo es nicht wichtig ist. Typischerweise nutzt man 3 bis 5 Modelle in unterschiedlichen Komplexitätsstufen für ein Objekt, die im Preprocessing berechnet
werden. Die Auswahl erfolgt während des Walkthrough in Abhängigkeit von der Entfernung
des Objektes. Je weiter das Objekt entfernt ist, desto geringer die Komplexität des LOD. Die
Motivation dafür ist, dass mit zunehmender Entfernung Fehler schlechter sichtbar sind und
somit eine geringere Komplexität ausreichend ist. Abbildung 6.1 zeigt ein Beispiel für dieses
Prinzip.
Entfernungsabhängigkeit der
Fehlersichtbarkeit
Verschiedene LOD Modelle
für das Objekt
Abbildung 6.1: LOD-Modelle für verschiedene Entfernungen.
Für
jedes
Objekt
O
werden
im
Preprocessing
LODs
LOD(O1 ), LOD(O2 ), LOD(O3 ), . . . , LOD(Ol ) berechnet und es werden Abstände
79
Kapitel 6. Level of Detail
d(O1 ), d(O2 ), d(O3 ), . . . , d(Ol ) definert. Falls dann zur Laufzeit ein Objekt O mit Abstand d
zum Betrachter gerendert werden soll, wobei d(Oi ) ≤ d < d(Oi+1 ) gilt, dann wird das Objekt
mit d(Oi ) gerendert. Falls d < d(O1 ) ist, dann wird die höchste Auflösung verwendet.
6.1 Arten des Level of Detail
Es gibt verschiedene Arten, das Level of Detail auszuführen, die im Folgenden vorgestellt
werden sollen.
6.1.1 Discrete Level of Detail
Das Objekt wird in Abhängigkeit von der Entfernung durch unterschiedliche LODs dargestellt. Dies hat den Nachteil, dass Sprungeffekte (Popping-Artefakte) entstehen, wenn ein
LOD getauscht wird. Das Objekt verändert so plötzlich sein Aussehen.
6.1.2 Continuous Level of Detail
Bei dieser Variante wird im Preprocessing ein kontinuierliches Spektrum von LODs kodiert.
Dabei werden mehrere unterschiedliche LODs (Auflösungen) in einer einzigen Darstellung
kodiert. Zur Laufzeit wird das gewünschte LOD daraus berechnet. Je höher die Auflösung
(Granularität), desto feiner sind die Übergänge zwischen den Modellen.
6.1.3 View-Dependent Level Of Detail
Für sehr große und lange Objekte, wie z.B. einen Zug oder ein Oberflächennetz, sind einzelne
Teile des Objektes unterschiedlich weit entfernt. Die Idee des sichtpunktabhängigen LOD besteht darin, dass man mehrere LODs für ein einziges Objekt gleichzeitig benutzt. Es sollen
nahe Teile des Objektes in höherer Auflösung dargestellt werden, als weiter entfernte Teile
des Objektes. Damit erhält man ein sichtpunktabhängiges LOD, bei dem man für ein einzelnes Objekt kontrollieren kann, an welcher Stelle wie viele Polygone zur Darstellung benutzt
werden sollen.
6.2 LOD - Hierarchie
LODs können z.B. in der von Clark vorgeschlagenen LOD-Hierarchie organisiert werden. Die
LOD Hierarchie ist ein hierarchischer, azyklischer Baum. Dieser enthält als Wurzel ein LOD
der ganzen Szene. Tiefere Ebenen enthalten verfeinerte LODs von einzelnen Objekten, wie in
Abbildung 6.2 für die Smiley Figur dargestellt. Jeder Knoten enthält verfeinerte Teilobjekte
der Elternknoten (LODs) und Transformationen, die das Objekt an die Objekte an die richtige
Position der Szene verschieben.
Die Hierarchie wird so verwendet, dass im Baum bis zur gewünschten Detailtiefe abgestiegen wird, die der gewünschten Genauigkeit entspricht. Alle Knoten der gewünschten Tiefe
AlgoCG 09
80
3%,-
1%2'
,&4'
HEINZ NIXDORF INSTITUT
I J5&K%1*%"(3)1(*%#"*9:;*-%&*2,"K%"*
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()( fine
LK%"%
coarse
In den Knoten
I $%&M%#"%&(%*Q%#1/.P%?(%*-%&*N1(%&"?"/(%"*
R9:;O'S
refined
l
level
l2
I Q&,"'M/&4,(#/"%"
3%,-
1%2'
R$%&'=3#%.%"*-%&*:.P%?(%*,"*-#%*&#=3(#2%*
Level of Detail
'?511
4/5(3 1%M(
+/'#(#/" #" -%& LK%"%S
+/'#(#/"*#"*-%&*LK%"%S
!"#$%&'()(*+&'
fine
*-%&*2,"K%"*
"*$%&M%#"%&(%*
.P%?(%"
-%&*N1(%&"?"/(%"*
l
level
l3
4/5(36. 1%M(
Kapitel
Level of&#23(
Detail
%G%'
1%2
%2
1%2
2
'4#1%G
level 1
r Baum
'?511
l
level
l3
I (#%M%&%*N.%"%"*%"(3,1(%"*$%&M%#"%&(%*
F3/1%*'=%"%
9:;O'*$/"*%#"K%1"%"*:.P%?(%"
s?
??*@ABCDE
@ABCDE
refined
l
level
l2
Hierarchischer azyklischer Baum
1%2
%2
%G%'
,&4'
HEINZ NIXDORF INSTITUT
&#23(
1%2
2
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
(a)
9/:5*;<""(%*-#%*=#%&,&>3#%*"/>3*$%&?%"-%(*?%&-%"@
V/&1%'5"2*W012/&#(34%"*#"*-%&*>/475(%&2&,M#?XY*LL*Z[[B
(b)
T,((3#,'*U#'=3%&
AD
View-Frustum-Culling
Abbildung 6.2: LOD Hierarchie nach Clark.
A :5*B%-%4*6"/(%"*#'(*'%#"%*C/5"-#"2./8 2%'7%#>3%&(
gehörenA zur
sogenannten
Die/.
Knoten
der Front werden
gerendert,
Knoten oberhalb
7&DE%
7&DE%*.%#*B%-%4*6"/(%"F*/.*-#%*C/5"-#"2./8
.%# B%-%4Front.
6"/(%"
-#% C/5"-#"2./8
'#>3(.,&
'#>3(.,&*#'(
#'(
und unterhalb der Front werden nicht gerendert. Dabei wird ein sichtpunktabhängiges LOD
A E,11'*-#%*C/5"-#"2./8 "#>3(*'#>3(.,&*#'(F*&%"-%&%*#3&%"*G"3,1(*"#>3(*
unterstützt, da einzelnen Teile des Modells aus einer tieferen Ebene genommen werden kön5"-*.&%>3%*-#%*H&,$%&'#%&5"2*,"*-%4*6"/(%"*,.
nen, wie der Rest des Objektes. In dem Ausschnitt in Abbildung 6.3 wird z.B. ein gröberes
(%*,"*-#%*&#=3(#2%*
LOD für die Arme und ein feineres LOD für den Rest des Objektes verwendet.
-#%'%&*6"/(%"*#'(*5"'#>3(.,&
?3/1%*'>%"%
-%&*>/475(%&2&,M#?XY*LL*Z[[B
coarse
level 1
T,((3#,'*U#'=3%&
'4#1%I
refined
level 2
3%,';511
fine
level 3
1%2'
4/5(3 11%E(
E(
1%2
%I%'
AD
-#%'%&*H%#1*?#&-*2%&%"-%&(
,&4'
&#23(
1%2
6/7EV*W%$%1*X
0&4%V*W%$%1*S
N/&1%'5"2*O012/&#(34%"*#"*-%&*P/475(%&2&,E#;QF*RR*STTU
LM
J,((3#,'*K#'>3%&
Abbildung 6.3: Verwendung der Hierarchie für sichtpunktabhängiges LOD und ViewFrustum-Culling.
Die Hierarchie kann außerdem zum View-Frustum-Culling verwendet werden, wenn zu jedem Knoten seine Boundingbox gespeichert wird. Für einen Knoten wird dann zunächst geprüft, ob die Boundingbox sichtbar ist. Falls nicht, wird der Inhalt des Knotens nicht gerendert und die Traversierung an dem Knoten abgebrochen. Abbildung 6.3 zeigt auch dies, da
die Beine des Smileys nicht sichtbar sind.
6.3 Automatische Frameratenregulierung
Das Ziel des Algorithmus ist es, eine konstante Framerate zu erzielen. Dabei sind als Eingabe
mehrere Objekte O, sowie mehrere LODs L für jedes Objekt gegeben. Zusätzlich wird davon
AlgoCG 09
81
Kapitel 6. Level of Detail
ausgegangen, dass eine bestimmte Menge x von Dreiecken in Echtzeit (d.h. mit mind. 20 fps)
dargestellt werden kann. Der Algorithmus muss nun vor dem Rendern für jedes Objekt eine
bestimmte Auflösung wählen, um die Framerate konstant zu halten. Dazu definieren wir:
• den Nutzen Benef it(O, L) und
• die Kosten Cost(O, L) eines Objektes für jedes seiner LODs.
Der Nutzen wird als Produkt von der Größe und der Wichtigkeit des Objektes, sowie der
Bewegungsgeschwindigkeit, dem Focus (Mittelpunkt des Bildschirms oder nicht) und der Hysterese (wann wurde das LOD zuletzt gewechselt) berechnet.
Für die Abschätzung der Kosten wird angenommen, dass die Rendering Pipeline das Bottleneck ist. Die Kosten der Pipeline bestehen zum einen aus den Kosten der Geometrietransformation (Polygone + Punkte) und zum anderen aus der Rasterung. Der Bottleneck ist entweder die Transformation oder die Rasterung, weshalb das Maximum der Kosten dieser beiden
Schritte betrachtet wird. Die Koeffizienten werden empirisch für alle LODs bestimmt.
Für eine Menge S von Objekten im View-Frustum soll nun der Benefit maximiert werden
unter der Bedingung, dass die Kosten die Ziel-Framerate nicht übersteigen. Dies ist jedoch
ein Rucksackproblem und damit leider NP-vollständig. Man verwendet deshalb einen GreedyAnsatz, der jeweils das LOD mit dem besten Nutzen/Leistungsverhältnis auswählt.
6.4 Vereinfachung von Polygonmodellen
Für ein gegebenes 3D-Modell bestehend aus n Dreiecken sollen dem Original möglichst ähnlich sehende 3D-Modelle berechnet werden, die n0 << n Polygone besitzen. Sie sollen ein
ähnliches Polygonnetz bei gleichem Aussehen besitzen. Für die Verringerung der Polygonzahl bei gleichem Aussehen und die Messung der Qualität gibt es vier Ansätze, die im Folgenden vorgestellt werden sollen. Die meisten Methoden sind eine Mischung dieser vier Grundansätze.
6.4.1 Decimation
Bei diesem Ansatz werden sukzessive Punkte aus dem Modell entfernt und nach jedem entfernten Punkt doch entstandene Loch neu trianguliert. Das Verfahren terminiert, wenn der gewünschte Reduktionsgrad oder eine bestimmte Anzahl an Dreiecken erreicht wurde. Abbildung 6.4 zeigt ein Beispiel. Die roten Punkte wurden nicht ausgewählt und die grünen Punkte
werden im nächsten Schritt entfernt. Wie in der Abbildung dargestellt, ist es möglich, mehrere
Punkte in einem Schritt zu entfernen.
Bei der Auswahl der Punkte sorgt ein Fehlermaß dafür, das gelöschte Punkte nur zu kleinen
Fehlern führen. Eine Variante ist das erhalten einer lokale Topologie, z.B. für einen Käse mit
Löchern werden keine Punkte entfernt, die ein Verschwinden von Löchern verursachen.
AlgoCG 09
82
; ?&@"< +5":(%*=%&-%"*#4*")>3'(%"*A>3&#((*%"(B%&"(
; #"*%#"%4*A>3&#((*:C""%"*%#"*/-%&*4%3&%&%*+5":(%*,5'2%=)31(*=%&-%"
#" %#"%4 A>3&#(( :C""%" %#" /-%& 4%3&%&% +5":(% ,5'2%=)31( =%&-%"
Kapitel 6. Level of Detail
/&#2#",1*4/-%1
# # 1
- 1
B# - #
B#&'(*-%>#4,(#/"
#
O
'%>/"-*-%>#4,(#/"
-- #
#
G
(3#&-*-%>#4,(#/"
3# - - #
#
F
D,((3#,'*E#'>3%&
H/&1%'5"2*I012/&#(34%"*#"*-%&*J/475(%&2&,B#:KL*AA*GMMN
FG
HEINZ NIXDORF INSTITUT
Abbildung
6.4: Arbeitsweise des Decimation Algorithmus.
Vereinfachung
von Polygonmodellen
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$%&'(
6.4.2 Sampling
Beispiel
Bei diesem Ansatz werden zufällig neue Punkte auf die Oberfläche des Objektes verteilt. An9 :/(; werden
/&#2#",1alle
/&#2#",1*+5"<(%
+5"<(%
schließend
originalen Punkte entfernt und die neuen Punkte zu einer Oberfläche
trianguliert.
Anzahl der neuen Punkte bestimmt die Komplexität des neuen Polygonmo9 =&>";Die
"%5%*+5"<(%
dells. Abbildung 6.5 illustriert dieses Verfahren, wobei die originalen Punkte rot und die neuen
Punkte grün sind.
"%5%*+5"<(%*,5?*-#%*
@.%&?1)A3%*'%(B%"
/&#2#",1 4/-%1
/&#2#",1*4/-%1
/&#2#",1%*+5"<(%*%"(?%&"%"*
2
"%5%*+5"<(%*(&#,"251#%&%"
',471%- 4/-%1
',471%-*4/-%1
&%(&#,"251,(%- 4/-%1
&%(&#,"251,(%-*4/-%1
Abbildung 6.5: Arbeitsweise des Sampling Algorithmus.
G/&1%'5"2*H012/&#(34%"*#"*-%&*I/475(%&2&,?#<JK*LL*MNNO
EF
C,((3#,'*D#'A3%&
Für die Verteilung der neuen Punkte gibt es zwei Strategien. Sie können entweder direkt auf
die Oberfläche der Dreiecke oder auf die gedachte Oberfläche des Objektes gesetzt werden.
Der Vorteil dieses Verfahrens ist die gezielte Steuerbarkeit, an welchen Stellen des Modell
eine hohe Komplexität entstehen soll. Ein Problem ist jedoch, dass, wie in Abbildung 6.6
dargestellt, scharfe Kanten schnell verloren gehen können.
AlgoCG 09
83
9 '<3,&?%*6,"(%"*@A""%"*'<3"%11*$%&1/&%"*2%3%"
Kapitel 6. Level of Detail
Abbildung 6.6: Verlust von scharfen Kanten bei der Anwendung des Sampling
Algorithmus.DE
B,((3#,'*C#'<3%&
F/&1%'5"2*G012/&#(34%"*#"*-%&*H/475(%&2&,?#@I>*==*JKKL
HEINZ NIXDORF INSTITUT
Vereinfachung von Polygonmodellen
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$"%&'"#()*(
6.4.3
Vertex Merging
Bei diesem
Verfahren werden benachbarte Punkte verschmolzen, so dass der neue Punkt in der
Beispiel
Nähe der alten Punkte liegt. Dabei zu einer Linie kollabierende Dreiecke werden entfernt. Die
9 :/(; +5"<(%*.1%#.%"*5".%&=3&(
+5"<(% .1%#.%" 5".%&=3&(
neue Fläche kommt damit mit weniger Dreiecken aus. Diese beiden Schritte werden solange
9 >&=";
+5"<(%*?%&-%"*$%&'@34/1A%"
wiederholt,
bis die
gewünschte Reduktion erreicht wurde. Abbildung 6.7 zeigt ein Beispiel, in
dem die9 unberührten
Punkte
rot, die verschmolzenen
Punkte grün und der neue verschmolzene
B1,5; -%&*"%5%*$%&'@34/1A%"%*+5"<(
-%& "%5%
$%&'@34/1A%"%
+5"<(
Punkt blau dargestellt sind.
-#%'% C&%#%@<%
-#%'%*C&%#%@<%*
3,.%*#3&%*D/&4*
$%&)"-%&(
4%&2%-*$%&(#@%'
"%?*$%&(%8
Abbildung 6.7: Arbeitsweise des Vertex Merging Algorithmus.
H/&1%'5"2*I012/&#(34%"*#"*-%&*J/475(%&2&,K#<LM*NN*OPPG
E,((3#,'*D#'@3%&
FG
Mit diesem Verfahren ist die gezielte Reduktion an bestimmten Stellen des Netzes möglich.
6.4.4 Adaptive Subdivision
Bei diesem Verfahren wird ein grobes Modell des Originalmodells berechnet, das sogenannte
Basisnetz. Anschließend wird ein Fehlermaß definiert, dass den Abstand zum Ausgangsmodell misst. Dann werden sukzessive neue Knoten eingefügt, um das Basisnetzt zu verfeinern
und den Fehler zu reduzieren. Neue Punkte werden dort eingefügt, wo der Fehler stark verkleinert werden kann. Abbildung 6.8 illustriert diese schrittweise Verfeinerung.
Das Verfahren arbeitet damit „umgekehrt“ zum Decimation Verfahren. Der Vorteil ist, dass
Fehler durch das Einfügen von Punkten leichter zu justieren sind als durch das Wegnehmen
von Punkten. Der Nachteil besteht darin, dass das Basisnetz mit einem anderen Verfahren
erzeugt werden muss.
AlgoCG 09
84
9 :#&*;<2%"*-/&(*"%5%*+5"=(%*%#">*?/*?#&*-%"*@%31%&*A54*B&#2#",14/-%11*'(,&=*
$%&%#";,C3%"*=D""%"
Kapitel 6. Level of Detail
E,'#'"%(A*4#(*,"-%&%4*
F%&;,3&%"*%&A%52(
/&#2#",1*4/-%1
GH*0"")3%&5"2
*.,'%*4/-%1
IH*0"")3%&5"2
*;#&'(*'5.-#$#'#/"
*'%C/"-*'5.-#$#'#/"
Abbildung 6.8: Arbeitsweise des Adaptive Subdivision Algorithmus.
J,((3#,'*@#'C3%&
F/&1%'5"2*L012/&#(34%"*#"*-%&*M/475(%&2&,;#=N>*OO*IPPQ
KI
6.5 Schrittweise Verfeinerung mit Progressive Meshes
Progressive Polygonnetze sind grobe und feine Modellierungen eines Polygonmodells in einem Modell. Dies erlaubt den Wechsel zwischen groben und feinen Darstellungen und somit
einen feinstufigen Wechsel zwischen verschiedenen Auflösungen in Echtzeit. Dazu wird eine
Folge von Dreiecken
M̂ = M n , M n−1 , M n−2 , M n−3 , . . . , M 3 , M 2 , M 1 , M 0
erzeugt, wobei M̂ das originale Polygonnetz ist und M 0 die gröbste Stufe (ggfs. nur ein
HEINZ NIXDORFzu
INSTITUT
Dreieck).
Dabei ist esPolygonnetze
möglich, M j aus M j+1 durch eine lokale Veränderung
erzeugen.
Progressive
!"#$%&'#()(*+,-%&./&"
!"#$%&'()#)
012/&#(34%"*5"-*6/471%8#()(
6.5.1 Vergröberung
Operation: Edge Collapse #*(+,-
./0-&/0/v’s1
Die Vergröberung
wird%#"%
durch
die;-Funktion
Edge Collapse ecol(vs , vt , vs0 ) durchgeführt. Dazu
9 :#&*:)31%"*%#"%*6,"(%*;:#& :)31%"
6,"(%
-&<
./0wird eine Kante
(vs , vt ) gewählt und die beiden Endpunkte der Kante werden
zu einem neuen
9 :#&*=,''%"*-#%*.%#-%"*6"/(%"*-%&*6,"(%*>5*%#"%4*"%5%"*6"/(%"*-2
.
Dieser Vorgang ist in Abbildung 6.9 dargestellt.
Knoten vs0 zusammengefasst.
>5',44%"
#*(+,-./0-&/0/v’s1
-&
-$
-+
-+
-2.
-$
-.
Abbildung 6.9: Arbeitsweise des Edge Collapse Algorithmus bei Verwendung von Progressive Meshes.
BC
?,((3#,'*@#'A3%&
Das resultierende Netz besitzt nun einen Knoten und zwei Dreiecke
weniger. Der
neue
0
Punkt vs muss jedoch zusätzlich gespeichert werden. Für die Platzierung des neuen Knotens
gibt es verschiedene Strategien, die in Abbildung 6.10 zusammengefasst sind.
D/&1%'5"2*E012/&#(34%"*#"*-%&*F/475(%&2&,=#GHI*JJ*KLLC
AlgoCG 09
85
Kapitel 6. Level of Detail
/&#2#",1%'*
< - 11
</-%11
-%&*"%5%*+5"=(%*
,5>*-%&*
>3?7/(3%(#'@3%"*
A.%&>1)@3%
-%&*"%5%*+5"=(*
4#((%"*,5>*-%&*
#((
>%"(>%&"(%"*6,"(%
-%&*"%5%*+5"=(*
,5>*%#"%4*-%&*
> #
B@=75"=(%
Abbildung 6.10: Positionierung des neuen Punktes bei Ausführung von Edge Collapse.
DE
<,((3#,'*C#'@3%&
F/&1%'5"2*G012/&#(34%"*#"*-%&*H/475(%&2&,>#=IJ*KK*LMMN
Bei der Positionierung des neuen Punktes auf der hypothetischen Oberfläche tendiert das
Netz zur Originalgröße. Die resultierende Form ist jedoch oft nicht bekannt. Bei der Positionierung auf der Mitte der entfernten Kante tendiert das Netz hingegen dazu, kleiner zu werden. Die Positionierung auf einem der Eckpunkte ist die einfachste Möglichkeit, da hier keine
Berechnungen angestellt werden müssen.
Durch eine Folge von Edge Collapse Anwendungen erhält man nun eine Folge von Netzen,
die alle aus dem originalen Netz entstehen. Somit kann man zur Laufzeit das Polygonnetz
vergröbern.
6.5.2 Verfeinerung
Progressive Polygonnetze
HEINZ NIXDORF INSTITUT
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$%&'()#)
Da das Netz nicht nur vergröbert werden soll, sondern bei Bedarf auf wieder verfeinert werden
*+",-*+./*,./*
muss, wird dieOperation:
FunktionVertex
zum Split
Vergröbern
umgekehrt.
Man erhält so die Funktion Vertex Split
$./.v’s /v’t0
0
0
:#&
:)31%"
%#"%"
+5";(
die die
Vergröberung
wieder rückgängig macht. Dazu wird ein Punkt vs
vt ),
vspl(vs , vl , vr , v9 s ,:#&*:)31%"*%#"%"*+5";(*
in
wieder in eine Gerade
(vs0 , vt0 ) aufgeteilt, wie
9 5"-*(%#1%"*#3"*,5<*#"*-#%*6,"(%**1
+./*1
&. Abbildung 6.11 dargestellt.
*+",-*+./*,./*$./.v’s /v’t0
*,
*+
*$
*1&
*,
*$
*1+
Abbildung 6.11: Arbeitsweise des Vertex Split Algorithmus bei Verwendung von Progressive
Meshes.
A/&1%'5"2*B012/&#(34%"*#"*-%&*C/475(%&2&,<#;DE*FF*GHHI
=,((3#,'*>#'?3%&
@@
Das resultierende Netz besitzt damit einen Knoten und zwei Dreiecke mehr. Dazu müssen
die neu entstandenen Knoten vs0 und vt0 gespeichert werden.
Man erhält nun den reversiblen Prozess durch eine Folge von Vertex Split Operationen und
eine Folge von verfeinerten Netzen bis hin zum Original Polygonnetz.
AlgoCG 09
86
Kapitel 6. Level of Detail
Über die Verwendung von Edge Collapse und Vertex Split kann nun beliebig zur Laufzeit
zwischen verschiedenen Detailgraden gewechselt werden.
6.5.3 Messung der Qualität
Mit der Qualitätsmessung sollen Kanten identifiziert werden, die sich besonders gut eignen,
um sie zu entfernen. Dabei sollen mehrere Eigenschaften des Modells möglichst erhalten
bleiben:
• Geometrie, d.h. Ecken, Kanten, Rundungen
• Skalare, d.h. Farben
• Diskontinuitäten, d.h. Normalen, Materialien
Dazu wird eine Energiefunktion definiert, die diese Eigenschaften quantitativ ausdrückt.
Diese Energiefunktion ist definiert als:
E(M ) = Egeo (M ) + Escalar (M ) + Edisc (M )
Dabei ist
• Egeo (M ) ein Maß für die geometrische Abweichung des reduzierten Netzes vom Original
• Escalar (M ) ein Maß für die Genauigkeit von skalaren Werten
• Edisc (M ) ein Maß für die Abweichungen von diskontinuierlichen Werten
Alle Funktionen sind Heuristiken und können keine Garantie für eine genaue bzw. qualitativ hohe Wiedergabe geben. Es sind andere Bewertungsfunktionen oder Definitionen der
einzelnen Terme möglich.
6.5.4 Verfeinerungsalgorithmus
Der Algorithmus nutzt eine PriorityQueue, in der alle Edge-Collapse Operationen
ecol(vs , vt , vs0 ) gespeichert sind. Der Schlüssel ist die Veränderung der Energiefunktion ∆E,
die die Anwendung der Operation ecol(vs , vt , vs0 ) nach sich ziehen würde. Dabei wird eine
kleine Änderung bevorzugt. Das Verfahren fasst Algorithmus 19 zusammen.
Die Berechnung des PM-Modells wird im Preprocessing durchgeführt. Zur Laufzeit wird
dann mit der PM-Repräsentation eine Verfeinerung oder Vergröberung der aktuellen Auflösung vorgenommen.
AlgoCG 09
87
Kapitel
LevelINSTITUT
of Detail
HEINZ6.
NIXDORF
Progressive Polygonnetze
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$"%&"'
Algorithmus 19 Erzeuge Progressive Mesh
Level of
Detail
1: Continuous
function E RZEUGE
PM(originalesNetz
M)
0
2: 9 -#%*6/471%8#()(*%#"%'*:%(;%'*1)''(*'#<3*?.%1#%.#2
Initialisiere
Priority-Queue
mit
allen
Operationen
s , vt , vs )
-#% 6/471%8#()( %#"%' :%(;%' 1)''( '#<3
.%1#%.#2=ecol(v
*>%#"*&%2%1"
>%#" &%2%1"
3:
repeat
9
-#%*@1%#"'(%*A#"3%#(*#'(*B*6"/(%"*-%'*+/1C2/""%(;%'*
4:
wende oberstes Element der Queue ecol(vs , vt , vs0 ) an
5:
aktualisiere Schlüssel der Elemente in der Nachbarschaft der eliminierten Kante
(vs , vt )
6:
until gewünschte Auflösung erreicht oder Queue leer
7: end function
()
*+,-)
*+,-.
*+,-/0.
*+,-"0.
(/
()
2
("1(
(/
Abbildung 6.12: Anwendung der Progressive Meshes für kontinuierliches LOD.
FG
D,((3#,'*E#'<3%&
HEINZ NIXDORF INSTITUT
H/&1%'5"2*I012/&#(34%"*#"*-%&*J/475(%&2&,>#@KL*MM*NOOP
6.5.5
Progressive Polygonnetze
Anwendungen
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
!"#$"%&"'
Eine Anwendung für Progressive Meshes ist das kontinuierliche Level of Detail, da sich die
Komplexität +&/2&%''#$%*9&,"'4#''#/"
des Netzes „beliebig“ fein regeln lässt. Die kleinste Einheit ist 1 Knoten des Polygonnetzes. Man
Auflösungen um< %#"*+/1=2/""%(>*?#&-*'5:>%''#$%*;.%&*%#"%"*6,",1*;.%&(&,2%"
# kann
+ 1 somit fast
# - stufenlos
:
# zwischen
;.
# den
6 verschiedenen
1 ;.
schalten, wie in Abbildung 6.12 angedeutet.
< ?)3&%"-*-%&*@.%&(&,25"2*?#&-*-,'*A/-%11*.%&%#('*-,&2%'(%11(
Eine zweite Anwendung ist eine progressive Übertragung (progressive Transmission). Da< -#%*B,&'(%115"2'D5,1#()(*$%&C%#"%&(*'#E3*?)3&%"-*-%&*@.%&(&,25"2
-# Bzunächst
( 11 in einer
1#()(groben
C # Auflösung
( # 3 )3 übertragen
- - @. und
( anschließend werden
bei wird das Modell
die Verfeinerungen übertragen. Damit kann das Modell schon während der Übertragung dargestellt werden.
Die?#%
Darstellungsqualität
F3"1#E3
F3"1#E3*?#%*7&/2&%''#$%*G7%2
7&/2&%''#$% G7%2 verfeinert sich dann im Laufe der Übertragung, ähnlich wie dies auch bei progressive jpeg durchgeführt wird. Das Verfahren illustriert Abbildung
6.13
H%#(
()
-#%'%&*9%#1*#'(*
.%#4*
I47C)"2%&
I47C)"2%&*
,"2%:/44%"
*+,-)
*+,-.
*+,-/0.
*+,-"0.
()
M/&1%'5"2*N012/&#(34%"*#"*-%&*O/475(%&2&,C#:PQ*RR*STTU
(/
1
(
A,((3#,'*J#'E3%&
KL
Abbildung 6.13: Anwendung der Progressive Meshes für progressive Übertragung.
AlgoCG 09
88
7 Aspect Graph und Viewpoint Space
Partition
Die Viewpoint Space Partition und der dafür erzeugte Aspect Graph dienen zur Bilderkennung. Die Idee ist es, alle möglichen Ansichten eines Objektes zu speichern und das gerade
aufgenommene Bild mit diesen Ansichten zu vergleichen. Alle Ansichten, die die gleiche
Bild-Topologie darstellen, werden zu Klassen, den sogenannten Aspekten zusammengefasst.
Die Grundlage für diese Betrachtungen sind Polyeder, die aus Polygonen zusammengesetzt
sind. Dabei gehört jede Kante zu genau zwei Polygonen. Man kann zwischen konvexen und
nicht konvexen Polyedern unterscheiden. In einem konvexen Polyeder verläuft eine gerade
Verbindungslinie von zwei beliebigen Punkten immer innerhalb des Polyeders.
Eine Ansicht ist nun eine 2-dimensionale Projektion der Ecken und Kanten des Polyeders.
Dabei werden Kreuzungen von Linien zu Punkten, zusammentreffenden Linien zu Punkten
und Linien zwischen den Punkten zu Kanten.
7.1 Viewpoint Space Partition
Die Menge aller möglichen Bildpunkte wird in Regionen unterteilt. Innerhalb einer Region
bleibt das Erscheinungsbild gleich, d.h. es gibt nur Änderungen „topologischer Art“. Dabei
ist nur eine Änderung der Struktur von Ecken und Kanten wichtig, nicht aber die Länge der
Kanten.
Die Regionen mit gleichem Erscheinungsbild haben Grenzen an denen sich das Erscheinungsbild ändert. Diese Änderungen werden Ereignisse genannt. Bei konvexen Polyedern
tritt ein Ereignis nur dann auf, wenn sich ein Polygon vom Betrachter wegdreht. Solange man
immer nur die gleichen Flächen, Kanten und Punkte eines Polyeders sieht, ändert sich die Region nicht. Sobald eine neue Fläche sichtbar wird, geschieht ein Ereignis. Abbildung 7.1 zeigt
ein Tetraeder als Beispiel für einen solchen konvexen Polyeder. Der Tetraeder besteht aus 4
Polygonen A, B, C und D.
Für diesen Tetraeder gibt es verschiedene Ansichten, von denen aus unterschiedliche Kombinationen der Seitenflächen sichtbar sind, dies sind die Regionen für den Tetraeder. Die verschiedenen Regionen zeigt Abbildung 7.2. Man nennt diese Aufteilung auch die Viewpoint
Space Partition.
Die VSP wird über eine orthographische Projektion dargestellt. Dies ist eine Parallelprojektion, bei der alle Projektionslinien senkrecht zur Projektionsebene verlaufen. Zur Bestimmung des Blickpunktes reicht damit ein Richtungsvektor aus. Alle möglichen Blickpunkte
lassen sich als Kugeloberfläche einer Einheitskugel im 3-dimensionalen Raum beschreiben.
Abbildung 7.3 zeigt die zwei Parameter, über die der Blickpunkt charakterisiert wird.
89
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Kapitel 7. Aspect Graph und Viewpoint Space Partition
VSP)
-#%*<#%=7/#"(
>7,?%*
*%&2%.%"*-#%*<#%=7/#"(
>7,?%*
*-,'*(/7/1/2#'?3%*
/2#'?3%*
A%-%&'*21%#?3
#?3
/1A%-%&'*-,&C
Abbildung 7.1: Tetraeder.
,&C
!"#$%&#'()*+,&#-!*+#%"#.+/0&%1&/,%22#/34%&/4#5%/$6#7&83""4#"-2#$%&#9%*+4/%*+4!21#:!6#";<#)77%=$!21#>#
Abbildung 7.2: Viewpoint
0&%14#&%2&#2&1-4%?&#"#!2$#@3,%4%?&#!#A34-4%32
. Space Partition für den Tetraeder.
#
FF
D,((3#,'*E#'?3%&
B
5(%&2&,I#JKL*>>*MNNO
D
FF
D,((3#,'*E#'?3%&
"
'
D
!
:C6C6D;
0
#
Abbildung 7.3: Die Blickpunkte !""#$%&'()*+)
liegen auf der Oberfläche der Einheitskugel.
,-.)/&'01)2!3"4)5&6)%-.)7#'8-#190&(-$):-#(1))
-#'-);#<81.#<81&'():&=)>.9?.&'()%-9)@AA.%#'51-'9B91-=9)2C3B3:4+#
#
E%&# F3@3=31%&# $&,# G%=$&,# 8-22# ,%*+# "%4# $&/# H2$&/!21# ?32# 9%*+4@!284&2# I2$&/2<# E%&,&# H2$&/!21&2#
2&224#"-2#7.-#('#99-<#J%2#7.-#('#9#8-22#2%*+4#2!/#7&%"#)!K4-!*+&2#3$&/#L&/,*+5%2$&2#?32#A&1%32&2#
AlgoCG 09
90
%"#G%=$#-!K4/&4&26#,32$&/2#-!*+#7&%#&%2&/#H2$&/!21#$&/#)20-+=#$&/#M-24&2#%2#&%2&/#A&1%32<#)77%=$!21#
N#0&%14#&%2#,3=*+&,#J/&%12%,<#E%&#9%*+4@!284&6#%2#$&2&2#J/&%12%,,&#-!K4/&4&26#=%&1&2#-!K#$&2#O/&20&2#
$&/#A&1%32&2#$&,#9%*+4@!284/-!",6#%2#$&2&2#$%&#P&=4#$-,,&=7&#43@3=31%,*+&#)!,,&+&2#+-46#$<#+<#$%&#
94/!84!/#$&/#Q%2%&2#!2$#%+/&/#9*+2%44@!284&2#%"#G%=$#1=&%*+#,%2$<
Kapitel 7. Aspect Graph und Viewpoint Space Partition
Der Winkel θ beschreibt die Drehung bezüglich des Basis Vektors (0, 0, 1). Diese Drehung
kann positiv oder negativ sein. Der Winkel ϕ beschreibt die Drehung nach oben oder unten.
Damit lässt sich jeder Punkt der Oberfläche referenzieren. Für den Tetraeder gibt es für jede
Teilmenge seiner vier Seiten, d.h. für jedes Element der VSP eine geschlossene Region auf
der Kugeloberfläche.
7.2 Aspect Graph
Der Aspect Graph ist eine vereinfachte Darstellung der VSP. Für jede Region gibt es einen
Knoten. Eine Kante existiert zwischen zwei Knoten, falls die Regionen benachbart sind. Einen
Aspect Graphen für die VSP aus Abbildung 7.2 ist in Abbildung 7.4 dargestellt.
$#
!#
!$#
!
!"#
!$
!"
!$"
$
#
"#
"
$"
$"#
Abbildung 7.4: Aspect Graph zu einer VSP.
!""#$%&'()*+)!,-./0)123-4)562).#'.')7.023.%.2+)
Für die Abschätzung der Größe des Aspect Graph ist zunächst die Beobachtung wichtig,
dass
Oberfläche
derkonvexe
Einheitskugel
von jeder Polygonfläche in zwei Hälften geteilt wird.
3.2die
Aspekt
Graph für
Polyeder
% Grenze dieser zwei Hälften sind alle Blickpunkte, von denen die Blickrichtung parallel
Die
zur&'%()*+*,%-./)0*1%2*3(*'%'43%()*%56'7*8*'%961:*(*3%;*03.<=0*0>%#)*+*%?)'+<=3@'54'A%7*3*)'B.<=0%(.+%
Oberfläche läuft. Man erhält die Blickrichtungen, indem man die Kugel mit der Ebene
936;1*,C%(*''%()*%D63(*3+*)0*%76'%*)'*,%56'7*8*'%961:*(*3%)+0%),,*3%7611+0@'()A%+)<=0;.3C%(>=>%*)'*%
schneidet,
die durch oder parallel zum Polygon verläuft und durch den Ursprung geht. Diesen
E1@<=*%7*3(*<50%5*)'*%.'(*3*%E1@<=*>%#)*%*)'F)A*%G*)+*C%(.++%()*%E1@<=*%4'+)<=0;.3%2*3(*'%5.''C%)+0%
;*)%*)'*3%#3*=4'A%2*A%76,%$*03.<=0*3%H482#98'03$.)://$&,#8'I>%&,%56'7*8*'%E.11%5J''*'%F2*)%-'60*'%
Schnitt
nennt man auch den Great Circle.
(*+% !+/*50% K3./=+% ')<=0% ()*+*1;*% -1.++*% 76'% !'+)<=0*'% 3*/3@+*'0)*3*'>% G*''% ()*+*1;*% -1.++*% 76'%
Durch den Schnitt aller Great Circles von allen Polygonen erhält man die Partition der
!'+)<=0*'%.4+%F2*)%L)<=0/4'50*'%+)<=0;.3%)+0C%+6%)+0%+)*%.4+%.11*'%L)<=0/4'50*'C%()*%.4B%(*,%5M3F*+0*'%
Kugeloberfläche
in verschiedene Regionen. Die einzelnen Regionen werden durch Kreisab9B.(%F2)+<=*'%()*+*'%L)<=0/4'50*'%1)*A*'C%+)<=0;.3>%
?)'*% E1@<=*%
*)'*+%Dabei
56'7*8*'%
961:*(*3+%
)+0% % .4+%
N*(*3%durch
L)<=03)<=04'A%
+)<=0;.3C%
.4B% ()*%
D63(*3+*)0*%
schnitte
begrenzt.
wird
jeder Great
Circle
den Schnitt
mit()*%
einem
weiteren
Great
()*+*3% E1@<=*% F*)A0>% G*''% d% *)'*% L)<=03)<=04'A% 4'(% n% *)'*% O63,.1*% F4% ()*+*3% E1@<=*% +)'(C% (.''% )+0%
Circle
in genau zwei Kreisabschnitte geteilt. Für n Polygonflächen erhält man n Great Circles
(.+%(*3%E.11C%2*''%n Pd Q%R%)+0>%#)*%K3*'F*%F2)+<=*'%(*'%+)<=0;.3*'%S*A)6'*'C%)'%2*1<=*'%()*%E1@<=*%
von
denen
jeder
die
anderen
Great
Circles
n Kreisabschnitte
wird.
Man
erhält
+)<=0;.3% 4'(%
)'% durch
2*1<=*'%
+)*%
4'+)<=0;.3%
)+0C% )+0%
(43<=%in
(*')
;2.#,% Td :% n PdU% Rzerteilt
V% (*B)')*30>%
#.+%
)+0% (*3%
2
L<=')00/4'50%(*3%-4A*1%,)0%*)'*3%?;*'*C%()*%(43<=%(*'%W3+/34'A%A*=0%4'(%630=6A6'.1%F4%'%)+0>%
also O(n ) viele Kreisabschnitte. Da jeder Kreisabschnitt an genau zwei Regionen grenzt,
?)'%56'7*8*%961:*(*3%,)0%'%E1@<=*'%=.0%(.''%'%-3*)+*>%#)*%0*)1*'%(*'%L)<=03.4,%)'%*)'*%W'0*30*)14'AC%
gibt
es auch O(n2 ) Regionen und damit einen Aspect Graph der Größe O(n2 ). Diese Größen)'%(*3%()*+*1;*%X*'A*%76'%E1@<=*'%.4+%.11*'%L)<=0/4'50*'%(*3%S*A)6'%+)<=0;.3%)+0>%#)*+*%W'0*30*)14'A%
schranke
ist eng. Ein Beispiel für einen solchen Polyeder ist das in Abbildung 7.5 dargestellte
)+0%.1+6%()*%DL9>%Y2*)%-3*)+*%5J''*'%/..32*)+*%M;*3*)'+0),,*'%6(*3%+)<=%)'%F2*)%94'50*'%+<='*)(*'>%
^
I%
G*3(*'%M;*3*)'+0),,*'(*%-3*)+*%.4Z*3%.<=0%A*1.++*'C%+6%=.;*'%'%-3*)+*%=J<=+0*'+%'H'[\I%U%]H'
Objekt.
L<=')00/4'50*>%!1+6C%)+0%()*%K3JZ*%(*3%DL9%]H'_I>%#*3%!+/*50%K3./=%)+0%(4.1%F43%DL9%4'(%5.''%.4+%
DerDL9%
Polyeder
besteht
aus )'(*,%
zwei Bändern,
die jeweils
aus,.<=0C%
Quadraten
bestehen.()*%S*A)6'*'%
Die Quadrate
(*3%
56'+034)*30%
2*3(*'C%
,.'% S*A)6'*'%
F4% -'60*'%
4'(% ()*%-.'0*'C%
03*''*'C%
(*'%
-.'0*'C% ()*%
;*'.<=;.30*%dass
-'60*'%
#.+% 5.''%
(*3% jewerden
soF4%
mit
Dreiecken
verbunden,
der7*3;)'(*'C%
Polyeder@'(*30>%
geschlossen
ist.)'% 1)'*.3*%
Wählt Y*)0%
man)'%aus
K3JZ*%(*3%DL9%56'+034)*30%2*3(*'>%#.,)0%%5.''%(*3%!+/*50%K3./=%)'%]H'_I%56'+034)*30%2*3(*'>
%
dem Band ein Quadrat aus, erhält man für diesen Körper bei jedem Great Circle zwei Schnitt-
AlgoCG 09
91
HEINZ NIXDORF INSTITUT
Graph und Viewpoint Space Partition
!"#$%&'#()(*+,-%&./&"
012/&#(34%"*5"-*6/471%8#()(
Kapitel 7. Aspect Graph und Viewpoint Space Partition
der VSP (untere Schranke)?
:;3&,"<%*=>"?@*-%'*A:+*%"2B
2%"*-,'*,"*G/12%"-%4*+/1H%-%&
'(%3(*,5'*FJ%#*K)"-%&"
%'*K,"-*,5'*%#"F%1"%"*<1%#"%"*M5,-&,(%"
Abbildung 7.5: Polyedermodell zur Illustration der Größenschranke.
.#"-%*-#%*M5,-&,(%*'/*5"(%&%#","-%&N*-,'*-%&*+/1H%-%&*
';31/''%"*J#&-
punkte auf der Einheitskugeloberfläche. Diese bilden die Punkte des VSP, wobei alle Paare
von Quadraten unterschiedliche Schnittpunkte liefern. Man erhält so eine Größe von Ω(n2 )
für den Aspect Graph.
Betrachtet man nun an Stelle der orthographischen Projektion eine perspektivische ProjekQR
O,((3#,'*P#';3%&
tion, so ist ein Blickpunkt kein Punkt der Kugeloberfläche
mehr,
sondern ein beliebiger Punkt
3
im R . Das Polygon ist von allen Punkte aus sichtbar, die vor dem Polygon im Raum liegen.
Damit wird der R3 also durch die Ebene, die durch das Polygon verläuft, in zwei Halbräume
geteilt. Der Schnitt aller Ebenen ergibt dann die VSP.
In jeder Ebene entstehen Schnittgeraden durch den Schnitt mit den übrigen Ebenen. Durch
die Schnittgeraden entstehen wiederum Schnittpunkte in der Ebene und Geradenabschnitte
zwischen den Schnittpunkten. Jeder Geradenabschnitt begrenzt jeweils zwei Flächenstücke
der VSP. Durch den Schnitt mit O(n) Ebenen entstehen O(n) Geraden in der Ebene. Durch
die Schnitte der Geraden untereinander erhält man O(n2 ) Geradenabschnitte in jeder Ebene.
Da die Geradenstücke die Flächenstücke der VSP begrenzen, erhält man somit O(n2 ) Flächenstücke pro Ebene. Insgesamt erhält man damit für alle n Ebenen O(n3 ) Flächenstücke,
die die VSP begrenzen. Da auf jeder Seite des Flächenstücks genau eine Zelle der VSP ist, erhält man O(n3 ) Regionen und somit einen Aspect Graph der Größe O(n3 ). Über den Polyeder
in Abbildung 7.5 kann man wieder zeigen, dass diese Schranke eng ist.
A/&1%'5"2*S012/&#(34%"*#"*-%&*T/475(%&2&,G#<UN*::*VWWX
AlgoCG 09
92
Abbildungsverzeichnis
1.1
1.2
Rendering Pipeline. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Entlastung der Rendering Pipeline. . . . . . . . . . . . . . . . . . . . . . . .
1
3
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
Orthogonale Bereichsanfrage: Punkte bestimmen, die im Rechteck liegen. . .
Beispiel für einen kd-Baum. . . . . . . . . . . . . . . . . . . . . . . . . . .
Zweites Beispiel für einen kd-Baum. . . . . . . . . . . . . . . . . . . . . . .
Regionen in einem kd-Baum. . . . . . . . . . . . . . . . . . . . . . . . . . .
Auswertung von Regionen in einem kd-Baum. . . . . . . . . . . . . . . . . .
Geschnittene Regionen bei vertikaler Gerade und vertikaler Splittinggerade. .
Geschnittene Regionen im kd-Baum. . . . . . . . . . . . . . . . . . . . . . .
Aufteilung einer Gruppierung von Dreiecken durch eine Splittinggerade. . . .
Autopartition einer Menge von Geraden im 2D. . . . . . . . . . . . . . . . .
Benennung der Elemente des BSP für den Painter’s Algorithmus. . . . . . . .
Aufbau eines 2D BSP-Baums. . . . . . . . . . . . . . . . . . . . . . . . . .
Anzahl zerteilter Segmente bei Wahl von si . . . . . . . . . . . . . . . . . . .
Ein Splittingsegment schützt ein anderes Segment. . . . . . . . . . . . . . .
Polygone als Splittingebenen im 3D. . . . . . . . . . . . . . . . . . . . . . .
Beispiele für Free-Splits. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Unterschiede in der Arbeitsweise zwischen rekursivem und iterativem Algorithmus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Nachweis einer unteren Schranke für die Anzahl von Fragmenten. . . . . . .
Aufbau eines Quadtrees. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Aufbau eines Octrees. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Speicherung von Dreiecken in einem Quadtree. . . . . . . . . . . . . . . . .
Größe von Qudraten in Ebene i in einem Quadtree. . . . . . . . . . . . . . .
Nordnachbar eines Knotens v. . . . . . . . . . . . . . . . . . . . . . . . . .
Suche des Nordnachbarn zu einem Knoten v. . . . . . . . . . . . . . . . . .
Unbalancierter Quadtree. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Balancierter Quadtree. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Unbalancierte Quadtree Situationen. In (a) ist die Ausgangssituation unbalanciert, in (b) entsteht die unbalancierte Situation durch Aufteilung von σ(v). .
Balancierung eines Quadtree. . . . . . . . . . . . . . . . . . . . . . . . . . .
Auswirkung der Balancierung eines SE-Quadrats. . . . . . . . . . . . . . . .
Auswirkung der Balancierung eines Quadrats auf benachbarte Knoten. . . . .
Objekte, die Splittinggeraden schneiden, liegen in großer Bounding-Box. . .
Größe der Bounding-Box und Abstand der Mittelpunkte. . . . . . . . . . . .
4
5
5
7
8
9
9
10
11
11
13
14
15
16
17
2.17
2.18
2.19
2.20
2.21
2.22
2.23
2.24
2.25
2.26
2.27
2.28
2.29
2.30
2.31
93
18
19
19
20
20
22
23
24
25
25
26
27
28
28
30
31
Abbildungsverzeichnis
2.32 Vergrößerte Bounding-Boxen im Loose Octree . . . . . . . . . . . . . . . .
2.33 Überlappungsbereiche in Abhängigkeit des Parameters k. . . . . . . . . . . .
2.34 Kinder decken den Raum der Eltern nicht mehr vollständig ab. . . . . . . . .
31
32
32
3.1
3.2
3.3
Übersicht über verschiedene Culling Techniken. . . . . . . . . . . . . . . . .
Abhängigkeit der Tiefenkomplexität vom Standpunkt. . . . . . . . . . . . . .
(a) zeigt einen exact visibility Test, (b) einen conservative Test und (c) einen
approximative Test. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wände (schwarz) und Portale (rot gestrichelt), die verschiedene Zellen definieren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Sichtbarkeit verschiedener Räume mit einem gegebenen Adjazenzgraphen. .
Für einen Grundriss zeigt (a) eine spanning face und (b) die Zellen mit dem
Adjazenzgraphen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Stabtree zu einer Menge von Zellen. . . . . . . . . . . . . . . . . . . . . . .
Für den Grundriss in (a) zeigt (b) eine existierende lineare Trennung und (c)
eine zweite. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vier Methoden für die Berechnung der Eye-to-cell visibility. . . . . . . . . .
Dynamische Berechnung der PVS. . . . . . . . . . . . . . . . . . . . . . . .
Vollständige Verdeckung von Objekten durch ein größeres Objekt. . . . . . .
Prüfe für eine achsenparallele Boundingbox ob Teile von ihr unsichtbar sind.
Aufbau der Z-Pyramide. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Propagierung der Z-Werte in der Pyramide. . . . . . . . . . . . . . . . . . .
Prüfung der Sichtbarkeit von Dreiecken auf dem gröbsten möglichen Level. .
Abstieg in der Z-Pyramide zur Auflösung kleiner Elemente, die große Boxen
schneiden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verdeckungspotential verschieden großer Occluder. . . . . . . . . . . . . . .
Verdeckungspotential eines aggregierten Occluders. . . . . . . . . . . . . . .
Ablauf des Rendering unter Verwendung von HOM Culling. . . . . . . . . .
Occlusion-Map Hierarchie. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tiefentest der überlappenden Occludees, (a) zeigt die Variante mit einer zEbene, (b) zeigt die Variante mit mehreren z-Partitionen. . . . . . . . . . . .
Ausführung des Tiefentests, (a) zeigt die 2D Projektion von Occluder und
Occludee, (b) zeigt eine 3D Übersicht mit eingezeichneten z-Ebenen. . . . .
35
36
Generelle Idee der Color-Cubes. . . . . . . . . . . . . . . . . . . . . . . . .
Ein Color-Cube mit unterschiedlichen Seitenfarben, die die unterschiedlichen
orthogonalen Aufsichten approximieren . . . . . . . . . . . . . . . . . . . .
Rendering mit Color-Cubes. Für die grünen Zellen wird die Geometrie gerendert, für die blauen der Color-Cube gezeichnet und die roten liegen außerhalb
des Frustums. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Berechnung des initialen Farbwerts eines Color-Cubes. . . . . . . . . . . . .
Berechnung des Farbwerts eines Color-Cubes für einen inneren Knoten. . . .
Aufteilung in Nah- und Weitbereich für das Rendern der Szene. . . . . . . .
56
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16
3.17
3.18
3.19
3.20
3.21
3.22
4.1
4.2
4.3
4.4
4.5
4.6
AlgoCG 09
37
38
39
40
41
41
43
44
45
46
47
47
48
48
50
50
51
52
54
54
57
57
58
59
60
94
Abbildungsverzeichnis
4.7
4.13
Artefaktbildung bei langen, gekrümmten Oberflächen, in der Aufsicht ((a))
sind die Color-Cubes undurchsichtig, von der Seite ((b)) erscheinen sie teilweise transparent. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Schräge Aufsicht auf gekrümmte Oberfläche aus Color-Cubes kann zu Löchern führen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Artefaktbildung durch benachbarte Zeichnung von Color-Cube und Geometrie.
Objekte werden in eine Textur gerendert und erst bei großer Kameraverschiebung neu gerendert. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wahl der Splittingebenen. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Berechnung der Splittingebenen. (a) zeigt die Ausgangssituation, (b) die beiden Listeneinträge und (c) den Korridor mit den wenigsten geschnittenen Objekten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fehlermetrik für das Hierarchical Image Caching. . . . . . . . . . . . . . . .
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
5.10
5.11
5.12
5.13
Die Hauptschritte des Rendering. . . . . . . . . . . . . . . . . . . . . . . .
Parallelisierte Rendering Architektur. . . . . . . . . . . . . . . . . . . . .
Aufteilung in Kacheln beim Sort-First Ansatz. . . . . . . . . . . . . . . . .
Berechnung und Zusammensetzung der Einzelbilder beim Sort-First Ansatz.
Probleme bei der Anwendung von Sort-First. . . . . . . . . . . . . . . . .
Aufteilung der projizierten 2D-Polygone auf Kacheln. . . . . . . . . . . . .
Vorteil und Problem bei der Anwendung von Sort-Middle. . . . . . . . . .
Berechnung der Einzelbilder bei Sort-Last. . . . . . . . . . . . . . . . . . .
Zusammensetzung der Einzelbilder zu einem Gesamtbild bei Sort-Last. . .
Idee der Partitionierung beim Hybrid-Sort . . . . . . . . . . . . . . . . . .
Ablauf des Rendering beim Hybrid-Sort . . . . . . . . . . . . . . . . . . .
Partitionierung der Szene mit Sweep-Lines. . . . . . . . . . . . . . . . . .
Illustration der Berechnung der Kommunikations-Overhead . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
69
69
71
71
72
72
73
73
74
75
76
77
78
6.1
6.2
6.3
LOD-Modelle für verschiedene Entfernungen. . . . . . . . . . . . . . . . . .
LOD Hierarchie nach Clark. . . . . . . . . . . . . . . . . . . . . . . . . . .
Verwendung der Hierarchie für sichtpunktabhängiges LOD und ViewFrustum-Culling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Arbeitsweise des Decimation Algorithmus. . . . . . . . . . . . . . . . . . .
Arbeitsweise des Sampling Algorithmus. . . . . . . . . . . . . . . . . . . . .
Verlust von scharfen Kanten bei der Anwendung des Sampling Algorithmus. .
Arbeitsweise des Vertex Merging Algorithmus. . . . . . . . . . . . . . . . .
Arbeitsweise des Adaptive Subdivision Algorithmus. . . . . . . . . . . . . .
Arbeitsweise des Edge Collapse Algorithmus bei Verwendung von Progressive Meshes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Positionierung des neuen Punktes bei Ausführung von Edge Collapse. . . . .
Arbeitsweise des Vertex Split Algorithmus bei Verwendung von Progressive
Meshes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Anwendung der Progressive Meshes für kontinuierliches LOD. . . . . . . . .
Anwendung der Progressive Meshes für progressive Übertragung. . . . . . .
79
81
4.8
4.9
4.10
4.11
4.12
6.4
6.5
6.6
6.7
6.8
6.9
6.10
6.11
6.12
6.13
AlgoCG 09
61
61
62
63
65
66
67
81
83
83
84
84
85
85
86
86
88
88
95
Abbildungsverzeichnis
7.1
7.2
7.3
7.4
7.5
Tetraeder. . . . . . . . . . . . . . . . . . . . . . . . . . . .
Viewpoint Space Partition für den Tetraeder. . . . . . . . . .
Die Blickpunkte liegen auf der Oberfläche der Einheitskugel.
Aspect Graph zu einer VSP. . . . . . . . . . . . . . . . . . .
Polyedermodell zur Illustration der Größenschranke. . . . .
AlgoCG 09
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
90
90
90
91
92
96