10.10.2013 Aufrufe

Triangle Strips

Triangle Strips

Triangle Strips

MEHR ANZEIGEN
WENIGER ANZEIGEN

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.

Bakkalaureatsarbeit<br />

Anwendungen von <strong>Triangle</strong> <strong>Strips</strong> und deren<br />

Generierung aus triangulierten Meshes. ∗<br />

David Botzenhart<br />

Johannes Priewasser<br />

28. Februar 2008<br />

∗ Betreut von Ao.Univ.-Prof. Dipl.-Ing.Dr. Martin Held<br />

1


held m.<br />

Inhaltsverzeichnis<br />

1 Einleitung 3<br />

1.1 Darstellung und Beschreibung von Körpern in der Computergrafik<br />

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3<br />

1.2 Die Grafik Pipeline einer Grafik Prozessor Einheit (GPU) am<br />

Beispiel von OpenGL . . . . . . . . . . . . . . . . . . . . . . . 5<br />

2 <strong>Triangle</strong> <strong>Strips</strong> (Tri<strong>Strips</strong>) 7<br />

2.1 Dreiecksequenzen . . . . . . . . . . . . . . . . . . . . . . . . . 7<br />

2.2 Definitionen zu <strong>Triangle</strong> <strong>Strips</strong> (Tri<strong>Strips</strong>) . . . . . . . . . . . 7<br />

3 Fans 12<br />

4 Graphentheorie in Verbindung mit Meshes 12<br />

4.1 Dualer Graph in einem triangulierten Mesh . . . . . . . . . . . 12<br />

4.2 Hamiltonische Pfade in einem dualen Graph . . . . . . . . . . 13<br />

4.3 Sätze und Definitionen zu triangulierten Meshes . . . . . . . . 14<br />

5 Algorithmen 15<br />

5.1 SGI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15<br />

5.2 STRIPE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16<br />

5.3 FTSG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18<br />

5.3.1 Triangulieren aller Flächen des Modells . . . . . . . . . 19<br />

5.3.2 Bilden eines spannenden Baumes im dualen Graph eines<br />

triangulierten Meshes . . . . . . . . . . . . . . . . 19<br />

5.3.3 Partitionierung des Baumes in hamiltonische Pfade . . 20<br />

5.3.4 Auflösung der Pfade in <strong>Strips</strong> oder Fans . . . . . . . . 22<br />

5.3.5 Konkatenierung der <strong>Strips</strong> . . . . . . . . . . . . . . . . 23<br />

5.3.6 Statistiken . . . . . . . . . . . . . . . . . . . . . . . . . 26<br />

5.4 Tunneling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26<br />

1


Abbildungsverzeichnis<br />

1 Primitive. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3<br />

2 Beschreibung und Orientierung von einem Dreieck. . . . . . . 4<br />

3 Eine vereinfachte Grafik Pipeline. . . . . . . . . . . . . . . . . 5<br />

4 Verbundene Dreiecke als Sequenz. . . . . . . . . . . . . . . . . 7<br />

5 Ein einfacher <strong>Triangle</strong> Strip (TriStrip). . . . . . . . . . . . . . 8<br />

6 Generalisierte <strong>Triangle</strong> <strong>Strips</strong> in einem triangulierten Mesh. . . 9<br />

7 Generalisierter <strong>Triangle</strong> Strip. . . . . . . . . . . . . . . . . . . 10<br />

8 Konstruktion eines Fan. . . . . . . . . . . . . . . . . . . . . . 12<br />

9 Dualer Graph in einem triangulierten Mesh. . . . . . . . . . . 13<br />

10 Hamiltonischer Pfade in einer hamiltonischen Triangulation. . 14<br />

11 SGI Algorithmus. . . . . . . . . . . . . . . . . . . . . . . . . . 17<br />

12 Patch und anschließende Triangulation. . . . . . . . . . . . . . 18<br />

13 Graphensuchalgorithmen. [10, Xiang] . . . . . . . . . . . . . . 20<br />

14 Path Peeling Algorithmus. . . . . . . . . . . . . . . . . . . . . 21<br />

15 Beispiel einer Triangulation und zwei daraus ableitbare duale<br />

Bäume. [10, Xiang] . . . . . . . . . . . . . . . . . . . . . . . . 22<br />

16 Optimale Stripkonkatenation. . . . . . . . . . . . . . . . . . . 24<br />

17 Stripkonkatenation mit Ersparnis von 1 Vertex. . . . . . . . . 24<br />

18 Stripkonkatenation ohne Ersparnis. . . . . . . . . . . . . . . . 24<br />

19 Tunneling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29<br />

Tabellenverzeichnis<br />

1 Vergleich von SGI und STRIPE. [4, Evans et al.] . . . . . . . . 18<br />

2 Auswertung verschiedener Heuristiken des FTSG. [10, Xiang] . 27<br />

3 Vergleich von FTSG, SGI und STRIPE. [10, Xiang] . . . . . . 28<br />

4 Vergleich der Stripanzahl von SGI, STRIPE und Tunneling.<br />

[8, Stewart] . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30<br />

5 Vergleich der Laufzeiten von SGI, STRIPE und Tunneling. [8,<br />

Stewart] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30<br />

2


1 Einleitung<br />

1.1 Darstellung und Beschreibung von Körpern in der<br />

Computergrafik<br />

Die wissenschaftliche Disziplin der Computergrafik, ein Teilbereich der Informatik,<br />

beschäftigt sich mit der Erzeugung von computergenerierten Bildern.<br />

Meist dienen Modelle bei der Erzeugung von computergenerierten Bildern als<br />

Quelle. Diese Modelle, auch Objekte genannt, können durch Grafik-Primitive<br />

wie Vertices, Linien, Dreiecke, Polygone, Rechtecke, Quadrate, aber auch als<br />

<strong>Triangle</strong> <strong>Strips</strong>, Fans und viele mehr beschrieben werden.[7, Nischwitz et al.]<br />

(a) (b) (c) (d)<br />

Abbildung 1: Primitive.<br />

So manch einer mag sich nun an die Bauklötzchen seiner Kindheit zurück<br />

erinnern, wenn wir nun anhand eines Türmchens in Abbildung 1 einige Primitive<br />

betrachten. Unser Türmchen (a) kann durch einen hohlen Zylinder (b),<br />

einen Kegel und einer Scheibe, welche als Boden dient, beschrieben werden.<br />

Dies kann durch eine zehnseitige Pyramide, ein Zehneck und einem zehnseitigen<br />

Zylinder (c) angenähert werden. Diese neuen Teile lassen sich nun wiederum<br />

durch planare Primitive beschreiben. Also durch dreiseitge Polygone<br />

(Dreiecke), vierseitige Polygone (Quadrate auch Quads genannt) und durch<br />

unsere Bodenplatte als zehnseitiges Polygon. Im letzten Schritt (d) können<br />

3


nun alle Polygone mit mehr als drei Eckpunkten trianguliert, das heißt in<br />

Dreiecke unterteilt, werden. Die primitive Einheit schlechthin die eine Fläche<br />

beschreibt ist also das Dreieck. Und so ist es also nicht verwunderlich, dass<br />

in der 3D Computergrafik vorallem die Berechnung von Dreiecksflächen von<br />

Interesse ist. Zur Vollständigkeit sei aber erwähnt das moderne Grafikkarten<br />

