Simulation der Steuerung eines Segelbootes mit OpenSG

Simulation der Steuerung eines Segelbootes mit OpenSG Studienarbeit Vorgelegt von Christian Rieder Institut für Computervisualistik Arbeitsgruppe Computergraphik Betreuer: Prüfer: Dipl.-Inform. Matthias Biedermann Prof. Dr.-Ing. Stefan Müller März 2006

Inhaltsverzeichnis 1 Einleitung 1 2 Rendering System 2 2.1 OpenSG............................... 2 2.2 Szenengraph............................. 2 2.3 Datenstrukturen........................... 2 2.3.1 Vektoren.......................... 3 2.3.2 Matrizen.......................... 3 2.3.3 Quaternionen........................ 3 2.4 Funktionen............................. 4 3 Physikalische Grundlagen 6 3.1 Translationsbewegung....................... 6 3.2 Rotationsbewegung......................... 6 3.3 Physik Simulation.......................... 7 3.3.1 Numerisches Integrieren - Euler sches Polygonzugverfahren 8 3.3.2 Euler Integration für die Translation............ 8 3.3.3 Euler Integration für die Rotation............. 9 3.4 Auftrieb............................... 10 3.5 Aerodynamik............................ 10 3.6 Dynamischer Auftrieb....................... 11 3.6.1 Widerstandskraft...................... 11 3.6.2 Dynamische Auftriebskraft................. 12 3.6.3 Druckverhältnisse der Tragfläche............. 12 4 Segeltheorie 13 4.1 Das Segelboot............................ 13 4.2 Segelkurse.............................. 14 4.3 Wahrer Wind - scheinbarer Wind.................. 15 4.4 Antriebskräfte............................ 15 4.4.1 Antrieb durch Widerstand................. 16 4.4.2 Antrieb durch Auftrieb................... 16 4.4.3 Die Querkraft........................ 16 4.4.4 Die Abdrift......................... 16 4.5 Stabilität eines Segelbootes..................... 17 4.6 Aerodynamik am Segelboot.................... 18 5 Praktische Umsetzung 19 5.1 Das 3D-Modell........................... 19 5.1.1 Modellierung........................ 19 5.1.2 Exportierung in OpenSG.................. 20 5.1.3 Der Szenengraph des Bootes................ 20 i

5.2 Softwaretechnischer Entwurf.................... 20 5.3 Implementierung.......................... 22 5.3.1 Die Klasse Boat....................... 22 5.3.2 Die Klasse Wind...................... 22 5.3.3 Die Klasse Simulation................... 23 5.3.4 Die Klasse Translation................... 25 5.3.5 Die Klasse Rotation.................... 26 5.3.6 Die Klasse Roll....................... 27 5.3.7 Die Klasse Controls.................... 27 5.4 Die Applikation SailSim...................... 28 5.4.1 Der Szenengraph...................... 28 5.4.2 Die Display Methode.................... 30 6 Ergebnisse 32 7 Fazit und Ausblick 35 7.1 Fazit................................. 35 7.2 Ausblick............................... 35 Literatur 36 Abbildungsverzeichnis 37 ii

1 Einleitung Das Segelboot ist eines der ältesten Fortbewegungsmittel. Auch heute, in einer voll industrialisierten Welt, wird noch gesegelt, allerdings meist als Freizeitaktivität und Sport. Aus versicherungstechnischen Gründen ist es nötig, einen Segelschein bzw. Sportboot Führerschein zu erwerben. Ähnlich wie bei dem Autoführerschein werden erst Theoriestunden besucht und danach die komplexe Segelpraxis erlernt. Während der Theorie wäre es sicherlich interessant das Segeln auf einem Computer vor der Praxis zu simulieren, um den Lernaufwand zu minimieren. Segelsimulatoren, die das Verhaltens eines Segelbootes korrekt simulieren sind jedoch nicht so weit verbreitet wie Simulatoren von Fahr- und Flugzeugen, welche eine extrem hohe Komplexität aufweisen. Ziel der Arbeit ist es, eine physikalisch plausible Steuerung eines Segelbootes in einer Beispielanwendung umzusetzen und zu vermitteln. Ausgehend von einem möglichst realitätsnahen 3D-Modell eines Segelbootes werden geeignete Parameter zur echtzeitfähigen Simulation ausgewählt und steuern in der Anwendung das Verhalten des Modells. Eine grafische Oberfläche gibt zudem Informationen über die relevanten Parameter und bietet einfache Steuerungsmöglichkeiten. 1

