Diplomarbeit - Detlef Krömke - Goethe

Diplomarbeit
Echtzeit-Simulation eines
wassergefüllten Ballons mit
Feder–Masse–Dämpfer-Systemen
eingereicht bei
Prof. Dr-Ing. Detlef Krömker,
Professur für Graphische Datenverarbeitung
von
Daniel Groh
([email protected])
Eingereicht am
16. November 2006
Fachbe re ich 12
Informatik und Mathe matik
Institut für Informatik
Betreuung durch
Dr. Tobias Breiner
Dieses Dokument ist online Verfügbar unter http://www.cap23.de/uni/siwaba.pdf
Eidesstattliche Erklärung
Ich erkläre hiermit an Eides Statt, dass ich die vorliegende Arbeit selbstständig
und ohne Benutzung anderer als der angegebenen Hilfsmittel angefertigt habe; die
aus fremden Quellen direkt oder indirekt übernommenen Gedanken sind als solche
kenntlich gemacht.
Die Arbeit wurde bisher in gleicher oder ähnlicher Form keiner anderen
Prüfungskommission vorgelegt und auch nicht veröffentlicht.
Frankfurt am Main, den 16. November 2006
_________________________
(Daniel Groh)
ii
Zusammenfassung
In dieser Diplomarbeit wird ein Echtzeit-Verfahren vorgestellt, um einen
wassergefüllten Ballon zu simulieren. Grundlage des Verfahrens ist ein FederMasse-Dämpfer–System, das zusammen mit Methoden zur Erhaltung des
Innenvolumens sowie einer topologieerhaltenden Datenstruktur kombiniert
wurde. Die Masse des Wassers wird dabei auf Massepartikel an der Oberfläche des
Gummiballons aufgeteilt, an denen die Wirkung der physikalischen Kräfte
Gravitation, Innendruck und elastische Zugkraft der Oberfläche ausgewertet wird.
Dies erfolgt durch iterative Anwendung eines Simulationsschrittes, bei dem die auf
die Massepartikel wirkenden Beschleunigungen ermittelt und in eine Bewegung
übertragen wird. Bei der Umsetzung in C++ wurde das Verfahren mit Hilfe des
Echtzeit-3D-Szenengraphen OGRE (Object-oriented Graphics Rendering Engine)
implementiert.
Mögliche Einsatzgebiete sind interaktive Simulationsumgebungen oder andere
Echtzeit-Anwendungen in den Bereichen Multimedia und Unterhaltung sowie
Nicht-Echtzeit-Verfahren zur Bildgenerierung und physikalischen Simulation.
Abstract
This thesis introduces a method to simulate a water-filled balloon. This is
accomplished by using a Spring–Mass–Damper-System, which was combined
together with methods for sustaining the interior volume as well as a topologyconserving data structure. For this purpose the mass of the water is split to mass
particles on the surface of the rubber ballon, at which the effect of the physical
forces gravitation, internal pressure and elastic traction of the surface are evaluated.
This is done by applying an iterative simulation step, which determines a mass
particles acceleration and transforms it into movement. The method was
implemented in C++ using the realtime-scenegraph OGRE (Object-oriented
Graphics Rendering Engine).
Possible applications are interactive simulation environments or other real-time
applications such as in multimedia and entertainment as well as non-realtime
procedures in the field of digital image generation and physical simulations.
iii
Danksagung
Ich danke allen, die mich in meiner Arbeit unterstützt und gefördert haben,
insbesondere Dr. Tobias Breiner für seine Betreuung sowie meinen Prüfern
Prof. Dr.-Ing. Detlef Krömker und Prof. Dr.-Ing. Lars Hedrich für die aufgebrachte
Zeit.
Zudem danke ich allen, die mit ihrer Energie und Kreativität helfen, die
Entwicklung von OpenSource-Projekten voranzutreiben. Dank ihnen war ich in
der Lage, meine Arbeit ganz auf der Basis freier Software zu erstellen.
Nicht zuletzt danke ich meiner Lebensgefährtin Kirsten Schreiber für ihre
Korrekturlesungen und anhaltenden Ermutigungen zu verstärktem Arbeitseifer in
kritischen Phasen sowie meinen Eltern Werner und Margitta Groh für ihre
fortwährende Unterstützung während meines Studiums.
Acknowledgment
I want to thank all who helped and supported me in my work, in particular
Dr. Tobias Breiner for supervising me as well as my examiners Prof. Dr.-Ing. Detlef
Krömker and Prof. Dr.-Ing. Lars Hedrich for their spent time.
Besides, I want to thank all those people, who help with their energy and
creativity to advance the development of OpenSource projects. I owe them the
ability of using free software as a base for mastering my work.
Last but not least I thank my friend and fellow Kirsten Schreiber for her services
as proof-reader and her continuous encouragements to intensify my effords in
critical phases as well as my parents Werner and Margitta Groh for their continual
support during my study.
iv
Inhaltsverzeichnis
1 Einleitung....................................................................................................1
2 Grundlagen..................................................................................................3
2.1 Geometrische Grundlagen......................................................................... 4
2.1.1 Polygonale Geometrierepräsentation........................................................... 4
2.1.2 Geometrische Körper aus der Mathematik.................................................. 5
2.2 Volumenberechnung mit dem Gaußschen Integralsatz........................ 8
2.3 Feder–Masse–Dämpfer-Systeme............................................................. 11
2.3.1 Harmonische Schwingungen und das Hookesche Gesetz.......................... 11
2.3.2 Feder–Masse-Systeme................................................................................ 12
2.3.3 Feder–Masse-System mit Dämpfer ............................................................ 14
2.4 Anwendungen........................................................................................... 17
2.4.1 Feder–Masse–Dämpfer-Systeme in der Elektrotechnik.............................. 17
2.4.2 Muskeldeformation mit Feder–Masse-Systemen....................................... 18
2.4.3 Wasseroberfläche und Stoff mit Feder–Masse-Systemen........................... 21
3 Entwurf......................................................................................................23
3.1 Anforderungsanalyse................................................................................ 24
3.2 Die verwendeten Geometriemodelle..................................................... 26
3.3 Einbettung der physikalischen Simulation...........................................
3.3.1 Anbindung an das Geometriemodell.........................................................
3.3.2 Simulation der auftretenden Kräfte...........................................................
3.3.3 Reaktion mit der Simulationsumgebung...................................................
3.4 Die physikalischen Kräfte........................................................................
3.4.1 Notation der Kräfte....................................................................................
3.4.2 Gravitation.................................................................................................
3.4.3 Dämpfung..................................................................................................
3.4.4 Oberflächenspannung................................................................................
3.4.5 Innendruck................................................................................................
3.5 Eine Topologische Datenstruktur...........................................................
3.5.1 Aufbau.......................................................................................................
3.5.2 Die Operation Face-Split............................................................................
27
27
28
31
33
33
33
33
35
36
39
39
40
v
4 Umsetzung.................................................................................................42
4.1 Der 3D-Szenengraph OGRE..................................................................... 43
4.2 Objektstruktur........................................................................................... 44
4.2.1 Allgemeiner Programmaufbau................................................................... 44
4.2.2 Geometriemodelle...................................................................................... 45
4.2.3 Datenstrukturen für Topologie und physikalische Kräfte.......................... 46
4.3 Nebeneffekte des Simulationsverfahrens.............................................. 50
4.4 Codebeispiele.............................................................................................
4.4.1 Rekonstruktion der Vertextopologie..........................................................
4.4.2 Berechnung der Normalenvektoren..........................................................
4.4.3 Volumenberechnung.................................................................................
4.4.4 Simulationsschritt......................................................................................
52
52
52
53
55
5 Bewertung.................................................................................................56
5.1 Ergebnisse................................................................................................... 57
5.2 Laufzeitanalyse.......................................................................................... 59
5.3 Berechnungsgenauigkeit.......................................................................... 62
5.4 Nachteile des Verfahrens......................................................................... 65
6 Ausblick.....................................................................................................67
6.1 Verbesserungen......................................................................................... 68
6.1.1 Einbindung einer Gleit- und Haftreibungskraft......................................... 68
6.1.2 Mögliche Erhöhung der Berechnungsgenauigkeit..................................... 69
6.2 Fazit............................................................................................................. 70
Anhang A: Literaturverzeichnis...............................................................71
Anhang B: Verwendete Software............................................................73
vi
1 Einleitung
Kapitel 1
Einleitung
Die Darstellung von Wasser ist in der Computergrafik seit der Generierung der
ersten künstlichen Bilder eine der größten Herausforderungen. Kein Wunder,
wenn man bedenkt, wie komplex sich Wasser in verschiedenen Situationen
verhält. Schon ein einzelner Wassertropfen erfordert bei der physikalischen
Beschreibung
einen
hohen
Aufwand,
wenn
Oberflächenspannung
und
Turbulenzen im Inneren berücksichtigt werden. Dieser Aufwand verblasst aber
geradezu vor dem Hintergrund von Wasserfällen, Wellenbewegungen oder den
Strömungen in einem Fluss. Hinzu kommen die optischen Eigenschaften von
Wasser, die durch seine teilweise Transparenz und Lichtbrechung an der Oberfläche
ebenfalls schwer zu beschreiben sind.
Bislang begrenzt sich die Darstellung von Wasser daher darauf, für einzelne
optische Eigenschaften verschiedene Konzepte zur Darstellung zu entwickeln, sich
also z. B. auf die Darstellung der Wasseroberfläche zu begrenzen. Trotz der starken
Vereinfachung bleibt der Aufwand immer noch hoch. So mussten beispielsweise
350 SGI CPUs und 200 DEC Alpha CPUs rund drei Monate rechnen, um die
Wassereffekte des Kinofilms „Titanic“ zu erzeugen. [Str98]
Rechnerraum für die Erzeugung von Wassereffekten
Seite 1
Einleitung
1
Die Schwierigkeiten bei der formalen Beschreibung von Wasser übertragen sich
auch auf physikalische Simulationen, bei denen Wasser eine Rolle spielt. Möchte
man zudem eine interaktive Simulationsumgebung erstellen, setzt das die
Generierung von wenigstens 10-30 Einzelbildern pro Sekunde voraus. [FDF97] Es
wird schnell klar, dass die Beschreibung des Wassers drastisch vereinfacht werden
muss, denn neben der eigentlichen Simulation muss auch noch die Darstellung in
der kurzen Zeit bewältigt werden.
Der Einsatz von physikalischen Simulationen beschränkt sich in EchtzeitAnwendungen daher auch vorwiegend auf starre Objekte (wie etwa den oft
gesehenen Kistenstapel). Im Rahmen dieser Arbeit wird am Beispiel eines
wassergefüllten Ballons untersucht, inwieweit auch deformierbare Objekte in
angemessener Geschwindigkeit dargestellt werden können, ohne dass dabei
charakteristische Bewegungsmerkmale verloren gehen. Um eine angemessene
Berechnungsgeschwindigkeit zu erreichen, wird das Wasser im Inneren auf
einzelne Massepartikel reduziert, die über die Ballonoberfläche verteilt sind. Zur
Simulation des elastischen Gummis wird ein Feder–Masse–Dämpfer-System
eingesetzt, durch das die Massepartikel verbunden sind. Damit dabei das Volumen
des Ballons erhalten bleibt, wird zudem der Druck des Wassers auf die Innenseite
der Ballonoberfläche simuliert.
Seite 2
2 Grundlagen
Kapitel 2
Grundlagen
In diesem Kapitel wird in die Techniken eingeführt, die bei der Realisierung der
Aufgabenstellung zum Einsatz kommen. Nach einem kurzen Einblick in die
polygonale Geometrierepräsentation wird eine schnelle Methode zur Berechnung
eines Polyedervolumens auf Grundlage des GAUSSschen Integralsatzes entwickelt.
Danach werden theoretische Grundlagen von Feder–Masse–Dämpfer-Systemen
erläutert.
Abschließend werden einige Anwendungsgebiete von Feder–Masse–DämpferSystemen vorgestellt. Neben der Verbindung zu elektronischen Schwingkreisen
werden
anhand
zweier
Publikationen
aus
dem
Gebiet
der
Graphischen
Datenverarbeitung aktuelle Resultate und Probleme umrissen.
Seite 3
Grundlagen
2
2.1 Geometrische Grundlagen
2.1.1 Polygonale Geometrierepräsentation
Wie Geometrische Daten im Computer repräsentiert werden, richtet sich
sinnvollerweise nach dem Zweck der Anwendung – entsprechend vielfältig sind die
vorhandenen Möglichkeiten. Ein verbreiteter Ansatz ist die Polygondarstellung.
Aus den Basisprimitiven Vertex, Edge und Face (engl. für „Knoten“, „Kante“ und
„Fläche“) werden planare Polygone erzeugt, mit denen die Oberfläche der
Szenengeometrie beschrieben wird.
Abbildung 2.1: Vertex, Edge und Face
Die Polygondarstellung hat zunächst den Nachteil, dass sich nicht alle Objekte
exakt darstellen lassen. So kann eine runde Oberfläche durch eine Menge von
Polygonen immer nur angenähert werden. Um den Eindruck der Rundung zu
erhalten, muss die Oberfläche durch kleine und damit viele Polygone nachgebildet
werden. Erst durch speziell angepasste Hardware konnte der Rechenaufwand
komplexer Szenen mit einer hohen Polygonzahl bewältigt werden. So findet sich
heute auf jeder handelsüblichen Grafikkarte ein „3D-Beschleuniger“, also ein
Grafikchip, der die beim Rendern einer 3D-Szene anfallenden Rechenoperationen
besonders effizient ausführen kann.
Die Leistung aktueller Grafikchips reicht aber aus, um mehrere 100.000
Polygone darzustellen. Zudem existieren Algorithmen, die eine beliebig deformierte
Oberfläche so in Polygone zerlegen, dass die resultierende Gesamtzahl niedrig, der
optische Eindruck aber weitgehend erhalten bleibt. Durch geschickte Modellierung
lassen sich mittels Polygondarstellung also nahezu beliebige Szenen beschreiben
und in Echtzeit darstellen.
Seite 4
Grundlagen
2
2.1.2 Geometrische Körper aus der Mathematik
Ein fluider Körper wird unter Einwirkung einer Oberflächenspannung stets
bestrebt sein, seine Oberfläche zu minimieren, also eine Minimalfläche zu bilden.
Ist die Oberfläche so beschaffen, dass die Spannkraft an jeder Stelle gleich ist, also
durch eine gleich große Dehnung immer eine gleich große Kraft entsteht, dann ist
seine Minimalfläche eine regelmäßige Kugel. [Vog99]
4
3
r
3
O = 4 r 2
V =
r
Abbildung 2.2: Regelmäßige Kugel
Aus diesem Grund werden im Folgenden zwei Varianten einer polygonalen
Näherung an eine regelmäßige Kugel vorgestellt.
Die erste Variante ist die UV-Sphere. Bei dieser wird eine regelmäßige Kugel in n
Segmente und m Ringe unterteilt, ähnlich den Längen- und Breitengraden eines
Globi. Dazu werden die Variablen u 1 ,u 2 u n und v 1 , v 2 v m regelmäßig auf das
Intervall [0, 1] verteilt, so dass u 1 = v1 = 0, u n = v m = 1 und u i1 −u i =  u bzw.
v i1−vi =  v ist. Ein Paar ui ,v j  entspricht auf der Oberfläche der UV-Sphere dem
Schnittpunkt des linken Randes von Segment i mit dem j-ten Ring. Die Vertices
der UV-Sphere werden bestimmt durch alle Paare ui ,v j  mit 1 ≤ i ≤ n und
1 ≤ j ≤ m.


Abbildung 2.3: UV-Sphere
Seite 5
Grundlagen
2
Zur Bestimmung der Koordinaten einer Vertex werden die Winkel i = 2⋅u i
(gemessen an der x-Achse) und  j = ⋅v j (gemessen an der y-Achse) berechnet.
Über
trigonometrische
Funktionen
wird
das
Winkelpaar
 i , j  auf