auch durchwegs mit mehr als nur mit Dreiecksflächen als Primitive optimiert<br />

arbeiten können. Wir wollen aber nun im folgenden davon ausgehen, dass<br />

unser Grafik Prozessor bevorzugt Dreiecke verarbeitet. Um also unser Türmchen,<br />

bereits aus einzelnen Dreiecken bestehend, von der CPU an den Grafik<br />

Prozessor (GPU) zu übertragen, benötigen wir pro Dreieck drei Punkte, in<br />

der Computergrafik auch Vertices genannt. Diese Vertices definieren bereits<br />

durch Ihre Orientierung die Vorderseite bzw. die Rückseite eines Dreiecks.<br />

Der Normalvektor nv steht senkrecht zur Vorderseite des Dreiecks.<br />

v3<br />

v1<br />

nv<br />

Abbildung 2: Beschreibung und Orientierung von einem Dreieck.<br />

Es folgt, dass wir für n Dreiecke 3n Vertices zum Grafik Prozessor übertragen<br />

müssten. In unserem Fall wären das 8 Dreiecke für die Bodenplatte,<br />

10 Dreiecke für die Pyramide und 20 Dreiecke für den Zylinder. Dies ergäbe<br />

(8 + 10 + 20) 3 = 114 Vertices die zu übertragen wären. Wir werden uns<br />

im Folgenden damit beschäftigen, wie wir diese Anzahl der Vertices, ohne<br />

Informationsverlust reduzieren können. Aber betrachten wir vorerst welche<br />

weiteren Vorteile durch die Reduktion der Vertices zu erwarten sind.<br />

4<br />

v2<br />

v2<br />

nv<br />

v1<br />

v3


1.2 Die Grafik Pipeline einer Grafik Prozessor Einheit<br />

(GPU) am Beispiel von OpenGL<br />

Die Operationen zur Erzeugung von computergenerierten Bildern laufen bei<br />

heutigen Computersystemen im Allgemeinen in der Grafik Pipeline eines<br />

Grafik Prozessors ab.<br />

Abbildung 3: Eine vereinfachte Grafik Pipeline.<br />

Die Grafik Pipeline ist hier vereinfacht dargestellt, dabei wurde absichtlich<br />

auf spezielle Features wie Blending, logische Operationen und Vertex Buffer<br />

Operationen verzichtet. Natürlich verfügen heutige Grafik Pipelines über wesentlich<br />

mehr Funktionalität, doch sind die hier beschriebenen Elemente der<br />

Grafik Pipeline im Prinzip noch immer in dieser oder jener Form enthalten.<br />

(a) Übertragung: Die Grafikdaten werden von der CPU an den Grafik<br />

Prozessor übertragen. Es werden neben den Modelldaten (Türmchen)<br />

auch Transformationsdaten, Translationsdaten, Beleuchtungsdaten, Augenpunkt<br />

und Blickrichtung, Effektdaten und Texturdaten übertragen.<br />

Auf diese wollen wir aber nicht genauer eingehen, da sie für unsere<br />

Überlegungen nicht von wesentlichem Interesse sind.<br />

(b) Display Listen: Display Listen dienen dazu, geometrische Primitive<br />

oder Bilddaten zu komplexen Objekten zusammenzufassen. In unserem<br />

Fall würden unsere 38 Dreiecke bzw. 114 Vertices wieder zu einer<br />

Einheit ” Türmchen“gruppiert.<br />

5


(c) Vertex Operationen: Die Vertex-Daten werden zunächst in mehreren<br />

Stufen transformiert. Dazu gehört die Positionierung (Translation), die<br />

Drehung (Rotation), die Skalierung und abschließend die Projektion,<br />

um die 3D Koordinaten auf die 2D Bildebene zu projezieren. Gegebenenfalls<br />

werden noch Normalvektoren und Texturkoordinaten transformiert.<br />

Ist der Beleuchtungsmodus aktiv, wird in dieser Verarbeitungsstufe<br />

aus den Vertices, Normalvektoren und Materialeigenschaften der<br />

Objekte auf der einen Seite und den Eigenschaften der Lichtquellen<br />

auf der anderen Seite, für jeden Vertex die Beleuchtungsberechnung<br />

durchgeführt bzw. die Farbe ermittelt. Sollten Schnittebenen (Clipping<br />

Planes) definiert sein, werden die Geometriedaten eliminiert, welche<br />

sich im weggeschnittenen Halbraum befinden. [7, Nischwitz et al.]<br />

Hier wird deutlich wie wichtig eine Reduktion der Vertices für die Berechnungsgeschwindigkeit<br />

ist. Zusammenfassend bedeutet eine Reduktion von<br />

Vertices:<br />

1. Es müssen weniger Vertices zur Grafik Prozessor Einheit übertragen<br />

werden.<br />

2. Es müssen weniger Vertices transformiert werden.<br />

3. Es müssen weniger Beleuchtungsberechnungen durchgeführt werden.<br />

4. Es müssen weniger Line Clippings durchgeführt werden.<br />

Ist allerdings die CPU-GPU Pipeline der so genannte Flaschenhals, wird sich<br />

die Optimierung der Performanz in der Grafik Pipeline nur wenig auf die<br />

Berechnungsgeschwindigkeit und somit auf die Framerate, also die Anzahl<br />

berechenbarer Bilder pro Sekunde, auswirken.<br />

6


2 <strong>Triangle</strong> <strong>Strips</strong> (Tri<strong>Strips</strong>)<br />

2.1 Dreiecksequenzen<br />

Wie ist es nun möglich Dreiecke mit weniger als drei Punkten zu beschreiben?<br />

Dazu sehen wir uns in Abbildung 4 einen Teil unseres eingehenden Beispiels,<br />

den Zylinder des Türmchens (a) an.<br />

(a) (b)<br />

Abbildung 4: Verbundene Dreiecke als Sequenz.<br />

Hierbei handelt es sich um verbundenene Dreiecke, die sich jeweils eine Kante<br />

teilen. Und darin liegt auch schon das Geheimnis begraben. Wir beschreiben<br />

Dreiecke nicht als einzelne Primitive sondern als Sequenz (b) von benachbarten<br />

Dreiecken.<br />

2.2 Definitionen zu <strong>Triangle</strong> <strong>Strips</strong> (Tri<strong>Strips</strong>)<br />

Im folgenden wird Allgemeines zu <strong>Triangle</strong> <strong>Strips</strong> definiert. [1, Akenine-<br />

Möller et al.]<br />

Definition 2.1 Ein <strong>Triangle</strong> Strip ST wird durch eine geordnete Liste,<br />

einem n-Tupel beschrieben.<br />

ST = (v0, v1, . . . vn−1) (1)<br />

Das Startdreieck T0 wird durch die Vertices v0, v1 und v2 definiert. Das folgende<br />

Dreieck T1 wird durch die zwei zuletzt gesendeten Vertices v1, v2, welche<br />

7


eine gemeinsame Kante von T1 und T0 beschreiben, und einen neuen Vertex<br />

v3 definiert. Die Orientierung des Dreiecks T0 ist aber der Orientierung von<br />

T1 zwangsläufig entgegengesetzt. Durch diese Definition ergibt sich, dass ein<br />

v0<br />

T0<br />

v2<br />

v1<br />

T1<br />

T2<br />

v3<br />

v4<br />