2 Rendering System Ein Rendering System ist für die Berechnung und Weiterleitung von dreidimensionalen Daten an die Grafikkarte verantwortlich. Hier werden diese von 3D in 2D umgewandelt und an ein Ausgabegerät (Monitor) gesendet werden. Im folgenden Kapitel soll das Rendering System OpenSG erläutert werden. 2.1 OpenSG OpenSG [7] ist ein auf der Idee des Szenengraphen basierendes Echtzeit 1 Rendering System. Die Idee eines solchen Systems ist es, dass der Benutzer interaktiv in Echtzeit, in einer dreidimensionalen Szene navigieren und Aktionen ausführen kann. Die Bibliothek OpenSG setzt auf OpenGL 2 auf und funktioniert als Schicht zwischen Applikation und OpenGL-Code. In OpenSG sind die meisten OpenGL Funktionalitäten durch eigene Methoden gekapselt. Da OpenGL als state machine konzipiert ist und keine Kenntnis über die gesamten Daten einer Szene hat, ist die Berechnung komplexer Szenen mit vielen Polygonen nicht sehr effizient. Im Gegensatz zu OpenGL speichert OpenSG die Szene in einem Szenengraph, welcher hierarchisch aufgebaut ist. So ist es z.b. möglich, Objekte, die sich hinter der Kamera befinden auszublenden. Die Objekte werden dann nicht an OpenGL zum berechnen weitergegeben. Da dadurch die rechenintensive OpenGL States-Changes minimiert werden, kann die sichtbare Szene effizienter und mit geringerem Zeitaufwand berechnet werden. Weitere Vorteile von OpenSG sind die Fähigkeit das System auf Clustern laufen zu lassen, auch in einem heterogenem Netzwerk, und die Multithread optimierte Datenstruktur. OpenSG läuft auf verschiedenen Betriebssystemen (u.a. Windows, Linux und Mac OSX). 2.2 Szenengraph Der Szenengraph sortiert die Geometrie in eine Baumstruktur ein, um die Daten effizient an die Hardware zu schicken. Die Hauptbestandteile sind die Wurzel (Root), Knoten (Nodes) und Kerne (Cores), wobei die Knoten den Kern enthalten, der die Eigenschaften festlegt. Einige wichtige Cores sind der Group-Core, dieser fasst nur die unter ihm liegende Teilbäume zusammen, der Geometry-Core, dieser enthält die Geometrie und der Transform-Core, welcher eine Transformationsmatrix enthält, die auf dem unter ihm liegenden Teilbaum angewendet wird. 2.3 Datenstrukturen OpenSG ist ein Echtzeitsystem ist, mit dem man die Möglichkeit hat, geometrische Objekte in der Szene interaktiv zu transformieren (Translation, Rotation und 1 ab 15-20 Bilder pro Sekunde wirken Bewegungen ruckelfrei 2 Open Graphics Library 2

car geo group wheel front left wheel front right wheel back left wheel back right transform transform transform transform geo wheel front l geo wheel front r geo wheel back l geo wheel back r geometry Abbildung 1: Beispiel eines einfachen Szenengraphen Skalieren). Um diese Transformationen zu kontrollieren stellt OpenSG einige mathematische Datenstrukturen zur Verfügung. 2.3.1 Vektoren Da Szenen in OpenSG in dem 3-dimensionalen Raum dargestellt werden, ist es müssen Vektoren benutzt werden, um die Orientierung der geometrischen Objekte zu beschreiben. OpenSG stellte eine komplette Vektor-Datenstruktur mit vielseitigen Funktionen zur Verfügung, die aus der Mathematik bekannt sind. 2.3.2 Matrizen Eine Matrix besteht aus Spalten- und Zeilenvektoren, die Zahlen werden zusammen in Tabellenform angeordnet. Um Objekte in einer Szene zu verschieben, sind Matrizen nötig. Diese Transformationsmatrizen [9] werden in einen Transformation- Core des Szenengraphen eingetragen und auf alle Unterobjekte angewendet. OpenSG besitzt eine Vielzahl von Funktionen, um Matrixoperationen durchführen zu können. 2.3.3 Quaternionen Quaternionen sind eine Verallgemeinerung der komplexen Zahlen. Die Idee ist, eine Rotation durch die Beziehung eines Vektors und dessen Drehwinkel beschreiben zu können. Quaternionen werden durch einen vierdimensionalen Vektor beschrieben, der aus einen dreidimensionalen Vektor, die Ausrichtung, und einem Rotationswinkel, die Drehung, besteht. Eine Rotation in 3D lässt sich daher sehr einfach 3

Abbildung 2: Die Transformationsmatrix (Abb. aus [6]) durch ein Quaternion beschreiben. OpenSG unterstützt auch hier viele Rechenund Umformoperationen. Der Einsatz von Quaternionen ist in einem Echtzeitsystem deshalb empfehlenswert, da die mathematischen Operationen in Bezug auf die Quaternionen effizienter durchgeführt werden können als Matrixoperationen. Abbildung 3: Grafische Darstellung eines Quaternions (Abb. aus [7]) 2.4 Funktionen In der Bibliothek OpenSG befinden sich eine Vielzahl von verschiedener Funktionen, die für diese Studienarbeit eingesetzt wurden. Mit der SkyBackground-Klasse lässt sich z.b. ein Panorama-Hintergrundbild aus sechs Einzelbildern zusammenfügen. Das Hintergrundbild befindet sich in der Szene in unendlicher Entfernung und wird durch eine Kamerabewegung nicht beeinflusst. Kamera und Lichtquellen lassen sich leicht erstellen und sind ein Teil des Szenengraphen. Mit Hilfe einer Navigator-Klasse lässt sich die Bewegung der Maus in eine Bewegung der Kamera transformieren. Der VRML 3 -Loader ermöglicht das Laden von exportierten Modellen aus gängigen Modelliertools wie 3ds max und Maya. 3 Virtual Reality Modeling Language, eine Beschreibungssprache für 3D-Szenen 4

3 Physikalische Grundlagen In diesem Abschnitt werden physikalische Grundlagen beschrieben, die für die Segeltheorie und die Kinematik von Bedeutung sind. Diese umfassen die Definition, Erklärung und Beschreibung der Bewegungsgleichungen und der Auftriebs- bzw. der Widerstandskräfte. 3.1 Translationsbewegung Allgemeine Bewegungsgleichungen für die gleichmäßig beschleunigte Bewegung: Weg Zeit Funktion : s = s 0 + v 0 t + 1 2 a 0 t 2 Geschwindigkeit Zeit Funktion : v = v 0 + a 0 t = ṡ Beschleunigungs Zeit Funktion : a = a 0 = konstant = s Sie beschreiben eine Bewegung, die zur Zeit t 0 = 0 an der Stelle s = s 0 mit der Geschwindigkeit v = v 0 beginnt. gleichförmige Bewegung s v a s = vt v = konstant t t a = 0 t s gleichmäßig beschleunigte Bewegung v a s = ½ at² v = at a = konstant t t t Abbildung 4: Weg-Zeit-Diagram Beschleunigte Bewegung 3.2 Rotationsbewegung Die Geschwindigkeit eines Punktes auf einer Kreisbahn ist: v(t) = ω(t) r(t) 5

ѡ A v r 0 Abbildung 5: Rotationsgeschwindigkeit Wobei ω die Winkelgeschwindigkeit und r der Abstand zum Drehpunkt ist. Mit Hilfe der Gesetze der Translations- und Rotatinsbewegung (siehe Abb. 6) lässt sich die Fahrt eines Körpers durch ein homogenes Medium beschreiben. Speziell für ein Segelboot ergibt sich eine Translationsbewegung durch die Fahrt des Bootes, und zwei Rotationsbewegungen, durch die Drehung und die Neigung des Bootes. Abbildung 6: Vergleich von Translationsbewegung und Rotationsbewegung 3.3 Physik Simulation Vielfach sind physikalische Zusammenhänge nur mit erheblichem mathematischen Aufwand zu bearbeiten. Die Berechnung bestimmter Werte x zum Zeitpunkt t einer unbekannten Weg-Zeit-Funktion, welche eine gleichmäßig beschleunigte Bewegung beschreibt, ist nur durch das Lösen der Differentialgleichung 4 möglich. Dieser analytische Ansatz ist jedoch für die Berechnung in Echtzeit zu komplex. 4 eine Gleichung, die die Ableitungen einer Funktion enthält 6