die
Kugeloberfläche abgebildet und damit die resultierenden Koordinaten einer Vertex
berechnet.
Das zweite Verfahren beruht auf einem besonderen geometrischen Objekt, dem
Ikosaeder. Zusammen mit dem Pentagondodekaeder ist es der komplexeste der fünf
platonischen Körper, welche über eine außerordentliche Regelmäßigkeit und
Symmetrie verfügen. [Hom06] So sind alle Seitenflächen eines platonischen
Körpers zueinander kongruente, regelmäßige Vielecke, von denen in jeder Ecke
jeweils gleich viele zusammentreffen. Es ist bewiesen, dass tatsächlich nur fünf
solcher Körper existieren. [www01]
a
5a3
3 5
12
O = 5a 2  3
a
r =  2 5 5
4
V =
Abbildung 2.4: Ikosaeder
Das Ikosaeder besteht aus zwölf Eckpunkten, 20 gleichseitigen und kongruenten
Dreiecken sowie 30 gleich langen Kanten. Es wird von drei gleich großen
Rechtecken aufgespannt, deren Seitenverhältnis dem Goldenen Schnitt entspricht.
Die Vertices eines Ikosaeders entsprechen den Eckpunkten dieser Rechtecke. Ein
Ikosaeder mit der Kantenlänge a = 2, dessen Mittelpunkt im Ursprung des
Koordinatensystems liegt, lässt sich daher mit folgenden Koordinaten erfassen:
±1 ,± , 0, 0 ,±1 ,±, ± ,0 ,±1, mit  = 1 5 / 2
Auch wenn das Ikosaeder über hervorragende Symmetrieeigenschaften verfügt,
so ist es zur Beschreibung einer regelmäßigen Kugel noch zu kantig. Man kann die
Oberfläche des Ikosaeders aber durch sukzessives Unterteilen der Seitenflächen
abrunden. Dazu wird jeweils ein Dreieck der Oberfläche durch vier neue Dreiecke
Seite 6
Grundlagen
2
ersetzt. Die neu entstandenen Vertices werden anschließend auf die Umkugel des
Ikosaeders projiziert.
Abbildung 2.5: Face-Split an den Seitenflächen des Ikosaeders
Schon nach wenigen Unterteilungsschritten entsteht der Eindruck einer runden
Kugel. Leider gehen bei der Teilung einige Eigenschaften des Ikosaeders verloren.
So treffen nach der Unterteilung in manchen Eckpunkten fünf, in anderen sechs
Seitenflächen zusammen. Dennoch ist das Ikosaeder von den platonischen Körpern
am besten geeignet, um eine möglichst gute Näherung an eine regelmäßige Kugel
zu erhalten. [Hom06] Ein auf die beschriebene Weise unterteiltes Ikosaeder nennt
man auch geodätische Kugel.
Abbildung 2.6: Aus einem Ikosaeder konstruierte geodätische Kugeln
Seite 7
Grundlagen
2
2.2 Volumenberechnung mit dem Gaußschen Integralsatz
Zur Berechnung des Volumens geschlossener geometrischer Körper ist im
Allgemeinen die Auswertung von Mehrfachintegralen notwendig:
VK =
K
∭ dV
∫ f  x , y , zdV
=
K
Für beliebige geometrische Körper ergibt sich bei der Auswertung eines solchen
Integrals ein möglicherweise komplizierter und schwer zu beschreibender
Integrationsbereich. Es bietet sich daher in vielen Fällen an, den Körper in weniger
komplexe Teilobjekte zu zerlegen und die dadurch vereinfachten Einzelintegrale
aufzusummieren. [BM01]
Liegt ein Körper in Randdarstellung vor, kann der GAUSSsche Integralsatz
angewendet werden. Dieser stellt einen Zusammenhang zwischen räumlichen
Bereichsintegralen und Oberflächenintegralen her:
Sei B⊂ℝ3 ein räumlicher Bereich, der von einer stückweise glatten Fläche F
berandet wird. Weiterhin sei 
f : ℝ3  ℝ3 eine stetig differenzierbare Vektorfunktion
und n äußeres Normaleneinheitsfeld an F. Dann gilt: [MW99]
∫ g dB
B
=
∫ f ⋅n dF,
mit g = div f =
F
∂ fx ∂ fy ∂ fz


∂x
∂y
∂z
Man nennt g :ℝ 3  ℝ eine Divergente zu f ; dabei ist g nicht notwendigerweise
eindeutig. Wendet man den GAUSSschen Integralsatz auf das Mehrfachintegral zur
Berechnung des Volumens an, ergibt sich:
VK =
∫ g dV
=
∫ f ⋅n  dF
∂K
K
Das Volumen wird also durch die Oberfläche ∂ K des Körpers ausgedrückt. Diese
kann in einzelne Flächenstücke F i zerlegt werden:
∫ f ⋅n  dF
∂K
=
∑ ∫ f ⋅n i dF i
i
Fi
Seite 8
Grundlagen
2
Sei nun 
f  x , y , z = x , y , z  die Identitätsfunktion. Dann ist 
f stetig und
differenzierbar und liefert bei der Integration über ein Flächenstück F i genau die
Punkte Q i ⊂F i der Fläche selbst. Zudem gilt, dass das Skalarprodukt eines Vektors
mit einem Einheitsvektor die Länge der Projektion dieses Vektors auf die vom
Einheitsvektor definierte Gerade ergibt. [www02] Es ist also P i , j⋅n gleich für alle
P i , j ∈ Q i, da n sowohl Einheitsvektor wie auch normal zu F i ist. Es gilt somit für
jeweils beliebiges j:
∫ f ⋅n dF i
Fi
=
∫ Q i⋅n dF i
Fi
= P i , j⋅n ∫ dF i = P i , j⋅n AF i 
Fi
Nun kann jeder Punkt in Q i auch als vom Ursprung des Koordinatensystems
ausgehender Vektor aufgefasst werden. Die Randpunkte von F i bilden dann einen
unregelmäßigen schiefen Kegel mit der Grundfläche AF i , dessen Spitze im
Ursprung des Koordinatensystems liegt. P i , j⋅n ist die Höhe des Kegels, so dass für
das Gesamtvolumen des Körpers gilt: [Gol94]
VK =
1
3
∣∑
 P i , j⋅
ni  AF i 
i
∣
Diese Feststellung basiert auf der Gleichung für das Volumen einer Pyramide:
VP =
1
G⋅h
3
Die Übertragung auf den unregelmäßigen schiefen Kegel wird durch das Prinzip
von CAVALIERI erlaubt; es besagt, dass zwei Körper das gleiche Volumen haben,
wenn alle ebenen Schnitte miteinander übereinstimmen, die parallel zu einer
vorgegebenen Grundebene und in übereinstimmenden Abständen ausgeführt
werden. Daher ist das Volumen einer Pyramide nur von der Höhe und vom
Flächeninhalt der Grundfläche, nicht aber von deren Form abhängig. [www03]
Sind alle Flächenstücke F i des Körpers Dreiecke mit den Eckpunkten P i ,0 , P i ,1
und P i , 2, die in Bezug auf die nach außen gerichtete Dreiecksseite gegen den
Seite 9
Grundlagen
2
ni
Uhrzeigersinn angeordnet sind, dann lassen sich die Normaleneinheitsvektoren 
durch
ni =

P i ,1 −P i ,0  ×  P i ,2 −Pi ,0 
∣P i ,1 −P i ,0  ×  P i ,2 −Pi ,0 ∣
bestimmen. Des weiteren gilt für den Flächeninhalt AF i  eines Dreiecks der
Zusammenhang
AF i  =
1
∣P −P i ,0  ×  P i ,2−P i ,0∣,
2 i ,1
da durch v = P i ,1−P i ,0 und 
w = P i ,2 −P i ,0 zwei Dreiecksseiten gegeben sind und aus
der Definition des Kreuzproduktes ∣v ×
w∣ = ∣v∣⋅∣
w∣⋅∣sin∢v ,
w ∣ folgt.
Zusammengefasst kann also das Volumen eines geometrischen Körpers K,
dessen Umrandung aus den Dreiecken F i besteht, berechnet werden mit
VK =
1
6
∣∑
i
 Pi ,0⋅
n i ⋅∣ P i ,1 −P i ,0  ×  P i ,2 −P i ,0 ∣
∣
Seite 10
Grundlagen
2
2.3 Feder–Masse–Dämpfer-Systeme
2.3.1 Harmonische Schwingungen und das Hookesche Gesetz
Eine periodische Schwingung, die bei einer gleichförmigen Kreisbewegung
entsteht, heißt harmonische Schwingung. [Vog99] Sie ist gekennzeichnet durch
eine Gleichung der Form
x = A⋅sin  t ,
wobei ∣A∣ die Amplitude,  die Kreisfrequenz und  die Phasenverschiebung
angeben. Fasst man die Schwingung als eine räumliche Auslenkung auf, so ergeben
sich durch Differenzierung
v = ẋ = v 0 cos t
a = ẍ = −a 0 sin  t 
v0 =  A
2
a0 =  A
Ein Vergleich der Gleichungen zeigt, dass für jeden Zeitpunkt t die Auslenkung x
der Beschleunigung a entgegengesetzt, aber zu dieser proportional ist:
a = −
a0
2
x = − x
A
Wird ein Körper mit der Masse m gemäß der Schwingung bewegt, muss auf ihn
also eine Kraft F =−m 2 x = −Dx proportional zu seiner Auslenkung wirken. Eine
Kraft, die auf diese Weise von einem Abstand abhängt, nennt man elastische Kraft,
die Proportionalitätskonstante D heißt Federkonstante.
Eine elastische Kraft F = D⋅s beschreibt eine eindimensionale und lineare
elastische Deformation. Sie ist damit ein Spezialfall des HOOKEschen Gesetzes:
[www04]
 = E⋅
Das HOOKEsche Gesetz beschreibt das elastische Verhalten von Festkörpern, deren
elastische Verformung  proportional zur anliegenden Spannung  ist. Für eine
ideale Feder kann statt der anliegenden Spannung  (Kraft pro Fläche) direkt die
resultierende Kraft angegeben werden. Der Auslenkung s entspricht dann die
elastische Verformung der Feder, die durch ihre relative Längenänderung  l / l
Seite 11
Grundlagen
2
gegeben ist. Der Federkonstanten D entspricht das Elastizitätsmodul E, das, wie die
Federkonstante auch, ein werkstoffkonstanter Proportionalitätsfaktor ist.
2.3.2 Feder–Masse-Systeme
Mit dem HOOKEschen Gesetz lässt die Zugkraft bzw. Auslenkung einer idealen
linearen Feder beschreiben. Damit ist die Grundlage für ein einfaches Feder–MasseSystem gegeben. Anhand des folgenden Aufbaus nach [Edw01] sollen die
auftretenden Kräfte beschrieben werden:
l
l e
2 /
FG FS
Abbildung 2.7: Einfaches Feder–Masse-System
Eine ideale lineare Feder der Länge l wird durch eine Masse m gedehnt. Die
Gewichtskraft greift am Schwerpunkt der Masse an und wirkt senkrecht nach
unten. Die Zugkraft der Feder ist der Gewichtskraft genau entgegengesetzt und
wirkt entlang einer Geraden durch die Feder (HOOKEsche Gerade). Befindet sich das
System in Ruhelage, heben sich Zugkraft der Feder und Gewichtskraft der Masse
auf. Die Feder werde dabei um eine Länge e gedehnt; ihre Zugkraft beträgt dann
nach dem HOOKEschen Gesetz:
FS =
E⋅ l
E⋅e
=
l
l
Da sich die Zugkraft der Feder und die Gewichtskraft der Masse aufheben, gilt
F S = F G. Wird die Feder um eine zusätzliche Länge y nach unten gedehnt, steigert
sich ihre Zugkraft auf
Seite 12
Grundlagen
F 'S =
2
E⋅e y 
l
Die nach unten wirkende resultierende Gesamtkraft beträgt somit F  = F G − F 'S. Mit
F G = F S folgt:
F  = F G − F 'S = F G −
E⋅e  y
E⋅y
E⋅y
= FG − F G −
= −
l
l
l
Damit kann F  für eine beliebige Auslenkung y berechnet werden. Um nun den
Bewegungsverlauf der Masse beschreiben zu können, muss die verstrichene Zeit t
in die Gleichung integriert werden. Da keine äußeren Kräfte auf das Feder–MasseSystem wirken, ist die Auslenkung der Masse nur von der Zeit selbst abhängig und
es gilt y = y  t. Gemäß dem 2. NEWTONschen Gesetz ist F = m⋅a. Daraus ergibt sich
für das Feder–Masse-System:
F =−
E⋅y t 
d 2 y t 
, F  = m⋅
l
dt 2
⇒ m⋅
d 2 y t  E⋅y t 

= 0
l
dt 2
Die resultierende Gleichung ist eine homogene lineare Differentialgleichung
2. Ordnung. Sie enthält die unabhängige Variable t, die davon abhängige Variable y
und die Parameter m, E und l, die die physikalischen Eigenschaften des Systems
beschreiben. Zur Lösung der Differentialgleichung muss eine Funktion gefunden
werden, deren zweite Ableitung negativ proportional zu sich selbst ist. Die Sinusund Cosinusfunktionen haben diese Eigenschaft. Eine allgemeine Lösung ist daher
[www05]
y t  = a⋅sin  t   b⋅cos t = y ⋅sin  t, mit  =

E
und y  =  a 2 b 2
l⋅m
Um die Konstanten y  und  zu bestimmen, muss eine Anfangswertaufgabe
gelöst werden. Typische Anfangswerte sind die initiale Auslenkung y 0 und die
initiale Geschwindigkeit ẏ 0. Zusammen mit den physikalischen Eigenschaften in
 wird dadurch der Bewegungsverlauf der an der Feder hängenden Masse
schließlich vollständig beschrieben.
Offensichtlich bewegt sich die Masse des analysierten Feder–Masse-Systems
gemäß einer harmonischen Schwingung.
Seite 13
Grundlagen
2
2.3.3 Feder–Masse-System mit Dämpfer
Das vorangehende Feder–Masse-System bewegt sich – einmal aus der Ruhelage
gebracht – ewig weiter. Dieses Verhalten ist unrealistisch, weil Deformations- und
Reibungskräfte einem realen System Energie entziehen und es somit nach einer
bestimmten Zeit zum Stillstand bringen. Um dieses Verhalten nachzubilden,
erweitert man das Feder–Masse-System um einen Dämpfer. Dieser abstrahiert alle
Kräfte, die dem System Energie entziehen. [Edw01]
v
FD
Abbildung 2.8: Feder–Masse–Dämpfer-System
Aus Versuchen geht hervor, dass Reibungs- und Deformationskräfte an einer
Masse annähernd proportional zur Geschwindigkeit sowie dieser entgegengesetzt
sind. Ein entsprechender Dämpfer kann also, in Abhängigkeit von der
Geschwindigkeit zum Zeitpunkt t, definiert werden als
dy t 
F D = −R⋅
dt
Die Konstante R nennt man den Dämpfungsfaktor. Für das um den Dämpfer
erweiterte System ergibt sich für die senkrecht nach unten wirkende Gesamtkraft
F  der Zusammenhang F  = F G − F 'S − F D. Bei analoger Anwendung des 2.
NEWTONschen Gesetzes entsteht wieder eine Differentialgleichung:
m⋅
d 2 y t 
dy t  E⋅y t
 R⋅

= 0
2
dt
l
dt
Auch hierbei handelt es sich um eine homogene lineare Differentialgleichung
2. Ordnung. Um eine Lösung anzugeben, muss berücksichtigt werden, dass im
Seite 14
Grundlagen
2
Gegensatz zur Gleichung ohne Dämpfer hier auch die erste Ableitung vorhanden
ist. Da aber alle Koeffizienten konstant sind, lässt sich eine Lösung mit Hilfe der
charakteristischen Gleichung konstruieren. Der Ansatz y t = e⋅t führt zu [MW99]
2 m   R 
E
= 0,
l
also einer linearen Gleichung 2. Grades. Welcher Art die Lösung dieser Gleichung
ist, lässt sich anhand ihrer Diskriminanten ermitteln:
• (I): R 2 − 4 m
E
 0