T3<br />

T4 T5<br />

Abbildung 5: Ein einfacher <strong>Triangle</strong> Strip (TriStrip).<br />

Das 8-Tupel (v0, v1 . . . v7) beschreibt einen TriStrip. Es ist zu beachten, dass das erste Dreieck T0 die<br />

Orientierung der folgenden Dreiecke vorgibt.<br />

Dreieck Ti eines <strong>Triangle</strong> <strong>Strips</strong> beschrieben wird, durch Ti = (vi, vi+1, vi+2),<br />

und dass ein <strong>Triangle</strong> Strip mit n Vertices n − 2 Dreiecke besitzt.<br />

Definition 2.2 Sei TST die Menge der Dreiecke eines <strong>Triangle</strong> <strong>Strips</strong> der<br />

Länge n. Ein <strong>Triangle</strong> Strip ST<br />

beschreibt, und es gilt:<br />

heißt sequentiell wenn er n − 2 Dreiecke<br />

v5<br />

v6<br />

0 ≤ |TST | < n − 2 (2)<br />

Definition 2.3 Handelt es sich bei einem <strong>Triangle</strong> Strip ST mit l = |TST |<br />

Dreiecke, um einen sequentiellen <strong>Triangle</strong> Strip, so gilt für die Kompressionsrate<br />

Cr(ST ):<br />

Cr(ST ) =<br />

3 + (l − 1)<br />

l<br />

8<br />

= 1 + 2<br />

l<br />

v7<br />

(3)


Ein Spezialfall, der meist zwar unerwünscht ist, aber dennoch bei der Erzeugung<br />

von <strong>Triangle</strong> <strong>Strips</strong> auftreten kann ist ein <strong>Triangle</strong> Strip mit der Länge<br />

l = 1 also |TST = 1|<br />

Definition 2.4 Ein Singleton <strong>Triangle</strong> Strip ist ein <strong>Triangle</strong> Strip der<br />

genau ein Dreieck beschreibt.<br />

Definition 2.5 Ein trianguliertes Mesh ist eine Struktur bestehend aus miteinander<br />

verbundenen Dreiecken (siehe Abbildung 6).<br />

Erinnern wir uns an unser eingehendes Beispiel, unser Türmchen (siehe Abbildung<br />

6) . Wir hatten unser Ziel formuliert, die Anzahl der an die Grafik<br />

Prozessor Einheit zu sendenden Vertices, zu minimieren. In unserem Beispiel<br />

kann man die gesamte Oberfläche unseres Türmchens durch ein Mesh<br />

beschreiben.<br />

(a) (b)<br />

Abbildung 6: Generalisierte <strong>Triangle</strong> <strong>Strips</strong> in einem triangulierten Mesh.<br />

In den meisten Fällen kann ein Mesh nicht durch einen einzelnen sequentiellen<br />

<strong>Triangle</strong> Strip beschrieben werden. Sehen wir dazu Abbildung 7 an. Die<br />

9


v0<br />

T0<br />

v2<br />

v1<br />

T1<br />

T2<br />

v3<br />

v4<br />

T3<br />

v6<br />

v10<br />

Abbildung 7: Generalisierter <strong>Triangle</strong> Strip.<br />

Dreiecke T0, T1, T2 und T3 lassen sich noch durch einen sequentiellen <strong>Triangle</strong><br />

Strip beschreiben. Aber Dreieck T4 wird jetzt nicht durch v4, v5 und v6<br />

gebildet, sondern durch v5, v3 und v6.<br />

Definition 2.6 Ein generalisierter <strong>Triangle</strong> Strip (Generalized <strong>Triangle</strong><br />

Strip) ist ein <strong>Triangle</strong> Strip der jeden Vertex nur einmal enthält. [6, Deering<br />

at al.]<br />

Um einen solchen Strip verwenden zu können muss ein Cache in der Grafik<br />

Prozessor Einheit eingeführt werden, welcher zumindest einen Teil der gesendeten<br />

Vertices buffert. Die Sequenz des generalisierten <strong>Triangle</strong> Strip aus<br />

Abbildung 7 kann nun wie folgt beschrieben werden:<br />

STS = (v0, v1, v2, v3, v4, i(3), v5, v6, i(5), v7, i(5), v8, i(5), v9, i(4), v10)<br />

Nicht nur Vertices sind nun als Elemente der <strong>Triangle</strong> Strip Sequenz zugelassen<br />

sondern auch Indizes. Ein Index, wie zum Beispiel i(3), verweist auf den<br />

bereits gesendeten Vertex v3. Ein Index ist nur ein eindimensionales Datum,<br />

im Gegensatz zu einem Vertex, und benötigt daher auch wesentlich weniger<br />

Bandbreite. Der Vorteil liegt nun stark darin, dass in der Grafik Prozessor<br />

Einheit kaum ein Vertex doppelt oder mehrfach vorkommt und daher die<br />

Anzahl der Vertex Operationen reduziert wird.<br />

10<br />

T9<br />

T4<br />

T8<br />

v5<br />

v9<br />

T5<br />

T7<br />

T6<br />

v7<br />

v8


Satz 2.1 Eine kontrollierbarer Cache (kein FIFO) von der Größe O( √ n) in<br />

der Grafik Prozessor Einheit ist ausreichend, um jeden Vertex eines generalisierten<br />

<strong>Triangle</strong> <strong>Strips</strong> nur einmal zu senden. [3, Yehuda und Gotsman]<br />

Eine trickreiche Variante der generalisierten <strong>Triangle</strong> <strong>Strips</strong> stellen quasisequentiell<br />

generalisierte <strong>Triangle</strong> <strong>Strips</strong> dar. Hierzu werden die Indizes aus<br />

den generalisierten <strong>Triangle</strong> <strong>Strips</strong> durch einen Befehl, den sogennanten SWAP<br />

ersetzt.<br />

Definition 2.7 Ein SWAP vertauscht die Ordnung der zwei zuletzt gesendeten<br />

Vertices.<br />

Sehen wir uns dazu noch einmal Abbildung 7 an. Mit unserem neu eingeführten<br />

SWAP Befehl sieht die Sequenz wie folgt aus:<br />

STS SW AP = (v0, v1, v2, v3, v4, swap, v5, v6, swap, v7, swap, v8, swap, v9, v4, v10)<br />

Steht der SWAP Befehl nicht zur Verfügung, so kann man diesen durch das<br />

wiederholte Senden des vorletzt gesendeten Vertex erreichen. Dies geschieht<br />

allerdings nicht ganz kostenlos. Zu der doppelten Übertragung eines Vertex<br />

kommt noch hinzu, dass ein zusätzliches Dreieck, allerdings ohne Flächeninhalt,<br />

entsteht. Dies kann unter Umständen auch zu Darstellungsfehlern<br />

führen, und sollte daher nur angewandt werden wenn es von der Grafik Prozessor<br />

Einheit unterstützt wird. Eine solche Sequenz sieht für den Strip aus<br />

Abbildung 7 wie folgt aus:<br />

STS = (v0, v1, v2, v3, v4, v3, v5, v6, v5, v7, v5, v8, v5, v9, v4, v10)<br />

11


3 Fans<br />

v1<br />

v2<br />

v6<br />

v3<br />

v0<br />

v5<br />

v4<br />

Abbildung 8: Konstruktion eines Fan.<br />