3.3.1 Numerisches Integrieren - Euler sches Polygonzugverfahren Mit dem Euler schen Polygonzugverfahren, einem der bekanntesten Iterationsverfahren 5, kann ausgehend von einem bekanntem Funktionswert zum Zeitpunkt t und dessen Tangente (bzw. Tangentensteigung) der nächste Funktionswert zum Zeitpunkt t + 1 berechnet werden. Man nähert also die durch die Tangenten oder Ableitungen ermittelten Werte punktweise an den Funktionsverlauf an (Abb. 7). Aus diesem Grund funktioniert dieses Verfahren auch nur dann gut, wenn die Zeitintervalle t genug klein sind. Bei zu großen Intervallen werden die Werte ungenau und die Fehler zu groß, was zu Stabilitätsproblemen der Simulation führt. Abbildung 7: Euler Integration (Abb. aus [6]) 3.3.2 Euler Integration für die Translation Die Euler Integration für die Translation beginnt mit der Initialisierung der Startwerte, die Masse m, der Ort s und der Geschwindigkeit v für jeden Massenpunkt zum Zeitpunkt t = 0. Der erste Schritt ist die Darstellung der Szene mit OpenSG zum Zeitpunkt t = 0. Aus der Renderingzeit ergibt sich das Zeitintervall t. Im nächsten Schritt wird die Summe aller Kräfte berechnet. Danach muss die Position aus der alten Geschwindigkeit berechnet werden. In dem darauf folgenden Schritt wir die neue Geschwindigkeit aus der alten Beschleunigung a = F m berechnet. Der letzte Schritt ist die Berechnung des neuen Zeitpunktes t aus dem alten Zeitpunkt t und dem Intervall t. Nun beginnt ein neuer Simulationsablauf mit den neuen Werten. 5 Verfahren zur schrittweisen Annäherung an die Lösung 7

Abbildung 8: Schematischer Ablauf der Euler Integration für die Translation 3.3.3 Euler Integration für die Rotation Auch die Euler Integration für die Rotation beginnt mit der Initialisierung der Startwerte zum Zeitpunkt t = 0. Die Werte sind der Trägheitstensor J, der Vektor r zum Angriffspunkt einer Kraft F, die Orientierung qorient (als Quaternion) und der Drehimpuls L. Der erste Schritt ist wieder die Darstellung der Szene mit OpenSG zum Zeitpunkt t = 0. Im zweiten Schritt wir zuerst die Orientierung qorient von der Quaternionen-Form in die Matrixform morient umgerechnet. Die neue Winkelgeschwindigkeit ω ergibt sich aus der Matrixmultiplikation der Orientierung morient, des inversen Tensors J 1, der transponierten 6 Matrix morient T und dem Drehimpuls L. Im nächsten Schritt wird die Drehkraft τ aus der Summe aller Kreuzprodukte i r i F i berechnet. Die neue Orientierung qorient ergibt sich aus der alten Orientierung und dem puren Quaternion 7 ω. In dem nachfolgenden Schritt wird der neue Drehimpuls L n+1 aus dem alten Drehimpuls und der Drehkraft τ berechnet. Der letzte Schritt ist wieder die Berechnung des neuen Zeitpunktes t aus dem alten Zeitpunkt t und dem Intervall t. Danach beginnt ein neuer Simulationsablauf. 6 vertauschen von Zeilen- und Reihenvektoren 7 Veckor, interpretiert als ein Quaternion mit Winkel 0 8

Abbildung 9: Schematischer Ablauf der Euler Integration für die Rotation 3.4 Auftrieb Als Auftrieb [4] bezeichnet man eine Kraft, die eine Flüssigkeit oder ein Gas auf einen Körper ausübt. Die Kraft, die der Schwerkraft entgegenwirkt, ist der statische Auftrieb. F = ρ V g wobei ρ die Dichte des Gases oder der Flüssigkeit, V das verdrängte Volumen und g die Gewichtskraft des Körpers sind. Ein Boot schwimmt im Wasser, weil die Auftriebskraft der verdrängten Wassermenge gleich der Gewichtskraft des Bootes ist [1]. 3.5 Aerodynamik Die Aerodynamik beschreibt das Strömungsverhalten von Flüssigkeiten und Gasen. Vortrieb und (dynamischer) Auftrieb sind Phänomene der Aerodynamik, die durch Druckunterschiede entstehen. 9

3.6 Dynamischer Auftrieb Der dynamische Auftrieb entsteht, wenn sich ein Körper relativ zum Gas oder zur Flüssigkeit bewegt. Die Kraft, die das Gas oder die Flüssigkeit auf den Körper ausübt, besteht aus zwei Komponenten: der Widerstandskraft der dynamischen Auftriebskraft 3.6.1 Widerstandskraft Die Widerstandskraft wirkt in Richtung der Anströmung: F w = 1 2 ρ c w A v 2 wobei ρ die Dichte des Gases oder der Flüssigkeit, c w der Widerstandsbeiwert, A die Fläche, auf der der Auftrieb wirkt, und v die Anströmgeschwindigkeit sind. Abbildung 10 zeigt typische Widerstandsbeiwerte für vier Grundkörper. Stromlinienprofil c w = 0,06 Kugel c w = 0,40 Halbkugel c w = 0,80 Scheibe c w = 1,20 Abbildung 10: Widerstandsbeiwerte von Grundkörpern 10

3.6.2 Dynamische Auftriebskraft Die dynamische Auftriebskraft wirkt rechtwinklig zur Anströmung (siehe Abb. 11): F a = 1 2 ρ c a A v 2 wobei ρ die Dichte des Gases oder der Flüssigkeit, c w der Auftriebsbeiwert, A die Fläche, auf der der Auftrieb wirkt, und v die Anströmgeschwindigkeit ist. 3.6.3 Druckverhältnisse der Tragfläche Die Erklärung für den dynamischen Auftrieb sind die unterschiedlichen Druckverhältnisse an einem angeströmten Körper. An dieser sog. Tragfläche entsteht auf der Seite, die entgegen der Richtung der Strömung zeigt, ein Überdruck, auf der anderen Seite, die in Richtung der Strömung zeigt, ein Unterdruck. Dieser Unterdruck bewirkt die Kraft F a, die senkrecht zur Anströmung steht. Zusammen mit der Widerstandskraft F w ergibt sich daraus die Gesamtkraft F g, die senkrecht zur Tragfläche wirkt (Abb. 11). Fa Fg Unterdruck A Anströmung Fw Überdruck Ag A: Querschnittfläche des Profils Ag: Grundfläche des Tragflügels Abbildung 11: Aerodynamische Kräfte an einer Tragfläche 11