l
Die charakteristische Gleichung hat zwei verschiedene reellwertige
Lösungen. Eine allgemeine Lösung der Differentialgleichung ist
1
2
y  t = c1 e ⋅t  c 2 e ⋅t , mit 1, 2 =
• (II): R 2 − 4 m
−R± R − 4 m⋅E / l
2m
2
E
= 0
l
Die charakteristische Gleichung hat eine doppelte reellwertige
Lösung. Eine allgemeine Lösung der Differentialgleichung ist
y  t = c1 e
1⋅t
• (III): R 2 − 4 m
 ⋅t
 c 2 t e , mit 1 =−
1
R
2m
E
 0
l
Die charakteristische Gleichung hat zwei komplexwertige Lösungen.
Eine allgemeine Lösung der Differentialgleichung ist
y  t = e
R⋅t
und  R =
 c 1 sin  I⋅t  c 2 cos  I⋅t , mit 1 =  R I i,  2 =  R − I i

R
E
,  I = R2 − 4 m
2m
l
Zur Bestimmung von c1 und c 2 müssen wiederum zwei Anfangswerte angegeben
werden.
Seite 15
Grundlagen
2
Die Art der Lösung hängt also von den physikalischen Konstanten ab. So
verwundert es nicht, dass ein im Verhältnis zu Masse und Federeigenschaften
schwach gedämpftes System (R 2  4 m E /l) oszilliert. Betrachtet man die allgemeine
Lösung der Differentialgleichung, so besteht diese im Kern aus einer harmonischen
Schwingungskomponente, die von einer stetig fallenden Exponentialfunktion
gedämpft wird.
Seite 16
Grundlagen
2
2.4 Anwendungen
2.4.1 Feder–Masse–Dämpfer-Systeme in der Elektrotechnik
Es besteht ein direkter Zusammenhang zwischen Feder–Masse–DämpferSystemen und Schwingkreisen. [Vog99] Ein Schwingkreis besteht aus einem
idealen Kondensator mit Kapazität Q, einer Spule mit Induktivität L und einem
Widerstand R. Wenn der Schwingkreis keine Spannungsquelle enthält, muss nach
dem 2. KIRCHHOFFschen Gesetz die Summe der Spannungsabfälle über allen
Schaltelementen Null ergeben.
R
u t 
C
L
Abbildung 2.9: Schwingkreis
Hat der Kondensator die Ladung q t und fließt im Schwingkreis der Strom i t ,
dann ist die Summe der Spannungsabfälle [Edw01]
di  t 
q  t
L⋅
 R⋅i t 
= 0
dt
C
Diese Differentialgleichung hat zwei abhängige Variablen: i t  und q t. Der
Stromfluss und die Ladung des Kondensators sind aber voneinander abhängig:
t
q t = ∫ i dt, also ist i t  =
0
dq t 
di  t d 2 qt 
=
und
dt
dt
dt 2
Diese Beziehung berücksichtigt, ergibt sich für obige Differentialgleichung
d 2 q t 
d q t q t 
L⋅
 R⋅

= 0
2
dt
C
dt
In dieser Form wird die Verbindung zu Feder–Masse–Dämpfer-Systemen
offensichtlich: Die Differentialgleichungen beider Systeme haben denselben Aufbau
und die mechanischen Größen lassen sich in elektrotechnische übersetzen. [Vog99]
So entsprechen sich Induktivität und Masse, Widerstand und Dämpfungsfaktor
Seite 17
Grundlagen
2
sowie Kapazität und der Kehrwert aus der Federkonstanten. Zudem entspricht die
aktuelle Ladung des Kondensators der Auslenkung der Masse.
Durch diesen Zusammenhang kann ein Feder–Masse–Dämpfer-System durch
einen analogen Schaltkreis simuliert werden. Zudem können die Ergebnisse aus der
Analyse der Feder–Masse–Dämpfer-Systeme auf Schwingkeise übertragen werden.
Aus der Kreisfrequenz  eines ungedämpften Systems ergibt sich so z. B. die
Schwingungsdauer eines Schwingkreises ohne Widerstand (THOMSON-Gleichung):
=

2
D
, T=
m

⇒
T = 2   LC
2.4.2 Muskeldeformation mit Feder–Masse-Systemen
NEDEL und THALMANN haben in [NT98] eine Methode zur Echtzeit-Deformation
von Muskeln mit Feder–Masse-Systemen vorgestellt. Sie repräsentieren einen
Muskel durch eine Wirkungslinie und ein daran gekoppeltes polygonales
Geometriemodell, das die Oberfläche des simulierten Muskels darstellt. Ziel der
Autoren war es, bei gestauchtem Muskel eine Verdickung desselben zu erhalten.
Dazu werden äußere Bewegungen, etwa die eines Skelettes, auf die
Wirkungslinie übertragen. Ihre Endpunkte können z. B. mit den Knochen eines
Gelenkes verbunden werden; Bewegungen im Skelettmodell stauchen oder dehnen
dann die Wirkungslinie.
Das Geometriemodell ist wiederum an die Wirkungslinie gekoppelt; einzelne
Vertices werden dazu mit einem hierfür von den Autoren entwickelten Editor an
die Linie gebunden. Eine Transformation oder Deformation der Wirkungslinie
wirkt sich dann in entsprechender Weise auch auf diese Vertices aus. Die Position
der restlichen Vertices soll berechnet werden. Hierfür wird jede Vertex des
Geometriemodells als Massepartikel aufgefasst. Weiterhin wird jede horizontal und
jede vertikal zur Wirkungslinie verlaufende Edge als Feder interpretiert. Das
Geometriemodell ist somit ein komplexes Feder–Masse-System.
Seite 18
Grundlagen
2
Abbildung 2.10: Geometriemodell mit Feder–Masse-System
Damit die Edges des Geometriemodells als horizontal und vertikal erkannt
werden können, kann kein beliebiges Muskelmodell verwendet werden. Vielmehr
muss eine Muskelgeometrie, die etwa aus medizinischen Abtastverfahren oder
einer Rekonstruktion am Computer entstanden sein kann, zunächst algorithmisch
in ein Modell mit einem regelmäßigem Gitter überführt werden.
Durch vertikale und horizontale Federn allein kann aber noch keine Verdickung
des Muskels erreicht werden. Wird die Wirkungslinie gestaucht, schieben sich die
nicht an sie gekoppelten Vertices unkontrolliert zusammen, was stellenweise auch
zu einer Verjüngung des Muskels führen kann. Um eine nach außen gerichtete
Wölbung zu erhalten, wurde das Feder–Masse-System von den Autoren um
Wirkungslinie
zusätzliche Querfedern erweitert.
Abbildung 2.11: Querfedern. Links schematisch, rechts Frontal- und Draufsicht
Die Querfedern verlaufen ebenfalls horizontal und vertikal. Sind drei
benachbarte Punkte durch horizontale oder vertikale Edges verbunden, wird eine
Querfeder zwischen dem mittleren Punkt und der Mitte der Verbindungslinie der
äußeren Punkte eingefügt. Bewegt sich nun der mittlere Punkt während einer
Deformation in Richtung des Muskelinneren, wird er von seinen horizontalen und
vertikalen Querfedern zunehmend nach außen gedrückt.
Seite 19
Grundlagen
2
Durch die Querfedern wird der gewünschte Effekt der Muskelverdickung
erreicht. Diese Vorgehensweise hält allerdings das Volumen des Muskels nicht
konstant. Vielmehr müssen für die Federn realistisch anmutende Werte auf
empirische Weise ermittelt werden.
Die Simulation des Feder–Masse-Systems wird mit einem System von
Differentialgleichungen durchgeführt. Es wird dabei jeder Vertex, also jedem
Massepartikel des Muskels, eine Gleichung ähnlich der in Kapitel 2.3.3 (Feder–
Masse-System mit Dämpfer) beschriebenen zugewiesen:
mi⋅
d 2 y i t 
dt
2
 Ri⋅
dyi t 
 f r  y i t  = f e i ,t 
dt
Es ist yi t  die Position der i-ten Vertex zum Zeitpunkt t und f r die resultierende
Gesamtkraft aller auf diese Vertex wirkenden Federn. Durch die Inhomogene f e
können externe Kräfte eingebracht werden.
Zur näherungsweisen Lösung des Differentialgleichungssystem wird von den
Autoren das klassische RUNGE–KUTTA-Verfahren angewendet. Sie simulierten einen
Muskel mit 82 Massepartikeln auf einer SGI Impact Workstation mit MIPS R10000
Prozessor und erreichten dabei eine Berechnungsgeschwindigkeit von 16 Bildern
pro Sekunde.
Abbildung 2.12: Deformierbarer Muskel (aus: [NT98])
Seite 20
Grundlagen
2
2.4.3 Wasseroberfläche und Stoff mit Feder–Masse-Systemen
Einen ähnlichen Ansatz hat FOMITCHEV in [Fom00] beschrieben. Er benutzt ein
regelmäßiges 2D-Gitter, um in Echtzeit die Oberfläche von Wasser, Gummi und
Stoffen zu simulieren.
Jede Vertex des 2D-Gitters wird dabei wieder als Massepartikel aufgefasst. Sie ist
zudem mittels den über ihre Edges laufenden Federn mit ihren Nachbarvertices
verbunden. Im Unterschied zu [NT98] wird dabei jede Edge zwischen zwei Vertices
als Feder aufgefasst. Um Deformationen durch äußere Krafteinwirkung zu
berechnen, wird auf ein aufwendiges System von Differentialgleichungen
verzichtet. Stattdessen werden die Massepartikel durch einen entsprechenden
Algorithmus in diskreten Zeitabschnitten sequentiell simuliert. Dabei werden
anhand der Position einer Vertex die Kräfte berechnet, die durch die Federn zur
südlichen, süd-östlichen und östlichen Nachbarvertex entstehen. Nachdem alle
Vertices besucht wurden, sind wegen der Regelmäßigkeit des Gitters auch alle
Federkräfte auf dem Gitter berechnet worden.
F ext
C
FE
FS
F SE
S
E
SE
Abbildung 2.13: Federkräfte auf dem 2D-Gitter
Zur Berechnung der Kräfte wird anhand einer vorher gespeicherten Nullposition
der Vertex zunächst der Abstand zu den drei Nachbarvertices berechnet. Mit den
Federkonstanten und Abständen können dann die Kräfte F E, F SE und F S bestimmt
werden. Es ergibt sich für die Gesamtkraft:
F total = F ext  F E  F SE  F S
Ist die Berechnung der Federkräfte für alle Vertices abgeschlossen, werden ihre
neuen Positionen ermittelt. Dazu werden zunächst die neuen Geschwindigkeiten
der Vertices bestimmt:
Seite 21
Grundlagen
v neu = v alt 
2
F total
⋅ t
m
Damit ergeben sich die neuen Positionen der Vertices aus
sneu = salt  v neu⋅ t
Die Geschwindigkeitsvorteile gegenüber der Berechnung mit einem System von
Differenzialgleichungen sind offensichtlich. Allerdings wirkt sich die Auslenkung
einer Vertex zunächst auch immer nur auf die unmittelbaren Nachbarvertices aus,
und nicht wie bei einem realen Feder–Masse-System auf alle Massepunkte
gleichzeitig. Eine in das System eingebrachte Kraft benötigt also mehrere
Simulationsschritte, um sich über das System auszubreiten.
Abbildung 2.14: Eingebrachte Kraft zum Zeitpunkt t 0= t, t 1 =2⋅t und t 2=3⋅ t
Ein weiterer Nachteil ist die enge Bindung an das regelmäßige Gitter. Die
Methode ist daher nur bedingt zur Anwendung auf volumetrische Körper geeignet.
Zudem wird durch die Verwendung von Nullpositionen eine beliebige äußere
Verformung des Systems im 3D-Raum ausgeschlossen; es können nur solche
Deformationen angewendet werden, die ein Mitführen der Nullpositionen
ermöglichen.
Seite 22
3 Entwurf
Kapitel 3
Entwurf
In diesem Kapitel wird auf der Grundlage der zuvor vorgestellten Publikationen
ein Konzept zur Simulation eines Wasserballons entwickelt. Dazu werden in einer
Anforderungsanalyse zunächst die Ziele der Aufgabenstellung festgestellt.
Darauf aufbauend wird ein Geometriemodell zur Darstellung des Wasserballons
und dessen Anbindung an die Simulation beschrieben. Es folgt eine Einbettung der
simulierten physikalischen Kräfte. Zuletzt wird der bis dahin entwickelte Entwurf
um eine topologieerhaltende Datenstruktur erweitert und die Operation Face-Split
auf dieser Datenstruktur beschrieben.
Seite 23
Entwurf
3
3.1 Anforderungsanalyse
Die Aufgabenstellung zu dieser Diplomarbeit lautet wie folgt:
„Im Rahmen der Diplomarbeit soll eine State–of–the–Art-Analyse
über bereits vorhandene Techniken zur Belastungssimulation von
wassergefüllten Körpern erstellt werden. Aufbauend auf dieser Analyse
soll ein Verfahren vorgestellt werden, das die Körperhülle mit einem
Feder–Masse-System auf physikalischer Basis simuliert.
Ein weiterer Teil der Arbeit ist eine Implementierung des vorgestellten
Verfahrens in C/C++. Dabei soll eine interaktive dreidimensionale
Simulationsumgebung erzeugt werden, in der an einem wassergefüllten
Ballon Belastungstests durchgeführt werden können.“
Die Aufgabenstellung verlangt die Konzeption und Entwicklung einer
interaktiven Simulationsumgebung. Es ist daher besonders zu berücksichtigen, dass
eine gute Performance in Bezug auf die Bildwiederholungsrate erreicht wird, oder
anders formuliert, dass das zu entwickelnde Verfahren auch mit wenig Rechenzeit
gute Ergebnisse erzielt.
Die Interaktivität bezieht sich sinnvollerweise auf die Simulationsumgebung,
d.h. die dort vorhandenen Rahmenbedingungen wie die physikalischen Kräfte
sollten während dem Simulationsprozess beeinflussbar sein. Es sollte darüber
hinaus auch möglich sein, einen direkten Einfluss auf den Wasserballon und dessen
physikalische Eigenschaften nehmen zu können.
Eine besondere Rolle kommt der Wahl eines geeigneten Geometriemodells zu.
Eine Analyse der im vorherigen Kapitel vorgestellten Publikationen zeigt, dass ein
bestimmtes Geometriemodell die Durchführung der physikalischen Simulation mit
einem Feder–Masse–System erst möglich gemacht hat, damit aber gleichzeitig auch
Einschränkungen verbunden waren. Zudem ist davon auszugehen, dass die
modellspezifischen Eigenschaften einen vorerst nicht absehbaren Einfluss auf die
Seite 24
Entwurf
3
Simulation haben werden. Um diese Auswirkungen zu untersuchen und um
generell wenig Einschränkung in der Verwendung zu haben, sollte das Verfahren
also auf einem möglichst unspezifischen Geometriemodell beruhen.
An das verwendete Geometriemodell muss dann das Feder–Masse-System
gekoppelt werden. Hierzu wurde der Ansatz übernommen, die Vertices der
Geometrie als Massepunkte zu interpretieren, da in den vorgestellten Publikationen
damit gute Ergebnisse erzielt wurden.
Damit der Wasserballon unter der Zugkraft der elastischen Gummioberfläche
nicht in sich zusammenfällt, muss nach jeder Deformierung sein Innenvolumen
berechnet und mit einem Zielvolumen verglichen werden, um bei einer
Abweichung Gegenmaßnahmen einleiten zu können. Eine Methode ist hierbei die
Simulation des durch die Kompression des Wassers zunehmenden Innendrucks,
der mit einer Druckkraft auf die Innenseite der Gummioberfläche wirkt und
dadurch die Volumendifferenz wieder ausgleicht.
Um Belastungstests an dem Wasserballon durchführen zu können, kann dieser
mittels einer Gravitationskraft in eine Fallbewegung versetzt werden. Bei der
Kollision mit einer Begrenzungsgeometrie können dann die Verformungen der
Gummioberfläche beobachtet werden. Zudem geben die bei der Kollision
aufgezeichneten Messwerte von maximal wirksamen Kräften oder maximaler
Oberflächendehnung Aufschluss darüber, ob der Ballon den Aufprall überstanden
hätte.
Nicht zuletzt gelten für die Umsetzung der Aufgabenstellung natürlich auch
allgemeine Vorgehensweisen, wie sie im Sinne der Informatik angewendet werden.
Dies betrifft eine objektorientierte Programmstruktur genauso, wie eine effiziente
und korrekte Implementierung. Dadurch wird sichergestellt, dass der entwickelte
Programmcode bei zukünftigen Anpassungen wiederverwertet werden kann, etwa
wenn weitere physikalische Kräfte eingebunden werden sollen. Es ist zudem
wünschenswert, wenn der Programmcode mit geringem Aufwand auf andere
Rechnerarchitekturen bzw. Betriebssysteme portiert werden kann.
Seite 25
Entwurf
3
3.2 Die verwendeten Geometriemodelle
Eine geeignete Geometrierepräsentation zu wählen, gehört zu den ersten und
wichtigsten Schritten bei der Bearbeitung der Aufgabenstellung. Durch die
Geometrie muss visuell das umgesetzt werden, was die physikalische Simulation zu
Tage fördert. Die Simulation kann sich also immer nur in den Grenzen bewegen, in
denen ihr Effekt an der Geometrie beobachtbar ist. Wenn die Simulation dazu noch
eng mit den Geometriedaten verknüpft ist, können nachträgliche Änderungen in
der Geometrierepräsentation die Ergebnisse der Simulation beeinträchtigen.
Eventuell muss die Simulation dann angepasst oder schlimmstenfalls grundlegend
neu konzipiert werden.
In Hinblick auf die Anforderungsanalyse und die vorgestellten Publikationen
wurde eine polygonale Geometriedarstellung verwendet. Neben der Unterstützung
aktueller Grafikhardware bietet sich mir ihr die Möglichkeit, die Verformungen auf
der Gummioberfläche des Wasserballons anzunähern.
Da die Minimalfläche des Wasserballons nach Kapitel 2.1.2 (Geometrische
Körper aus der Mathematik) eine regelmäßige Kugel ist, werden für die Simulation
als polygonale Näherung die in selbigem Kapitel beschriebenen UV-Spheren und
Ikosaeder bzw. daraus abgeleitete geodätische Kugeln verwendet.
Die einzige weitere Anforderung an das Geometriemodell ist neben der
Polygondarstellung, dass durch es ein geschlossener Polyeder mit Seitenflächen in
Form von Dreiecken beschrieben wird, d.h. die Dreiecke zerlegen genau die
Oberfläche des Polyeders und es kommt nicht zu Überlappungen oder
überstehenden Flächenstücken. Diese Eigenschaft wird später zur Berechnung des
Innenvolumens benötigt und von den verwendeten Geometriemodellen bereits
erfüllt.
Es soll im Folgenden davon ausgegangen werden, dass das im jeweiligen
Kontext verwendete Geometriemodell aus der Vertexmenge V und der Edgemenge
E besteht.
Seite 26
Entwurf
3
3.3 Einbettung der physikalischen Simulation
3.3.1 Anbindung an das Geometriemodell
Die Simulation beschränkt sich auf die Gummioberfläche des Wasserballons,
denn es besteht wenig Aussicht darauf, das komplexe Verhalten des Wassers im
Inneren im Rahmen einer Echtzeit-Anwendung erfassen zu können. Damit das
Wasser dennoch in der Simulation berücksichtigt werden kann, wird seine Masse
auf die Vertices der Geometrie verteilt und diese als Massepartikel interpretiert.
Abbildung 3.1: Masseverteilung auf die Vertices
Dazu ordnet eine Funktion m:V ℝ jeder Vertex v i ∈ V die Masse mvi  zu. Da
die Vertices bei den verwendeten Geometriemodellen annähernd gleichmäßig über
die Oberfläche verteilt sind, wird jeder Vertex der gleiche Masseanteil zugewiesen.
Es soll an dieser Stelle aber darauf hingewiesen werden, dass bei anderen
Geometriemodellen eine ungleichmäßige Verteilung durch eine andere Wahl von
m ausgeglichen werden kann. In jedem Fall gilt für die Gesamtmasse des Wassers
mW =
∑ m v 
i
vi ∈ V
mW lässt sich anhand des Ausgangsvolumens V 0 des Wasserballons und der
Dichte
von
Wasser
bestimmen,
wenn
die
Masse
der
Gummioberfläche
vernachlässigt wird. Es ist [Vog99]
mW = ϱ V 0  ⋅ p
Diese Gleichung gilt bei 20° Celsius Raumtemperatur, einem Druckunterschied von
 p gemessen an 1 atm Raumdruck und den entsprechenden Eigenschaften des