Bevor wir uns nun an die Generierung von <strong>Triangle</strong> <strong>Strips</strong> heran machen,<br />

sollte noch ein wichtiger Verwandter des <strong>Triangle</strong> <strong>Strips</strong> vorgestellt werden,<br />

der Fan. Ein Fan, zu Deutsch Fächer, wird wie der Name schon vermuten<br />

lässt, durch einen Punkt im Zentrum, den ersten Vertex der Sequenz und die<br />

ihn umlaufenden Dreiecke welche durch die folgenden Vertices beschrieben<br />

werden, bestimmt. Eine typische Fan Sequenz FT (siehe Abbildung 8) sieht<br />

wie folgt aus:<br />

FT = (v0, v1, v2, v3, v4, v5, v6)<br />

Es sei noch erwähnt, dass heutige Grafik Prozessor Systeme eine Vielzahl an<br />

Primitiven kennen, die ähnliche Effizienzvorteile mit sich bringen wie <strong>Strips</strong><br />

und Fans.<br />

4 Graphentheorie in Verbindung mit Meshes<br />

Die meisten Algorithmen konstruieren im ersten Schritt einen dualen Graph<br />

dem das triangulierte Mesh zu Grunde liegt. Daher wollen wir uns zunächst<br />

noch ein wenig dem Gebiet der Graphentheorie zuwenden.<br />

4.1 Dualer Graph in einem triangulierten Mesh<br />

Definition 4.1 Sei TP die Triangulation eines planaren Meshes also die<br />

Menge aller Dreiecke (siehe Abbildung 10). Ein Graph G(TP ) heißt dualer<br />

Graph eines triangulierten Meshes wenn gilt:<br />

12


ν<br />

µ<br />

λ<br />

ϑ<br />

η<br />

ψ<br />

δ ε<br />

χ<br />

ω<br />

T (ν)<br />

T (µ)<br />

T (λ) T (ϑ)<br />

Abbildung 9: Dualer Graph in einem triangulierten Mesh.<br />

T (η)<br />

T (δ)<br />

T (ψ)<br />

T (χ)<br />

• Der Graph G(TP ) hat für jedes Dreieck aus TP genau einen Knoten.<br />

Jeder Knoten ν repräsentiert ein Dreieck T (ν).<br />

• Es existiert eine Kante zwischen zwei Knoten ν und µ genau dann,<br />

wenn die zugehörigen Dreiecke T (ν) and T (µ) eine gemeinsame Seite<br />

teilen.<br />

Definition 4.2 Die Ordnung eines Knoten in einem dualen Graph ist die<br />

Anzahl der Kanten die von einem Knoten ausgehen.<br />

4.2 Hamiltonische Pfade in einem dualen Graph<br />

Definition 4.3 Ein Pfad in einem dualen Graph heißt hamiltonischer<br />

Pfad genau dann, wenn der Pfad jeden seiner Knoten genau einmal besucht.<br />

Definition 4.4 Ein dualer Graph heißt hamiltonischer Graph genau dann,<br />

wenn ein hamiltonischer Pfad existiert, der alle Knoten genau einmal besucht.<br />

Satz 4.1 Jede Punktmenge kann hamiltonisch trianguliert werden, und zwar<br />

in einer Zeit von O(n log n) . [2, Arkin at al.]<br />

Definition 4.5 Eine Triangulation wird genau dann hamiltonisch genannt,<br />

wenn der dazugehörige duale Graph hamiltonisch ist.<br />

Satz 4.2 Testen ob ein Triangulation hamiltonisch ist, kann nicht deterministisch<br />

in Polynomialzeit festgestellt werden.<br />

13<br />

T (ε)<br />

T (ω)


Abbildung 10: Hamiltonischer Pfade in einer hamiltonischen Triangulation.<br />

4.3 Sätze und Definitionen zu triangulierten Meshes<br />

Satz 4.3 Euler’s Theorem für zusammenhängende planare Graphen besagt:<br />

v − e + f − 2g = 2 (4)<br />

Wobei v die Anzahl der Knoten (Vertices) ist, e ist die Anzahl der Kanten<br />

(Edges), f ist die Anzahl der Flächen (faces) und g ist das Geschlecht (genus),<br />

sprich die Anzahl der Löcher in dem Objekt.<br />

Da jede Kante zwei Flächen teilt und jede Fläche mindestens drei Kanten<br />

besitzt, gilt 2e >= 3f. Setzt man das in Euler’s Theorem ein, erhält man<br />

nach der Vereinfachung f


Satz 4.5 Eine Buffergröße von 1.649 √ n ist notwendig für ein optimales Rendering<br />

im schlechtesten Fall.<br />

5 Algorithmen<br />

5.1 SGI<br />

Dieser Algorithmus wurde im Jahr 1990 von Kurt Akeley, Paul Haeberli<br />

und Derrick Burns veröffentlicht. Er war zu finden auf der ” SGI Developer’s<br />

Toolbox CD“, in Form eines C Programmes, und ist daher auch unter dem<br />

Namen tomesh oder tomesh.c bekannt.<br />

Entwickelt wurde der Algorithmus für die Graphics Library (GL) von SGI,<br />

welche auch Swaps unterstützt. Daher versucht der Algorithmus gar nicht<br />

erst Swaps zu verhindern. Er funktioniert nur für vollständig triangulierte<br />

Modelle, das bedeutet wenn Polygone mit mehr als 3 Ecken in dem Modell<br />

enthalten sind, dann müssen diese Polygone zuerst in Dreiecke zerlegt werden<br />

bevor der Algorithmus darauf angewandt werden kann. Der Algorithmus<br />

funktioniert nach dem Greedy Prinzip, das heißt er geht bei jedem Schritt<br />

zum nächst besten Dreieck, aus lokaler Sicht von der aktuellen Position aus<br />

gesehen. Gibt es mehrere gleich gute Dreiecke, dann geht er weiter zu den<br />

Nachbarn dieser Dreiecke und bewertet diese. Ist die Entscheidung dann immer<br />

noch nicht eindeutig, wird unter allen möglichen Dreiecken eines zufällig<br />

ausgewählt.<br />

Das Ziel des Algorithmus bei der Generierung eines <strong>Strips</strong> ist es, die verbleibende<br />

Triangulation nicht in zu viele kleine Teilbereiche zu trennen, da<br />

dadurch die Wahrscheinlichkeit, dass weitere <strong>Strips</strong> eher kurz sein werden,<br />

oder sogar Singleton <strong>Strips</strong> entstehen, erhöht würde.<br />

Algorithmus [9, Vaněček]:<br />

1. Wenn keine Dreiecke in der Triangulation übrig sind, beende.<br />

2. Wähle ein Startdreieck T mit der geringsten Anzahl an Nachbarn.<br />

3. Starte einen neuen Strip.<br />

4. Füge das Dreieck T zum Strip hinzu und entferne es aus der Triangulation.<br />

15


5. Wenn T keinen Nachbarn hat, gehe zu Schritt 1<br />

6. Wähle ein neues Dreieck T ′ , welches zu T benachbart ist und die kleinste<br />

Ordnung aufweist. Gibt es mehrere Dreiecke der selben Ordnung,<br />

schaue eine Ebene weiter.<br />

7. T ′ wird zu T . Gehe zu Schritt 4<br />

