Sie sind auf Seite 1von 19

Virtual Reality - Headtracking

Prepared for: Prof. Dr. Jens Uwe Hahn


Prepared by: Kai Aras MI WS 08/09

25 February 2009

Hochschule der Medien - Medieninformatik - Kai Aras - WS 08/09


Inhalt

I. Projektbeschreibung 2
II. Projektablauf 3
Vicon Motion Capturing System 3
Vicon Hardware 3
Kameras 3
Funktionsprinzip: 3
Datastation 3
Vicon Software 4
Setup 4
Kalibrierung 4
Subjekt Definieren 5
Bewegungsradius evaluieren 5
Radiolab (HdM Installation) 6
Allgemeine Codeänderungen 6
Pipeline 6
Wiimote Steuerung 6
Hardware Specs 6
Anbindung 7
1. Versuch 7
2. Versuch 8
Die Methode trackHead_Brille_Wiimote() 9
Tastenbelegung 9
Radiolab (DIY Alternative) 10
Idee 10
Radiolab Implementierung 10
Die Methode trackHead_Wiimote() 11
Fingertracking 12
Idee 12
Python Implementierung 12
Sourcecode 13
III. Probleme 16
Allgemein 16
Technisch 16
Zeitlich 16
IV. Fazit 17
V. Quellen 18
VI. Anhänge 18
Virtual Reality - Headtracking - Kai Aras - WS 08/09 1
Projektbeschreibung

Die folgende Arbeit wurde im Rahmen der Vorlesung “Grundlagen der Virtual-Reality” verfasst, und nutz als Grundlage die
Diplomarbeit “Implementierung von Positions- und Headtracking für Stereoprojektion und Head-Mounted-Display in
Radiolab und Entwicklung eines Eingabegerätes zur Navigation” von Susanne Meitzner und Vanessa Huck.

Inhalt dieser Diplomarbeit war, der Aufbau eines VR-Systems basierend auf Motion Capturing Hardware der Firma Vicon,
sowie die Implementierung von Headtracking für teil- und vollimmersive Anwendungen mit HMD oder Stereorückprojektion
innerhalb von Radiolab.

Basierend auf damaliger Software Implementierung und Hardware Anschaffungen, waren die Ziele dieser Arbeit die
folgenden:

• Verstehen und Anwenden der vorhandenen Technologien

• Aufbau des damaligen Rückprojektions Setup zur teil immersiven Anwendung im CA-Labor

• Evaluation des Setups für Festinstallation im CA-Labor

• Einbindung der Nintendo Wiimote als Eingabegerät

• Entwicklung einer Selbstbau-Variation des Systems, für den interessierten Heimanwender

• Experimente mit den verwendeten Technologien

Virtual Reality - Headtracking - Kai Aras - WS 08/09 2


Projektablauf

I. Vicon Motion Capturing System

Begleitend zum Studium der Diplomarbeit, war meine erste Aufgabe, mich in das verwendete Vicon Motion Capturing
System einzuarbeiten, zu verstehen, und anwenden zu können. Nachfolgend möchte ich dies zusammenfassen.

1. Vicon Hardware
Der Hardwareteil des Vicon-Systems besteht im wesentlichen aus :

1. Vicon Kameras

2. Vicon Datastation + Breakoutbox

Kameras
hier wurden drei Exemplare der Serie Vicon MX60 verwendet. Diese liefern eine Bildrate von bis
zu 120Hz und sind von einem “starken” IR-LED Strahler-Kranz umrundet. Zur Testinstallation
wurden hier Stative der Firma Manfrotto verwendet, da diese viel Platz brauchen, und
teilweise zwangsläufig die Leinwand verdecken, sollte ein geeignetes Setup der drei
Kameras zur Festinstallation an der Raumdecke gefunden werden.

Funktionsprinzip:

Die Kameras sind zusätzlich zum IR-Strahler mit einem IR-Filter ausgestattet, d.h. sie “sehen” nur
IR-Licht. Ausgenutzt wird dies indem man das “zu trackende” Objekt durch reflektierende Marker
markiert, und so für die Kamera sichtbar macht. Die Kamera “sieht” dann nur diese Marker, in Form von Blobs,
und das System kann aus den Perspektiven der einzelnen Kameras die Position des “zu
trackenden” Objekts im 3-Dimensionalen Raum berechnen.

Datastation
Die Signale der 3 Kameras führen über eine kleine Breakoutbox in die Vicon Workstation.
Diese ist im wesentlichen eine “Blackbox”, d.h. ihre Funktionalität ist nicht dokumentiert.
In der Praxis, verbindet man die Box lediglich mit Netzstrom, der Breakoutbox, und einem
Lan Kabel und schält sie an, anschließend, zeigt sie auf ihrem Frontdisplay die IP Adresse,
unter der sie zu erreichen ist. Viel mehr hat man hier nicht zu tun.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 3


2. Vicon Software
Die zugehörige Software zum Vicon System nennt sich Vicon IQ und bietet vielfältige Möglichkeiten zum Einsatz der
Hardware. Ich möchte hier im nur auf die für diese Arbeit relevanten Funktionen eingehen, die im wesentlichen sind:

• Realtime Engine (Tarsus)


Neben den eigentlichen MoCap Funktionalität wie Capturing, Post Processing oder Modelling, bietet Vicon IQ
auch die Möglichkeit von externen Anwendungen auf den Realtimestream den das System liefert zuzugreifen.

• Setup und Kalibrierung

• Definieren trackbarer Objekte

i. Setup
1. Festlegen der Verwendeten Hardware
Der erste Schritt beim Setup von Vicon IQ ist das festlegen der verwendeten Kameras,
und der Workstation.

2. Festlegen der IP-Adresse der Vicon Workstation


Hier legt man lediglich die IP Adresse der Vicon Workstation fest, diese wird auf dem Display der
Workstation angezeigt.

3. Verbindung zu Vicon Workstation herstellen


Ein klick auf den “Connect” Button, verbindet die Tarsus Realtime Engine mit der Vicon Hardware.

ii. Kalibrierung
1. Kalibieren des Volumens mit Hilfe des “Kalibrierungs-Wands”
Damit das Vicon System das Volumen des erfassten Raumes berechnen kann, ist
zunächst ein Kalibrierungsvorgang erforderlich. Praktisch nimmt man dazu ein im
Vicon System vordefiniertes Werkzeug, den so genannten “Wand” und führt diesen
so lange durch das Volumen, bis er von jeder Kamera mind. 10000 mal erkannt
wurde.

2. Kalibieren der Achsen mit Hilfe des “L-Frames”


Um die lokalen Achsen innerhalb Vicon IQ festzulegen, benutzt man ein ebenfalls
vordefiniertes Werkzeug, den “L-Frame”.
Man wählt hierzu einfach die Funktion “Track L-Frame” und legt den “L-Frame” ins
Volumen.
Wird dieser vom System erfasst, richtet man ihn wie gewünscht aus und bestätigt.

INFO: Die Achse des L-Frames, mit drei Markern stellt die X-Achse dar,
die Achse mit einem Marker stellt die Y-Achse dar, und
die Senkrechte zum “L-Frame” stellt die Z-Achse dar.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 4


3. Anschließend ist das Vicon System kalibriert und man bekommt ein 3-Dimensionale Ansicht des erfassten
Volumens inkl. der Ausrichtung der Kameras.

iii. Subjekt Definieren


Damit das System ein zu trackendes Objekt erkennt, muss dieses zunächst erst einmal definiert werden.
Ein solches Objekt wird in Vicon IQ “Subjekt” genannt und kann recht einfach auf folgende Art und weise
definiert werden.