4 Segeltheorie Das Kapitel Segeltheorie behandelt die theoretischen Grundlagen des Segelns. Hier werden die Grundkörper eines Segelbootes vorgestellt und ihre Funktion erläutert. Weiterhin werden die verschiedenen Segelkurse, die am Segelboot durch Wind verursachten Kräfte, sowie deren Wirkungen vorgestellt. 4.1 Das Segelboot Ein Segelboot besteht aus dem Rumpf, dem Rigg [8] und den Segeln. Der Rumpf ist der Bootskörper, der das Segelboot auf dem Wasser trägt. In der Mitte der Unterseite des Rumpfes ist ein Schwert bzw. Kiel angebracht, am Heck 8 das Ruder. Die Aufgabe des Schwertes bzw. des Kiels ist die Stabilisierung des Bootes. Das Ruder dient zur Steuerung der Fahrtrichtung und wird vom Skipper 9 mit Hilfe der Pinne bedient. Das Rigg ist die Takelage 10 eines Segelbootes. Die Takelage lässt Verklicker Vorstag Großsegel Fock (Vorsegel) Mast Want Saling Großbaum Großschot Pinne Fockschot Ruder Kiel Abbildung 12: Schematische Darstellung einer Kiel-Jolle 8 Hintere Teil des Bootes 9 Schiffsführer 10 das Tauwerk, die Masten und Segel 12

Am Wind sich in den Mast und den Baum, welche man Spieren [2] nennt, dem stehendem Gut (Wanten, Stagen) und dem laufendem Gut (Schoten, Fallen) unterteilen. Die Takelage trägt die Segel eines Segelbootes, welche meist aus Vor- und Großsegel bestehen. Die Funktion der von dem Wind angeströmten Segel ist die Entwicklung einer Kraft, die für den Vortrieb genutzt wird. Wanten und Stagen sind starke Drahtseile, welche zur Befestigung bzw. Stabilisierung des Mastes dienen. Die Saling [5] ist an dem Mast angebracht und soll den Wanten mehr Spreiz und dadurch dem Mast mehr Halt verleihen. Außerdem dient die Saling dazu, dem Mast eine nötige Krümmung zu geben, welche die Wölbung der Segel beeinflusst. Die Schot ist das Ende (Tau), mit dem man ein Segel so setzt, wie es der Wind erfordert. Auf der Mastspitze ist der Verklicker montiert, welcher meist aus einem kleinen Fähnchen besteht, das die Windrichtung anzeigt. 4.2 Segelkurse Wie in Abbildung 13 dargestellt kann man mit einem Segelboot bis zu 45 o an den Wind heranfahren (Rennyachten bis zu 38 o ). nur durch Kreuzen zu erreichen ~38 ~45 ~38 ~45 Am Wind max. Geschw. Raumschots halber Wind vor dem Wind Abbildung 13: Der Sektor zum Wind eines Segelbootes 13

Am Wind bedeutet, die max. Höhe, die ein Boot fahren kann. Der Winkel zwischen Wind und Kurs 11 ist am kleinsten, die Geschwindigkeit ist gering. Halber Wind bezeichnet den Kurs, bei dem scheinbare Wind (siehe Abb. 14) quer, also mit 90 o, einfällt. Die theoretische Geschwindigkeit des Segelbootes ist hier am größten. Raumer Wind (Raumschots) herrscht zwischen halbem Wind und vor dem Wind. Vor dem Wind bezeichnet den Kurs, bei dem der Wind genau von achtern 12 kommt. All diese Kurse sind spiegelgleich für Backbord und Steuerbord. 4.3 Wahrer Wind - scheinbarer Wind Ein Segelboot bewegt sich durch das Wasser mit einer Geschwindigkeit fort, dabei erfährt es ausser dem wahren Wind 13 noch den Fahrtwind. Diese beiden Winde bilden zusammen den scheinbaren Wind. Mit Hilfe eines Parallelogramms kann man den scheinbaren Wind bestimmen. Abbildung 14 zeigt, dass der scheinbare Wind abhängig von dem gesegelten Kurs größer (Am-Wind-Kurs) oder keiner (Vor-Wind-Kurs) als der wahre Wind ist. Auch die Richtung des wahren Windes variiert mit der Segelrichtung. wahrer Wind scheinbarer Wind wahrer Wind Fahrtwind scheinbarer Wind Fahrtwind wahrer Wind Abbildung 14: Der scheinbare Wind 4.4 Antriebskräfte Es gibt zwei Antriebskräfte mit unterschiedlichen Wirkungen, die verantwortlich sind, dass ein Segelboot auch gegen den Wind fahren kann. 11 die Richtung, die ein Schiff fährt 12 achtern = hinten 13 der tatsächlich wehende Wind 14

4.4.1 Antrieb durch Widerstand Die Segel setzten dem von hinten kommenden Wind einen Widerstand entgegen. Es entsteht ein Vortrieb. Je grösser die Fläche des Segels ist, desto grösser ist auch der Widerstand und somit die Geschwindigkeit des Bootes (siehe Abb. 15). Antrieb durch Auftrieb Antrieb durch Widerstand Abbildung 15: Antrieb durch Auftrieb und durch Widerstand 4.4.2 Antrieb durch Auftrieb Im Am-Wind-Bereich, der Wind trifft seitlich auf das Segel, erzeugt das Segel keinen Widerstand mehr. Hier entsteht der Antrieb durch die aerodynamischen Kräfte, die am Segel wirken. 4.4.3 Die Querkraft Die gesamte Kraft, die am Segel entsteht, ist orthogonal zur Segelfläche. Diese Gesamtkraft kann man mit Hilfe eines Kräfteparallelogramms (siehe Abb. 16) in den Vortrieb, parallel zum Boot, und die Querkraft, senkrecht zum Boot, zerlegen. Der Vortrieb, der durch den Lateralplan 14 verursacht wird, ist je nach Kurs wesentlich geringer als die Gesamtkraft. Die Querkraft, der sich der Lateralplan mit seinem großen Widerstand entgegenstellt, verursacht das Abdriften und Kränken des Bootes. 4.4.4 Die Abdrift Die Abdrift eines Segelbootes hat zur Folge, dass das Boot nicht den angesteuerten Kurs fährt, sondern seitlich versetzt wird. Um die Abdrift auszugleichen, ist es nötig, gegen zu steuern. Dies wird exemplarisch in Abb. 17 aufgezeigt. 14 Fläche des Unterwasserschiffs 15