In Abbildung 11 sieht man den Entstehungsprozess der <strong>Triangle</strong> <strong>Strips</strong> an<br />

einem Beispielmesh. Der Algorithmus beginnt mit der Auswahl eines Startdreiecks.<br />

In diesem Beispiel stehen vier mögliche Dreiecke mit nur einem<br />

Nachbarn zur Auswahl. Der Algorithmus entscheidet sich zufällig für eines<br />

der vier, wie bei (a) ersichtlich. Ein Strip wird mit diesem Dreieck begonnen<br />

und der Algorithmus hat nur ein Dreieck zur Auswahl um den Strip fortzusetzen.<br />

Die Auswahl bleibt auch bei den nächsten Dreiecken beschränkt,<br />

bis wir an einem Dreieck mit zwei Nachbarn ankommen. Wie bei Schritt (b)<br />

dargestellt gibt es nun zwei mögliche Richtungen den Strip weiterzuführen.<br />

Das Dreieck mit der niedrigeren Ordnung wird bevorzugt und das ist, wie<br />

beim nächsten Schritt (c) zu sehen ist, das rechte. Der Strip wird fortgesetzt<br />

bis kein Dreieck mehr hinzugefügt werden kann. Danach wird ein neues<br />

Startdreieck, für den nächsten Strip gesucht und dieser auf die selbe Weise<br />

gebildet. Das Ergebnis dieses Beispiels ist bei (d) zu sehen.<br />

5.2 STRIPE<br />

Dieser Algorithmus wurde im Jahr 1996 von Francine Evans, Amitabh Varshney<br />

und Steven Skiena veröffentlicht. Der STRIPE Algorithmus unterteilt<br />

sich in zwei Phasen, einer globalen und einer lokalen Phase. In der globalen<br />

Phase sucht STRIPE in einem Modell nach Patches.<br />

Definition 5.1 Ein Patch ist definiert als viereckigen Region, welche selbst<br />