1. Man legt das zu definierende Subjekt in die Mitte des Volumens, und achtet darauf, dass alle Marker des
Objektes vom System erfasst werden.

2. Ist dies der Fall, werden die Marker im “3D-Live Workspace” von ViconIQ angezeigt, und man kann diese
mit der Maus selektieren.

3. Sind alle Marker selektiert, genügt ein Klick auf “Create Subjekt” um das Subjekt zu definieren.

4. Anschließend, ist das Subjekt definiert, wird vom System erkannt und kann “getrackt” werden.

iv. Bewegungsradius evaluieren


Nachdem das System Kalibriert war, konnte ich den gegebenen Bewegungsradius testen, da dies ein
Hauptziel dieser Arbeit war. und der komplette Vorgang bei jeder Veränderung der Kameraaufstellung
komplett wiederholt werden muss, hat dieser Punkt außerordentlich viel Zeit in Anspruch genommen.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 5


II. Radiolab (HdM Installation)

1. Allgemeine Codeänderungen
Den zur Diplomarbeit gehörigen Radiolab- Originalcode habe ich im wesentlichen nicht verändert, sondern lediglich
durch die zwei folgenden Methoden Ergänzt:

• trackHead_Brille_Wiimote()
basiert auf der Methode trackHead_Brille() und Implementiert anstatt der ursprünglich Vicon- basierten
Navigation, die Steuerung via Nintendo Wiimote.

• trackHead_Wiimote()
Implementiert eine lowcost Headtracking Variante basierend auf einer Nintendo Wiimote Kamera.

2. Pipeline

3. Wiimote Steuerung
Da die ursprüngliche Lösung zur Navigation innerhalb einer Radiolab-Szene nur noch in Einzelteilen vorlag, und
ohnehin nicht sonderlich praktisch war, kam mir die Idee eine Nintendo Wiimote als Eingabegerät zur Navigation zu
benutzen, Um dies umzusetzen hatte ich zwei Ansätze die ich im folgenden kurz erläutern möchte.

Hardware Specs
Die Nintendo Wiimote besitzt folgende Hardware Eigenschaften:

• Anbindung via Bluetooth

• IR-Kamera

• 3-Achsen Accelerometer

• 11 Tasten

• Lautsprecher

• 4 LEDs

Virtual Reality - Headtracking - Kai Aras - WS 08/09 6


Anbindung
Da die Wiimote glücklicherweise, als HID-Kompatibles Gerät implementiert wurde, ist zur Anbindung via Bluetooth
kein spezieller Treiber nötig. Besonders reibungslos funktioniert dies unter Linux, sowie Mac OS X, auf Windows-
basierten Systemen scheinen die unterschiedlichen Implementierungen des Bluetooth Stacks eine große Rolle bei
der Kompatibilität der Wiimote zu spielen, so war es z.B. unter Verwendung des MS-Bluetooth Stacks und eines
HAMA Nano BT-Dongels zwingend nötig alle Wiimotes nach jedem Disconnect neu zu “pairen”.

1. Versuch
Mein erster Gedanke war. aus Zeitgründen, einfach die Radiolab eigene Maussteuerung zu benutzen,
indem man Wiimote Bewegungen auf Maus Bewegungen abbildet.
Möglich ist dies unter Windows recht einfach mittels des frei verfügbaren Tools “glovePIE”.

“glovePIE”
wurde ursprünglich entwickelt um die Anbindung von Datenhandschuhen an beliebige Anwendungen zu
erleichtern. Mittlerweile werden eine Vielzahl von Eingabegeräten unterstützt, u.a. auch die Nintendo
Wiimote. glovePIE bietet ein simples Scripting- Interface, dass es erlaubt Parameter oder Events eines
Eingabegerätes, z.B. der Wiimote, auf eine Anderes, z.B die Maus abzubilden, Siehe nachfolgendem
Screenshot.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 7