Wassers, also der Dichte ϱ = 0,998 g cm−3 und der Kompressibilität  = 5⋅10−5 Pa −1.
Seite 27
Entwurf
3
3.3.2 Simulation der auftretenden Kräfte
Welche Beschleunigung ein Körper unter Einwirkung einer Kraft erfährt, hängt
nach dem 2. NEWTONschen Gesetz von seiner Masse ab. Die auf den Wasserballon
wirkenden Kräfte müssen somit an seinen Massepartikeln, die durch seine Vertices
repräsentiert sind, ausgewertet werden.
3
Eine Kraft 
F i wird durch einen Vektor im ℝ dargestellt. Richtung und Länge
des Vektors entsprechen Richtung und Betrag der Kraft. Um die auf eine Vertex v j
wirkende Gesamtkraft zu bestimmen, muss nach dem 1. NEWTONschen Gesetz die
Summe aller Einzelkräfte ermittelt werden:

Fv =
j
F
∑
i
∣
F i wirkt auf v j
i
Um die Wirkung der so ermittelten Kraft auf das Massepartikel in Abhängigkeit
einer verstrichenen Zeit t zu bestimmen, kann wie in der in Kapitel 2.4.2
(Muskeldeformation mit Feder–Masse-Systemen) vorgestellten Publikation ein
System von Differentialgleichungen aufgestellt und eine Lösung angenähert
werden. Eine Berechnung auf diese Art ist im Sinne der Mechanik genau und auch
realistisch, wenn man von der Umverteilung der Wassermasse auf die
Massepartikel einmal absieht.
Diese Genauigkeit muss aber mit einem immensen Rechenaufwand bezahlt
werden. Zudem lassen sich die Differentialgleichungen nur schlecht um weitere
physikalische Einflüsse erweitern. Solche müssen entweder als externe Kraft in die
Gleichung eingebracht oder durch eine Erweiterung des Feder–Masse-Systems
beschrieben werden, was die Komplexität der Differentialgleichungen und damit
den Rechenaufwand für eine Näherungslösung noch weiter erhöht.
Es wurde daher eine schnellere, wenn auch ungenauere Simulationsmethode
entwickelt, die auf der in Kapitel 2.4.3 (Wasseroberfläche und Stoff mit Feder–
Masse-Systemen) vorgestellten Arbeit basiert. Dabei wird jeweils zwischen zwei
Zeitintervallen ein Simulationsschritt durchgeführt, der in zwei Phasen die
Bewegung der Massepartikel und damit die Deformierung des Wasserballons für
das jeweils verstrichene Zeitintervall berechnet.
Seite 28
Entwurf
3
In der ersten Phase werden alle physikalischen Kräfte ermittelt, die auf ein
Massepartikel wirken. Dies geschieht durch eine Analyse der Ballongeometrie und
deren Interaktion mit der Simulationsumgebung. Da die Positionen der
Massepartikel in dieser Phase noch nicht verändert werden, können sie sequentiell
und in einer beliebigen Reihenfolge betrachtet werden. Anhand der auftretenden
Einzelkräfte kann abschließend für die erste Phase für jedes Massepartikel eine
entsprechende Gesamtkraft ermittelt werden.
Anhand der sich daraus ergebenden Beschleunigung wird in der zweiten Phase
eine Positionsänderung für jedes Massepartikel berechnet. Die Beschleunigung wird
dabei so interpretiert, als wäre sie innerhalb des letzten Zeitfensters konstant
gewesen. Dies ist eine Vereinfachung gegenüber einem realen System, in dem
bereits infinitissimal kleine Positionsänderungen die Kraft und damit die
resultierende Beschleunigung an einem Masseteilchen beeinflussen. Die zu
erwartende Berechnungsungenauigkeit nimmt mit der Dauer der Zeitintervalle ab,
denn geht diese gegen Null, so entspricht die Art der Berechnung einer
Differenzierung nach der Zeit.
Zur Berechnung der Positionsveränderung wird ein Massepartikel zunächst nur
in einem lokalen Kontext gesehen, d.h. innerhalb des jeweils letzten Zeitintervalls
und ohne den vorherigen Verlauf der Simulation. In dem lokalen Kontext ist ein
Massepartikel daher zunächst in einer Ruhelage. Wirkt während des Zeitintervalls
 t dann die ermittelte Beschleunigung 
a konstant auf das Massepartikel, so ändert
es bis zum Ende des Zeitintervalls seine Position um [FD97]

sl =
1
⋅a t 2
2
Anschließend wird der globale Kontext des Massepartikels betrachtet. Hatte das
Massepartikel beim Betreten des Zeitintervalls die Geschwindigkeit v , so wird es
gemäß dem 1. NEWTONschen Gesetz unabhängig von der lokalen Positionsänderung
bestrebt sein, die Strecke

sg = v  t
zurückzulegen. Damit ergibt sich die neue Position des Massepartikels beim
Verlassen des Zeitintervalls durch
Seite 29
Entwurf
3
 s =  
sl   
sg
Anhand der Positionsänderung wird abschließend für die zweite Phase die neue
globale Geschwindigkeit des Massepartikels berechnet.
a = const.
v

sg
v
 s

sl
t
Abbildung 3.2: Globale und lokale Positionsänderung im Zeitfenster
In der zweiten Phase des Simulationsschrittes kann ebenfalls eine beliebige
Reihenfolge der Massepartikel gewählt werden, da alle wirkenden Kräfte in der
ersten Phase bereits ermittelt wurden und die Verschiebung eines Massepartikels
die auf die anderen Partikel wirkenden Kräfte nicht mehr beeinflusst.
Die Einteilung der Zeitintervalle ist an sich beliebig, jedoch sollte die Dauer eines
Zeitintervalls aufgrund der besseren Berechnungsgenauigkeit möglichst klein sein.
Je nach Art der Anwendung kann die Einteilung dynamisch erfolgen. Für eine
interaktive Simulation bietet es sich z. B. an, die Zeitintervalle an die aktuelle
Bildwiederholungsrate anzupassen. Falls die Bildfrequenz des Anzeigegerätes
limitiert ist und zwischen zwei generierten Bildern noch Rechenzeit zur Verfügung
steht, können auch mehrere Simulationsschritte pro dargestelltem Bild ausgeführt
werden. Es sind zwar immer nur die Auswirkungen des jeweils letzten
Simulationsschrittes zu sehen, die kleineren Zeitintervalle erhöhen aber die
erwartete Berechnungsgenauigkeit.
Bei einer dynamischen Wahl der Zeitintervalle kann der Bewegungsablauf einer
vorherigen Simulation allerdings nicht mehr exakt reproduziert werden: Eine
Rundung oder eine veränderte Berechnungsgenauigkeit aufgrund einer kleinen
Abweichung in der Dauer eines Zeitintervalls kann zum sprichwörtlichen „Zünglein
an der Waage“ werden und den Bewegungsablauf nachhaltig beeinflussen. Dieses
Verhalten entspricht gewissermaßen einem realen System, das sich zwar innerhalb
seiner physikalischen Grenzen bewegt, aber doch nie die exakt gleiche Bewegung
Seite 30
Entwurf
3
ausführt. Soll aber z. B. für eine Skriptsequenz ein Bewegungsablauf exakt
wiederholt werden, so müssen Zeitintervalle mit konstanter Dauer gewählt werden.
Die Simulation wird dadurch von der Echtzeit entkoppelt und muss gegebenenfalls
mit anderen Methoden wieder synchronisiert werden. Durch die Entkopplung von
der Echtzeit kann ein Simulationsverlauf auch in Zeitlupe bzw. Zeitraffer dargestellt
werden.
Um Belastungstests an dem Wasserballon vorzunehmen, können in jedem
Simulationsschritt Maximalwerte für die wirkende Gesamtkraft und die Dehnung
der Oberfläche mitgeführt werden. Es kann dann beispielsweise für vorher
definierte Schwellenwerte ermittelt werden, wann die Gummioberfläche des
Ballons bei einem Aufprall zerreißen würde.
3.3.3 Reaktion mit der Simulationsumgebung
Nach der zweiten Phase eines Simulationsschrittes werden die Positionen der
Massepartikel entsprechend der ermittelten Beschleunigung und Geschwindigkeit
aktualisiert. Dabei wird zunächst keine Rücksicht auf die Geometrie der
Simulationsumgebung genommen. Es kann daher vorkommen, dass einzelne
Massepartikel diese Geometrie durchdringen. Dieser Effekt kann in einem realen
System
nicht
vorkommen,
weshalb
nach
jedem
Simulationsschritt
eine
Kollisionserkennung durchgeführt werden muss, bei der die falsch platzierten
Massepartikel erkannt und korrigiert werden.
Im Rahmen dieser Arbeit wird lediglich ein Quader als Begrenzungsgeometrie
verwendet, dessen Seitenflächen parallel zu den jeweils von zwei Achsen des
Koordinatensystems aufgespannten Ebenen sind. Die Kollisionserkennung gestaltet
sich dadurch sehr einfach, denn es muss nur überprüft werden, ob eine der
Koordinaten einer Vertex die Begrenzung durch den Quader überschritten hat. Es
existieren jedoch auch Methoden, um die Kollision mit einer beliebigen
Szenengeometrie zu erkennen. [MH99]
Wurde die Kollision eines Massepartikels mit der Szenengeometrie erkannt, wird
der Punkt bestimmt, in dem das Massepartikel die Szenengeometrie durchdrungen
Seite 31
Entwurf
3
hat. Dazu wird eine Gerade durch die aktuelle und die vorherige Position des
Massepartikels gebildet und ihr Schnittpunkt mit der Szenengeometrie berechnet.
Das Massepartikel wird auf diesen Schnittpunkt zurückgesetzt und seine neue
globale Geschwindigkeit für den nächsten Simulationsschritt entsprechend
angepasst.
Abbildung 3.3: Kollision von Massepartikeln mit der Umgebungsgeometrie
Seite 32
Entwurf
3
3.4 Die physikalischen Kräfte
3.4.1 Notation der Kräfte
In der ersten Phase eines Simulationsschrittes wird für jedes Massepartikel die
Krafteinwirkung ermittelt. Dazu müssen pro Massepartikel alle auf es wirkenden
Einzelkräfte bestimmt werden. Dies geschieht je nach der Art der Kraft auf
unterschiedliche Weise.
Um Aussagen über die Menge aller Massepartikel einfach formulieren zu
können, wird bei der Beschreibung der verschiedenen physikalischen Kräfte eine
funktionale Schreibweise benutzt, wie sie schon bei der Verteilung der
Wassermasse angewendet wurde. Sinngemäß wird diese Art der Notation auch auf
andere physikalischen Größen übertragen. Mit v  v i  ist z. B. die Geschwindigkeit
der Vertex v i zum Zeitpunkt des jeweiligen Simulationsschrittes gemeint.
3.4.2 Gravitation
Die Gravitationskraft f G : V  ℝ3 ist die einfachste der Kräfte, die in die
Simulation integriert wurden. Sie wirkt auf jedes Massepartikel mit dem gleichen
Betrag und stets senkrecht nach unten. Sie kann durch die Gravitationskonstante
g = 9,80665m s−2 und der einer Vertex zugewiesenen Masse bestimmt werden:

0
f G v i  = −1 ⋅mvi  g
0
3.4.3 Dämpfung
Ein Dämpfer soll in der Simulation alle Einflüsse zusammenfassen, die dem
Wasserballon in einem offenen System Energie entziehen. Das sind etwa
Reibungskräfte oder die Wärmeentwicklung bei einer Deformation. Nach [Edw01]
Seite 33
Entwurf
3
können diese Einflüsse durch eine Kraft angenähert werden, die proportional zu
der Geschwindigkeit und dieser entgegengesetzt ist. Die auf eine Vertex v i wirkende
Dämpfungskraft f R :V ℝ3 kann somit durch
m  vi  v  v i 
f R  v i  = − R⋅
t
bestimmt werden, wobei R der Dämpfungsfaktor ist.
Für die Simulation wird noch eine weitere Art der Dämpfung eingesetzt, die
nicht linear zu der Geschwindigkeit ist, sondern durch die ein Maximalbetrag
v max  k für die Geschwindigkeit eines Massepartikels vorgegeben wird. Diese Art
der Dämpfung ist nicht physikalisch motiviert, hat sich aber bei der Umsetzung als
hilfreich erwiesen, ein zur Oszillation neigendes System zu stabilisieren.
Die Dämpfung wird dabei während der zweiten Phase eines Simulationsschrittes
angewendet. In dieser wird eine neue globale Geschwindigkeit zu jedem
Massepartikel berechnet, anhand derer seine neue Position bestimmt werden soll.
Vor der Verschiebung des Partikels wird auf die neue Geschwindigkeit die
Dämpfungsfunktion f m : ℝ 3 ℝ3 angewendet:
f m v vi  =
{
v vi 
v
n v v i ⋅v max − e
max
−v v i − k

∣
∣v v i∣ ≤ vmax −k
∣v v i∣  vmax −k
f m v vi 
v max
k{
v max − k
v v i 
Abbildung 3.4: Die Dämpfungsfunktion f m
Solange der Betrag der Geschwindigkeit den Wert v max − k nicht überschreitet,
bleibt die Geschwindigkeit unverändert. Ist ihr Betrag jedoch höher, wird die
Geschwindigkeit verringert. Dazu wird der normierte Geschwindigkeitsvektor
Seite 34
Entwurf
n  v  v i  mit dem Term v max − e v
max
−v  vi −k
3
multipliziert; der Betrag der Geschwindigkeit
entspricht dann eben diesem Term, die Richtung bleibt unverändert.
Die Eigenschaften dieses Terms können durch die etwas allgemeinere Funktion
g x = x 0 − e x − x− k beschrieben werden. Es ist zunächst ersichtlich, dass der
0
Wertebereich von g für alle Eingaben x  0 durch die obere Schranke x 0 begrenzt
ist, denn es ist
lim g x = lim x 0 − e x − x−k = x 0
0
x ∞
x ∞
Die Funktion f m drosselt also den Betrag einer Geschwindigkeit auf den
festgelegten Maximalwert, denn der durch g beschriebene Term wird auf alle
Geschwindigkeiten mit einem Betrag ∣v v i ∣  v max−k  0 angewendet. Zudem ist
der Übergang an den Funktionsdefinitionen stetig, denn es ist
g x0 −k  = x 0 − e x − x − k − k = x 0 − k
0
0
und
g ' x  = e x − x− k
0
⇒
g '  x0 −k  = e x − x −k − k = e 0 = 1
0
0
Durch diese Art der Dämpfung wird erreicht, dass auch zwischen zwei
Geschwindigkeiten oberhalb des Maximalwertes noch unterschieden werden kann:
Die größere der beiden Geschwindigkeiten wird nach der Drosselung immer noch
größer sein, wenn auch bei zunehmender Überschreitung mit immer kleinerer
Differenz. Die Konstante k kann in Abhängigkeit des gewünschten Maximalwertes
für die Geschwindigkeit gewählt werden. Durch k = vmax / 3 werden beispielsweise
alle Geschwindigkeiten gedrosselt, die sich im oberen Drittel des Maximalwertes
oder darüber befinden.
3.4.4 Oberflächenspannung
Die elastische Zugkraft der Gummioberfläche des Wasserballons wird, wie von
der Aufgabenstellung vorgesehen, durch ein Feder–Masse-System umgesetzt. Dabei
Seite 35
Entwurf
3
dienen sinnvollerweise die Edges zwischen den Vertices als Verbindungsfedern. Um
möglichst unabhängig von einer bestimmten Strukturierung des verwendeten
Geometriemodells zu bleiben, wird dabei jede Edge als Feder aufgefasst.
Eine Feder zwischen zwei beweglichen Massepartikeln zieht diese gleichzeitig
aufeinander zu. Im Rahmen des Simulationsschrittes wird aber zu jedem Zeitpunkt
nur ein einzelnes Massepartikel betrachtet. Um die auf beide Partikel entstehenden
Kräfte unabhängig voneinander bestimmen zu können, wird die Feder zwischen
ihnen als eine doppelte Feder aufgefasst. Jeweils eines der beiden Massepartikel
dient dabei als Ankerpunkt für die Kraftübertragung auf das andere.
Abbildung 3.5: Geometriemodell mit Doppelfedern
Eine Vertex erfährt also durch jede ihrer Nachbarvertices eine Zugkraft. Die
Gesamtkraft folgt aus der Summe der Einzelkräfte. Ist N  v i  die Menge aller
Nachbarvertices von v i und l :V ×V ℝ die initiale Federlänge, dann folgt aus
Kapitel 2.3.2 (Feder–Masse-Systeme):
f S v i  =
∑
v j ∈ N  vi 
E⋅v i − v j 
l vi , v j 
3.4.5 Innendruck
Die elastische Gummioberfläche des Wasserballons ist stets bestrebt, sich
zusammenzuziehen. Damit sein Volumen erhalten bleibt, muss der Innendruck
simuliert werden. Es wurden dafür zwei Methoden entwickelt.
Seite 36
Entwurf
3
Die erste Methode ist rein physikalisch motiviert. Zieht sich das Gummi des
Ballons zusammen, kommt es im Bereich der Oberfläche zu einer leichten
Kompression des Wassers und damit zu einer Verringerung des Ballonvolumens
um  V. Anhand der Kompressibilität von Wasser kann zu der Volumenabnahme
eine resultierende Drucksteigerung berechnet werden: [Vog99]
p = −
V
⋅V
Durch den Überdruck im Inneren entsteht eine Kraft auf die Oberfläche, die
Druckkraft. Diese greift auf der gesamten Oberfläche mit dem gleichen Betrag an
und wirkt senkrecht nach außen zu dieser. Auf ein Flächenstück F i wirkt also die
Kraft

FP =  p
n⋅
i A  F i ,
wobei 
n i Normaleneinheitsvektor an F i und A  F i  der Flächeninhalt von F i ist. Um
zu der Druckkraft eine Beschleunigung zu berechnen, wird die Kraft gleichmäßig
auf die umliegenden Massepartikel verteilt. Für das Flächenstück F i sind dies die
drei Vertices, die das Dreieck um F i aufspannen.
Die Gesamtkraft, die auf eine einzelne Vertex v j wirkt, ergibt sich somit aus der
Summe aller Kräfte, die sie durch in ihr zusammenlaufende Flächenstücke erhält:
f P v j  =
1
∑  p ni⋅A F i  ∣ v j ∈ F i
3
Die zweite Methode zur Erhaltung des Innenvolumens nutzt aus, dass Wasser
eine sehr geringe Kompressibilität hat. Es kann in der Größenordnung der Kräfte,
wie sie an einem Wasserballon entstehen, als inkompressibel angesehen werden.
Daraus folgt, dass das Volumen auch bei einer Deformation des Wasserballons
konstant bleiben muss. Kommt es durch das Zusammenziehen der Oberfläche oder
durch eine Kollision mit der Simulationsgeometrie zu einer Volumenabnahme, so
wird durch eine Schätzfunktion ein Korrekturfaktor ermittelt. Es werden
anschließend alle Vertices entlang ihrer Normalen um diesen Korrekturfaktor nach
Seite 37
Entwurf
3
außen verschoben – dies entspricht einer Bewegung, die durch einen Überdruck im
Inneren verursacht werden würde.
Es ist allerdings kaum möglich, eine gute Schätzfunktion auf deduktive Weise zu
erhalten, denn der Wasserballon kann sich in allen erdenklichen Lagen innerhalb
der Szenengeometrie befinden. Liegt er z. B. auf einer Ebene auf, so werden die
nach unten korrigierten Vertices bei der Kollisionserkennung umgehend wieder
zurückgesetzt. Eine Schätzfunktion, die für den fallenden Wasserballon einen guten
Korrekturwert ermitteln würde, kann das Volumen in einer solchen Situation nicht
aufrecht erhalten.
Es kann jedoch ausgenutzt werden, dass das Volumen einer Kugel in einem
kubischen Verhältnis zu ihrem Radius steht. Das Verschieben einer Vertex entlang
ihrer Normalen entspricht im Groben einer Verlängerung des Radi, weshalb die
Volumendifferenz auch in einem kubischen Verhältnis zu dem Korrekturfaktor
stehen sollte. Auf diese Weise kann zumindest ansatzweise ein angemessener
Korrekturfaktor ermittelt werden. Um die Volumendifferenz aber tatsächlich
auszugleichen, muss der Korrekturfaktor an die jeweilige Lage des Wasserballons
angeglichen werden. Dies geschieht durch eine zeitliche Adaption. In jedem
Simulationsschritt wird die Abweichung vom Zielvolumen sowie der daraufhin
ermittelte Korrekturfaktor abgespeichert. Im nächsten Simulationsschritt wird
überprüft, ob das Zielvolumen mit dem gespeicherten Korrekturfaktor erreicht
werden konnte. Falls nicht, muss der neue Korrekturfaktor entsprechend größer
gewählt werden.
Seite 38
Entwurf
3
3.5 Eine Topologische Datenstruktur
3.5.1 Aufbau
Bei der polygonalen Geometriedarstellung gehen üblicherweise Informationen
über die Topologie der Geometrie verloren, da zum Rendern nur die Topografie
benötigt wird. Diese kann schon mit einer Liste unzusammenhängender Faces
beschrieben werden. [ESW97] Für die Simulation werden jedoch topologische
Informationen zu den Vertices benötigt, da an die Geometrie diesbezüglich keine
speziellen Anforderungen, wie etwa eine bestimmte Grundstruktur oder Ordnung,
gestellt wurde. Die Topologie kann aus den Koordinaten der Vertices dynamisch
rekonstruiert werden; diese Vorgehensweise ist aber nicht zweckmäßig, da der
erforderliche Rechenaufwand den Einsatz in einer Echtzeit-Umgebung erschweren
würde.
Es wird also eine Datenstruktur benötigt, die die Topologie erhalten kann. Für
das Feder–Masse-System sind dabei die Nachbarschaftsbeziehungen der Vertices
wichtig: Zu jeder Vertex müssen alle über Edges erreichbaren Nachbarvertices
abgefragt werden können. Diese Abfrage sollte zudem schnell sein, da in jedem
Simulationsschritt für jede Vertex mindestens einmal alle Nachbarvertices ermittelt
werden müssen. Die Vertices können dabei von der Datenstruktur in einer
beliebigen Reihenfolge geliefert werden.
Die Datenstruktur sollte zudem in der Lage sein, eine dynamische Anzahl von
Elementen aufnehmen zu können, wie es etwa bei der Generierung geodätischer
Kugeln benötigt wird.
Die geforderten Laufzeiten und Eigenschaften lassen sofort an eine verkettete
Liste denken. Ihre Größe kann dynamisch an die Menge der Daten angepasst
werden und ein sequentielles Abfragen der Listenelemente läuft konstant in der
Anzahl der Elemente. Damit die Topologie berücksichtigt werden kann, wurde das
Konzept der verketteten Liste um Datenkapseln erweitert.
Eine Datenkapsel ist dabei nichts anderes als eine Art Zeiger auf das eigentliche
Datum, z. B. auf eine Vertex. Der Vorteil gegenüber einer normal verketteten Liste
besteht darin, dass die Daten selbst nicht Bestandteil der Listenstruktur sind.
Stattdessen wird für jedes einzufügende Element eine Datenkapsel erstellt, die auf
Seite 39
Entwurf
3
das entsprechende Datum verweist. Die Datenkapseln selbst werden untereinander
wie Elemente einer normalen Liste verkettet. Auf diese Weise kann ein Datum zur
gleichen Zeit aus mehreren Listen referenziert werden, ohne dass es vervielfältigt
werden müsste.
Abbildung 3.6: Verkettete Liste mit Datenkapseln
Für die Gesamtgeometrie des Wasserballons wird auf diese Weise eine Liste von
Datenkapseln angelegt, in der jede Vertex der Geometrie genau einmal referenziert
wird. Zudem wird für jede einzelne Vertex eine weitere Liste von Datenkapseln
angelegt, die alle Nachbarvertices enthält. Eine Vertex taucht also genau einmal in
der Liste für die Gesamtgeometrie auf und jeweils ein weiteres mal in der Liste
jeder ihrer Nachbarvertices.
Die geforderten Laufzeiten können von dieser Datenstruktur eingehalten
werden. Die Abfrage aller vorhandenen Vertices benötigt jeweils zwei Schritte pro
Vertex, wenn mit der ersten Datenkapsel der Liste begonnen und anschließend die
Liste sequentiell durchlaufen wird: das Abfragen der Datenkapsel aus der Liste und
ihre Auflösung zum Datum. Bei ∣V ∣ Vertices werden also insgesamt 2⋅∣V ∣ = O ∣V ∣
Schritte benötigt. Das Gleiche gilt für die Abfrage der Nachbarvertices.
3.5.2 Die Operation Face-Split
Bei der Erzeugung von geodätischen Kugeln aus einem Ikosaeder wird eine
Funktion zur Unterteilung der Faces benötigt. Um ein einzelnes Face zu
unterteilen, müssen lediglich neue Vertices in der Mitte aller zum Face gehörenden
Edges eingefügt werden. Diese bilden zusammen mit den schon vorhandenen
Seite 40
Entwurf
3
Vertices die Ausgangspunkte für die Unterteilung. Durch eine voneinander
unabhängige Teilung der Faces wird allerdings die Topologie der Geometrie
zerstört, da zwei benachbarte Faces auf ihrer Verbindungs-Edge je zwei separate
Vertices generieren:
Abbildung 3.7: Durch Face-unabhängige Unterteilung wird die Topologie zerstört
Bei einer Deformation der Oberfläche entstehen so Risse in der Geometrie, da die
Faces nicht mehr untereinander verbunden sind.
Um die Topologie zu erhalten, müssen die von einem Face eingefügten Vertices
an die umliegenden Faces übermittelt werden. Die umliegenden Faces können
leicht ermittelt werden, da die topologische Datenstruktur zu jeder Vertex eine
Referenz auf alle Faces enthält, von denen sie ein Teil ist. Auf diese Weise werden
bei der weiteren Unterteilung der Faces nur an solchen Edges neue Vertices
eingefügt, die an ein noch nicht unterteiltes Face grenzen. Die Topologie bleibt
dadurch erhalten.
Abbildung 3.8: Eine Übermittlung der eingefügten Vertices auf die umliegenden
Faces erhält die Topologie
Seite 41
4 Umsetzung
Kapitel 4
Umsetzung
In diesem Kapitel wird beschrieben, wie das zuvor konzipierte Verfahren
umgesetzt wurde.
Es wird zunächst kurz die Funktionsweise von Szenengraphen erläutert und der
bei der Implementierung verwendete Szenengraph OGRE vorgestellt. Anschließend
wird die bei der Umsetzung verwendete Objektstruktur dargestellt.
Danach werden zwei Nebeneffekte des Simulationsverfahrens beschrieben, die
bei der Implementierung an einer UV-Sphere aufgetreten sind. Zum Abschluss des
Kapitels werden Beispiele aus dem Quelltext der entwickelten C++ Anwendung
aufgeführt und erläutert.
Seite 42
Umsetzung
4
4.1 Der 3D-Szenengraph OGRE
Vor der Implementierung muss eine Methode festgelegt werden, mit der die
Simulation visuell umgesetzt wird, denn die weitere Implementierung wird diese
Methode als Grundlage zur Ausgabe der berechneten Daten verwenden. Neben der
Neuentwicklung einer Ausgabemechanik gibt es die Möglichkeit, auf eine
vorhandene Grafikbibliothek wie z. B. DirectX oder OpenGL zurückzugreifen.
Mittlerweile gibt es aber auch eine Vielzahl frei verfügbarer 3D-Szenengraphen.
Ein Szenengraph ist eine hierarchische Datenstruktur, mit der der logische und
räumliche Aufbau einer Szene beschrieben werden kann. Der Szenengraph enthält
dazu einen Wurzelknoten, der als Basis für die Anordnung der Szene verwendet
wird. An die Wurzel werden Kindknoten angefügt, die selbst wieder Wurzel eines
Teilgraphen sein können. An die Knoten des Szenengraphen werden auch die
Objekte der Szene eingefügt. Je nach Szenengraph können die Objekte dabei
Geometrien, Lichter oder Materialien repräsentieren.
Um eine hierarchische Modellierung zu ermöglichen, enthalten die Knoten des
Szenengraphen jeweils eine Transformationsmatrix, die auf alle Objekte des
Knotens selbst, aber auch auf alle Kindknoten angewendet wird. Dadurch werden
an einem Objekt alle Transformationen durchgeführt, die die Knoten auf dem Pfad
von seinem Vaterknoten bis zur Wurzel des Szenengraphens enthalten. So
bewegen sich z. B. die Teile einer zusammengesetzten Geometrie zu dieser mit,
wenn sie durch einen Teilgraphen beschrieben sind und die Wurzel des Teilgraphen
eine Transformation enthält.
BREINER hat in [Bre06] eine Studie über die Leistungsfähigkeit verschiedener
aktueller Sznenengraphen erstellt. Dabei hat sich der OpenSource-Szenengraph
OGRE als besonders vorteilhaft herauskristallisiert. (siehe auch [Bre04], [Sch06])
OGRE
(Object-oriented
Graphics
Rendering
Engine)
ist
ein
flexibler,
objektorientierter 3D-Szenengraph in C++, der speziell auf die Verwendung mit
hardwarebeschleunigter 3D-Grafik hin entwickelt wurde. Daher wurde für die
Implementierung eine Anbindung an OGRE als Methode zur visuellen Umsetzung
der Simulation gewählt.
Seite 43
Umsetzung
4
4.2 Objektstruktur
4.2.1 Allgemeiner Programmaufbau
Die bei der Umsetzung erstellten Objekte lassen sich grob in die drei Kategorien
Anbindung an Ogre, Geometrie und physikalische Kräfte einteilen. Die drei
Programmbereiche werden durch die zentrale Klasse Core verknüpft.
Force Base
{abstract}
Append(Force*):
ApplyForces() = 0
void
Og re ::Root
Force Gravity
Og re ::Re nde rWindow
Force Sping
Og re ::Came ra
Force Pre ssure
Og re ::Sce ne Mg r
Og re ::Frame Liste ne r
Frame Liste ne r
frameStarted(Ogre::FrameEvent&): bool
keyClicked(Ogre::KeyEvent*):
void
updateGUI():
void
Core
renderScene():
createScene():
destroyScene():
checkCollision(Ogre::Vector3*):
void
void
void
bool
Ge oBase
{abstract}
Abbildung 4.1: Anbindung an OGRE und Struktur der Basisobjekte
Die Klasse Core erstellt und verwaltet dabei die zentralen Objekte der anderen
Klassen. Zu Beginn werden die benötigten Klassen zum Betrieb von OGRE
instantiiert und initialisiert. Es wird dann mit der Klasse Ogre::SceneMgr die
Simulationsszene angelegt; dazu gehören die Geometrie sowie Beleuchtung,
Materialien und eine Instanz der Klasse Ogre::Camera, mit der Blickpunkt und
-richtung festgelegt werden.
Anschließend wird die Geometrie des Wasserballs generiert, was durch die
abstrakte Klasse GeoBase bzw. die daran gebundenen Erbklassen für die
verschiedenen implementierten Geometriemodelle veranlasst wird.
Seite 44
Umsetzung
4
Schließlich werden die verschiedenen physikalischen Kräfte initialisiert. Als
Schnittstelle dient hierzu die abstrakte Klasse ForceBase, die als Basisklasse für
alle Kräfte verwendet wird.
Die Klasse Core steuert zudem den Simulationsablauf. Sie besitzt dazu die
Funktion renderScene(), von der aus jeweils ein Simulationsschritt eingeleitet
wird. Die Funktion wird jeweils vor dem Rendervorgang für ein neues Einzelbild
aufgerufen. Hierbei ist ein Objekt der Klasse FrameListener das Bindeglied zum
Renderprozess von OGRE: Nachdem es registriert wurde, wird vor dem Rendern
jedes neuen Einzelbildes die Funktion frameStarted() aufgerufen. Die Klasse
FrameListener dient zudem der Abfrage von Tastatur- und Mausereignissen.
4.2.2 Geometriemodelle
Als Basisklasse für die Geometriemodelle wurde die Klasse GeoBase
implementiert. Durch sie wird in der Simulationsszene der Wasserballon dargestellt.
Sie enthält die Geometriedaten der Ballonoberfläche und alle sonstigen zum
Rendern benötigte Objekte, wie etwa verschiedene Materialien. Mit der Funktion
draw() aktualisiert die Klasse ihre Geometriedaten im Szenegraphen von OGRE.
Um eine möglichst hohe Geschwindigkeit zu erreichen, wird dazu – sofern
verfügbar – ein Bereich im Speicher der Grafikhardware alloziiert.
Darüber hinaus bietet GeoBase eine Schnittstelle für die physikalischen Kräfte.
Sie stellt ihnen einen Zugang zu den Vertices des Geometriemodells bereit, die den
Massepartikeln des Wasserballons entsprechen. Sie hält zudem Klassenvariablen
zur Erfassung der physikalischen Eigenschaften des Ballons wie etwa seine Masse,
Dichte oder Kompressibilität.
Seite 45
Umsetzung
4
Og re ::Simple Re nde rable
Ge oBase
{abstract}
mass:
float
volume:
float
area:
float
doPhysics():
void
calcVolume():
void
draw():
void
createGeometry() = 0
Ge oUVSphe re
radius:
rings:
segments:
int
int
int
createGeometry():
void
Ge oIcosahe dron
edgeLength:
int
Ve rte xGuard
Face Guard
createGeometry():
void
Ge oGe ode stic
subdivisions:
int
createGeometry():
void
Abbildung 4.2: Objektstruktur der Geometriemodelle
Auch bei der eigentlichen Simulation ist GeoBase beteiligt. Da alle
Geometriemodelle die benötigten Eigenschaften haben, kann die Funktion zur
Berechnung des aktuellen Volumens zentral untergebracht werden. Zudem wird in
der
Funktion
doPhysics()
die
zweite
Phase
des
Simulationsschrittes
durchgeführt, bei dem die auf die Massepartikel wirkende Gesamtkraft in eine
Bewegung umgesetzt wird.
Die von GeoBase abgeleiteten Klassen für die einzelnen Geometriemodelle
enthalten lediglich die modellspezifische Funktion createGeometry(), die die
gleichnamige virtuelle Funktion der Basisklasse ersetzt und ihrem Namen gerecht
wird, indem sie zu jedem Geometriemodell die entsprechenden Geometriedaten
erzeugt.
4.2.3 Datenstrukturen für Topologie und physikalische Kräfte
Damit die Topologie dauerhaft in der Datenstruktur für eine Geometrie
gespeichert werden kann, wird das Konzept aus Kapitel 3.5 (Eine Topologische
Seite 46
Umsetzung
Datenstruktur)
auf
eine
entsprechende
Klassenstruktur
übertragen.
4
Diese
Klassenstruktur wird anschließend für die zu haltenden Daten angepasst. Auf diese
Weise entstanden je ein Satz Klassen für Vertices und Faces. Die Klassen sind im
Kern gleich aufgebaut, weswegen hier stellvertretend die Klassen zur Verwaltung
der Vertices erläutert werden.
Ve rte xGuard
count:
int
root:
VertexCapsule*
Append(Vertex*):
void
getRoot():
VertexCapsule*
releaseData():
void
Ve rte xCapsule
next:
VertexCapsule*
data:
Vertex*
setData(Vertex*): void
getData():
Vertex*
getNext():
VertexCapsule*
.....
Ve rte xCapsule
next:
VertexCapsule*
data:
Vertex*
setData(Vertex*): void
getData():
Vertex*
getNext():
VertexCapsule*
Ve rte x
position:
normal:
totalForce:
velocity:
mBuddies:
mFaces:
Ve rte x
Ogre::Vector3
Ogre::Vector3
Ogre::Vector3
Ogre::Vector3
VertexGuard*
FaceGuard*
position:
normal:
totalForce:
velocity:
mBuddies:
mFaces:
Ogre::Vector3
Ogre::Vector3
Ogre::Vector3
Ogre::Vector3
VertexGuard*
FaceGuard*
Abbildung 4.3: Verkettete Liste mit Datenkapseln für Vertices
Durch
die
Klasse
VertexGuard
werden
die
Datenkapseln
in
einer
Listenstruktur organisiert. Es wurden hierfür entsprechende Funktionen zum
Einfügen und Entfernen von Datenkapseln implementiert, wie sie sich auch bei
normalen verketteten Listen finden. Die Klasse VertexCapsule bildet die
Datenkapsel für eine einzelne Vertex. Sie enthält einen Zeiger auf die nächste und
vorherige Datenkapsel sowie auf das gekapselte Datum, in diesem Falle ein Objekt
der Klasse Vertex.
Seite 47
Umsetzung
4
Die Klasse Vertex enthält schließlich alle Informationen, die zu einer
Repräsentation des Massepartikels nötig sind. Dies sind neben der Position und der
Einheitsnormalen auch die Geschwindigkeit und die Summe der Kräfte, die auf das
Massepartikel einwirken. Die Informationen über die Topologie der Vertex wird
durch eine weitere Instanz der Klasse VertexGuard sowie einer Instanz der Klasse
FaceGuard integriert, die das Pendant zur Verwaltung von Faces ist.
Wie das UML-Diagramm schon anzeigt, können Objekte der Klasse Vertex
auch unabhängig von einer Datenkapsel bestehen. Dies ist z. B. nötig, wenn bei der
Verfeinerung der geodätischen Kugel eine Seitenfläche aus der Geometrie entfernt
wird, um sie durch eine Unterteilung zu ersetzen: Die entsprechende Klasse Face
hält Datenkapseln auf alle Vertices, durch die ihre Edges beschrieben werden und
würde diese Vertices mit löschen, wenn sie selbst entfernt wird.
Da die Vertices aber unabhängig von den Datenkapseln verwaltet werden, ergibt
sich das Problem, dass bei der Terminierung der Simulation der von den Vertices
belegte Systemspeicher nicht wieder freigegeben wird. Daher enthält die Klasse
VertexGuard zusätzlich die Funktion release(), die alle von ihr verkapselten
Datenelemente löscht. Die Funktion wird bei der Terminierung sinnvollerweise von
dem Objekt aufgerufen, das die Vertexdaten auch generiert hat: einer Instanz der
Klasse GeoBase.
Etwas abweichend wurde die Datenstruktur für die physikalischen Kräfte
implementiert. Diese werden auch in einer Listenstruktur verwaltet, es ist jedoch
keine Kapselung der Daten nötig. Für jede auf ein Massepartikel wirkende Kraft
wird ein separates Objekt der Klasse Force erstellt, das die dem Massepartikel
entsprechende Vertex referenziert. Für eine physikalische Kraft, die auf alle
Massepartikel wirkt, werden also mehrere Objekte der Klasse Force instantiiert, je
ein Objekt pro Vertex. Wenn gleichzeitig verschiedene Kräfte auf ein Massepartikel
einwirken, wird die dem Massepartikel entsprechende Vertex von mehreren
Instanzen der Klasse Force referenziert.
Seite 48
Umsetzung
Force Base
{abstract}
mForces:
4
Force Gravity
init():
void
ApplyForces(): void
FaceGuard*
Append(Force*): void
ApplyForces() = 0
Force Guard
mForces:
FaceGuard*
ApplyForces():
Force
source:
Vertex*
target:
Vertex*
targetDirection: Ogre::Vector3
Apply():
void
...
void
Force
source:
Vertex*
target:
Vertex*
targetDirection: Ogre::Vector3
Apply():
void
Ve rte x
...
Ve rte x
Ve rte x
Abbildung 4.4: Anbindung der Kräfte an die Vertices
Seite 49
Umsetzung
4
4.3 Nebeneffekte des Simulationsverfahrens
Die auf eine Vertex einwirkende elastische Gesamtkraft ist die Summe der
Federkräfte ihrer Nachbarvertices. Hieraus ergibt sich das Problem, dass der Betrag
der Kraft von der Anzahl der Nachbarn abhängig ist. Bei der regelmäßigen Struktur
einer geodätischen Kugel fällt dieser Umstand kaum ins Gewicht, da alle Vertices
entweder fünf oder sechs Nachbarn haben. Bei einer UV-Sphere kann diese
Differenz jedoch deutlich größer ausfallen. Je nach gewählter Segmentanzahl
haben die beiden Vertices an den Polkappen m, alle anderen Vertices genau sechs
Nachbarn. Ein für die restlichen Vertices angemessener Dämpfungsfaktor ist mit der
Vielzahl an Federkräften, die auf die Polkappen wirken, daher überfordert. Es
kommt zu einer starken Oszillation, die sich schnell auf die ganze UV-Sphere
ausbreitet:
Abbildung 4.5: Zunehmende Oszillation im Geometriemodell einer UV-Sphere
Um diese Reaktion auszugleichen, kann das Elastizitätsmodul einer auf eine
Vertex wirkenden Feder durch die Anzahl der vorhandenen Nachbarvertices geteilt
werden. In der Summe ist dann das Gesamt-Elastizitätsmodul aller Vertices gleich
groß. Tatsächlich tritt die oben gezeigte Oszillation dadurch nicht mehr auf.
Ein interessanter Effekt entsteht in der Annahme, dass die Oberfläche eines
Ballons in befülltem Zustand bereits unter Spannung steht, d.h. dass die Ruhelänge
der angesetzten Federn kleiner ist als ihre Länge zu Beginn der Simulation.
Implementiert man Federn mit einer Ruhelänge von 0, zeigt eine UV-Sphäre ein
zunächst sonderbares Verhalten:
Seite 50
Umsetzung
4
Abbildung 4.6: Bildung der Minimalfläche
Bei näherer Überlegung wird jedoch klar, dass sich die Oberfläche der UVSphäre der Form ihrer Minimalfläche nähert, diese jedoch von einer regelmäßigen
Kugel abweicht. Ursache hierfür sind die Längenunterschiede der Federn zu Beginn
der Simulation. Durch den Wegfall der Ruhelänge in der Berechnung sind alle
Federn bestrebt, dieselbe möglichst kurze Dehnung zu erfahren. Innerhalb einiger
Sekunden gleichen sie daher ihre Länge an, soweit es der Innendruck des Ballons
zulässt.
Seite 51
Umsetzung
4
4.4 Codebeispiele
4.4.1 Rekonstruktion der Vertextopologie
Die meisten Algorithmen zur Generierung von Geometriedaten berücksichtigen
nicht explizit die Topologie, wenn diese später nicht verwendet wird. [ESW97] Um
diese Algorithmen trotzdem nutzen zu können, ist es sinnvoll, die Topologie der
Vertices unabhängig vom verwendeten Algorithmus zu regenerieren. Dazu werden
lediglich die generierten Faces benötigt:
void GeoBase::prepareBuddies()
{
//get root capsule and face data
FaceCapsule* cFace = this->mFaces->getRoot();
Face* face = cFace->getData();
//for all faces do
for(std::size_t i = 0; i < this->mFaces->count(); i++)
{
//notify face vertices about their neighbours
face->mVertices[0]->hasBuddies(
face->mVertices[1], face->mVertices[2]);
face->mVertices[1]->hasBuddies(
face->mVertices[0], face->mVertices[2]);
face->mVertices[2]->hasBuddies(
face->mVertices[0], face->mVertices[1]);
}
//get next capsule and face data
cFace = cFace->getNext();
face = cFace->getData();
}
Die Funktion prepareBuddies() informiert jede Vertex eines Faces über ihre
beiden Nachbarvertices. Die jeweilige Vertex überprüft dann, ob ihr die mitgeteilten
Nachbarn schon bekannt sind und nimmt diese falls nötig in ihre Nachbarliste auf.
4.4.2 Berechnung der Normalenvektoren
Bei der Simulation des Wasserballons müssen nach jedem Simulationsschritt die
Normalenvektoren auf allen Vertices und Faces neu berechnet werden, da die
Gummioberfläche vielleicht deformiert wurde. Eine schnelle Möglichkeit, die
Seite 52
Umsetzung
4
Normale zu einem Face zu erhalten, ist das Kreuzprodukt zweier Randvektoren zu
bilden, denn es ist senkrecht zu der von den Vektoren aufgespannten Ebene. Der
Ergebnisvektor muss anschließend nur normiert werden, was durch eine Division
durch seine Länge erreicht wird:
void Face::generateNormal()
{
//get edge vectors
Ogre::Vector3 v = this->mVertices[1]->Position this->mVertices[0]->Position;
Ogre::Vector3 w = this->mVertices[2]->Position this->mVertices[0]->Position;
//calculate face normal
this->Normal = v.crossProduct(w);
this->Normal.normalise();
}
Die Normalen zu den Vertices können anhand der Normalen der Faces
berechnet werden, die in ihr zusammenlaufen. Die Normalen werden dazu
vektoriell addiert und das Ergebis normalisiert:
void Vertex::generateNormal()
{
//we need at least one face
if(this->mFaces->hasNoData())
return;
//calculate average of face normals
FaceCapsule* cFace = this->mFaces->getRoot();
for(std::size_t i = 0; i < this->mFaces->count(); i++)
{
this->Normal += cFace->getData()->Normal;
cFace = cFace->getNext();
}
this->Normal.normalise();
}
4.4.3 Volumenberechnung
Ebenfalls neu berechnet werden muss nach jedem Simulationsschritt das
Volumen des Wasserballons. Dazu wird das in Kapitel 2.2 (Volumenberechnung
Seite 53
Umsetzung
4
mit dem Gaußschen Integralsatz) vorgestellte Verfahren angewendet. Als
Nebenprodukt wird dabei gleichzeitig der Flächeninhalt der einzelnen Faces und
der gesamten Oberfläche ermittelt:
void GeoBase::calcVolume()
{
//reset values from last step
this->Volume = 0.0f;
this->Area = 0.0f;
float faceA = 0.0f;
//get root capsle and face data
FaceCapsule* cFace = this->mFaces->getRoot();
Face* face = cFace->getData();
//for all faces do
for(std::size_t i = 0; i < this->mFaces->count(); i++)
{
//calc face area (doubled value)
faceA = cFace->getData()->fastAreaDbl();
this->Area += faceA;
//calc volume with gauss's theorem
this->Volume += faceA * face->Normal.dotProduct(
face->mVertices[0]->Position);
//get next capsule and face data
cFace = cFace->getNext();
face = cFace->getData();
}
//calculate final area and volume
this->Area /= 2.0f;
this->Volume = Ogre::Math::Abs(this->Volume) / 6.0f;
}
Die Fläche eines einzelnen Faces wird durch das Kreuzprodukt ermittelt:
float Face::fastAreaDbl()
{
//get edge vectors
Ogre::Vector3 v = this->mVertices[1]->Position this->mVertices[0]->Position;
Ogre::Vector3 w = this->mVertices[2]->Position this->mVertices[0]->Position;
//calculate face area (doubled value)
return v.crossProduct(w).length();
}
Seite 54
Umsetzung
4
4.4.4 Simulationsschritt
In der ersten Phase des Simulationsschrittes werden alle Einzelkräfte berechnet.
Ist die jeweilige Kraft in der Simulationsumgebung aktiviert, so wird sie mittels der
Funktion ForceBase::Apply() auf das Geometriemodell übertragen:
//apply gravity force
if(this->forceGravity)
this->mGravity->Apply(dt);
//apply volume pressure force
if(this->forcePressure)
this->mPressure->Apply(dt);
//apply spring force
if(this->forceSpring)
this->mSpring->Apply(dt);
Anschließend erfolgt die zweite Phase des Simulationsschrittes. Diese wird durch
die Funktion GeoBase::doPhysics() durchgeführt:
void GeoBase::doPhysics(double dt)
{
[...]
//global vertex position
vertex->Position += vertex->velocity * dt;
//transform force into acceleration
a = vertex->totalForce / this->VertexMass;
//calculate local velocity
dV = a * dt;
//local vertex position
dS = 0.5f * dV * dt;
vertex->Position += dS;
//do collision detection
this->mCore->checkCollision(&vertex->Position);
//apply dampers
vertex->velocity *= this->semilogDamp(
vertex->velocity.normalise());
vertex->velocity -= vertex->velocity *
this->mCore->envDamp * dt;
}
Seite 55
Bewertung
5
5 Bewertung
Kapitel 5
Bewertung
In diesem Kapitel werden die Ergebnisse vorgestellt, die bei der Umsetzung des
entwickelten Simulationsverfahrens erzielt wurden.
Zu Beginn wird mit Screenshots aus der entwickelten Anwendung ein visueller
Eindruck gegeben. Es folgt eine Analyse über die Laufzeit des Verfahrens. Danach
werden zur Bewertung der Berechnungsgenauigkeit Messwerte produziert und
denen einer idealen physikalischen Simulation gegenübergestellt. Zum Abschluss
werden die Nachteile des Verfahrens diskutiert.
Seite 56
Bewertung
5
5.1 Ergebnisse
An dieser Stelle sollen statt vieler Worte zunächst einige Bilder einen Eindruck
von dem vermitteln, was im Rahmen dieser Arbeit erreicht wurde. Im Folgenden
werden zwei Bewegungsabläufe eines simulierten Wasserballons bei einem Aufprall
auf eine Ebene gezeigt. Der Wasserballon fiel dabei jeweils aus einem Meter Höhe
bei Normalfallbeschleunigung.
In der ersten Simulation wurde ein relativ starkes Elastizitätsmodul verwendet,
wie es auch für einen echten Wasserballon charakteristisch ist: [Dom00]
Abbildung 5.1: Aufprall eines Wasserballons mit starkem Elastizitätsmodul
In der zweiten Simulation wurde ein deutlich niedrigeres Elastizitätsmodul
verwendet, was den Ballon zeitweise wie einen aufschlagenden Wassertropfen
aussehen lässt:
Seite 57
Bewertung
5
Abbildung 5.2: Aufprall eines Wasserballons mit niedrigem Elastizitätsmodul
Leider gehörte nicht selten auch das, was das letzte Bild zeigt, zu den gemachten
Erfahrungen bei der Implementierung – eine aufgrund zu starker Oszillation außer
Kontrolle geratene Simulation:
Abbildung 5.3: Nicht mehr kontrollierbare Simulation
Seite 58
Bewertung
5
5.2 Laufzeitanalyse
Während der Durchführung eines Simulationsschrittes werden folgende Werte
berechnet:
• Normalen für alle Vertices und Faces
• Flächeninhalt für alle Faces und die Gesamtoberfläche
• Innenvolumen
• Einzelkräfte auf jedes Massepartikel
• Gesamtkraft auf jedes Massepartikel
• neue Position für jedes Massepartikel
• neue Geschwindigkeit für jedes Massepartikel
Zur Berechnung der Normalen eines Faces wird das Kreuzprodukt aus zwei
aufspannenden Vektoren gebildet und anschließend normiert. Pro Face fällt dafür
eine konstante Zahl von Rechenschritten an. Nachdem die Normalen auf allen
Faces ermittelt worden sind, werden die Normalen der Vertices bestimmt. Für jede
Vertex werden dazu die Normalen der in ihr zusammenlaufenden Faces vektoriell
addiert und der Ergebnisvektor normiert, wofür pro angrenzendem Face konstante
Laufzeit benötigt wird. Während der Berechnung aller Normalen wird jedes Face
und jede Vertex einmal in der Datenstruktur aufgesucht. Zusätzlich werden für jede
Vertex alle angrenzenden Faces noch einmal besucht. Da für das Geometriemodell
eine Dreiecksstruktur vorausgesetzt wurde, wird infolge dessen jedes Face genau
drei mal aufgesucht, nämlich von seinen drei Vertices. Alle Anfragen werden
sequentiell und in einer beliebiger Reihenfolge durchgeführt, somit erreicht die
eingesetzte Datenstruktur eine konstante Laufzeit pro abgefragtem Element (die
Vertices haben eine lokale Referenz auf ihre Faces). Somit ergibt sich als Laufzeit
zum Berechnen aller Normalen
c1⋅∣F∣   c 2⋅∣V ∣  3 c 3⋅∣F ∣  c 4⋅∣ F∣  ∣V ∣ = O ∣ F∣ ∣V ∣
Bevor das Innenvolumen bestimmt werden kann, muss zunächst der
Flächeninhalt aller Faces einzeln ermittelt werden. Dazu wird erneut das
Seite 59
Bewertung
5
Kreuzprodukt berechnet, nur ohne anschließende Normierung. Die Flächeninhalte
werden während der Berechnung der Einzelflächen aufsummiert, so dass zur
Berechnung der Einzelflächen und der Gesamtfläche eine konstante Laufzeit pro
Face benötigt wird. Zur Berechnung des Volumens wird jede Einzelfläche mit dem
Skalarprodukt aus einem Flächenpunkt und der Flächennormalen multipliziert und
die jeweiligen Ergebnisse aufsummiert. Da bei der Berechnung der Flächeninhalte
und des Volumens ebenfalls keine bestimmte Reihenfolge der Faces eingehalten
werden muss, beträgt die Laufzeit hierfür
c 1⋅∣F∣  c 2⋅∣F ∣ = O ∣F∣
Bei der Übertragung der physikalischen Kräfte kommt es je nach Art der Kraft
zu unterschiedlichen Laufzeiten. Die Gravitationskraft überträgt je eine Einzelkraft
auf jedes Massepartikel, benötigt also konstante Laufzeit pro Vertex. Für den
Innendruck wird zunächst einmalig in konstanter Zeit der Überdruck bzw. der
Korrekturfaktor ermittelt. Anschließend wird jedes Face einmal aufgesucht und die
resultierende Kraft auf die drei Vertices des Faces übertragen, was pro Vertex eine
konstante Zahl an Rechenschritten benötigt. Für die elastische Zugkraft der
Gummioberfläche wird wegen der Doppelfedern jede Edge zweimal ausgewertet,
d.h. es wird ihre relative Längenänderung und die daraus resultierende Zugkraft
auf die entsprechenden Vertices berechnet. Da jede Edge immer zu genau zwei
Faces gehört, ist die benötigte Laufzeit zur Ermittlung aller Einzelkräfte durch
c1⋅∣V ∣   c 2  3 c 3⋅∣F ∣  3 c4⋅∣ F∣ = O ∣ F∣ ∣V ∣
gegeben. Die Ermittlung der Gesamtkraft für jedes Massepartikel erfolgt simultan
zur Ermittlung der Einzelkräfte; diese werden bei der Übertragung auf eine Vertex
aufsummiert, so dass anschließend neben allen Einzelkräften auch die Gesamtkraft
ermittelt ist. Die benötigte Laufzeit ist in der obigen Gleichung also bereits
enthalten.
Die benötigte Zeit zur Bestimmung der neuen Position und Geschwindigkeit
sowie die Durchführung der Kollisionkorrektur benötigt bei dem hier verwendeten
Erkennungsverfahren ebenfalls eine konstante Laufzeit pro Massepartikel, so dass
die Durchführung eines Simulationsschrittes insgesamt
O ∣ F∣  ∣V ∣  O ∣F∣  O ∣F∣  ∣V ∣  c 1⋅∣V ∣ = O ∣ F∣ ∣V ∣
Seite 60
Bewertung
5
Rechenschritte erfordert.
Die benötigte Zeit für einen Simulationsschritt ist also linear in der Komplexität
des verwendeten Geometriemodells. Durch die zusätzliche Verwendung von
Hardware-Vertex-Buffern und Backface-Culling kann eine hardwarebeschleunigte
Darstellung zudem voll ausgenutzt werden. Das Verfahren eignet sich von seiner
Performance also sehr gut für eine interaktive Simulationsumgebung.
Auf einem handelsüblichen Desktop-Computer mit 2,4 GHz Prozessor und
500 MHz 3D-Grafikbeschleuniger konnten bei einem Geometriemodell aus 20.000
Polygonen etwa 15 Einzelbilder pro Sekunde generiert werden. Einen runden
Eindruck erhält man je nach Geometriemodell ab etwa 2.000 Polygonen. Die
hierbei erreichte Bildrate betrug etwa 800 Einzelbilder pro Sekunde.
Seite 61
Bewertung
5
5.3 Berechnungsgenauigkeit
Das im Rahmen dieser Arbeit entwickelte Verfahren zur Simulation von
Massepartikel beruht auf vereinfachten physikalischen Gegebenheiten. Es muss
daher mit einer Abweichung der Berechnungsergebnisse von denen einer idealen
Simulation gerechnet werden. Um die auftretenden Abweichungen genauer
untersuchen zu können, wurde ein Programm zur Simulation eines einfachen
Feder–Masse-System implementiert. Die Simulation wurde dabei anhand einer
ideal konstruierten Bewegungsgleichung durchgeführt, wie sie in Kapitel 2.3.2
(Feder–Masse-Systeme) behandelt wurde. Zudem wurde das im Rahmen dieser
Arbeit entwickelte Verfahren integriert.
Die erwartete Abweichung ist, wie in Kapitel 3.3.2 (Simulation der auftretenden
Kräfte) erläutert, Abhängig von der Länge der Berechnungsintervalle. Diese
Vermutung wurde durch die erhaltenen Messwerte bestätigt:
Abbildung 5.4: Simulation eines
Feder–Masse-Systems über eine
Zeitdauer von 10 Sekunden mit
verschieden Zeitintervallen.
Oben: 1 ms und 10 ms
Rechts: 100 ms
Die grüne Kurve zeigt die Schwingung
eines idealen Systems, die rote die des
vereinfacht simulierten.
Bei Zeitintervallen von 1 ms Dauer ist fast keine Abweichung zu erkennen. Bei 10 ms
und 100 ms kann ein Anstieg der Amplitude beobachtet werden. Eine Erklärung
Seite 62
Bewertung
5
hierfür ist die Simulation der Massepartikel zu diskreten Zeitpunkten. Fällt nicht
zufällig der Zeitpunkt, an dem sich die Abwärtsbewegung des Massepartikels in
eine Aufwärtsbewegung ändert, genau auf eine Intervallgrenze, so wird es im
folgenden Zeitintervall weiter ausgelenkt, als es in einer idealen Simulation der Fall
sein würde. Die Zugkraft der Feder wird dadurch erhöht; folglich wird das
Massepartikel im weiteren Simulationsverlauf mit einer entsprechend stärkeren
Beschleunigung nach oben bewegt. Seine maximale Auslenkung nach oben fällt
dadurch um den Teil größer aus, den es vorher zu weit nach unten bewegt wurde.
Kombiniert mit weiteren Abweichungen entsteht ein sich selbst verstärkender
Prozess, der immer größer werdende Auslenkungen zur Folge hat.
Die Messkurve für Zeitintervalle von 100 ms zeigt eine solche Eskalation: Die
Simulation ist nicht mehr kontrollierbar. Dieser Effekt kann auch bei der
Anwendung des Verfahrens auf den Wasserballon beobachtet werden. Es stellt sich
daher die Frage, welche Gegenmaßnahmen sich zu einer effektiven Stabilisierung
des Verfahrens eignen. Dabei hat sich eine Dämpfung des Systems als bislang beste
Methode erwiesen.
Durch die Drosselung auf eine Maximalgeschwindigkeit, wie es im Kapitel 3.4.3
(Dämpfung) beschrieben wurde, kann eine Stabilisierung des Systems unabhängig
von der Intervalldauer bewirkt werden:
Abbildung 5.5: Dämpfung durch eine Maximalgeschwindigkeit
Die Charakteristik des Systems bleibt erhalten, es kommt allerdings zu einer
Phasenverschiebung der Bewegungskurve.
Seite 63
Bewertung
5
Eine lineare Dämpfung in Abhängigkeit von der aktuellen Geschwindigkeit eines
Massepartikels, wie ebenfalls in Kapitel 3.4.3 beschrieben, bewirkt sogar noch
bessere Ergebnisse.
Abbildung 5.6: Empirisch ermittelte Dämpfungsfaktoren. Links (für 10 ms):
0.99925. Rechts (für 100 ms): 0.9685.
Wie die Messwerte zeigen, verläuft die Bewegungskurve jetzt nahezu identisch zu
der eines idealen Systems. Die eingesetzten Dämpfungsfaktoren wurden allerdings
auf empirische Weise ermittelt und lassen sich nicht ohne weiteres auf andere
Simulationsobjekte übertragen.
Seite 64
5
Bewertung
5.4 Nachteile des Verfahrens
Während der Implementierung des Verfahrens hat sich gezeigt, dass es mitunter
sehr schwierig ist, die verschiedenen physikalischen Kräfte in Einklang zu bringen.
Nach [Vog99] führt jede Abweichung von einem stabilen Gleichgewichtszustand
zunächst zu einer proportionalen Rücktreibungskraft, die in Abwesenheit von
Reibung
zu
harmonischen
Schwingungen
führt.
Dieser
Effekt
führt
in
Kombination mit der niedrigen Kompressibilität des Wassers zu einem äußerst
instabilen System. Schon bei einer geringen Abnahme des Innenvolumens
entstehen so große Kräfte auf die Massepartikel, dass diese regelrecht nach außen
katapultiert werden. Dabei kommt es zu einer sich selbst verstärkenden Oszillation,
wie sie im vorangehenden Kapitel auch für die Feder–Masse-Systeme beschrieben
wird.
Um die Simulation durchführen zu können, müssen in der Praxis daher deutlich
niedrigere Werte für die Kompressibilität des Wassers angenommen werden.
Zudem muss, wie in Kapitel 2.3.3 (Feder–Masse-System mit Dämpfer) erläutert,
eine hohe Dämpfung eingesetzt werden, um eine systembedingte Oszillation durch
das Feder–Masse-System zu unterdrücken. Von weiteren Ansätzen, die zur
Stabilisierung der Simulation testweise implementiert wurden, haben sich die in
Kapitel
3.4.3
(Dämpfung)
entwickelte
Funktion
zur
Erzwingung
einer
Maximalgeschwindigkeit sowie die in Kapitel 3.4.5 (Innendruck) beschriebene
Anwendung eines Korrekturfaktors am ehesten bewährt. Die letztgenannte
Methode führt dabei noch zu optischen Nebeneffekten, da die Positionen der
Vertices direkt beeinflusst werden und somit kein kontinuierlich erscheinender
Bewegungsverlauf erzeugt wird; sie bietet aber wahrscheinlich die beste
Ausgangsbasis für eine Verbesserung des Verfahrens in dieser Hinsicht.
Ein weiterer Nachteil ist die nur schrittweise Ausbreitung eingebrachter Kräfte
über das Geometriemodell, wie es auch bei der in Kapitel 2.4.3 (Wasseroberfläche
und Stoff mit Feder–Masse-Systemen) vorgestellten Publikation der Fall ist. Es ist
die Folge aus der Betrachtung der einzelnen Massepartikel zu diskreten
Zeitpunkten und ihre Unabhängigkeit zu anderen Massepartikeln innerhalb der
dazwischenliegenden Zeitfenster. Dieser Nachteil kann allerdings in einer Echtzeit-
Seite 65
Bewertung
5
Anwendung mit dem Schwerpunkt einer schnellen Berechnung vernachlässigt
werden, denn der Einfluss einer eingebrachten Kraft nimmt mit zunehmender
Entfernung von den angegriffenen Massepartikel ab. Je größer also der Einfluss
einer eingebrachten Kraft auf ein Massepartikel ist, desto schneller wird sie sich
über das Geometriemodell zu diesem ausgebreitet haben.
Weiterhin können durch die Art der Berechnung keine Vorhersagen über den
Zustand des Wasserballons zu einem zukünftigen Zeitpunkt gemacht werden, ohne
dass die Simulation schrittweise bis zu diesem Zeitpunkt durchgeführt wird. In
einer interaktiven Simulationsumgebung verliert eine Vorhersage jedoch dadurch
an Bedeutung, dass die Rahmenbedingungen jederzeit geändert werden können
und eine Vorhersage damit hinfällig wäre. Vorherige Simulationsverläufe können
mit der in Kapitel 3.3.2 (Simulation der auftretenden Kräfte) beschriebenen Wahl
konstant langer Zeitintervalle reproduziert werden.
Schließlich ergeben sich durch die Polygondarstellung Ungenauigkeiten bei der
Kollisionserkennung. So kann es vorkommen, dass der Wasserballon eine Spitze in
der Szenengeometrie durchdringt, ohne dass dies erkannt wird – etwa wenn die
Spitze mittig auf eine Seitenfläche trifft und sich die umliegenden Vertices noch
außerhalb der Szenengeometrie befinden. Eine solche Situation kann nur von einer
doppelseitigen Kollisionserkennung korrekt bewertet werden. Aber auch dann sind
die Möglichkeiten einer Angleichung der Ballonoberfläche an die Szenengeometrie
begrenzt, da hierfür die Seitenflächen des verwendeten Geometriemodells eine
genau an die unterliegende Struktur angepasste Triangulierung aufweisen müsste.
Abbildung 5.7: Fehlgeschlagene Kollisionserkennung
Seite 66
6 Ausblick
Kapitel 6
Ausblick
Dieses Kapitel beschreibt mögliche Erweiterungen und Verbesserungen, die an
dem Simulationsverfahren vorgenommen werden können.
Es wird skizziert, wie Haft- und Gleitreibungskräfte in die Simulationsumgebung
einbezogen werden können, sowie ein Ansatz gegeben, mit dem unter Umständen
die Genauigkeit der Berechnung verbessert werden kann. Zum Abschluss der
Diplomarbeit wird in einem Fazit auf die Ergebnisse der Arbeit zurückgeblickt.
Seite 67
Ausblick
6
6.1 Verbesserungen
6.1.1 Einbindung einer Gleit- und Haftreibungskraft
Die Konzeption des entwickelten Verfahrens erlaubt die Eingliederung weiterer
physikalischer Kräfte in die Simulation. Im Folgenden wird eine Möglichkeit
skizziert, um Haft- und Gleitreibungskräfte zu integrieren.
Eine Haft- bzw. Gleitreibungskraft entsteht immer dann, wenn es zu einer
Berührung zweier Oberflächen kommt. Die Grundlage für diese Art von Kraft wird
daher die Kollisionserkennung sein. Kommt es zu einer Kollision eines
Massepartikels mit der Szenengeometrie, so wird dieses mit einem entsprechenden
Hinweis markiert. Im folgenden Simulationsschritt wird überprüft, ob ein
markiertes Massepartikel erneut mit der Szenengeometrie kollidiert ist. Ist dies der
Fall, muss sich das Massepartikel im letzten Zeitintervall entlang der Oberfläche der
Szenengeometrie bewegt und damit einer Gleitreibungskraft ausgesetzt haben.
t

Fg
v

F ges

FN
Abbildung 6.1: Gleitreibungskraft
Um den Betrag der Krafteinwirkung zu ermitteln, wird anhand der Gesamtkraft,
die auf das Massepartikel einwirkt, der senkrecht zur zurückgelegten Strecke
wirksame Anteil ermittelt. Wird dabei die Haftreibungskraft überschritten, so wird
die Position des Massepartikels wie bei einer normalen Kollisionskorrektur versetzt
und eine entsprechende Gleitreibungskraft entgegengesetzt der Bewegungsrichtung
auf
es
übertragen.
Bleibt
die
Haftreibungskraft
unterschritten,
wird
das
Massepartikel auf seine Ausgangsposition zurückgesetzt, da es sich im Zeitintervall
nicht bewegen konnte.
Seite 68
Ausblick
6
6.1.2 Mögliche Erhöhung der Berechnungsgenauigkeit
Eine Vereinfachung bei der Berechnung basiert auf der Annahme, dass die auf
ein Massepartikel wirkende Beschleunigung innerhalb eines Zeitintervalls konstant
ist, obwohl sich das Massepartikel innerhalb des Zeitintervalls offensichtlich bewegt
und damit die auf sich wirkenden Kräfte beeinflusst hat.
Von der grundlegenden Vorgehensweise, ein Massepartikel unabhängig von
anderen Partikeln zu betrachten, kann, ohne immense Geschwindigkeitseinbußen
hinnehmen zu müssen, nicht abgesehen werden. Für jedes Zeitintervall sind aber
zumindest die Werte der aktuellen und vorherigen Beschleunigung bekannt. Es
wird dennoch bei der Simulation davon ausgegangen, dass die Beschleunigung
konstant ist und der aktuelle Wert für die Berechnung verwendet. Eine
Interpolation zwischen den beiden Werten dürfte eine größere Genauigkeit
ergeben. Möglich wäre auch, innerhalb eines Zeitfensters eine Differentialgleichung
für jedes Massepartikel aufzustellen, die die jeweils anderen Partikel als
unbeweglich ansieht und nur in einem lokalen Kontext gelöst wird.
Seite 69
Ausblick
6
6.2 Fazit
Das vorgestellte Verfahren zur Simulation eines wassergefüllten Ballons eignet
sich durch seine lineare Laufzeit und ausreichende Berechnungsgenauigkeit sehr
gut zum Einsatz in einer interaktiven Simulationsumgebung. Die schnelle Laufzeit
wird allerdings durch eine Vereinfachung der physikalischen Gegebenheiten
erkauft. Das Verfahren ist daher nur bedingt in Situationen einsetzbar, in denen
eine hohe Berechnungsgenauigkeit im Vordergrund steht. Durch die vereinfachte
Berechnung entstehen zudem einige Nebeneffekte, die durch Korrekturverfahren
ausgeglichen werden müssen. Es gelingt mit dem Simulationsverfahren trotzdem,
charakteristische Bewegungsmuster eines Wasserballons nachzubilden.
Die Berechnungsgenauigkeit kann innerhalb bestimmter Grenzen durch die
Wahl kurzer Zeitintervalle und hoch aufgelöster Geometriemodelle beeinflusst
werden. Die Verwendung einer geodätischen Kugel brachte hierbei die besten
Resultate und bietet zudem eine gute Grundlage für die Anwendung von Level-ofDetail-Verfahren. [Hom06]
Durch die Möglichkeit, vorangegangene Simulationsabläufe reproduzieren zu
können, erschließen sich zusätzliche Anwendungsgebiete im Bereich der EchtzeitComputergrafik. Die Einsetzbarkeit kann noch erweitert werden, wenn es gelingt,
das Innenvolumen des Ballons konstant zu halten. Auf dieser Grundlage müsste die
Verwendung in nicht-Echtzeit-Simulationen neu bewertet werden. Interessante
Möglichkeiten ergeben sich bei der Simulation biologischer Strukturen: Eine Zelle
kann als wassergefüllter Körper mit einer elastischen Oberfläche betrachtet werden.
[Dom00] Mit der hohen Berechnungsgeschwindigkeit des entwickelten Verfahrens
könnten dann mehrschichtige Zellstrukturen bis hin zu ganzen Gewebepartien
simuliert werden.
Durch die verwendete Objektstruktur kann das Verfahren gut erweitert werden.
Durch die Implementierung mit Hilfe des Szenengraphen OGRE besteht zudem die
Möglichkeit, den entwickelten Programmcode auf verschiedenen Betriebssystemen
(derzeit Windows, Linux und Mac OSX) einzusetzen.
Seite 70
A
Literaturverzeichnis
7 Anhang A: Literaturverzeichnis
Anhang A
Literaturverzeichnis
[BM01]
Brüderlin, Beat; Meier, Andreas: Computergrafik und Geometrisches
Modellieren. Teubner Verlag, 2001.
[Bre04]
Breiner, Tobias: Openscenegraph, openSG, RealiMation, VirTools
und Java3D (Interner Bericht). Johann-Wolfgang-GoetheUniversität Frankfurt, 2004.
[Bre06]
Breiner, Tobias: Open-Source-Szenegraphen im Vergleich (Interner
Bericht). Johann-Wolfgang-Goethe-Universität Frankfurt, 2006.
[Dom00]
Domke, Jan: Mikromechanische Eigenschaftendünner Polymerfilme
und lebender Zellen (Dissertation). Ludwig-Maximilians-Universität
München, 2000.
[Edw01]
Edwards, P.: Mass-Spring-Damper Systems: The Theory.
Bournemouth University, 2001.
[ESW97]
Encarnação, J.; Straßer, W.; Klein, R: Graphische Datenverarbeitung
2: Modellierung komplexer Objekte. Kapitel 1.3.6 Datenstrukturen,
Seiten 37-40. R. Oldenburg Verlag, 1997.
[FD97]
Fischer, Tilo; Dorn, Hans-Jerg: Physikalische Formeln und Daten.
Ernst Klett Verlag, 1997.
[FDF97]
Foley, James D.; Dam van, Andries; Feiner, Steven K.; Hughes, John
F.: Computer Graphics. Principles and Practice in C. Kapitel 5.5
Efficiency, Seiten 212 f. Addison-Wesley Professional, 1997.
[Fom00]
Fomitchev, Max I.: 2D Surface Deformation.
http://www.gamasutra.com/features/20000216/deformation_pfv.ht
m (2000)
[Gol94]
Goldman, Ronald N.: Area of planar Polygons and Volume of
Polyhedra. In: Graphics Gems II. Hrsg. von James Arvo. AP
Professional, 1994.
[Hom06]
Homann, Jörg: Fraktale Planetengenerierung (Diplomarbeit).
Johann-Wolfgang-Goethe-Universität Frankfurt, 2006.
[MH99]
Möller, Thomas; Haines, Eric: Real-Time Rendering. Kapitel 10
Intersection Test Methods, Seiten 289-339. AK Peters, 1999.
Seite 71
A
Literaturverzeichnis
[MW99]
Merzinger, Gerhard; Wirth, Thomas: Repetitorium der höheren
Mathematik. Binomi Verlag, 1999.
[NT98]
Nedel, Luciana Porcher; Thalmann, Daniel: Real Time Muscle
Deformations Using Mass-Spring Systems. EPFL - Swiss Federal
Institute of Technology, 1998.
[Sch06]
Schmidt, Björn: Raytracing und Szenegraphen (Diplomarbeit).
Johann-Wolfgang-Goethe-Universität Frankfurt, 2006.
[Str98]
Strauss, Daryll: Visuelle High-Tech-Effekte mit Linux. iX Archiv
3/98, 1998.
[Vog99]
Vogel, Helmut: Gerthsen Physik. Springer Verlag, 1999.
[www01]
Wikipedia: Platonischer Körper.
http://de.wikipedia.org/wiki/Platonischer_Körper (2006)
[www02]
Wikipedia: Skalarprodukt.
http://de.wikipedia.org/wiki/Skalarprodukt (2006)
[www03]
Wikipedia: Bonaventura Cavalieri.
http://de.wikipedia.org/wiki/Bonaventura_Cavalieri (2006)
[www04]
Wikipedia: Hookesches Gesetz.
http://de.wikipedia.org/wiki/Hookesches_Gesetz (2006)
[www05]
Wikipedia: Harmonische Schwingung.
http://de.wikipedia.org/wiki/Harmonische_Schwingung (2006)
Seite 72
Verwendete Software
B
8 Anhang B: Verwendete Software
Anhang B
Verwendete Software
Textverarbeitung, Layout, Erstellung und Aufbereitung von Vektorgrafiken:
OpenOffice (http://www.openoffice.org)
Implementierung, Prototyping:
Eclipse (http://www.eclipse.org)
CDT (http://www.eclipse.org/cdt)
MinGW (http://www.mingw.org)
GCC (http://gcc.gnu.org)
OGRE (http://www.ogre3d.org)
Python (http://www.python.org)
FreeBasic (http://www.freebasic.net)
3D-Modelling, Export und Aufbereitung von Vektorgrafiken, Aufbereitung von
Rastergrafiken:
Blender (http://www.blender.org)
Inkscape (http://www.inkscape.org)
The GIMP (http://www.gimp.org)
Seite 73