nur aus viereckigen Flächen zusammengestzt ist (siehe 12.<br />

Kann ein gefundener Patch eine bestimmte Mindestgröße aufweisen, wird der<br />

Patch trianguliert und in einen Strip konvertiert. Anschließend wird versucht<br />

mit einem Greedy Algorithmus, ähnlich dem SGI Algorithmus, den entstandenen<br />

Strip an dessen Anfang und Ende zu verlängern soweit es möglich ist.<br />

In der lokalen Phase werden dann alle aus der ersten Phase verbleibenden<br />

Polygone trianguliert und in <strong>Strips</strong> zusammengefasst.<br />

16


(a) (b)<br />

1<br />

2<br />

(c) (d)<br />

Abbildung 11: SGI Algorithmus.<br />

Der STRIPE Algorithmus hat den Vorteil, dass die Triangulation ” on the<br />

fly“erfolgt und sich somit der Prozess der Stripifizierung flexibler gestalten<br />

lässt. Er funktioniert am besten mit Modellen die viele Vierecke beinhalten,<br />

da dadurch viele Patches gefunden werden können und aus den Patches gute<br />

sequentielle <strong>Strips</strong> gebildet werden können. Außerdem läuft der Algorithmus<br />

inzwischen in linearer Zeit, wenn auch etwas langsamer als der SGI Algorithmus.<br />

Der größte Nachteil des Algorithmus ist, dass er nur für Modelle<br />

funktioniert, welche keine konvexen Polygone enthält. [4, Evans at al.]<br />

In Tabelle 1 sieht man eine Gegenüberstellung des STRIPE Algorithmus und<br />

des SGI Algorithmus.<br />

17


5.3 FTSG<br />

Abbildung 12: Patch und anschließende Triangulation.<br />

Data File Num Num Cost Savings<br />

Verts Tris SGI STRIPE<br />

plane 1508 2992 4005 3509 12%<br />

skyscraper 2022 3692 5621 4616 18%<br />

triceratops 2832 5660 8267 6911 16%<br />

power lines 4091 8966 12147 10621 13%<br />

porsche 5247 10425 14227 12367 11%<br />

honda 7106 13594 16599 15075 9%<br />

bell ranger 7105 14168 19941 16456 17%<br />

dodge 8477 16646 20561 18515 10%<br />

general 11361 22262 31652 27702 12%<br />

Tabelle 1: Vergleich von SGI und STRIPE. [4, Evans et al.]<br />

Dieser Algorithmus wurde im Jahr 1999 von Xinyu Xiang, Joseph S. B. Mitchell<br />

und Martin Held entwickelt. FTSG steht für Fast <strong>Triangle</strong> Strip Generator<br />

und wird seinem Namen, wie die Statistiken zeigen, auch gerecht.<br />

Der Algorithmus besteht aus fünf Schritten:<br />

1. Triangulieren von allen Flächen des Modells.<br />

2. Bilden eines spannenden Baumes im Dual Graph der Triangulation.<br />

18


3. Partitionierung des Baumes in hamiltonische Pfade.<br />

4. Auflösung der Pfade in <strong>Strips</strong> oder Fans.<br />

5. Konkatenierung der <strong>Strips</strong>.<br />

5.3.1 Triangulieren aller Flächen des Modells<br />

Für den ersten Schritt wurde FIST (Fast Industrial-Strength Triangulation<br />

of Polygons) [5, Held] verwendet. FIST wurde entwickelt von Martin<br />

Held und wird dazu verwendet, Flächen eines Modells zu triangulieren, welche<br />

noch nicht trianguliert sind.<br />

5.3.2 Bilden eines spannenden Baumes im dualen Graph eines<br />

triangulierten Meshes<br />

Für den Schritt 2 kann zwischen drei verschiedenen Suchverfahren gewählt<br />

werden:<br />

• einer Tiefensuche (depth-first search, DFS),<br />

• einer Breitensuche (breadth-first search, BFS) und<br />

• einer Hybrid-Variante.<br />

Letztere führt eine Tiefensuche durch, kehrt dann aber zum höchsten Knoten<br />

zurück, welcher noch nicht vollständig besucht wurde. Die drei Suchmethoden<br />

werden in Abbildung 13 veranschaulicht.<br />

Wenn der gewählte Suchalgorithmus sich nun bei einem Knoten mit zwei<br />

unbesuchten Nachbarn befindet (Knoten 2. Ordnung), gibt es für die Wahl<br />

zwischen den beiden Knoten verschiedene Vorgehensweisen. Die einfachste<br />

Methode, ist es den nächsten Knoten zufällig auszuwählen (random marching).<br />

Eine andere von SGI entwickelte und in tomesh implementierte Heuristik,<br />

wählt den nächsten Knoten welcher die kleinste Anzahl an unbesuchten<br />

Nachbarn aufweist.<br />

Eine weitere Variante ist es, zu überprüfen von welcher Seite des vorhergehenden<br />

Dreiecks, in das aktuelle Dreieck eingetreten wurde, und dann die<br />

entgegengesetze Richtung zu wählen, sodass die Richtung des Pfades bei jedem<br />

Schritt alterniert (alternate-turn marching).<br />

Das Ziel ist, einen Baum zu erzeugen, welcher möglichst wenige Knoten der<br />

Ordnung 2 enthält. Je weniger Knoten 2. Ordnung der Baum letztlich enthält,<br />

19


S S S<br />

BFS DFS Hybrid<br />

Abbildung 13: Graphensuchalgorithmen. [10, Xiang]<br />

desto effektiver wird im nachfolgenden Schritt die Partitionierung sein, dass<br />

heißt desto weniger hamiltonische Pfade werden aus dem Graphen entstehen.<br />

Die Breitensuche tendiert dazu, sehr gut ausbalancierte Bäume zu erzeugen,<br />

welche eine große Anzahl an Knoten 2. Ordnung enthalten. Die Tiefensuche<br />

und die Hybrid-Variante erzeugen beide für den nachfolgenden Schritt besser<br />

geeignete Bäume, mit wenigen Knoten 2. Ordnung.<br />

5.3.3 Partitionierung des Baumes in hamiltonische Pfade<br />

Zur Partitionierung des im vorherigen Schritt entstandenen Baumes, wird<br />

der Path Peeling Algorithmus verwendet. Dieser partitioniert den dualen<br />

Graph in hamiltonische Pfade.<br />

Algorithmus [10, Xiang]:<br />

1. Sei v ein Knoten mit maximaler Tiefe, von allen Knoten mit 2 Kindern.<br />

Gibt es keinen solchen Knoten, gehe zu Schritt 3.<br />

Dann muss der Teilbaum mit der Wurzel v ein Pfad πv sein. Andernfalls<br />

würde ein tiefer liegender Knoten mit 2 Nachfolgern existieren,<br />

was wiederum der zuvor getroffenen Wahl von v widerspräche. Weiters<br />

besteht der Pfad πv aus mindestens drei Knoten.<br />

20


2. Entferne πv aus dem Baum. Ist der Baum nun leer, beende; ansonsten<br />

gehe zu Schritt 1.<br />

3. (Kein Knoten des Baumes hat zwei Kinder.) In diesem Fall, ist der<br />

Baum bereits ein Pfad (möglicherweise mit nur einem oder zwei Knoten),<br />

also beende.<br />

Abbildung 14 zeigt die Partitionierung eines Beispielbaumes durch den Path<br />

Peeling Algorithmus. Bild (a) zeigt den Ausgangsbaum. In diesem wird nun<br />

der Knoten mit maximaler Tiefe, von allen Knoten mit zwei Kindern gesucht.<br />

Es existieren fünf Knoten der Ordnung 2 und zwei davon liegen auf der selben<br />

Tiefe. Es wird einer der beiden zufällig ausgewählt. Dieser stellt nun die<br />

Wurzel des Teilbaumes dar, welcher in einen Pfad verwandelt werden kann,<br />

wie bei (b) zu sehen ist. Der nächste Knoten mit besagten Kriterien wird<br />

gesucht und ist diesmal eindeutig. Auch dieser wird in einen Pfad verwandelt,<br />

wie bei (c) ersichtlich. Es bleibt nur noch ein Knoten der Ordnung 2 übrig<br />

und zwar der Wurzelknoten des Ausgangsbaumes und auch dieser Teilbaum<br />

bildet, wie in (d) zu sehen, einen Pfad.<br />

(a) (b)<br />

(c) (d)<br />

Abbildung 14: Path Peeling Algorithmus.<br />

21


Der Algorithmus garantiert, dass jeder Pfad außer möglicherweise einer, aus<br />

mindestens drei Knoten besteht. Er kann in linearer Zeit ausgeführt werden,<br />

da jeder Knoten seine Tiefe und seine Ordnung kennt und jeder besuchte<br />

Knoten einem Pfad zugeordnet wird. Somit muss jeder Knoten nur genau<br />

einmal besucht werden.<br />

In Abbildung 15 ist ein Beispiel einer Triangulation zu sehen. In der Mitte<br />

sieht man den dualen Baum, welchen der Path Peeling Algorithmus aus<br />

diesem Beispiel erzeugt. Hierbei beträgt die durchschnittliche Anzahl an Vertices<br />

pro Dreick 2n. Rechts davon, ein alternativer Baum, welcher ebenso das<br />

Mesh repräsentiert, kommt auf eine durchschnittliche Anzahl von 5n<br />

Verti-<br />

3<br />

ces.<br />

4<br />

6 5 4 3<br />

5<br />

7 8 9<br />

10<br />

2 6<br />

11<br />

1<br />

12<br />

Abbildung 15: Beispiel einer Triangulation und zwei daraus ableitbare duale<br />

Bäume. [10, Xiang]<br />

5.3.4 Auflösung der Pfade in <strong>Strips</strong> oder Fans<br />

Nun können die Pfade in <strong>Strips</strong> umgewandelt werden. Es werden drei verschieden<br />

Arten davon generiert:<br />

• Nur Sequentielle <strong>Triangle</strong> <strong>Strips</strong>,<br />

• Nur Fan <strong>Strips</strong>,<br />

• Sequentielle <strong>Triangle</strong> <strong>Strips</strong> und Fan <strong>Strips</strong>.<br />

Wenn sequentielle <strong>Triangle</strong> <strong>Strips</strong> und Fan <strong>Strips</strong> generiert werden, werden<br />

die sequentiellen <strong>Strips</strong> bevorzugt. Ein Fan Strip kommt nur zustande, wenn<br />

22<br />

2n<br />

3<br />

7<br />

2<br />

1<br />

8<br />

9<br />

10<br />

11<br />

12<br />

5<br />

3 n


vier aufeinander folgende Dreiecke nicht zu einem sequentiellen Strip zusammengefasst<br />

werden können.<br />

5.3.5 Konkatenierung der <strong>Strips</strong><br />

Hierbei geht es darum die Anzahl der <strong>Strips</strong> zu reduzieren, indem man sie<br />

zusammenfügt. Dadurch entstehen weniger und auch längere <strong>Strips</strong>. In der<br />

nachfolgenden Erklärung zur Konkatenierung der <strong>Strips</strong>, sind sowohl flächenleere<br />

Dreiecke, sowie mehrfach vorkommende, identische Dreiecke erlaubt.<br />

Annahme 5.1 Seien<br />

σ1 = (v1, v2, v3, ..., vn, vn+1, vn+2)<br />

und<br />

σ2 = (u1, u2, u3, ..., um, um+1, um+2)<br />

zwei sequentielle <strong>Strips</strong> in der Triangulation S. Angenommen das erste oder<br />

letzte Dreieck von σ1 ist ein Nachbar vom ersten oder letzten Dreieck von<br />

σ2. Seien also (vn, vn+1, vn+2) und (u1, u2, u3) Nachbarn.<br />

Im Ergebnis der Konkatenierung sollten drei aufeinander folgende Vertices<br />

im neuen Strip entweder ein bestehendes Dreieck aus der Triangulation S,<br />

oder ein neu eingeführtes, degeneriertes Dreieck bilden. Nun müssen drei<br />

Fälle unterschieden werden:<br />

1. Falls vn+1 = u1 und vn+2 = u2<br />

σ1 + σ2 −→ (v1, ..., vn, u1, u2, u3, ...um+2)<br />

Dieser Fall kann nur bei genau einer Konstellation der Vertices eintreten,<br />

wie in Abbildung 16 dargestellt.<br />

2. Falls vn = u2 oder vn+1 = u2 oder vn+1 = u3, und vn+2 = u1<br />

σ1 + σ2 −→ (v1, ..., vn, vn+1, u1, u2, u3, ..., um+2)<br />

Dieser Fall kann in drei verschiedenen Konstellationen der Vertices eintreten,<br />

wie in Abbildung 17 ersichtlich.<br />

23


1<br />

2<br />

3<br />

4 4<br />

6<br />

5 5 7<br />

Abbildung 16: Optimale Stripkonkatenation.<br />

(1, 2, 3, 4, 5) + (4, 5, 6, 7, 8) −→ (1, 2, 3, 4, 5, 6, 7, 8)<br />

1<br />

2<br />

3<br />

4 4<br />

5<br />

7 8<br />

5<br />

1<br />

6<br />

2<br />

3<br />

Abbildung 17: Stripkonkatenation mit Ersparnis von 1 Vertex.<br />

(1, 2, 3, 4, 5) + (5, 4, 6, 7, 8) −→ (1, 2, 3, 4, 5, 4, 6, 7, 8)<br />

(1, 2, 3, 4, 5) + (5, 6, 4, 7, 8) −→ (1, 2, 3, 4, 5, 6, 4, 7, 8)<br />

(1, 2, 3, 4, 5) + (5, 3, 6, 7, 8) −→ (1, 2, 3, 4, 5, 3, 6, 7, 8)<br />

1<br />

2<br />

3<br />

Abbildung 18: Stripkonkatenation ohne Ersparnis.<br />

(1, 2, 3, 4, 5) + (3, 5, 6, 7, 8) −→ (1, 2, 3, 4, 5, 3, 5, 6, 7, 8)<br />

4<br />

6<br />

5<br />

24<br />

8<br />

4<br />

5<br />

7<br />

7<br />

8<br />

6<br />

1<br />

7<br />

2<br />

8<br />

3<br />

4<br />

5<br />

8<br />

6


3. Andernfalls<br />

σ1 + σ2 −→ (v1, ..., vn, vn+1, vn+2, u1, u2, u3, ..., um+2)<br />

Dieser Fall kann in vier weiteren Konstellationen der Vertices eintreten.<br />

Ein Beispiel dafür ist in Abbildung 18 zu sehen.<br />

Es kann hierbei offensichtlich die Anzahl der Vertices nicht reduziert<br />

werden. Trotzdem hat diese Form der Konkatenierung den Vorteil, dass<br />

insgesamt ein Strip eingespart werden kann.<br />

Die Konkatenierung von zwei Fans funktioniert folgenderweise:<br />

Annahme 5.2 Seien<br />

σ1 = (v1, v2, v3, ..., vn, vn+1, vn+2)<br />

und<br />

σ2 = (u1, u2, u3, ..., um+2)<br />

zwei Fan <strong>Strips</strong> in der Triangulation S. Seien wieder (vn, vn+1, vn+2) und<br />

(u1, u2, u3) benachbart. Dann kann σ1 und σ2 genau dann konkateniert werden,<br />

wenn v1 = u1 und vn+2 = u2, und σ1+σ2 −→ (v1, ..., vn+1, vn+2, u3, ...um+2).<br />

<strong>Strips</strong> welche nur ein einziges Dreieck (Singleton <strong>Strips</strong>) beinhalten bilden<br />

einen Sonderfall, da die Vertices (v1, v2, v3) zyklisch permutiert werden können.<br />

Dadurch kann natürlich ein benachbarter Strip, sehr einfach und effektiv mit<br />

dem Singleton Strip konkateniert werden. Singleton <strong>Strips</strong> haben also drei<br />

mögliche Nachbarn mit denen sie zusammengefügt werden können. Alle anderen<br />

<strong>Strips</strong> mit der minimalen Länge zwei haben zwei mögliche Kandidaten<br />

zur Konkatenierung.<br />

Dieser FTSG Konkatenations-Algorithmus kann nur bei einem Paar von benachbarten<br />

<strong>Strips</strong> σ1 und σ2 eine optimale Konkatenierung erreichen. Die<br />

Reihenfolge der Konkatenierung spielt also eine Rolle. Um das global beste<br />

Ergebnis zu erzielen, wird die Konkatenierung in drei Stufen durchgeführt. Es<br />

werden jene <strong>Strips</strong> bevorzugt, welche mit einer Einsparung von zwei Vertices<br />

konkateniert werden können. Danach folgen die Konkatenierungen mit einer<br />

Reduzierung von einem Vertex und abschließend jene mit keiner Einsparung.<br />

25


5.3.6 Statistiken<br />

Optionen des FTSG:<br />

• Drei verschiedene Varianten den Dual Graph zu durchsuchen, nämlich<br />

die Breitensuche ” bfs“(breadth-first search), die Tiefensuche ” dfs“(depthfirst<br />

search) und die Hybrid Variante ” hyb“(hybrid variant).<br />

• Zwei Möglichkeiten während der Graphensuche und zwar ” alt“(alternateturn<br />

marching) und ” rnd“(random marching).<br />

• Die Verwendung von flächenleeren Dreiecken ” zero“(zero-area triangles)<br />

oder von gleichen Dreiecken ” dup“(duplicate triangles) während der<br />

Konkatenierung der <strong>Strips</strong>.<br />

• Generierung von sequentiellen <strong>Strips</strong> mit ” seq“und Fan <strong>Strips</strong> mit ” fan“<br />

• Verwendung des dynamisch programmierten Algorithmus mit ” DP“<br />

In Tabelle 2 sieht man eine Gegenüberstellung der verschiedenen Heuristiken.<br />

Tabelle 3 zeigt den Vergleich des FTSG Algorithmus mit dem SGI Algorithmus<br />

(tomesh) und dem STRIPE Algorithmus. Angegeben sind die durchschnittliche<br />

Anzahl von Vertices pro Dreieck und die CPU Zeit.<br />

5.4 Tunneling<br />

Tunneling ist keine Methode um <strong>Strips</strong> in einem Mesh zu erzeugen, viel<br />

mehr ist das Ziel dieser Methode, die Anzahl der <strong>Strips</strong> zu reduzieren. Es<br />

operiert auf dem dualen Graph eines triangulierten Modells, wofür bereits<br />

die entsprechenden Tri<strong>Strips</strong> erzeugt wurden.<br />

Der duale Graph auf dem operiert wird, enthält Strip-Edges und Nonstrip-<br />

Edges, also Kanten welche einem Strip zugehörig sind und solche die keinem<br />

Strip zugehörig sind.<br />

Definition 5.2 Eine Sequenz von Kanten im dualen Graph, welche zwei<br />

<strong>Strips</strong> miteinander verbindet, wird Tunnel genannt. Ein Tunnel hat außerdem<br />

die Eigenschaft, dass er mit einer Nonstrip-Edge begonnen und beendet<br />

wird. Dazwischen alterniert der Tunnel bei jedem Schritt zum nächsten Knoten,<br />

zwischen Strip- und Nonstrip-Edges.<br />

Algorithmus:<br />

26


method avg. V/T CPU (ms)<br />

-dfs -alt -seq -zero 1.23 0.009<br />

-dfs -alt -seq -fan -zero 1.24 0.010<br />

-hyb -alt -seq -zero 1.25 0.013<br />

-hyb -alt -seq -fan -zero 1.27 0.013<br />

-hyb -rnd -seq -zero 1.28 0.012<br />

-dfs -alt -seq 1.29 0.009<br />

-dfs -rnd -seq -zero 1.29 0.011<br />

-hyb -alt -seq 1.32 0.012<br />

-hyb -alt -seq -fan 1.33 0.011<br />

-bfs -alt -seq -zero 1.33 0.010<br />

-hyb -rnd -seq 1.36 0.010<br />

-dfs -rnd -seq 1.38 0.009<br />

-dfs -alt -fan 1.57 0.010<br />

-hyb -alt -fan 1.58 0.014<br />

-hyb -alt -fan -zero 1.58 0.013<br />

Tabelle 2: Auswertung verschiedener Heuristiken des FTSG. [10, Xiang]<br />

1. Wähle einen Knoten an dem Ende eines <strong>Strips</strong>.<br />

2. Führe eine Breitensuche im Dual Graph durch, um den kürzesten Pfad<br />

von alternierenden Kanten, zu einem Knoten am Ende eines anderen<br />

<strong>Strips</strong> zu finden.<br />

3. Auf diesem Pfad werden Strip-Edges umgewandelt in Nonstrip-Edges<br />

und umgekehrt.<br />

4. Die Anzahl der <strong>Strips</strong> wurde um eins verringert.<br />

5. Diese Schritte können wiederholt werden, bis kein Tunnel mehr gefunden<br />

wird.<br />

Ein Beispiel für den Algorithmus ist in Abbildung 19 dargestellt. Bei Bild<br />

(a) sieht man eine triangulierte Fläche. Die Knoten des dualen Graph werden<br />

in Form von Kreisen in den Dreiecken dargestellt, die verbindenden Kanten<br />

sind entweder rot (Strip-Edges) oder grün (Nonstrip-Edges). Der Algorithmus<br />

beginnt mit der Auswahl des Knotens von dem die Breitensuche startet,<br />

27


method avg.V / T CPU (ms)<br />

FTSG -dfs -alt -DP -zero 1,21 0.014<br />

FTSG -dfs -alt -seq -zero 1,23 0.009<br />

FTSG -dfs -alt -DP 1,24 0.013<br />

tomesh 1,36 0.027<br />

STRIPE (convex faces) 1,36 0.263<br />

STRIPE (fully triangulated) 1,39 0.071<br />

Tabelle 3: Vergleich von FTSG, SGI und STRIPE. [10, Xiang]<br />

die bei den Schritten (b),(c) und (d) zu sehen ist. Auf dem dadurch gefundenen<br />

Pfad (e) werden jetzt die Kanten umgewandelt wie zuvor beschrieben.<br />

Im letzten Bild (f) ist das Ergebnis zu sehen. Die Verläufe der <strong>Strips</strong> vor dem<br />

Tunneling sind hier mit grün strichlierten Linien dargestellt. Man sieht, dass<br />

die Anzahl der <strong>Strips</strong> von fünf auf vier reduziert wurde.<br />

Beim zweiten Schritt des Algorithmus, der Breitensuche, gibt es einige Sonderfälle<br />

zu beachten:<br />

• Ein Tunnel, welcher nur aus einer Nonstrip Edge besteht ist möglich.<br />

Dies ist mit einer einfachen Konkatenierung zweier <strong>Strips</strong> zu vergleichen.<br />

• Ein Tunnel kann auch an einem Singleton Strip enden. Das isolierte<br />

Dreieck wird einem Strip hinzugefügt.<br />

• Die letzte Kante eines Tunnels darf nicht zwei Knoten desselben <strong>Strips</strong><br />

verbinden, da ansonst dieser Strip eine Schleife bildet und dadurch die<br />

Anzahl der <strong>Strips</strong> nicht reduziert wird.<br />

• Sei ei eine Nonstrip-edge eines Tunnels, welche zwei Knoten desselben<br />

<strong>Strips</strong> verbindet. Dann muss die nachfolgende Kante ei+1, falls sie existiert,<br />

in die Richtung des Startknotens der Kante ei zeigen. Würde<br />

man diese Bedingung nicht stellen, ergäbe sich wieder ein Strip der<br />

eine Schleife bildet.<br />

Diese hier beschriebenen Sonderfälle erfordern, dass jeder Knoten speichert<br />

zu welchem Strip er gehört. Wenn dann im dritten Schritt des Algorithmus<br />

28


(a)<br />

(c) (d)<br />

(e) (f)<br />

Abbildung 19: Tunneling.<br />

29<br />

(b)


alle Kanten komplementiert und somit <strong>Strips</strong> unterbrochen und neu zusammengefügt<br />

werden, muss bei allen Knoten die davon betroffen sind, die Information<br />

zu welchem Strip nun der Knoten gehört, neu gespeichert werden.<br />

Dieser Vorgang kann im schlimmsten Fall alle <strong>Strips</strong> betreffen und stellt damit<br />

den zeitaufwändigsten Schritt des Algorithmus dar.<br />

Tabelle 4 zeigt einen Vergleich der Anzahl der <strong>Strips</strong>, welche mit den Algorithmen<br />

SGI, STRIPE und dem Tunneling erreicht werden. Tabelle 5 stellt<br />

die Laufzeit der selben Algorithmen gegenüber.<br />

Model Number of Number of strips<br />

Faces SGI STRIPE Tunneling<br />

Random I 1 874 39 44 13<br />

Random II 19 598 404 401 82<br />

Bunny 69 451 705 917 158<br />

Random III 198 734 3 719 - 593<br />

Dragon 871 414 17 653 - 1 798<br />

Tabelle 4: Vergleich der Stripanzahl von SGI, STRIPE und Tunneling. [8,<br />

Stewart]<br />

Model Number of Execution time<br />

Faces SGI STRIPE Tunneling<br />

Random I 1 874 0.1 0.2 0.1<br />

Random II 19 598 1.5 1.9 4.0<br />

Bunny 69 451 10.3 9.5 17.4<br />

Random III 198 734 84.4 - 522.5<br />

Dragon 871 414 0.45 hours - 3.75 hours<br />

Tabelle 5: Vergleich der Laufzeiten von SGI, STRIPE und Tunneling. [8,<br />

Stewart]<br />

30


Literatur<br />

[1] T. Akenine-Möller and E. Haines. Real-Time Rendering. A. K. Peters<br />

Ltd., 2002.<br />

[2] E. M. Arkin, M. Held, J. S. B. Mitchell, and S. Skiena. Hamiltonian<br />

triangulations for fast rendering. The Visual Computer, 12(9):429–444,<br />

1996.<br />

[3] R. Bar-Yehuda and C. Gotsman. Time/space tradeoffs for polygon mesh<br />

rendering, 1996.<br />

[4] F. Evans, S. Skiena, and A. Varshney. Optimizing triangle strips for fast<br />

rendering, 1996.<br />

[5] M. Held. FIST: Fast industrial-strength triangulation of polygons. Algorithmica,<br />

30(4):563–596, 2001.<br />

[6] F. Michael, Deering, and N. R. Scott. Leo: A system for cost effective<br />

3d shaded graphics, 1993.<br />

[7] A. Nischwitz, M. Fischer, and P. Haberäcker. Computergrafik und Bildverarbeitung.<br />

Vieweg und Sohn Verlag, 2007.<br />

[8] A. J. Stewart. Tunneling for triangle strips in continuous level-of-detail<br />

meshes, 2001.<br />

[9] P. Vaněček. Comparison of stripification techniques, 2002.<br />

[10] X. Xiang. Succinct strip encoding of triangle meshes, 2001.<br />

31

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!