Fazit: Letztendlich hat die Navigation mittels der glovePIE Variante zwar ganz gut funktioniert und war
innerhalb kurzer Zeit umgesetzt, ich fand es allerdings recht “unschön” vor der Anwendung in Radiolab
zwangsläufig auch glovePIE zu starten und aktivieren zu müssen.

Aus diesem Grund habe ich mich entschieden doch einen anderen Weg zu wählen, mehr hierzu im 2.
Versuch.

2. Versuch
Die Alternative zu glovePIE war die direkte Implementierung der Wiimote - Steuerung innerhalb von
Radiolab, basierend auf der freien C++ Library “WiiYourself!”.

Zur Anbindung der Wiimote, wurde in Anlehnung an die Klasse MocapCtrl die Klasse WiimoteCtrl
eingeführt. Hier das zugehörige Headerfile:

#include "..\WiiYourself!\wiimote.h"

class WiimoteCtrl
{
public:

WiimoteCtrl(void);

~WiimoteCtrl(void);

wiimote* getWiimote(void);
wiimote* getWiicam(void);

wiimote* WIIremote;
wiimote* WIIcam;
wiimote* WIIcam2;
};

Instanziiert wird die Klasse WiimoteCtrl innerhalb des Konstruktors der Klasse RlabHdmView.
Anschließend wird durch Tastendruck des Benutzers die Methode virtualOnKeyDown(...) aufgerufen, die
in Abhängigkeit der betätigten Taste in den weiteren Betriebsmodus verzweigt.

virtualOnKeyDown(...)

If nChar==

B W

trackHead_Brille_Wiimote() trackHead_Wiimote()

Virtual Reality - Headtracking - Kai Aras - WS 08/09 8


Die Methode trackHead_Brille_Wiimote()
Die Methode trackHead_Brille_Wiimote() kopiert im wesentlichen die bereits implementierte Methode
trackHead_Brille(), dabei wurden alle relevanten Codesegmente der bisherigen Navigationslösung entfernt
und im wesentlichen durch folgenden Code zur Navigation via Wiimote ersetzt.

rot_winkel = -wiimctrl->WIIremote->Acceleration.X;

if (wiimctrl->WIIremote->Button.A()) {

//rotation
Trans R(rotation, scene_up, ((rot_winkel/10)));
ViewDir = R*ViewDir_start;
poi = eye + (ViewDir*screen_distance);

//movement
poi = poi + (ViewDir*(meter/4)*wiiY);
eye = eye + (ViewDir*(meter/4)*wiiY);

}

Tastenbelegung
Folgende Grafik Zeigt die Tasten- und Achsenbelegung der Wiimote zur Navigation innerhalb einer Radiolab-Szene.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 9


III. Radiolab (DIY Alternative)

1. Idee
Nach den ersten Labor-Versuchen mit funktionierender Stereoprojektion, kam schnell der Wunsch auf, auch zu
Hause Headtracking betreiben zu können. Um dies zu zu können, musste ich zunächst zu Hause die selben
Voraussetzungen schaffen wie ich sie im Labor zur Verfügung hatte.

Da Radiolab standardmäßig auch die Verwendung von simplen Anaglyph Brillen zur Streoprojektion unterstützt, war
dieser Punkt kein Problem, eine einfache Schutzbrille war mit etwas “bunter” Folie schnell zur Anaglyph Brille
umfunktioniert.

Das für eine Privatperson natürlich unerschwingliche Vicon System habe ich schlicht durch eine Nintendo Wiimote
und einen günstigen IR-LED- Strahler ersetzt, welche auf dem Monitor angebracht werden, der wiederum die
ursprünglich verwendete Rückprojektionsleinwand ersetzt. Da zur Stereoprojektion hier das Anaglyph Verfahren
verwendet wird, kann anders als bei Shutter-Brillen oder Brillen mit Polarisationsfiltern jeder Typ von Monitor, auch
LCD oder TFT verwendet werden.

