Professional Documents
Culture Documents
25 February 2009
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:
• Aufbau des damaligen Rückprojektions Setup zur teil immersiven Anwendung im CA-Labor
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
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.
i. Setup
1. Festlegen der Verwendeten Hardware
Der erste Schritt beim Setup von Vicon IQ ist das festlegen der verwendeten Kameras,
und der Workstation.
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.
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.
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.
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:
• IR-Kamera
• 3-Achsen Accelerometer
• 11 Tasten
• Lautsprecher
• 4 LEDs
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.
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()
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.
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.
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,
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()
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.
#!/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
#--------------------------------------------------------------------------------------------------------#
# - 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
xshift =0
yshift =0
doshift=0
#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
- mouse.c -
#include <stdio.h>
#include <stdlib.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
if(displayMain == NULL)
{
fprintf(stderr, "no Display !!!\n");
exit(EXIT_FAILURE);
}
XCloseDisplay(displayMain);
}
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.
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
und
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 Schienenkonstruktion im Halbkreis optimal wäre, da somit eine gewisse Flexibilität, auch für andere Anwendungen,
gegeben wäre.
• Diplomarbeit “Implementierung von Positions- und Headtracking für Stereoprojektion und Head-Mounted-Display in
Radiolab und Entwicklung eines Eingabegerätes zur Navigation”
• Vicon Manual
Anhänge
• 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.