Vortrieb Gesamtkraft Querkraft Querkraft Vortrieb Gesamtkraft Abbildung 16: Gesamtkraft, Querkraft und Vortrieb gesteuerter Kurs Abdrift gesegelter Kurs Abbildung 17: Gesteuerter Kurs, gesegelter Kurs und Abdrift 4.5 Stabilität eines Segelbootes Unter der Stabilität eines Segelbootes versteht man die Fähigkeit, sich aus eigener Kraft aus einer gekränkten Lage wieder aufzurichten. Die Kränkung wird von der Querkraft an dem Segeldruckpunkt D entsteht und der Wasserdruck, der auf den Lateralplan des Rumpfes wirkt, verursacht. Man unterscheidet bei Segelbooten die Stabilität in Formstabilität und in Gewichtsstabilität. Jollen 15 besitzen ausschließlich Formstabilität, die sich aus der Breite des Rumpfes, also dem Auftrieb, ergibt (siehe Abb. 18). Da diese nur sehr gering ist, ist es notwendig, dass zusätzliche Stabilität durch das Gewicht der Mannschaft erzeugt wird. Aus diesem Grund kann eine Jolle sehr leicht kentern, nämlich genau dann, wenn der Gewichtsschwerpunkt G den Formschwerpunkt F überholt. Kielboote dagegen, beziehen ihre Stabilität im wesentlichen aus der Gewichtsstabilität des tiefsitzenden Kielballastes. Je mehr eine Kielyacht kränkt, um so größer wird die aufrichtende Kraft, da der Gewichtsschwerpunkt G einen grösseren 15 offenes, flachgehendes Boot mit aufholbarem Schwert im Boden 16

Winddruck Formstabilität einer Jolle Gewichtsstabilität einer Kielyacht Fquer G Fquer D F G D Fquer F F F G D Kielyacht richtet sich wieder auf D Fquer Fauftrieb Fauftrieb Jolle kentert G Fauftrieb Fschwer Fschwer Fauftrieb Fschwer Fschwer Wasserdruck Abbildung 18: Form- und Gewichtsstabilität eines Segelbootes Abstand zu dem Formschwerpunkt F hat. Das ist der Grund warum eine Kieljacht kentersicher ist und sich immer wieder aufrichten kann. 4.6 Aerodynamik am Segelboot Die Segel eines Segelbootes wirken bei einem Am-Wind Kurs und mit ausreichender aerodynamischer Form 16 wie die Tragflügel eines Flugzeuges, also als Tragflächen. Wie in Kapitel 3.3 beschrieben, entsteht eine Kraft, die senkrecht auf der Tragfläche steht. Diese Kraft kann man mit einem Parallelogramm in zwei Komponenten zerlegen. Die Widerstandskraft F w, die in Richtung des Windes wirkt, und die Auftriebskraft F a, deren Richtung senkrecht zum Wind ist. wahrer Wind β Mittschiffslinie α Sehne des Segels Fauftrieb Fwiderstand Fgesamt Fwiderstand II wahrer Wind Fauftrieb wahrer Wind Abbildung 19: Aerodynamik am Segelboot 16 größte Wölbung kurz vor der Mitte des Segels 17

5 Praktische Umsetzung 5.1 Das 3D-Modell Für die Simulation auf einem Computer, ist es nötig, ein 3D-Modell eines Segelbootes zu erstellen. Die berechneten Kräfte, die in der Simulation auf das Segelboot wirken, werden an dem Modell visualisiert. 5.1.1 Modellierung Abbildung 20: Segelboot, gerendert mit 3ds max Das Vorbild für das Modell ist eine Dreimann Kiel-Yolle mit der Bezeichnung streamline [3]. Das Segelboot wurde mit dem Programm 3ds max von Autodesk17 erstellt. Bei der Modellierung kam es darauf an, das Segelboot so anzupassen, das alle nötigen Bewegungen mit OpenSG einfach durchzuführen sind. So wurde z.b. der Mast, im Gegensatz zu dem original Boot, nur gerade modelliert. Der Grund hierfür ist, dass die Drehbewegung des Segels bei einem nach hinten gebogenem 17 www.autodesk.com 18

Mast wesentlich komplizierter ist. Bei dem Modell wurde komplett auf das laufende Gut 18 sowie auf viele kleine Details verzichtet. 5.1.2 Exportierung in OpenSG Das fertige Modell wurde mit 3ds max im *.3ds Format gespeichert, und mit der freeware Version von VRED 19 geöffnet. In VRED, welches auf OpenSG aufsetzt, wurde das Modell optimiert, und als OpenSG-Binary-Datei gespeichert. Dieses Dateiformat lässt sich am schnellsten und am effizientesten in eine OpenSG Applikation laden. 5.1.3 Der Szenengraph des Bootes Um die Segel, das Ruder und den Verklicker in der OpenSG Anwendung interaktiv drehen zu können, wurden für jede bewegbare Komponente ein Transfomrations- Core angelegt, unter dessen sich die entsprechende Geometrie befindet. Boot group Fock Segel Ruder Verklicker geo Boot transform transform transform transform geometry geo Fock geo Segel geo Ruder geo Verkli cker geometry geometry geometry geometry Abbildung 21: Szenengraph des Segelbootes 5.2 Softwaretechnischer Entwurf Nach einer Phase zum Testen der Simulationen und vor der eigentlichen Implementierung wurde ein softwaretechnischer Entwurf erstellt. Dieser soll die beteiligten Klassen und deren Beziehungen festlegen (siehe Abb. 22). Ziel ist ein objektorientiertes Design mit einer klaren Struktur zu schaffen, die eine relativ einfache Implementierung der Simulation ermöglicht. 18 alle Leinen und Drähte, mit denen etwas bewegt wird 19 Virtual Reality Editor, www.vred.org 19

float ftime Simulation void simulate(boat* boat, Wind* wind) float computeforcea(float froh, float fface, float fca, float fvel) float computeca(float fangle) Quaternion integratequat(quaternion qquat, Vec3f vomega) Quaternion multvecquat(vec3f vvec, Quaternion qquat) Quaternion multquatfloat(quaternion qquat, float fvalue) Quaternion addquat(quaternion qquat1, Quaternion qquat2) Quaternion subquat(quaternion qquat1, Quaternion qquat2) void invertquat(bool& InvertAction, Quaternion& qquat) Quaternion diffquat(quaternion qquat1, Quaternion qquat2) float anglequat(quaternion quat)... Translation float ftime float fforceresist float fforcedrift float fforcedrive float fforce float facceleration float fvelocity float fneworientation float foldorientation float fdifforientation float fwindvelocity float frealwindvel... void translate(boat* boat, Wind* wind) float computeforcewind() float computeforcedrift() void computetranslation(float ftime) float computeforceresistwater() float computeforceresistwind() float computeforcedrive()... Rotation Vec3f vtorque Vec3f vangularvelocity Vec3f vangularmomentum Vec3f vforce Matrix morientation Matrix mboattensor Quaternion qneworientation Quaternion qoldorientation Quaternion qdifforientation... void rotate(boat* boat, Translation* trans, Wind* wind) Vec3f computeforcerudder(float fangle) void computerotation(float ftime) Quaternion getorientation() Quaternion getdifforientation()... Roll float ftime float fforcewind Vec3f vtorque Vec3f vangularvelocity Vec3f vangularmomentum Vec3f vforcesail Vec3f vforcekeel Vec3f vkeelpoint Vec3f vsailpoint Vec3f vtaukeel Vec3f vtausail Vec3f vtau Matrix morientation Quaternion qneworientation Quaternion qoldorientation Quaternion qdifforientation... void roll(boat* boat, Wind* wind) Vec3f computeforcesail(float fangle) void computeroll(float ftime) Quaternion getorientation()... Boat float fboatwidth float fboatlength float fboatmass float finversemass float KeelMass float fsailface float frudderface float funderwaterface float fangleboatsail float fangleboatrudder float fangleboatwind Vector3f vrudderpoint Vector3f vsailpressurepoint Vector3f vkeelpoint Matrix mboattensor void setangleboatsail(float fangle) void setangleboatrudder(float fanlge) void setangleboatwind(float fangle)... Wind float fwindvel float fanglewind Vec3f vwindorientation void setwindvel(float fvel) void setanglewind(float fangle) float getwindvel() float getanglewind() Vec3f getwindorientation() float fvalue Controls void setangleboatsail(float fvalue, Boat* boat) void setangleboatrudder(float fvalue, Boat* boat) void setwindvel(float fvalue, Wind* wind) void setanglewind(float fvalue, Wind* wind) Abbildung 22: Softwaretechnischer Entwurf 20