Um einen Kopf für die Kamera der Wiimote sichtbar, und damit trackbar zu machen, habe ich eine Anaglyph Brille
mit 2 reflektierenden Markern versehen, aus deren bekanntem Abstand, ich später den Abstand der Brille zum
Monitor berechnen kann.

Folgende Grafik soll diese Idee veranschaulichen:

2. Radiolab Implementierung
Auch hier kam die Library “WiiYourself!” zum Einsatz, die Klasse WiimoteCtrl wurde um ein Wiimote Objekt Cam
erweitert. Das Cam Objekt liefert kontinuierlich die IR-Daten der Wiimote- Kamera, welche in der Lage ist maximal
vier Marker zu erkennen. Die Position der Marker kann als X- und Y Koordinate des zugehörigen “Dots” im Sichtfeld
der Kamera abgefragt und zur weiteren Berechnung verwendet werden.
Die hier implementierte Methode des Headtrackings basiert auf einer Publikation von Johnny Chung Lee, dem
ersten, der Headtracking mittels Wiimote implementiert hatte. Da meine Versuche keine optimalen Ergebnisse
brachen, kam ich zu dem Schluss, seine Methode zu verwenden, eine bessere existiert meines Wissens nicht. Bei
diesem Verfahren wird der Bildschirm zunächst in Radianten eingeteilt, um aus dem bekannten Abstand der zwei
Marker, später den relativen Winkel zum Monitor berechnen zu können.Die Bewegung des Nutzers X-Richtung,

Virtual Reality - Headtracking - Kai Aras - WS 08/09 10


also parallel zum Monitor ergibt sich dann aus dem Offset des Mittelpunktes der zwei Marker zum
Bildschirmmittelpunkt, in Abhängigkeit des Z-Werts, also der Entfernung zum Monitor. Die Entfernung zum Monitor
kann wiederum aus der von de Kamera wahrgenommenen Entfernung der beiden Marker auf der Brille berechnet
werden, wobei deren “echter” Abstand bei initialem Abstand zum Monitor als Referenz dient.

Wie bei allen anderen Betriebsmodi ist der Einstiegspunkt auch hier die Methode virtualOnKeyDown() ,die bei
Betätigung der Taste “W” in den eigentlichen Betriebsmodus verzweigt.

virtualOnKeyDown(...)

If nChar==

B W

trackHead_Brille_Wiimote() trackHead_Wiimote()

Die Methode trackHead_Wiimote()


Die Methode trackHead_Wiimote() implementiert Headtracking mittels einer Wiimote-Kamera, dabei wurde
als Grundlage ebenfalls die Methode trackHead_Brille() verwendet.
Da diese Methode nicht mehr auf das Vicon System zurückgreift, wurden alle Codesegmente diesbezüglich,
entfernt. Sämtlicher Radiolab relevanter Code wurde zunächst beibehalten, in folgendem Codeabschnitt wird
letztlich das eigentliche Headtracking durchgeführt:

float radPerPix = (PI / 4.0f) / 1024.0f; // divide the screen in radians


pointDist = sqrt(dx * dx + dy * dy); // calculate the distance between the markers
float angle = radPerPix * pointDist / 2.0; // calculate angle in radians
float aX = (dotA.RawX + dotB.RawX) / 2.0f, aY = (dotA.RawY + dotB.RawY) / 2.0f; // calculate the
average marker midpoint

zshift = -1 * ((float)(MARKER_DIST) / atan(angle)); // calculate head distance


float deltaZ = zshift_old/100 - zshift/100; // calculate the delta between the current and
the last frame
eye = eye + (-((deltaZ)*(meter*0.15))*(ViewDir)); // move the eye point
screen_distance = (poi-eye).getNorm(); // update screen distance
blickWinkel = atan( (screen_distance) / 2600)*(180/PI); // calculate new FOV
zshift_old = zshift; // remember old value

