Dr. David Sabel Fachbereich Informatik und MathematikInstitut für Informatik Johann Wolfgang Goethe-Universität Frankfurt am Main

Praktikum BKSPPSommersemester 2010

Aufgabenblatt Nr. 2

Abgabe: Mittwoch, 16. Juni 2010

Auf diesem Aufgabenblatt wird OpenGL1 verwendet, um graphische(2D und 3D) Ausgaben zu erzeugen. Als Haskell-Bibliotheken zur An-bindung an OpenGL und GLUT2 werden die entsprechenden Cabal-Pakete OpenGL (http://hackage.haskell.org/package/OpenGL) und GLUT(http://hackage.haskell.org/package/GLUT) verwendet.

Die Haskell-Platform beinhaltet diese Bibliotheken bereits. Eventu-ell muss auf dem eigenen Rechner die GLUT Bibliothek (z.B. Free-GLUT unter Linux http://freeglut.sourceforge.net/ oder GLUT for Windows(http://www.xmission.com/∼nate/glut.html) nachinstalliert werden.

Testen auf verschiedenen System ergab, dass das Starten eines OpenGL-Fenster ausdem ghci heraus manchmal zu Abstürzen führt. In diesem Fall empfiehlt es sich dasProgramm zu kompilieren. Im Allgemeinen sollte ein Aufruf der Form

ghc --make -o output.exe Input.hs

wobei Input.hs das Programmfile ist, funktionieren. Anschließend kann das Programmoutput.exe ausgeführt werden.

Als erster Einstieg zur OpenGL-Programmierung mit Haskell kann die Seitehttp://www.haskell.org/haskellwiki/Opengl dienen, über die z.B. das OpenGL Tuto-rial 1 (http://www.haskell.org/haskellwiki/OpenGLTutorial1) und OpenGL Tutorial 2(http://www.haskell.org/haskellwiki/OpenGLTutorial2) zu finden sind.

Eine sehr gute Einführung bietet das Tutorial von Sven Eric Panitz, welches überhttp://www.cs.hs-rm.de/∼panitz/hopengl frei verfügbar ist.

1 Grundgerüst für ein OpenGL-Programm in Haskell

Wir betrachten ein einfaches Grundgerüst für ein in Haskell implementiertes OpenGL-Programm. Zunächst werden die beiden Bibliotheken für OpenGL und für GLUT im-portiert:

1OpenGL steht für Open Graphics Library, die Webseite von OpenGL ist http://www.opengl.org/2GLUT steht für OpenGL Utility Toolkit (siehe auch http://www.opengl.org/resources/libraries/glut/

1

import Graphics.UI.GLUTimport Graphics.Rendering.OpenGL

Das Hauptprogramm erhält folgendes Gerüst

main = do(prgName,_) <- getArgsAndInitializecreateWindow prgNamewindowSize $= Size 800 800displayCallback $= mainDisplaymainLoop

Hierbei wird in der ersten monadischen Aktion getArgsAndInitialize GLUT in-itialisiert und an prgName der Aufruf-Name des Programms gebunden. Im zwei-ten Schritt wird mittels createWindow prgName ein Fenster mit dem Titel des Pro-grammnamens erzeugt. In Zeile 3 wird mit dem Operator $= der OpenGL-VariablenwindowSize die Größe 800x800 zugewiesen, d.h. das Fenster wird auf diese Größe ein-gestellt. In Zeile 4 wird mit displayCallback $= mainDisplay der OpenGL-VariablendisplayCallback die Funktion mainDisplay zugewiesen (diese wird später definiert).Hierbei ist displayCallback ein (eingebauter) Ereignis-Handler, der das Ereignis desAnzeigens des Fensters übernimmt. Durch unsere Zuweisung wird bei jedem Anzei-gen und Wiederanzeigen des Fensters, die mainDisplay-Funktion aufgerufen, sie be-stimmt also den Fensterinhalt. Schließlich wird in der letzten Zeile mit mainLoop derGLUT-Ereignisprozesser gestartet, der sämtliche Ereignisse abfängt und an die vorherdefinierten Handler übergibt (in diesem Fall wurde nur der displayCallback-Handlervorher registriert).

Es fehlt nun noch die Implementierung der Funktion mainDisplay, die den Fensterinhaltbeschreibt. Eine ganz einfache Definition ist:

mainDisplay = clear [ColorBuffer]

In diesem Fall wird der Fensterinhalt gelöscht. Ruft man das Programm insgesamt auf,erhält man ein schwarzes Fenster.

Wir betrachten nun einige einfache Funktionen zum Anzeigen von Punkten, Linien,Streckenzügen und Polygonen. Wir definieren hierfür zunächst zwei Typsynonyme

type Coord = (GLfloat,GLfloat,GLfloat)type ColoredCoord = (GLfloat,GLfloat,GLfloat,Color4 GLfloat)

Der Typ Coord stellt ein 3-Tupel von GLfloat-Werten dar. Seine Bedeutung ist eine3-dimensionale Koordinate. Jeder der einzelnen drei Werte sollte hierbei einen Wertzwischen -1 und 1 besitzen, damit er innerhalb des Fensters liegt. Der Typ ColoredCoordist ein 4-Tupel, wobei die ersten 3 Komponenten wieder X-, Y-, und Z-Koordinaten sind

2

und der vierte Wert eine Farbe darstellt. Für die Farben benutzen wir den vordefiniertenTyp Color4 GLfloat, der RGBA-Farbwerte darstellen kann. RGBA steht für Red-Green-Blue-Alpha, mit dem Datenkonstruktor Color4 können Farben erzeugt werden, z.B.

red = Color4 1 0 0 1green = Color4 0 1 0 1blue = Color4 0 0 1 1

Alle 4 Werte sollten zwischen 0 und 1 liegen. Die ersten 3 Werte geben den Rot-, Grün,bzw. Blau-Anteil an, der letzte Wert (der Alpha-Wert) die Transparenz der Farbe.

Eine Funktion zum Anzeigen einer Liste von Punkten (vom Typ Coord) kann in Haskellnun programmiert werden als

displayPoints points =renderPrimitive Points $ mapM_ (\(x, y, z)-> vertex $ Vertex3 x y z) points

Die wesentliche Bibliotheksfunktion ist hierbei renderPrimitive, die einfache Grafikob-jekte erzeugen kann. Mit vertex $ Vertex3 x y z werden die Punkte vom Typ Coordnoch in für renderPrimitive passende Objekte (dies sind monadische IO-Aktionen)konvertiert.

Eine erweiterte Variante ist die folgende Funktion, die farbige Punkte (vom TypColoredCord) anzeigen kann:

displayCPoints points =renderPrimitive Points $ mapM_ (\(x, y, z, c) -> do

currentColor $= cvertex $ Vertex3 x y z) points

Der Aufbau gleicht fast displayPoints, mit der Ausnahme, dass für jeden Punkt eineerweiterte IO-Aktion erzeugt wird: Bevor der eigentliche Punkt mit vertex ... erzeugtwird, wird die aktuelle Farbe mit currentColor $= c auf den entsprechenden Farbwertgesetzt.

Eine Funktion zur Anzeige von Linien kann programmiert werden als

displayLines points =renderPrimitive Lines $ mapM_ (\(x, y, z)-> vertex $ Vertex3 x y z) points

Hierbei werden je zwei Punkte aus der Liste der übergebenen Punkte als Endpunkteeiner Linie verwendet.

Die Funktion

displayLineStrip points =renderPrimitive LineStrip $ mapM_ (\(x, y, z)-> vertex $ Vertex3 x y z) points

3

zeichnet einen Streckenzug durch die übergebenen Koordinaten.

Ein (konvexes) farbiges Polygon (gegeben durch Koordinaten und eine Farbe) kanngezeichnet werden mit

displayPolygon points color =docurrentColor $= colorrenderPrimitive Polygon $ mapM_ (\(x, y, z)-> vertex $ Vertex3 x y z) points

Wir können die mainDisplay-Funktion z.B. wie folgt abändern, um verschiedene Objek-te zu zeichnen. Hierbei sollte am Ende ein Aufruf von flush erfolgen, um alle Zwischen-buffer sicher zu leeren, und damit zu garantieren, dass wirklich alle Objekte gezeichnetwerden.

mainDisplay = do-- Hintergrundfarbe festlegenclearColor $= Color4 1 1 1 1-- Fensterinhalt l"oschenclear [ColorBuffer]-- Farbe auf Schwarz setzencurrentColor $= Color4 0 0 0 1-- Punkte anzeigendisplayPoints beispielPunkte-- farbige Punkte anzeigendisplayCPoints beispielFarbpunkte-- rotes Polygon anzeigendisplayPolygon beispielPunkte red-- aktuelle Farbe auf gr"un umstellencurrentColor $= green-- Linien zeichnendisplayLines beispielPunkte2currentColor $= blue-- Linien zeichnendisplayLineStrip beispielPunkte3flush

beispielPunkte :: [Coord]beispielPunkte =[(-0.25, 0.25, 0.0), (0.75, 0.35, 0.0), (0.75, -0.15, 0.0), (-0.75, -0.25, 0.0)]

beispielPunkte2 :: [Coord]beispielPunkte2 =[(-0.3, 0.1, 0.0), (0.8, 0.1, 0.0), (0.5, -0.7, 0.0), (-0.4, -0.1, 0.0)]

4

beispielPunkte3 :: [Coord]beispielPunkte3 =[(-0.3, 0.1, 0.0), (-0.1, 0.1, 0.0), (0.3, 0.4, 0.0), (0.8, 0.1, 0.0),(0.5, 0.7, 0.0), (0.4, -0.1, 0.0)]

beispielFarbpunkte :: [ColoredCoord]beispielFarbpunkte =[(-0.5, 0.5, 0.0, red), (0.5, -0.5, 0.0,green), (-0.5, -0.5, 0.0,blue),(0.5, 0.5, 0.0,Color4 1 1 1 1)]

Ausführung des Programms ergibt das folgende Fenster

Aufgabe 1 Implementieren Sie in Haskell ein OpenGL-Programm zum Zeichnen von Funkti-onsgraphen. Dabei sollte eine Funktion

plot :: GLfloat -> (GLfloat -> GLfloat) -> GLfloat -> GLfloat -> [Coord]plot delta f start stop = ...

erstellt werden, wobei delta eine Schrittweite, f eine Funktion auf GLfloat-Werten, und startund stop das zu betrachtende Intervall (X-Werte) markieren. plot berechnet die Koordinatendes Funktionsgraphen im Intervall [start,stop] mit einer Schrittweite von delta.

Implementieren Sie anschließend eine Funktion bestScale :: [Coord] -> [Coord], die eineListe von Koordinaten erhält und diese so skaliert, dass alle Punkte im Fenster liegen, d.h.X,Y,Z-Koordinaten der Ausgabe Koordinaten liegen im Intervall [−1, 1].

Kombinieren Sie plot und bestScale und lassen sie verschiedene Funktiongraphen zeichnen.

Als Beispiel betrachten wir die Exponentialfunktion im Bereich -5 bis 10:

5

test = let delta = 0.01start = -5stop = 10f x = 2**x

in plot delta f start stop

Die folgenden zwei Abbildungen zeigen links das Ergebnis ohne Skalierung und rechts dieAusgabe bei Verwendung von bestScale:

2 Zweidimensionale Turtlegrafiken

Im Folgenden verwenden wir Haskells OpenGL-Anbindung, um zweidimensionaleTurtle-Grafiken zu erzeugen. Wir implementieren hierfür keine eigene Turtle-Sprache,sondern betten diese Sprache als Datentyp in Haskell ein. Der Zustand einer (zweidi-mensionalen) Schildkröte (Turtle) besitzt die folgenden Attribute:

• Position im zweidimensionalen Raum als X- und Y-Koordinaten

• einen Winkel, der die Laufrichtung der Schildkröte angibt (im Gradmaß)

• Ein Flag, das angibt, ob die Schildkröte beim Laufen zeichnet oder nicht zeichnet.

• Eine Farbe, die angibt, mit welcher Farbe die Schildkröte zeichnet.

In Haskell stellen wir eine Schildkröte durch den Datentyp Turtle dar, wobei wir dieRecord-Syntax verwenden:

data Turtle = Turtle{ xpos :: GLfloat,

6

ypos :: GLfloat,angle :: GLfloat,painting :: Booltcolor :: Color4 GLfloat

}

Eine Schildkröte kann die folgenden Kommandos verarbeiten:

• Gehen: Die Schildkröte bewegt sich um einen übergebenen Wert vorwärts (inRichtung des eingestellten Winkels), ist der übergebene Wert negativ, so läuft dieSchildkröte rückwärts. Ist painting auf True gesetzt, so zeichnet die Schildkröteden gegangenen Weg.

• Drehen: Die Schildkröte dreht sich im Uhrzeigersinn, um den übergebenen Win-kel. Ist der Winkel negativ, so dreht sich die Schildkröte gegen den Uhrzeigersinn.

• Stift an/aus: Das Flag (Zeichnen ja/nein) wird geändert.

• Farbe setzen: Der Wert von tcolor wird auf einen übergebenen Farbwert gesetzt.

In Haskell stellen wir Schildkröten-Aktionen durch einen Datentypen dar:

data TurtleAction =Move GLfloat

| Turn GLfloat| FlipPaint| SetColor (Color4 GLfloat)

Aufgabe 2 Implementieren Sie eine Funktion

applyAction :: TurtleAction -> Turtle -> Turtle

die eine Schildkrötenaktion und eine Schildkröte erwartet und den Nachfolgezustand der Schild-kröte berechnet.

Hinweise:

• Beachten Sie, dass die Gehen-Aktion die Weglänge erhält. Um daraus entsprechende X-und Y -Koordinaten zu berechnen, sollten sie die in Haskell eingebauten trigonometrischenFunktionen sin und cos verwenden, wobei sie den Winkel hierfür vom Gradmaß insBogenmaß umrechnen müssen. Hierfür gilt die Formel3:

winkelImGradmaß = (winkelImBogenmaß/π) · 180

• Für die Berechnung der Koordinaten könnte folgendes Bild hilfreich sein:3Eine Näherung der Zahl π ist in Haskell durch die Funktion pi bereits vordefiniert.

7

sin(α) = a/h

cos(α) = b/h

Ein Schildkrötenprogramm ist eine Sequenz von Schildkrötenaktionen. In Haskell kannein solches Programm durch folgenden Typ dargestellt werden:

type TurtleProgram = [TurtleAction]

Aufgabe 3 Implementieren Sie in Haskell ein Programm, dass eine initiale Schildkröte und einSchildkrötenprogramm erwartet, und die von der Schildkröte bei Ausführung des Schildkröten-programms erzeugte Grafik mittels OpenGL darstellt.

Aufgabe 4 Implementieren Sie in Haskell ein Schildkrötenprogram (vom Typ TurtleProgram),welches das folgende „Haus vom Nikolaus“ zeichnet:

Aufgabe 5 Implementieren Sie in Haskell eine rekursive Funktion nEck, die eine Zahl n erwar-tet und ein Schildkrötenprogram (vom Typ TurtleProgram) generiert, welches ein gleichmäßigesn-Eck zeichnet. Die folgenden Abbildungen zeigen Aufrufe für n = 8 und n = 15:

Aufgabe 6 Implementieren Sie in Haskell eine rekursive Funktion nnEck, die eine Zahl n

erwartet und ein Schildkrötenprogram (vom Typ TurtleProgram) generiert, das n viele n-Eckeim Kreis herum zeichnet. D.h. vom Mittelpunkt aus: Nach Zeichnen eines n-Ecks wird dasnächste n-Eck um (360/n) Grad gedreht gezeichnet. Die folgenden Abbildungen zeigen Aufrufefür n = 3, n = 8 und n = 20, wobei die Größe der einzelnen n-Ecke angepasst wurde.

8

Aufgabe 7 Implementieren Sie in Haskell eine rekursive Funktion pBaum, die ein Schildkrö-tenprogram (vom Typ TurtleProgram) generiert, das einen so genannten Pythagorasbaumzeichnet.

Die Konstruktion (siehe linkes Bild unten) beginnt hierbei mit einem Quadrat, auf welches ineinem rechtwinkligen Dreieck rekursiv zwei Dreiecke gezeichnet werden, z.B. für die Winkel 30und 60 Grad. Führt man diese Konstruktion rekursiv weiter bis die Quadrate ziemlich kleinwerden, erhält man den Pythagorasbaum wie im mittleren Bild gezeigt. Schöner wird der Baum,wenn man nur die linke und die rechte Seite jedes Quadrats zeichnet und noch eine Färbungder Quadrate vornimmt (rechtes Bild).

3 Dreidimensionale Turtlegrafiken

In diesem Abschnitt wird das bisherige Turtle-Interface auf drei Dimensionen erwei-tert. Neben den bereits aus dem Zweidimensionalen bekannten Attributen, erhält einedreidimensionale Schildkröte die folgenden zusätzlichen Eigenschaften:

• Für die Position im dreidimensionalen Raum zusätzlich zu den X- und Y-Koordinaten eine Z-Koordinate.

• Der bisherige Winkel gibt eine Laufrichtung bzgl. der X- und Y-Achse an. Nunwird ein weiterer Winkel hinzugefügt, der die Laufrichtung bezüglich der X- undZ-Achse angibt. Dies entspricht im Wesentlichen so genannten Kugelkoordinaten.

Unser Haskell-Datentyp wird dementsprechend erweitert in:

9

data Turtle = Turtle{ xpos :: GLfloat,

ypos :: GLfloat,angle :: GLfloat,painting :: Bool,tcolor :: Color4 GLfloat,

-- neu:zpos :: GLfloat,angleXZ :: GLfloat

}

Damit sich die Schildkröte im 3-dimensionalen-Raum bewegen kann, wird als neueAktion das Drehen des Winkels angleXZ hinzugefügt. Die Interpretation der Gehen-Operation ändert sich natürlich auch, da beide Winkel beachtet werden müssen.

Das folgende Bild zeigt die Kugelkoordinaten, wobei α der Winkel zwischen der X- undder Y-Achse und β der Winkel zwischen der X- und der Z-Achse darstellt.

Sei r die Länge des blauen Pfeils. Dann kann man die Längen der Projektionen auf dieeinzelnen Achsen wie folgt berechnen (diese benötigen sie für die Implementierung derGehen-Operation!):

x = r · cos α · sin β

y = r · sin α · sin β

z = r · cos(β)

Aufgabe 8 Implementieren Sie in Haskell ein Modul Turtle3D, welches das zweidimensiona-le Schildkröteninterface auf drei Dimensionen erweitert und Schildkrötenprogramme ausführen(und korrekt darstellen) kann. Schildkrötenprogramme sind hierbei Listen von Elementen desTyps TurtleAction, der um die TurnXZ-Aktion erweitert wurde, d.h.

data TurtleAction =Move GLfloat

10

| Turn GLfloat| FlipPaint| SetColor (Color4 GLfloat)| TurnXZ GLfloat

Hinweise:Im CVS-Repository ist ein erweitertes Basisprogramm namens Basis3D.hs nebst zwei Hilfs-modulen (aus der Anleitung von S.E. Panitz) eingecheckt. Dieses erlaubt Interaktion: Durchdrücken der Pfeiltasten kann navigiert, durch Drücken von + und - gezoomt werden. Verwen-den Sie dieses Programm als Rahmenprogramm für das Schildkrötenprogramm.

Aufgabe 9 Implementieren Sie in Haskell eine Funktion

wuerfel :: GLfloat -> [TurtleProgram]

die eine Länge erwartet und ein Schildkrötenprogramm zur Erzeugung eines dreidimensionalenWürfels erzeugt. Eine Ausgabe zeigt folgendes Bild:

Aufgabe 10 Implementieren Sie in Haskell eine Funktion pyramide, die eine Zahl w erwartetund ein Schildkrötenprogramm erzeugt, welches eine Stufenpyramide zusammengesetzt ausWürfeln zeichnet, wobei die Grundfläche aus w × w Würfeln besteht.

Das linke Bild zeigt eine Pyramide für w = 5. Das rechte Bild eine Pyramide für w = 25, wobeidie einzelnen Ebenen in verschiedenen Farben gezeichnet wurden:

11

Aufgabe 11 Implementieren Sie in Haskell eine Funktion messeturm, die ein Schildkröten-programm generiert, welches den Messeturm zeichnet. Zumindest die im Folgenden gezeigtenMerkmale (2 Quader, 1 Zylinder, 1 Pyramide) sollten enthalten sein:

12