5.3 Implementierung Die Applikation wurde mit c++ in der Entwicklungsumgebung XCode unter dem Betriebsystem Mac OSX programmiert. 5.3.1 Die Klasse Boat Die Klasse Boat ist eine Container-Klasse, die die Attribute eines Bootes speichert. Hierzu gehören alle Attribute, die ein Segelboot beschreiben. Zusätzlich existieren weitere Variablen, die den Zustand des Boots festlegen. Um auf die Attribute zugreifen zu können, stellt die Klasse Boat set- und get-methoden bereit. // Konstruktor Boat( float init_fwidth, float init_flength, float init_fmass, float init_fkeelmass, float init_fsailface, float init_frudderface, float init_funderwaterface, Vec3f init_vrudderpoint, Vec3f init_vsailpressurepoint, Vec3f init_vkeelpoint ); virtual ~Boat(); // Breite // Laenge // Masse // Kielmasse // Segelflaeche // Ruderflaeche // Lateralplan // Ruderdrehpunkt (Vektor) // Segeldruckpunkt (Vektor) // Kielmassepunkt (Vektor) Die Variablen des Konstruktors werden bei der Instanzierung der Klasse Boat mit den realen Werten eines Segelbootes belegt. Aus diesen Werten werden weitere Variablen wie der Trägheitstensor J und die inverse Masse m 1 berechnet. // Setter // Setzt: void setboatorientation(quaternion qorient); // Orientierung void setangleboatsail(float fangle); // Winkel Boot-Segel void setangleboatrudder(float fangle); // Winkel Boot-Ruder void setangleboatwind(float fangle); // Winkel Boot-Wind void setglobalangle(float fangle); // Globalen Winkel Mit Set-Funktionen lassen sich die Werte des Bootes zur Laufzeit der Simulation verändern. 5.3.2 Die Klasse Wind Die Eigenschaften des Windes werden in der Klasse Wind festgelegt. Der Wind besitzt eine Richtung und eine Stärke, welche durch entsprechende Methoden ausgegeben und verändert werden können. 21

// Konstruktor Wind(float init_fwindvel, float init_fanglewind); virtual ~Wind(); // Setter void setwindvel(float fvel); void setanglewind(float fangle); // Setzt Windgeschwindigkeit // Setzt Winkel 5.3.3 Die Klasse Simulation Die Klasse Simulation bildet den Kern der Simulation. Aus dieser Klasse sind die Klassen Translation, Rotation und Roll abgeleitet. Diese Basisklasse stellt u.a. einige Methoden für die Berechnung von Quaternionen und für die Berechnung von aerodynamischen Kräften zur Verfügung. Die aus dem Kapitel Physik bekannte Formel der Aerodynamik ist in der Funktion computeforcea umgesetzt. float Simulation::computeForceA( float froh, // Dichte float fface, // Flaeche float fca, // C-Wert float fvel ) // Geschwindigkeit { float fforce = ( 0.5 * froh * fface * fca * (fvel * fvel) ); return fforce; } Der Auftriebsbeiwert C A wird mit der Funktion computeca berechnet. float Simulation::computeCA(float fangle) { float x,fvalue; x = fangle/pi; // 0 = 0 degree, 1 = 180 degree if(x>0 && x<=1) { fvalue = 15 * x * ( (1-x) * (1-x) * (1-x) ); } else { fvalue = 0; } return fvalue; } Die Funktion liefert den approximierten C A Wert eines Segels mit typischer Wölbung. Der Wert ist Abhängigkeit von dem Anströmwinkel auf die Segelflä- 22

che. Der Anströmwinkel kann 0 180 o betragen, welcher für die Funktion auf 0-1 skaliert wird. 1,5 1 Ca Wert 0,5 0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9 1 Winkel Wind Abbildung 23: Funktion C A Wert Um ein Quaternion, wie in dem Kapitel Eulerintegration der Rotation beschrieben, zu integrieren wird die Funktion integratequat benötigt. Parameter sind das alte Quaternion und ein dreidimensionaler Vektor, der als pures Quaternion interpretiert wird. Quaternion Simulation::integrateQuat( Quaternion qquat, Vec3f vomega ) { Quaternion qtmp, qresult; qtmp = multvecquat(vomega, qquat); qresult = addquat(qquat, multquatfloat(qtmp,(ftime*0.5f))); } return qresult; Die Klasse Simulation enthält weitere Funktionen für mathematische Rechenoperationen mit Quaternionen. // Multiplikation Vektor-Quaternion Quaternion multvecquat(vec3f vvec, Quaternion qquat); // Multiplikation Quaternion-Skalar Quaternion multquatfloat(quaternion qquat, float fvalue); // Addition Quaternion-Quaternion 23