xshift = sin(radPerPix * (aX-512))*zshift ; // calculate users x-offset


CamShiftH = (aX-384)*raPerPix; // set horizontal camshift
CamShiftV = (aY-384)*radPerPix; // set vertical camshift
xshift_old = xshift; // remember old value

Virtual Reality - Headtracking - Kai Aras - WS 08/09 11


IV. Fingertracking

1. Idee
Da ich von Natur aus ein sehr experimentierfreudiger Mensch bin, kamen mir beim Umgang mit den Verwendeten
Technologien schnell neue Ideen, von denen ich zumindest eine ausprobieren musste.
Es war schon immer mein Traum, einen PC gänzlich ohne physikalische Hilfsmittel bedienen zu können, und so
kam mir also die Idee vom “Fingertracking”, für die ich hier noch eine kleine Proof-of-Concept Anwendung
vorstellen möchte.

Die Idee basiert darauf, über die Kameras zweier Wiimotes die X- und Y-Koordinate eines Fingers zu “tracken”,
und z.B auf die Mauszeigerbeweung abzubilden. Ein Mausklick wird dann ausgelöst, sobald die Anwendung zwei
Finger erkennt.
Praktisch kann der Anwender so die Maus durch seinen Finger steuern, ein Klick kann z.B ausgelöst werden, in
dem man zur Maussteuerung Mittel- und Zeigefinger “schließt” und wieder “öffnet” um einen Mausklick auszulösen.

Weiter könnte man hier z.B. eine Gestenerkennung implementieren um dem Anwender weitere
Interaktionsmöglichkeiten zu schaffen.

2. Python Implementierung
Aus Platzgründen, habe ich dieses Experiment an meinem Netbook durchgeführt, welches ein Linux
Betriebssystem beherbergt, was mich wiederum dazu gebracht hat hier Python zur Implementierung zu benutzen.
Ich hatte bis zu diesem Punkt zwar keinerlei Erfahrung mit Python, der Einstieg war allerdings kein Problem, und so
konnte ich dieses Experiment trotz des allgemeinen Zeitdrucks doch noch erfolgreich in einer langen Nacht
durchführen.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 12


Sourcecode
wiimote-fingertrack.py

#!/usr/bin/python
""""*************************************************************************
Title: wiimote_fingertrack.py
Author: Kai Aras <ka010@hdm-stuttgart.de> http://0x17.wordpress.com
Software: python
Hardware: 2x Ninendo Wiimote
2x IR-LED Cluster

DESCRIPTION:
This is a simple proof-of-concept of how to do fingertracking and
control compiz as well as your mouse using only your fingers.
This is done by utilizing the nintendo wiimote's IR-camera.


REQUIRES:
- cwiid (wiimote library)
- X11 (tested only on linux)

*************************************************************************"""
#--------------------------------------------------------------------------------------------------------#
# - imports -
fdsfdsf
#--------------------------------------------------------------------------------------------------------#
import Xlib.display
# import X11 stuff
import Xlib.X
import Xlib.XK
import Xlib.error
import cwiid
# import wiimote lib
import time # import time (used for debugging only)
import compiz # import compiz to get control over the window manager
import sys
from Numeric import zeros
from ctypes import cdll,c_int # import c specific int type c_int and cdll

#--------------------------------------------------------------------------------------------------------#
# - callback methods -
#--------------------------------------------------------------------------------------------------------#

# callback method - gets calles when wiimote x reports new IR-Data
def callbackx(messages):
for message in messages: # iterate over all messages in buffer
if message[0] == cwiid.MESG_IR: # check if message contains IR-data
global dot_ctr # variable holds number of visible dots
dot_ctr = 0 # reset variable
for source in message[1]: # iterate over IR sources (max=4)
if source: # if source is valid
# set global variable doshift to the main loop
global doshift # do the actual shift inside
doshift = 1
global yshift
global xshift
global dot_ctr
dot_ctr = (dot_ctr+1)%3 # increment mod to prevent overflow

