Interaktives Augmented-Reality

Fachbereich 4: Informatik
Interaktives Augmented-Reality-Spiel
Studienarbeit
im Studiengang Computervisualistik
vorgelegt von
Marko Heinrich
Betreuer:
Prof. Dr. Stefan Müller
(Institut für Computervisualistik, AG Computergraphik)
Koblenz, im Juni 2006
Institut für Computervisualistik
AG Computergraphik
Prof. Dr. Stefan Müller
Postfach 20 16 02
56 016 Koblenz
Tel.: 0261-287-2727
Fax: 0261-287-2735
E-Mail: stefanm@uni-koblenz.de
Fachbereich 4: Informatik
Aufgabenstellung für die Studienarbeit
Marko Heinrich
Thema:
Interaktives Augmented Reality Spiel
In keinem Bereich der Informatik hat sich in den letzten Jahren die Hardware so rasant entwickelt, wie im
Bereich der Computergrafik. So kann man heute mit vergleichsweise kostengünstigen Graphikkarten virtuelle
Welten in einer Komplexität und Qualität darstellen, für die bis vor wenigen Jahren noch Investitionen in
Millionenhöhe nötig waren.
Kaum ein Gebiet der Informatik bietet ein so umfangreiches und ungenutztes Potential wie die Augmented
Reality. Insbesondere findet die visuelle Ergänzung immer mehr bei interaktiver Unterhaltungssoftware
Verwendung. Der Mögliche Einsatz einer solchen Technik im Bereich der Unterhaltung soll hier am Beispiel
einer Art Geschicklichkeits-/Reaktionsspiel aufgezeigt werden.
Eine Herausforderung ist neben der 3D-Darstellung aber auch die 3D-Interaktion, die in den Bereichen
Virtuelle Realität und Augmented Reality neue Potentiale für innovative Mensch-Maschine-Schnittstellen
vermuten lässt. Im Rahmen dieser Arbeit soll daher eine spielerische Anwendung mit 3D-Eingabmöglichkeiten
verbunden werden.
Ziel dieser Arbeit ist die Konzeption und Entwicklung eines interaktiven AR Geschicklichkeits/Reaktionsspiels.
Schwerpunkte dieser Arbeit sind:
1. Einarbeitung in das AR-Toolkit
2. Entwicklung eines Spielkonzepts
3. Implementierung und Umsetzung des Spielkonzeptes
4. Demonstration der Ergebnisse an Beispielen
5. Dokumentation der Ergebnisse
Koblenz, den 24.10.2005
- Prof. Dr. Stefan Müller-
Erklärung
Ich versichere, dass ich die vorliegende Arbeit selbstständig verfasst und keine
anderen als die angegebenen Quellen und Hilfsmittel benutzt habe.
Ja
Nein
Mit der Einstellung dieser Arbeit in die Bibliothek bin ich
einverstanden.
□ □
Der Veröffentlichung dieser Arbeit im Internet stimme ich zu.
□ □
Ort, Datum
Unterschrift
3
Inhaltsverzeichnis
1
EINLEITUNG .......................................................................................................5
1.1 Motivation ......................................................................................................................... 5
1.2 Ziel ..................................................................................................................................... 7
1.3 Aufbau ............................................................................................................................... 7
2
GRUNDLAGEN ....................................................................................................8
2.1 Augmented Reality ........................................................................................................... 8
2.2 Marker-Tracking.............................................................................................................. 8
2.3 Stand der Technik: Beispiele aus dem Bereich Unterhaltungssoftware mit
Augmented Reality Bezug..................................................................................................... 10
3
KONZEPT .........................................................................................................12
4
UMSETZUNG ....................................................................................................14
4.1 ARToolKit....................................................................................................................... 14
4.2 Implementierung des Spiels „CatchAR“ ...................................................................... 16
4.3 Probleme und Tipps ....................................................................................................... 22
5
ERGEBNISSE .....................................................................................................24
5.1 Die 3D-Modelle ............................................................................................................... 24
5.2 Benötigte Hardware ....................................................................................................... 25
5.3 Das Spiel „CatchAR“ ..................................................................................................... 26
5.3.1 Spielprinzip............................................................................................................ 26
5.3.2 Installation ............................................................................................................. 27
5.3.3 Spielablauf ............................................................................................................. 27
6
FAZIT / ERWEITERUNGSMÖGLICHKEITEN .....................................................32
6.1 Fazit ................................................................................................................................. 32
6.2 Erweiterungsmöglichkeiten ........................................................................................... 32
7
ANHANG ...........................................................................................................35
7.1 Eingesetzte Software ...................................................................................................... 35
ABBILDUNGSVERZEICHNIS ....................................................................................36
QUELLENVERZEICHNIS .........................................................................................37
4
1 Einleitung
1.1 Motivation
Die Idee für die Implementierung des hier vorgestellten interaktiven AugmentedReality-Spiels stammt aus dem LucasArts „Point and Click“ Adventure „Sam und
Max Hit the Road“ aus dem Jahre 1993. In diesem Spiel steuert der Spieler die
beiden Hauptakteure Sam (einen Hundedetektiv) und Max (einen aggressiven,
psychopatischen Hasen, mit hang zur unnötigen Gewalt) in einer sarkastische
Geschichte um die Suche nach einem Yeti quer durch Amerika.
In das eigentliche Adventure-Spielgeschehen wurden zur Auflockerung einige
kleine Zusatzspiele integriert, z. B. eine Variation des Spiels „Schiffe versenken“.
Unter diesen Zusatzspielen befindet sich auch das Spiel „Wak-A-Rat“, welches
den Anstoß für das in dieser Studienarbeit entwickelte Augmented-Reality-Spiel
liefert.
Die Aufgabe des Spielers in „Wak-A-Rat“ ist es Mäusen, die aus einer Kiste
erscheinen, auf den Kopf zu schlagen. Pro getroffene Maus gibt es dafür Punkte.
Abb. 1: Sam und Max hit the road
5
Variationen
Mittlerweile existieren eine Vielzahl von alternativen Umsetzungen des
„Wak-a-rat“ Spiels im Internet.
Eine einfache Variante des Originals ist unter dem gleichen Namen im Internet zu
finden. Bei „Wak-a-rat“1 muss der Spieler mit der Maus als Eingabegerät aus
einem Käse erscheinende Mäuse treffen. Nach zehn getroffenen Mäusen steigt der
Spieler einen Level auf. Um zum nächsten Level zu gelangen muss er 10 Mäuse
treffen.
Eine weitere, im Laufe dieser Studienarbeit erschienene Version ist „Tontie“2. Der
Ablauf dieses Spiels ist wesentlich komplexer als der des Originals, das
Grundprinzip ist jedoch das gleiche geblieben. Es müssen erscheinende Figuren
durch drücken der Zahlen auf der numerischen Tastatur getroffen werden Als
Erweiterungen existieren hier verschiedene Arten von Figuren („Gute“ und
„Böse“) und Bonusobjekte, wie z. B. Geldmünzen und Lebenspunkte. Diese
Geldmünzen kann man in einem virtuellen Laden gegen Verbesserungen
eintauschen.
Abb. 2: Wak-a-rat
1
2
Abb. 3: Tontie
http://www.alles-4-u.com/wak_a_rat/wakarat.html
http://www.eyezmaze.com/tontie/v1/index.html
6
Vereinzelt existieren auch Hardware-Umsetzungen dieses Spielprinzips. Diese
sind überwiegend auf Jahrmärkten zu finden.
1.2 Ziel
Ziel dieser Studienarbeit ist es, ein interaktives augmented reality Reaktions- und
Geschicklichkeitsspiel unter Verwendung des ARToolKits zu entwickeln. Von
allen Seiten wird propagiert, dass Kinder zu viel Zeit vor dem Computer
verbringen und sich zu wenig bewegen. Ein Augmented-Reality-Spiel löst dieses
Problem indem Computer spielen und Bewegung miteinander kombiniert werden.
Außerdem ist ein Spiel ein guter Weg, einer breiten Masse auf spielerische Art
und Weise eine neue Technologie nahe zu bringen. Augmented-Reality-Spiele
haben in den letzten Jahren auch in der Unterhaltungsindustrie eine immer
größere Verbreitung erlangt.
1.3 Aufbau
Im folgenden Kapitel werden die Grundlagen für das bessere Verständnis dieser
Studienarbeit vorgestellt. Hierzu gehören neben Einführungen in Augmented
Reality und das Marker-Tracking, die Vorstellung des Stands der Technik anhand
zweier Beispiele aus dem Bereich der Unterhaltungssoftware, die Augmented
Reality verwendet. In Kapitel 3 wird das ursprüngliche Konzept vorgestellt, das
Vorüberlegungen zur Umsetzung beinhaltet.
Die technische Seite des ARToolKits sowie des Spieles CatchAR wird in Kapitel
4 behandelt, außerdem wir an dieser Stelle auf einige aufgetretene Probleme,
sowie deren Lösung eingegangen.
Die Ergebnisse werden in Kapitel 5 gezeigt. Dort wird auf die Erstellung der 3DModelle und die für das Spiel benötigte Hardware eingegangen. Darüber hinaus
wird das umgesetzte Spielkonzept in diesem Kapitel vorgestellt.
Den Abschluss dieser Ausarbeitung bilden ein Fazit und ein Ausblick mit
Verbesserungs- und Erweiterungsvorschlägen.
7
2 Grundlagen
2.1 Augmented Reality
Der Begriff „Augmented Reality“ steht für eine „erweiterte Realität“. Dabei
werden digitale Informationen in das Sichtfeld des Benutzers (hier: Kamerabild)
projiziert. Diese Informationen überlagern und ergänzen dadurch das reale Bild.
In Augmented Reality schwinden die Grenzen zwischen Realität und
Computergrafik. Die Einsatzgebiete des Augmented Reality sind unbegrenzt.
Neben dem Einsatz in den Bereichen der Medizin, Bildung und Unterstützung von
Arbeitsprozessen
findet
es
auch
immer
größere
Verwendung
in
der
Unterhaltungsindustrie.
Das technische Hauptaugenmerk liegt bei Augmented Reality auf dem TrackingVerfahren. Dieses dient dazu, die Realität zu erkennen und zu analysieren und die
gewonnenen Informationen zur Weiterverarbeitung bereitzustellen. Mit Hilfe
dieser Informationen können nun die Zusatzinformationen über das reale Sichtfeld
eingeblendet werden
2.2 Marker-Tracking
Damit die virtuellen Objekte perspektivisch korrekt und passend skaliert
angezeigt werden können, werden Orientierungspunkte benötigt. Hierzu werden
bei optischem Tracking oft so genannte „Marker“ verwendet (siehe Abb. 4).
8
Abb. 4: Beispielmarker
Die Verwendung von Markern bringt einige Nachteile mit sich. So müssen die
Marker an den speziellen Orten, an denen später Informationen eingeblendet
werden sollen, angebracht werden. Hierdurch sind die Marker natürlich ständig
für jedermann sichtbar, auch wenn gerade nicht getrackt wird.
Die Vorteile beim Marker-Tracking liegen in dem geringen Aufwand und den
Kosten, da beliebig viele Marker einfach gedruckt werden können. Außerdem
sind keine Verkabelungen nötig und dadurch bedingt wird eine hohe Mobilität
erreicht. Zusätzlich bekommt man im Vergleich zu anderen optischen
Trackingverfahren nicht nur die Identifizierung des Markers (ID), sondern auch
dessen
Ausrichtung
mitgeliefert.
Dabei
werden
die
Marker
anhand
bildverarbeitender Berechnungen erkannt und ausgewertet. Genau diese
Funktionalität bietet das ARToolKit, welches in dieser Studienarbeit verwendet
wurde.
Die Probleme bei Augmented Reality in Verbindung mit Marker basiertem
Tracking liegen hauptsächlich im Bereich der Benutzerführung und der
Performanz. Bei der Benutzerführung wird häufig noch auf die Verwendung von
Tastatur und Maus zurückgegriffen. Dies zerstört jedoch einen Teil der
Immersion3, die auch bei Augmented Reality sehr wichtig ist.
3
Lat. Immersio = Eintauchung; Eintauchen in eine virtuelle Realität, ohne die wirkliche Realität
wahrzunehmen.
9
2.3 Stand der Technik: Beispiele aus dem Bereich
Unterhaltungssoftware mit Augmented Reality Bezug
Die bekannteste Anwendung von Augmented Reality aus dem Bereich der
Unterhaltungsindustrie ist das von Sony entwickelte „EyeToy“4 für die
Playstation 2, einer ebenfalls von Sony entwickelten Spielekonsole. Dabei wird
von einer Kamera die Bewegungen des Spielers aufgezeichnet und dadurch das
Spielgeschehen beeinflusst.
Abb. 5: EyeToy Kinetic
Die Spielerposition beruht hier nicht auf einer Marker-Erkennung, sondern auf
einem Motion-Tracking-System, das mit Differenzbildern arbeitet. Der Nachteil
dieser Technik ist, dass ein möglichst einfarbiger Hintergrund im Video benötigt
wird und die Kamera nicht bewegt werden darf.
Ein weiteres Beispiel ist das Augmented-Reality-Spiel „The Invisible Train“5 der
Universität Wien. Hierbei können mehrer Spieler parallel virtuelle Züge auf einer
realen Holzeisenbahnstrecke fahren lassen. Diese Züge sind nur durch PDA’s in
Verbindung mit einer Kamera sichtbar, an denen eine Kamera angebracht ist. Die
4
5
http://www.eyetoy.com
http://studierstube.icg.tu-graz.ac.at/invisible_train/
10
Spieler können interaktiv in den Streckenverlauf eingreifen, indem sie virtuelle
Weichen umstellen können. Das Ziel des Spiels ist es, einen Zusammenstoß der
fahrenden Züge zu vermeiden.
Abb. 6: Invisible Train auf PDA’s
11
3 Konzept
Die Überlegung für diese Studienarbeit bestand darin, aus dem Ideenanstoß der
Vorlage „Wak-a-rat“ aus „Sam und Max“ ein komplexeres Augmented-RealitySpiel zu entwickeln. Da das Originalspiel ein relativ einfaches Spielprinzip
besitzt, ist dafür beim Spieler keine Langzeitmotivation vorhanden. Bei der
Erstellung eines komplexeres Spielprinzips muss jedoch stets berücksichtig
werden, dass die Spielbalance immer ausgeglichen bleibt.
Auch sollte ein Reaktionsspiel nicht zu schnell ablaufen, damit der Spieler nicht
durch eine zu schwere Spielbalance demotiviert wird. Ist das Spiel zu langsam,
läuft man Gefahr, dass der Spieler sich zu schnell langweilt.
Der Vorteil von Augmented Reality ist die Möglichkeit einer Marker-Steuerung.
Im hier erstellten Spiel CatchAR wurde deshalb darauf Wert gelegt, die
Verwendung von anderen Eingabegeräten auf ein Minimum zu reduzieren.
Auch sollte das Spiel in seiner Gesamtheit harmonisch erscheinen. Es sollten so
wenig Stilbrüche bei der Verwendung von Rechnererzeugten Objekten und der
realen Hardware auftreten.
Obwohl die Kamera theoretisch während des gesamten Spiels frei beweglich ist,
sollte diese befestigt werden können, da während des Spielens eine
Beeinträchtigung des Spiels durch deren Bewegung vermieden werden sollte.
Als Thema des Spiels boten sich Tiere aus dem Bereich der Insekten an, da diese
in ihrer wirklichen Größe dargestellt werden können, was zu einer Zunahme des
Realitätseindrucks führt. Eine realitätsnahe Analogie ist es dabei, die Insekten mit
einem Kescher zu fangen. Zusätzlich ist dies ein weniger gewalttätiges
Spielprinzip als es die Urversion dieses Spiels besitzt, bei dem die Mäuse mit dem
Hammer getroffen werden müssen.
Das Spielbrett sollte durch einen oder mehrere Marker dargestellt werden. Um
eine technisch gute Umsetzung des Spiels zu erreichen, ist es sinnvoll nicht
12
einfach durch Verdecken eines Spielbrett-Markers einen Treffer zu erzielen, da
der Spieler so in Versuchung geführt werden würde, einfach seine Hand, anstelle
des Fanggerätes zu verwenden. Stattdessen sollte mit einem zusätzlichen Marker
gearbeitet werden, der an dem Fanggerät angebracht ist und dessen Position mit
den Positionen der Marker auf dem Spielbrett verglichen wird, um einen Treffer
zu erzielen.
13
4 Umsetzung
4.1 ARToolKit
Das ARToolKit ist eine in C geschriebene plattformunabhängige Bibliothek zum
markerbasierten Tracken und wurde an der Universität von Washington[3]
entwickelt.
Mit dem ARToolKit wird es Programmieren ermöglicht, relativ einfach
Augmented Reality Anwendungen zu entwickeln. Der Source-Code ist frei
erhältlich (Open Source, GPL Lizenz). Ein Vorteil des ARToolKit ist die
Verfügbarkeit für viele Plattformen (Windows, Linux, Mac, SGI, Matlab, ...).
Um eine Anwendung mit der ARTooKit Bibliothek auszuführen, werden folgende
Dinge benötigt:
•
Videoeingabegerät (z.B. Webcam)
•
OpenGL Treiber
•
GLUT Bibliothek
•
Microsoft DirectShow runtime (Teil von DirectX)
•
Optional: OpenVRML renderer
Funktionsweise des ARToolKits
Das ARToolKit stellt dem Programmierer Funktionen für das Aufnehmen von
Videobildern aus einer Videoquelle, Verarbeitung dieser Bilder für optisches
Tracking, sowie zur Anzeige von Computer generierten Informationen zur
Verfügung.
Der grobe Ablauf einer das ARToolKit nutzenden Anwendung ist im Prinzip
immer gleich:
1. Ein Videobild wird ausgelesen.
2. Dieses wird nach Markern und bekannten Mustern untersucht.
14
3. Die Kameratransformationen werden relativ zu jedem gefundenen Muster
berechnet.
4. Anhand dieser Transformationen werden die Virtuellen Objekte über die
erkannten Muster gezeichnet.
Dieser Ablauf wird für jeden einzelnen Videoframe wiederholt.
Den Prozess der Marker-Erkennung ist in folgender Darstellung gut zu erkennen
(Abb. 7).
Abb. 7: Marker-Erkennung im ARToolKit [4]
Das Videobild von einer Kamera wird anhand eines Schwellenwertes in ein
schwarzweißes Bild umgewandelt, in dem die schwarze Umrandung des Markers
detektiert wird.
Abb. 8: links Videobild, rechts Videobild nach Schwellwertanwendung (Schwellwert: 100)
15
Wird dieser Rahmen ein klein wenig überdeckt, kann schon der Fall eintreten, das
die Marker-Erkennung an diesem Punkt bereits fehlschlägt. Ist der schwarze
Rahmen gefunden, wird die Position und Ausrichtung des Markers relativ zu der
Kamera in Kamerakoordinaten berechnet. Dazu verwendet das ARToolKit jeweils
die vier Eckpunkte des Markers. Nun wird das Marker-Muster perspektivisch
entzerrt und anhand eines „confidence“ Wertes entschieden, welches der vorher
antrainierten
Muster
erkennbar
ist.
Anhand
der
zuvor
berechneten
Transformationen werden die virtuellen Objekte über das Videobild gezeichnet,
welches der Benutzer anschließend angezeigt bekommt.
4.2 Implementierung des Spiels „CatchAR“
Das aus dieser Studienarbeit resultierende Reaktionsspiel CatchAR wurde soweit
möglich in der Programmiersprache C++ geschrieben. Da das ARToolKit jedoch
in der Programmsprache C geschrieben ist, musste aus Kompatibilitätsgründen
hin und wieder ebenfalls C verwendet werden.
16
Im Folgenden eine Übersicht über die verwendeten Klassen und deren
Beziehungen untereinander. Auf deren Funktionsweise wird im Anschluss darauf
genauer eingegangen
uses
Class
MarkerManager
Class
BoardObject
map
Class
BoardMap
ScoreManager
Class
Class
GameManager
LifeManager
Class
UserInterface
Class
TimeManager
Class
LevelManager
Abb. 9: Übersicht des Programmaufbaus
17
Die Klassen LevelManager, TimeManager, LifeManager und ScoreManager
Abb. 10: Die Klassen LevelManager, TimeManager,
LifeManager und ScoreManager
Diese vier Klassen verwalten jeweils einen Teil der Spielvariablen. Die Klasse
LevelManager verwaltet dabei den Spiellevel und die Spielgeschwindigkeit. Sie
besitzt Methoden um diese beiden Variablen zu verändern.
Die Klasse TimeManager verwaltet die im Spiel verwendeten Timer und besitzt
Methoden um den Timer zu berechnen und zu verändern.
Die beiden Klassen LifeManager und ScoreManager verwalten die Lebenspunkte
bzw. Spielpunkte im Spiel. Beide besitzen ähnliche Methoden um diese beiden
Spielvariablen zu beeinflussen.
18
Die Klasse UserInterface
Abb. 11: Die Klasse UserInterface
Diese Klasse ist für das Zeichnen der grafischen Benutzeroberfläche im Spiel
zuständig. Sie besitzt Methoden um die einzelnen Elemente, sowie Textausgaben
abhängig von der aktuellen Spielphase zu zeichnen.
Die Klasse MarkerManager
19
Abb. 12: Die Klasse MarkerManager
Hier
werden
alle
Marker-Berechnungen
und
Marker-Positionsprüfungen
durchgeführt. Um die Position zweier Marker zu vergleichen, welche beim
Schlagen mit dem Catcher-Marker, der an der Fliegenklatsche angebracht ist, auf
einen Board-Marker des Spielfelds wichtig ist, damit der Schlag als Treffer
gewertet wird, wird die Methode compareMarkerDistance benutzt. Diese
vergleicht die Position eines beliebigen Markers mit der Position des CatcherMarkers. Für die Ermittlung der Position der beiden Marker greift sie auf die
beiden Methoden getMarkerPosX bzw. getMarkerPosY zurück.
Außerdem enthält diese Klasse die beiden Konstanten TOL_DIFF_X und
TOL_DIFF_Y. Diese enthalten die maximale Abweichung zweier Marker, anhand
derer eine Position zweier Marker als identisch angesehen, also als Treffer im
Spiel gewertet wird.
Des Weiteren befinden sich hierin die testSelection[...] Methoden, die die
Position des Catcher-Marker überwachen und so eine Menüführung mit lediglich
dem Catcher-Marker möglich macht.
Die Klasse BoardObject
Abb. 13: Die Klasse BoardObject
20
Zu den Instanzen der Klasse BoardObject gehören alle während des Spiels auf
dem Spielbrett gezeigten Objekte: Die verschiedenen Libellenarten sowie die
Fliege.
Deren Eigenschaften sind in den Variablen dieser Klasse gespeichert. Darüber
hinaus besitzt die Klasse neben dem Konstruktor zwei Methoden um bei einem
Treffer (updateEffects) bzw. keinem Treffen (updateIgnoredEffects) die
entsprechenden Eigenschaften des Objekts anzuwenden.
Die Klasse GameManager
Abb. 14: Die Klasse GameManager
In der Klasse GameManager wird der eigentliche Spielablauf gesteuert. Dazu
besitzt die Klasse eine Variable phase, in der die aktuelle Spielphase gespeichert
wird.
Das Spiel ist in mehrere Phasen eingeteilt. Das Spiel startet in der „MainMenu“Phase, in der das Hauptmenü angezeigt wird und ein Spiel begonnen werden
kann. Darauf folgt die „pregame”-Phase, in der ein Countdown von fünf
Sekunden heruntergezählt wird, damit sich der Spieler auf den Spielstart
vorbereiten kann. Die anschließende „Game“-Phase enthält den hauptsächlichen
Spielablauf. Ist ein Level beendet worden, wechselt das Spiel in die
„level_finished“-Phase, um kurz darauf wieder in die nächste „Game“-Phase zu
21
wechseln. Besitzt der Spieler keine Lebenspunkte mehr, endet das Spiel in einer
„game_over“-Phase.
Die Struktur MarkerStruct
Abb. 15: Die Struktur MarkerStruct
In der Struktur MarkerStruct werden Informationen zu den einzelnen SpielbrettMarkern gespeichert. Dazu gehören neben einer markerID und einer Klartext
Beschreibung des Markers (markerDescription) die Nummer der gerade
angezeigten VRML-Grafik (vrmlID_showing) und ob der Marker gerade von
dem Catcher-Marker verdeckt ist (isHiddenFromFlapper).
Die beiden uniqueIDs sind für den VRML-Austausch nötig.
Pro Spielbrett-Marker existiert ein MarkerStruct. Diese neun MarkerStructs
werden in der map BoardMap verwaltet.
Für die im Programm verwendeten ARToolKit Funktionen sei hier auf die
ARToolKit Dokumentation[04] verwiesen.
4.3 Probleme und Tipps
Nachfolgend nun einige Tipps, die mir bei der Hardware sowie der
Implementierung des Programms sehr hilfreich waren.
22
Um die Erkennungsrate der Marker zu erhöhen, ist es eine gute Lösung, die
schwarzen Bestandteile eines Markers mit schwarzem Filz zu bekleben, da dieser
weniger Störungen durch Lichtreflexion erzeugt.
Ein wichtiges Merkmal bei der Marker-Erkennung des ARToolKits ist die darin
verwendete „History Funktion“. Diese Funktion wird genutzt, um ein Flackern der
eingeblendeten Objekte zu verhindern. Dabei werden Informationen aus dem
vorherigen Videobild verwendet, um die Marker-Erkennung zu stabilisieren.
Wird die Funktion „arDetectMarkerLite“ benutzt, so wird bei Scheitern der
Mustererkennung angenommen, dass sich der gleiche Marker, der bei dem
vorherigen Videoframe erkannt wurde, immer noch an dieser Position befindet.
Voraussetzung dafür ist eine ähnliche Größe und Position des Markers im
aktuellen zum vorherigen Frame.
Diese Funktionsweise erzeugt bei einem auf Schnelligkeit basierendem
Reaktionsspiel wie CatchAR das Problem, dass bei einem schnellen Schlag auf
eine Blüte des Spielfelds der Catcher-Marker nicht erkannt wird. Da in dem
Moment des Treffens der Marker eine ähnliche Position und Größe wie der
Spielfeld-Marker besitzt, wird angenommen, es handele sich noch um den
vorherigen Marker und es wird weiterhin die Blüte anstelle des Netzes an dieser
Position angezeigt.
Die Nutzung einer bereits im ARToolKit implementierten Marker-Detektion ohne
„history function“ (arDetectMarkeRLite) behebt diesen Fehler auf Kosten der
Geschwindigkeit und Stabilität, bringt jedoch die Notwendige Verbesserung der
Musterkennung.
23
5 Ergebnisse
5.1 Die 3D-Modelle
Bei einem Augmented-Reality-Spiel ist die Verwendung von 3D-Modellen
essenziell. Die im Spiel verwendeten Modelle wurden mit der 3D Visualisierungsund Animationssoftware Autodesk Maya6 erstellt.
Abb. 16: Eine in Maya erstellte und gerenderte Libelle
Export der Modelle ins VRML Format
Das ARToolKit unterstützt die Anzeige von OpenGL-Grafiken, sowie VRML
(Virtual
Reality
Modeling
Language)
Objekte
(durch
Einbinden
von
OpenVRML). Für ein Augmented-Reality-Spiel eignet sich das VRML-Format
sehr gut, da es alle notwendigen Eigenschaften besitzt, die man dafür benötigt. Es
können damit Transparenzen, Texturen und Animationen dargestellt werden.
Nach dem Export von VRML-Dateien aus Maya heraus, ist jedoch ein wenig
Nachbearbeitung der Dateien notwendig, damit sie im ARToolKit korrekt
angezeigt werden. Da das VRML-Format ein ASCII basiertes Format ist, ist es
ohne weiteres möglich Änderungen mit einem beliebigen Editor vorzunehmen.
6
http://usa.autodesk.com/adsk/servlet/index?id=6871843&siteID=123112
24
Als erstes muss im VRML-Code den Befehl „Convex“ durch „ccw“ ersetzen
werden, da das ARToolKit keine Objekte lädt, die dieses Befehl enthalten.
Dies liegt an der vom ARToolKit verwendeten OpenVRML-Version (v0.14.3),
die den Befehl „convex“ in geometrischen Definitionen nicht mehr erlaubt.
Des Weiteren werden eigene erstellte Objekte im ARToolKit nur sehr wenig
beleuchtet dargestellt. Um dies zu ändern, sollte man in den Materialknoten die
drei Werte der „emissiveColor“ (=Eigenleuchten) jeweils auf „1.0“ ändern.
Besitzt die Textur bereits eine diffuse Farbe („diffuseColor“), so nimmt man
anstelle von „1.0“ die „diffuseColor“ Farbwerte auch als „emissiveColor“ Werte.
Damit besitzt nun jedes Material genügend Eigenleuchten, damit es im
ARToolKit erkennbar ist.
5.2 Benötigte Hardware
AR Spiele werden in der Regel durch die beim Benutzer vorhandene Hardware
eingeschränkt. Das üblichste Mittel, um ein Videobild für das Tracking
aufzunehmen ist eine Webcam. Als Ausgabemedium ist immer noch der
Computerbildschirm die erste Wahl. Nur die wenigsten Benutzer haben eine 3DStereobrille oder ähnliche Hardware zuhause.
Aus diesem Grund ist für das Spiel folgende Hardware nötig:
-
Eine modifizierte Fliegenklatsche mit Catcher-Marker (im folgenden
Catcher genannt) als Eingabegerät
-
Eine beklebte Holzplatte mit Spielbrett-Markern als Spielfläche
-
Eine Webcam als Aufnahmegerät
(Die hier genutzte Creative Webcam Notebook unterstützt u.a. eine
Videoauflösung von 640x480 pixel bei 15 frames bzw. 320x240 bei 30
frames.)
-
Optional kann als Kamerahalterung ein Gerüst aus Holz oder eine andere
Möglichkeit genutzt werden.
25
Abb. 17: Der Galgen zur
Abb. 18: Das Spielbrett und der
Kamerabefestigung
Catcher/ Kescher
Um die Immersion nicht zu zerstören, wurde bei dem hier erstellten
Reaktionsspiel auf eine Steuerung mit Maus oder Tastatur soweit wie möglich
verzichtet. Lediglich vor dem eigentlichen Start des Spiels muss die Auflösung
des Videobilds über die Tastatur eingegeben werden. Ist das Spiel einmal
gestartet, kann es komplett über den Catcher gesteuert werden.
5.3 Das Spiel „CatchAR“
Abb. 19: Das CatchAR Logo
5.3.1
Spielprinzip
Im Spiel Geschicklichkeits- und Reaktionsspiel CatchAR soll der Spieler
versuchen möglichst alle der auftauchenden Libellen einzufangen. Hierzu steht
dem Spieler ein virtueller Kescher zur Verfügung. Um eine Libelle zu fangen,
26
muss der Spieler mit dem Kescher auf die Libelle schlagen. Dafür erhält der
Spieler Punkte.
5.3.2
Installation
Der erste Kontakt, den der Anwender mit einer Software hat, ist die Einrichtung
derselbigen. Dies ist ein wichtiger erster Eindruck. Viele Anwender sind bereits
mit der Installation der Software überfordert, wenn dabei viele Schritte von ihnen
selbst erledigt werden müssen. Um den Anwender nicht schon bei der Einrichtung
abzuschrecken und möglichst vielen Benutzern den Zugang zu der Software zu
ermöglichen, ist eine möglichst automatische Installationsroutine unerlässlich.
Um den Umgang mit der Software zu vereinfachen, wurde mit dem Nullsoft
scriptable install system (NSIS) in Verbindung mit dem Editor HM NIS Edit 2.0.3
ein Installer geschrieben. Dieser ermöglicht es dem Benutzer die Software auf
eine bequeme und einfache Art und Weise auf seinem Computer zu installieren
und auch zu deinstallieren.
Nullsoft scriptable install system 2.16
Das Nullsoft Scriptable Install System (NSIS) ist eine Software zur Erstellung von
Installationsroutinen unter Windows. Es wurde von der Firma Nullsoft entwickelt,
die den Installer u. a. für ihren Mediaplayer „Winamp“ nutzt. Das Nullsoft
Scriptable Install System ist Open Source und steht unter der zlib/libpng Lizenz.
NSIS an sich verfügt lediglich über einen Kommandozeilen-Kompilierer und ein
graphisches Userinterface dafür, das beim Kompilieren hilft und einige
Einstellungen erleichtert. Allerdings erleichtert es die Arbeit, wenn ein NSIS
Editor zur Erstellung der Installationsroutine verwendet wird. Hierzu wurde der
HM NIS Edit Editor genutzt.
5.3.3
Spielablauf
Vor dem Start des eigentlichen Spiels CatchAR erscheinen zwei Fenster. Eines
davon ist ein Kommandozeilenfenster, das lediglich zur Ausgabe von
Systeminformationen dient. Im zweiten Fenster wird unter anderem die Auflösung
27
des Videobildes eingestellt, abhängig von der verwendeten Kamera und Treiber.
Hat der Spieler diese Einstellungen vorgenommen, schließt sich dieses Fenster
und das CatchAR Spiel wird geladen.
Das Videofenster öffnet sich nun in der vorher eingestellten Auflösung und sollte
am besten maximiert werden.
Hauptmenü
Das Spiel startet mit dem Hauptmenü. Dort kann der Spieler mit dem Kescher als
Auswahlwerkzeug den gewünschten Menüpunkt „Start Game“ oder „Exit Game“
auswählen. Dies funktioniert, indem er den Kescher hinter den gewünschten
Menüpunkt hält. Ist die Auswahl erkannt worden, wird sie aktiviert, indem ein
Rahmen um den ausgewählten Menüpunkt eingeblendet wird. Nun erscheint ein
neuer Menüpunkt „OK“. Durch dessen Anwahl wird der aktivierte Menüpunkt
bestätigt und das Spiel gestartet bzw. beendet.
Abb. 20: Das CatchAR Hauptmenü
28
Spielstart
Wählt der Spieler „Start Game“ aus, so wird ein neues Spiele gestartet. Damit der
Spieler sich auf das Spiel vorbereit kann, ist diesem ein Countdown von fünf
Sekunden vorgeschaltet.
Das Spiel
Das Spiel beginnt mit einem „leeren“ Spielfeld, auf dem nur leere Blumen
angezeigt werden. Nach dem Zufallsprinzip werden nun einzelne Marker des
Spielfelds und Objekt ausgewählt, die darauf angezeigt werden. Der Spieler muss
nun 60 Sekunden lang versuchen alle eingeblendeten „guten“ Libellen zu fangen.
Nach 60 Sekunden ist der Level beendet, und nach einem erneut vor geschalteten
Countdown
startet
der
nächste
Level.
Die
Spielgeschwindigkeit,
die
Geschwindigkeit in der die Insekten auf dem Spielbrett erscheinen, steigt von
Level zu Level.
Abb. 21: CatchAR Spiel
Um das Spiel interessanter zu machen, wurden auch negative Eigenschaften
verwendet. Wird ein Objekt verpasst, das heißt nicht getroffen, so kann es
abhängig von den Eigenschaften des Objektes negative Auswirkung auf die
anfangs 200 Lebenspunkte des Spielers haben (Siehe Abb. 16).
29
Objekt
Eigenschaft
Feuerlibelle (Rot)
Treffer: + 5 Spielpunkte
Kein Treffer: -10 Lebenspunkte
Wasserlibelle (Blau)
Treffer: + 10 Spielpunkte
Kein Treffer: -15 Lebenspunkte
Waldlibelle (Grün)
Treffer: -15 Spielpunkte
Kein Treffer: -5 Lebenspunkte
Feuerfliege (Rot)
Treffer: -50 Lebenspunkte
Kein Treffer: -
Abb. 22: Die Spielobjekte und deren Eigenschaften
Für gefangene Libellen erhält der Spieler Punkte auf seinem Punktekonto
gutgeschrieben.
Eine besondere Rolle spielt die Waldlibelle. Diese hat auf jeden Fall einen
Punktabzug zur Folge. Wird sie getroffen, bekommt der Spieler 15 Spielpunkte
abgezogen. Bei keinem Treffer sind es 5 Lebenspunkte, die der Spieler verliert.
Hier muss er sich also entscheiden, ob er es sich leisten kann Lebenspunkte zu
verlieren oder muss ansonsten einen Abzug der Spielpunkte hinnehmen. Dies
bringt eine zusätzlichen taktischen Faktor ins Spiel.
Das Fangen einer Feuerfliege ist nicht beabsichtig und bringt einen hohen Abzug
der Lebenspunkte mit sich. Der Anzahl der Lebenspunkte wird jeweils in das
nächste Level übernommen und nimmt so im Laufe des Spiels immer mehr ab.
Spielende
Das Spiel endet, wenn der Spieler keine Lebenspunkte mehr besitzt. Auf dem
Bildschirm bekommt er anschließend die erreichte Punktzahl angezeigt. Nun kann
er zurück zum Hauptmenü und von dort aus ein neues Spiel starten oder das Spiel
verlassen.
30
Abb. 23: CatchAR Spielende
31
6 Fazit / Erweiterungsmöglichkeiten
6.1 Fazit
Es hat sich gezeigt, dass man bei der Entwicklung einer Anwendung mit dem
ARToolKit, bei der es auf die Erkennung schneller Marker-Bewegungen
ankommt, rasch an die Grenzen stößt. Dieses Problem wird einerseits durch die
interne Vorgehensweise des ARToolKits, aber auch durch die Grenzen der
Bildwiederholrate und Auflösung einer Webcam verursacht. Eine Alternative
wäre hier der Ansatz mit einer digitalen Videokamera.
Ein wichtiger, zu beachtender Punkt bei Augmented Reality Anwendungen ist die
dreidimensionale Wahrnehmung. Wird nur eine Kamera verwendet, fehlt dieser
3D-Eindruck. Übertragen auf das Augmented-Reality-Spiel Catcher bedeutet dies,
dass der Blick der Spieler immer wieder zwischen der Augmented Reality auf
dem Bildschirm und dem Spielbrett hin und her wechselt, um einerseits die
eingeblendeten Objekte zu erkennen, andererseits den passenden Marker zu
treffen.
6.2 Erweiterungsmöglichkeiten
Um die Spielbalance etwas auszugleichen und dem Spieler die Möglichkeit zu
geben verlorene Lebenspunkte wiederzuerhalten, wäre es denkbar in die
Spielelogik eine Funktion dafür einzubauen. Anhand einer festgelegten
Wahrscheinlichkeit könnten getroffene Libellen Objekte verlieren, die dem
Spieler die Lebenspunkte zurückgeben. Diese müssten zum Aufsammeln vom
Spieler erneut getroffen werden und dann auf dem Lebenspunktekonto hinzu
addiert werden.
Um eine Verbesserung des Spielspaßes zu erreichen, wäre die Einbindung von
Musik und Soundeffekten in das Spiel sehr empfehlenswert. Dies wäre unter
32
Umständen mit der Open Source 3D Audio API OpenAL7 möglich. Darüber
hinaus würde eine Weiterentwicklung der Spieloberfläche ihr übriges dazu
beitragen. Möglichkeiten wären hierfür ein Ersetzen der bisher verwendeten mit
OpenGL gerenderten Schrift durch Texturen darzustellen. Dies würde die
kreativen Möglichkeiten in großem Maße erweitern.
Eine Verbesserung in Sachen Marker-Erkennung wäre durch den Einsatz
alternativer Marker-Erkennungspakete möglich. In Frage dafür kämen unter
Umständen ARTag8 oder das ARToolKit Plus9.
Neben der Verbesserung der vorhandenen Spielelogik wäre es ein Einfaches,
weitere Spiele mit den vorhandenen Klassen und Methoden umzusetzen. Im
Folgenden seien exemplarisch zwei mögliche Spielumsetzungen kurz erwähnt.
Handheldspiel Senso
Das Spiel besteht aus einem Gerät mit vier Feldern. Die Idee des Spiels ist relativ
einfach. In einer zufälligen Reihenfolge leuchten diese Felder auf. Die Aufgabe
des Spielers ist es, sich die diese vorgegebene Reihenfolge zu merken und durch
drücken der Tasten zu wiederholen. Jede Runde wird dieser Reihenfolge eine
weitere Farbe hinzugefügt.
7
http://www.openal.org
http://www.cv.iit.nrc.ca/research/ar/artag/
9
http://studierstube.icg.tu-graz.ac.at/handheld_ar/artoolkitplus.php
8
33
Abb. 24: Senso [14]
Von technischer Seite her, wäre eine Augmented Reality Version dieses Spiels
kein großer Aufwand. Für Jedes der Felder kann ein Marker genutzt werden.
Zur besseren Verdeutlichung des Spielprinzips kann bei neave.com10 eine online
Version dieses Spiels getestet werden.
Kopfrechenspiel
Eine andere Erweiterungsmöglichkeit wäre die eines Rechenspiels. Dabei werden
Aufgaben aus dem Bereich der Mathematik gestellt. Mögliche Ergebnisse der
Aufgabe werden auf die verschiedenen Marker projiziert. Wenn der Spieler das
richtige Ergebnis ausgewählt hat, erhält er Punkte. Auch wäre eine zwei Spieler
Version hiervon ohne weiteres möglich. Dazu müsste nur ein zweiter Catcher mit
einem neuen Marker angefertigt werden.
10
http://www.neave.com/games/simon/
34
7 Anhang
7.1 Eingesetzte Software
Folgende Software wurde zur Anfertigung dieser Studienarbeit in den
verschiedensten Bereichen eingesetzt:
-
Adobe Photoshop 6.0
http://www.adobe.com/de/products/photoshop/index.html
-
Alias Maya 6.0
http://usa.autodesk.com/adsk/servlet/index?id=6871843&siteID=123112
-
ARToolKit 2.71.2
http://www.hitl.washington.edu/artoolkit/
-
Doxygen 1.4.6
http://www.stack.nl/~dimitri/doxygen/
-
GLUT 3.7.6
http://www.xmission.com/~nate/glut.html
-
HM NIS Edit 2.0.3
http://hmne.sourceforge.net/index.php
-
Inkscape 0.43
http://www.inkscape.org
-
Microsoft Visual Studio .NET 2003
http://www.microsoft.com/germany/msdn/vstools
-
Nullsoft scriptable install system 2.17
http://nsis.sourceforge.net/Main_Page
-
Visual Paradigm for UML 5.2 Community Edition
http://www.visual-paradigm.com/
35
Abbildungsverzeichnis
Abbildung 1 – Sam und Max hit the road................................................................5
Abbildung 2 – Wak-a-rat .........................................................................................6
Abbildung 3 – Tontie...............................................................................................6
Abbildung 4 – Beispielmarker.................................................................................9
Abbildung 5 – EyeToy Kinetic..............................................................................10
Abbildung 6 – Invisible Train auf PDA’s..............................................................11
Abbildung 7 – Marker-Erkennung im ARToolKit ................................................15
Abbildung 8 – links Videobild, rechts Videobild nach Schwellwert Anwendung
(Schwellwert: 100).........................................................................15
Abbildung 9 – Übersicht der Klassen und Strukturen und deren Beziehungen ....17
Abbildung 10 – Die Klassen LevelManager, TimeManager, LifeManager und
ScoreManager .............................................................................18
Abbildung 11 – Die Klasse UserInterface .............................................................19
Abbildung 12 – Die Klasse MarkerManager.........................................................19
Abbildung 13 – Die Klasse BoardObject ..............................................................20
Abbildung 14 – Die Klasse GameManager ...........................................................21
Abbildung 15 – Die Struktur MarkerStruct ...........................................................22
Abbildung 16 – Eine in Maya erstellte und gerenderte Libelle.............................24
Abbildung 17 – Der Galgen zur Kamerabefestigung ............................................26
Abbildung 18 – Das Spielbrett und der Catcher/ Kescher.....................................26
Abbildung 19 – Das CatchAR Logo......................................................................26
Abbildung 20 – Das CatchAR Hauptmenü............................................................28
Abbildung 21 – CatchAR Spiel .............................................................................29
Abbildung 22 – Die Spielobjekte und deren Eigenschaften ..................................30
Abbildung 23 – CatchAR Spielende......................................................................31
Abbildung 24 – Senso............................................................................................34
36
Quellenverzeichnis
[1]
ARToolKit API (29.05.2006): http://artoolkit.sourceforge.net/apidoc/
[2]
ARToolKit Forum (29.05.2006): http://www.hitlabnz.org/forum/
[3]
ARToolKit Homepage (29.05.2006):
http://www.hitl.washington.edu/artoolkit/
[4]
ARToolKit Dokumentation (29.05.2006):
http://www.hitl.washington.edu/artoolkit/documentation/
[5]
cplusplus resources (29.05.2006): http://www.cplusplus.com/ref
[6]
OpenGL Programming Guide (The Red Book) (29.05.2006):
http://rush3d.com/reference/opengl-redbook-1.1/
[7]
Glut – The OpenGL Utility Toolkit (29.05.2006):
http://www.opengl.org/resources/libraries/glut/
[8]
OpenGL Wiki (29.05.2006): http://wiki.delphigl.com/index.php/OpenGL
[9]
Tobias Kammann: „Entwicklung eines Augmented-Reality-Spiels“,
Universität Koblenz-Landau
http://geri.uni-koblenz.de/Studienarbeiten/arspiel.pdf
[10]
Prof. Dr. Stefan Müller: „Virtuelle Realität und Augmented Reality“,
Vorlesungsunterlagen: http://www.uni-koblenz.de/FB4/Institutes/ICV
/AGMueller/Teaching/WS0506/VRAR
[11]
C++ Doxygen: http://www.stack.nl/~dimitri/doxygen/
[12]
nullsoft scriptable install system: http://nsis.sourceforge.net/Main_Page
[13]
HM NIS Edit: http://hmne.sourceforge.net/
[14]
Wikipedia (29.05.2006: http://de.wikipedia.org/wiki/Senso_(Spiel)
37