Quaternion addquat(quaternion qquat1, Quaternion qquat2); // Subtraktion Quaternion-Quaternion Quaternion subquat(quaternion qquat1, Quaternion qquat2); 5.3.4 Die Klasse Translation Eine Spezialisierung der Klasse Simulation ist die Klasse Translation. In dieser Klasse sind Methoden für die Euler-Integration der Translation implementiert. Die für die Integration benötigten Attribute des Bootes und des Windes werden aus der Klasse Boat und Wind referenziert. Zusätzlich besitzt diese Klasse eigene Attribute wie z.b. die Orientierung, die Geschwindigkeit und verschiedene Kräfte. // Referenziert alle benoetigten Werte von Boot & Wind void translate(boat* boat, Wind* wind); // Berechnet die Windkraft an den Segeln float computeforcewind(); // Berechnet die Querkraft des Bootes void computeforcedrift(); // Berechnet die Vortiebskraft des Bootes void computeforcedrive(); Der Vortrieb wird durch die Integration des Wegs und der Geschwindigkeit in der Funktion computetranslation berechnet. void Translation::computeTranslation(float ftime) { foldorientation = fneworientation; computeforcedrive(); // Widerstand des Wassers float fforceresistwater = computeforcea(...); facceleration = ( getforcedrive() - fforceresistwater - computeforcea(...) ) * finversemass; // integration Weg fneworientation = foldorientation + (fvelocity * ftime); 24

// integration Geschwindigkeit fvelocity = fvelocity + (facceleration * ftime); } fdifforientation = fneworientation - foldorientation; Analog wird in der Funktion computedrift die Abdrift berechnet. void Translation::computeDrift(float ftime) { folddrift = fnewdrift; computeforcedrift(); float fforceresist = (...); fdriftacceleration = (fforcedrift - fforceresist) * finversemass; fnewdrift = folddrift + (fdriftvelocity * ftime); fdriftvelocity = fdriftvelocity + (fdriftacceleration * ftime); } fdiffdrift = fnewdrift - folddrift; 5.3.5 Die Klasse Rotation In der Klasse Rotation sind die Methoden für die Euler-Integration der Rotation implementiert. Auf der Basis von referenzierten Attributen aus den Klassen Boat, Wind und Translation werden mithilfe eigener Attribute wie z.b. der Drehkraft oder dem Drehmoment die resultierenden Kräfte berechnet, welche für die Drehung des Bootes benötigt werden. Durch die Drehung des Bootes werden Attribute der Klasse Boat verändert. // Referenziert alle benoetigten Werte void rotate(boat* boat, Translation* trans, Wind* wind); // Berechnet Kraft am Ruder Vec3f computeforcerudder(float fangle); Die Funktion computerotation berechnet mithilfe der Euler-Integration die Drehung des Bootes. void Rotation::computeRotation(float ftime) { 25

qoldorientation = qneworientation; vforce = computeforcerudder(fangleboatrudder); // Matrix zu Quaternion qoldorientation.getvalue(morientation); Matrix morientationtrans = morientation; morientationtrans.transpose(); // transp. Matrix // w = R * J * R_trans * L // Matrixmultiplikation morientationtrans.mult(vangularmomentum, result); mboattensor.mult(result); morientation.mult(result); vangularvelocity = result; vtorque = vrudderpoint.cross(vforce); // Drehmoment = r x F // Integration Quaternion qneworientation = integratequat( qoldorientation, vangularvelocity ); qneworientation.normalize(); // Normalisierung } // neues Drehmoment vangularmomentum = vangularmomentum + (ftime * vtorque); 5.3.6 Die Klasse Roll Die Klasse Roll enthält wie die Klasse Rotation Methoden für die Euler-Integration der Rotation. Im Gegensatz zu dieser Klasse wird hier nicht die Drehung des Bootes berechnet, sondern die durch die resultierenden Kräfte entstehende Neigung. Um diese Kräfte berechnen zu können, werden Attribute aus den Klassen Boat und Wind referenziert. // Referenziert alle benoetigten Werte void roll(boat* boat, Translation* trans); // Berechnet Kraenkung void computeroll(float ftime); 5.3.7 Die Klasse Controls Die Schnittstelle mit Anwender der Applikation bildet die Klasse Controls. In dieser Klasse befinden sich Methoden, die es dem Benutzer erlauben, aus den Klassen 26

Boat und Wind referenzierte Attribute wie z.b. den Ruderwinkel, die Windstärke oder die Windrichtung zu verändern. // Setzt Winkel Boot-Segel void setangleboatsail(float fvalue, Boat* boat); // Setzt Winkel Boot-Ruder void setangleboatrudder(float fvalue, Boat* boat); // Setzt Windgeschwindigkeit void setwindvel(float fvalue, Wind* wind); // Setzt Winkel Wind void setanglewind(float fvalue, Wind* wind); // Setzt Pause void setpause(); 5.4 Die Applikation SailSim In dem Hauptprogramm der Applikation werden die Instanzen der Klassen der Simulation erzeugt und der Szenengraph, sowie das GLUT Fenster initialisiert. 5.4.1 Der Szenengraph Der Szenengraph enthält die Geometrie, Kamera und das Licht der Szene. 27

Root group Node Light Beac on Light DirecLight transform Trans formti on transform Roll Helpe r transform transform Boat Geom etry Beac onca mera Water Geo Helpe rgeo geometry transform geometry geometry Came radis play Cg Node geometry MaterialGroup Abbildung 24: Der Szenengraph 28