if (dot_ctr ==1): # if only one dot is visible
xshift = source['pos'][0] - pointer.win_x # get delta between mouse pointer and

elif message[0] == cwiid.MESG_ERROR: # if message is error message


print "ERROR: ", message[1] # print it
wmx.close() # and exit
exit(-1)
else: # if message is unknown
print "unknown msg" # print error message

Virtual Reality - Headtracking - Kai Aras - WS 08/09 13


# callback method for the y axis
def callbacky(messages):
for message in messages: # iterate over messages
if message[0] == cwiid.MESG_IR: # check if message holds IR Data
for source in message[1]: # iterate over sources
if source: # if source is valid
#print "point at ", source['pos']

global doshift # set state to do mouse pointer update


doshift = 1

global yshift

yshift = (source['pos'][1])-pointer.win_y # get delta between mouse pointer


#print "y: " , source['pos'][1] # and IR-dot
#mouseMove(0,yshift)
elif message[0] == cwiid.MESG_ERROR: # if message is error message
print "errory: ", message[1] # print it
wmy.close()
# and exit
exit(-1)
else: # if message type os unknonw
print "unknown msg" # print error message

#--------------------------------------------------------------------------------------------------------#
# - init -
#--------------------------------------------------------------------------------------------------------#
lib = "mouse.so" # library that contains a c-wrapper method to
call to Xlib/XWarpPointer(...) which is a c-
function
dll = cdll.LoadLibrary(lib) # load the library
mouseMove = (lambda x,y: dll.mouseMove(c_int(x), c_int(y))) # python-call mouseMove(...) calls c-wrapper-
function mouseMove(...) which then
# calls to Xlib/XWarpPointer(...) to actually
move the mouse pointer
display = Xlib.display.Display() # get x11 display
screen = display.screen() # get screen instance
root = screen.root # get screen root
pointer = root.query_pointer() # get mouse pointer

dot_ctr =0 # init variables

xshift =0
yshift =0
doshift=0

buffX = zeros(( 32))


buffXI = 0
buffY = zeros(( 32))
buffYI = 0

#connect the wiimotes


wmx = cwiid.Wiimote('00:1F:32:FA:8A:72') # connect directly via mac address
wmy = cwiid.Wiimote('00:1F:C5:61:BD:D0') # saves some time
print "connected" # were connected

#time.sleep(2)
wmx.enable(cwiid.FLAG_MESG_IFC) #
wmx.rpt_mode = cwiid.RPT_IR # set wiimote to report IR-Data only
wmx.mesg_callback = callbackx # register callback method for x-axsis
wmy.enable(cwiid.FLAG_MESG_IFC) #
wmy.rpt_mode = cwiid.RPT_IR # set wiimote to report IR-Data only
wmy.mesg_callback = callbacky # register callback method for y-axis

Virtual Reality - Headtracking - Kai Aras - WS 08/09 14


#--------------------------------------------------------------------------------------------------------#
# - main loop -
#--------------------------------------------------------------------------------------------------------#
#do forever
while (1):
#time.sleep(1/5)
pointer = root.query_pointer() # get mouse pointer position
if (doshift): # move pointer only if wiimote registers a
finger
#print xshift , " : " , yshift
mouseMove(xshift,yshift) # move mouse pointer to new position
#window = pointer.child
#window.warp_pointer(1,1)
doshift=0
# reset variables
xshift =0
yshift =0
if (dot_ctr == 2): # do custom actions if more than 1 fingers
are visible
compiz.call('scale','initiate_key')

# this is pretty much where i had to quit, because lack of time,

# but one could do all kinds of usefull interaction here, just one example

# could be guesture recognition.


- mouse.c -

#include <stdio.h>
#include <stdlib.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>

void mouseMove(int x, int y)