Der Root Knoten ist die Wurzel des Graphen. Er besitzt zwei Kinder, den Node- Light und den BeaconLight. Der BeaconLight Knoten setzt die Position des Lichtes, der NodeLight Knoten enthält das Licht selbst und ein Kind, den Transform Knoten. Dieser besitzt einen Transform Core, welcher die in der Simulation ermittelten Daten für die Translation und Rotation auf den Unterbaum anwendet. Die Kinder dieses Knoten sind der Roll Node und der Helper Node. Der Roll Knoten enthält einen Transformations Kern, welcher die Daten für die Neigung des Bootes besitzt. Das Kind dieses Knoten enthält die komplette Geometrie des Segelbootes. Der Helper Knoten besteht aus einem Transfomation Core, der eine Gegendrehung ausführt. Alle Kinder dieses Knoten werden mit transliert, aber nicht rotiert. Somit bleibt die Ausrichtung immer gleich. Die Kinder sind der BeaconCamera-, der WaterGeo- und der HelperGeo Node. Die Geometrie des HelperGeo Knoten dient der Orientierung und besteht aus einem einfachen Kompass und zwei Pfeilen, die die Windrichtung anzeigen. Der WaterGeo Core enthält die Geometrie des Wassers und dessen Cg 20 -Material. Der BeaconCamera Knoten besitzt den Transformations Kern für die Kamera. Das Kind dieses Knoten ist die Geometrie, die die Daten zum Steuern des Segelbootes einblendet. 5.4.2 Die Display Methode Die Display Methode ist die Schnittstelle zwischen der Physiksimulation und dem Renderingsystem. Diese ruft in jedem Berechnungsschritt des Renderingsystems die Funktionen der Simulation auf, die die aktuellen Werte für das Segelboot berechnen. Den Funktionen werden Objekte der Klassen und die Variable interval, die dem Zeitschritt t entspricht, übergeben. void display() {... trans->translate(streamline, wind); trans->computetranslation(interval); trans->computedrift(interval);... rot->rotate(streamline, trans, wind); rot->computerotation(interval); roll->roll(streamline, trans); roll->computeroll(interval); Für jedes Frame werden die neuen Werte aus der Simulation auf die Transformations- Matrizen angewendet. Die Matrizen werden den Kernen der Knoten zugewiesen. Somit ergibt sich für das Boot eine stetige Bewegung. 20 C for graphics - Programmiersprache für Grafikprozessoren 29

... begineditcp(coretransformation, Transform::MatrixFieldMask); tmp_matrix.setrotate(...); // setzt Rotation trans_matrix.mult(tmp_matrix); // multipliziert Matrix tmp_matrix.settransform(...); // setzt Translation trans_matrix.mult(tmp_matrix); // multipliziert Matrix // Kern erhaelt Matrix CoreTransformation->setMatrix(trans_matrix);... endeditcp(coretransformation, Transform::MatrixFieldMask); Nachdem alle benötigten Matrizen aktualisiert wurden, wird das Fenster gerendert.... } window->render(renderaction); 30

6 Ergebnisse Folgende Bilder aus der Applikation SailSim illustrieren die Ergebnisse der Studienarbeit. Abbildung 25: Streamline auf Halbwind-Kurs 31

Abbildung 26: Streamline auf Raumschots-Kurs Abbildung 27: Streamline auf Am-Wind-Kurs 32

Scheinbarer Wind Wahrer Wind Geschwindigkeitsanzeige Ruder Stellung Segelstellung Skala Abbildung 28: Anzeige für die Steuerung Abbildung 29: Streamline auf Am-Wind-Kurs 33

7 Fazit und Ausblick 7.1 Fazit Mit der Entwicklung der Applikation SailSim wurden die festgelegten Ziele der Studienarbeit erreicht. Die Anwendung ermöglicht die Steuerung eines virtuellen Segelbootes in Echtzeit, basierend auf einer Physiksimulation. Neben der Einarbeitung in das Szenengraph System OpenSG und das Erlernen der Funktionsweise einer physikalischen Simulation, wurden die c++ Kenntnisse deutlich verbessert. Um die Applikation visuell ästhetisch zu gestalten, wurde zusätzlich die Shadersprache Cg erlernt, welche für die Darstellung der Wasserfläche verantwortlich ist. Der Benutzer kann durch das Steuern des Segelbootes das Verhalten und die Prinzipien des Segelns studieren. Dabei wurden für die Simulation allerdings nur die wichtigsten Phänomene des Segelns berücksichtigt. Grund hierfür ist die enorme Komplexität der in der Realität angreifenden KrŠfte und deren Auswirkungen. Eine Versuch solche Phänomene physikalisch korrekt zu simulieren würde an der Echtzeitfähigkeit der Applikation scheitern. 7.2 Ausblick Die Applikation SailSim kann vielseitig erweitert werden. Denkbar wäre, dass das Segelboot von dem Wasser beeinflusst wird. So sollte das Boot auf die Wellenbewegung reagieren und auch eigene Wellen verursachen. Der Shader des Wassers selbst kann optisch verbessert werden um einen höheren Grad an Realismus zu erreichen. Interessant und vor allem für die Segler wichtig, wäre das Hinzufügen einer Segelmannschaft, die durch Gewichtsverlagerung den sog. Gewichtstrimm des Bootes erheblich beeinflussen kann. Das Darstellen der Crew auf einem Segelboot, die von dem Benutzer Anweisungen erhält, ist eine technische Herausforderung. Um die Kontrolle über das Segelboot zu verbessern, sollte es möglich sein, anstatt mit der Tastatur z.b. mit einem Joypad oder ähnlichem Eingabegerät, das Boot zu steuern. 34

Literatur [1] David M. Bourg. Physics for Game Developers. O Reilley and Associates, Inc., 2002. [2] Roland Denk. Das große Handbuch des Segelns. BLV Verlagsgesellschaft mbh, München, 1977. [3] Nautik GmbH. Klassenbestimmungen streamline, 2005. [4] J. Krause J. Grehn. Metzler Physik. Schroedel Verlag Gmbh, Hannover, 1998. [5] Wolhart Klasing. Führerschein A für Segler. Delius, Klasing und Co, Bielefeld, 1978. [6] Prof. Dr. Stefan Müller. Vorlesungsskripte zu Animation und Simulation, 2004. [7] OpenSG. OpenSG tutorial. http://www.opensg.org. [8] Heinz Overschmidt. Sportbootführerschein Binnen - Segel, Motor. Delius, Klasing und Co, Bielefeld, 1994. [9] Peter Shirley. Fundamentals of Computer Graphics. A K Peters, Ltd., 2002. 35

Abbildungsverzeichnis 1 Beispiel eines einfachen Szenengraphen.............. 3 2 Die Transformationsmatrix (Abb. aus [6])............. 4 3 Grafische Darstellung eines Quaternions (Abb. aus [7])...... 4 4 Weg-Zeit-Diagram Beschleunigte Bewegung........... 6 5 Rotationsgeschwindigkeit...................... 7 6 Vergleich von Translationsbewegung und Rotationsbewegung... 7 7 Euler Integration (Abb. aus [6])................... 8 8 Schematischer Ablauf der Euler Integration für die Translation.. 9 9 Schematischer Ablauf der Euler Integration für die Rotation... 10 10 Widerstandsbeiwerte von Grundkörpern.............. 11 11 Aerodynamische Kräfte an einer Tragfläche............ 12 12 Schematische Darstellung einer Kiel-Jolle............. 13 13 Der Sektor zum Wind eines Segelbootes.............. 14 14 Der scheinbare Wind........................ 15 15 Antrieb durch Auftrieb und durch Widerstand........... 16 16 Gesamtkraft, Querkraft und Vortrieb................ 17 17 Gesteuerter Kurs, gesegelter Kurs und Abdrift........... 17 18 Form- und Gewichtsstabilität eines Segelbootes.......... 18 19 Aerodynamik am Segelboot.................... 18 20 Segelboot, gerendert mit 3ds max................. 19 21 Szenengraph des Segelbootes.................... 20 22 Softwaretechnischer Entwurf.................... 21 23 Funktion C A Wert.......................... 24 24 Der Szenengraph.......................... 29 25 Streamline auf Halbwind-Kurs................... 32 26 Streamline auf Raumschots-Kurs.................. 33 27 Streamline auf Am-Wind-Kurs................... 33 28 Anzeige für die Steuerung..................... 34 29 Streamline auf Am-Wind-Kurs................... 34 36