{
Display *displayMain = XOpenDisplay(NULL);

if(displayMain == NULL)
{
fprintf(stderr, "no Display !!!\n");
exit(EXIT_FAILURE);
}

XWarpPointer(displayMain, None, None, 0, 0, 0, 0, x, y);

XCloseDisplay(displayMain);
}

Virtual Reality - Headtracking - Kai Aras - WS 08/09 15


Probleme

1. Allgemein
Ein großes Problem war definitiv, die Größe, bzw. der zur Verfügung stehende Platz im CA-Labor. Letztlich hat zwar alles
mehr oder weniger funktioniert, der Raum hat sich jedoch als nicht wirklich optimal zur Installation des Vicon Systems
entpuppt. Beim Test der Kameraaufstellung stand grundsätzlich entweder ein Tisch im Weg, oder es war einfach kein Platz
mehr da.

2. Technisch
Da ich bisher keinerlei Erfahrung in den hier verwendeten Sprachen C++ und Python hatte, gab es hin und wieder kleinere
Probleme die meist sprachspezifischer Natur waren. Letztlich habe ich daraus natürlich nur profitiert.

3. Zeitlich
Obwohl die Einarbeitung in die Diplomarbeit, und das Vicon System eigentlich relativ problemlos verliefen, ist zu viel Zeit
vergangen, bis ich beim Softwareteil des Projekts angekommen war. Aufgrund der anfänglichen Probleme mit Radiolab
bezüglich des Sourcecodes und später der Stereoprojektion, kam gegen Ende des Projekts zusätzlich großer Zeitdruck auf,
und ich hatte effektiv etwa 3 Wochen für meine Software Implementierungen, Tests und Evaluation des Gesamtsystems,
sowie den ein bis zwei anderweitigen Experimenten die ich noch vor hatte.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 16


Fazit

Im Großen und Ganzen bin ich persönlich zwar zufrieden mit meiner Arbeit, gerne hätte ich jedoch mehr Zeit zur Verfügung
gehabt, um

1. Das System besser testen zu können

und

2. Das System benutzerfreundlicher machen zu können.

Zum Schluss, möchte ich noch auf das Ziel der Festinstallation im CA-Labor eingehen. Die diversen Test- Setups mit drei
Kameras haben leider nicht zu einem optimalen Ergebnis geführt. Grund hierfür waren zum einen die Beschränkung der
Raumhöhe, sowie der fehlende Platz links und rechts der Leinwand. Sicher kann ich jedoch sagen, dass:

• eine Kamera direkt über der Leinwand hängen muss, um Verdeckungsprobleme zu minimieren.

• der Platz im CA-Labor zwar ausreicht, jedoch kein optimales Bewegungsfeld zulässt.

• eine Festinstallation im Halbkreis mittels Deckenmontur möglich wäre.

• eine Schienenkonstruktion im Halbkreis optimal wäre, da somit eine gewisse Flexibilität, auch für andere Anwendungen,
gegeben wäre.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 17


Quellen

• Diplomarbeit “Implementierung von Positions- und Headtracking für Stereoprojektion und Head-Mounted-Display in
Radiolab und Entwicklung eines Eingabegerätes zur Navigation”

• Vicon Manual

• WiiYourself! C++ Library http://wiiyourself.gl.tter.org/

• Cwiid Python Library http://abstrakraft.org/cwiid/

• Johnny Chung Lee’s Homepage http://johnnylee.net

Anhänge

Python Script wiimote-fingertrack.py

C++ Source Files

• rlabmdiViewHDM.cpp

• rlabmdiViewHDM.h

• WiimoteCtrl.cpp

• WiimoteCtrl.h

Das komplette, lauffähige Visual-Studio Projekt wird aufgrund der Datenmenge zusätzlich auf CD-Rom eingereicht.

Virtual Reality - Headtracking - Kai Aras - WS 08/09 18