forked from gabrielDiaz-performlab/CatchB
-
Notifications
You must be signed in to change notification settings - Fork 0
/
vrlabConfig.py
449 lines (346 loc) · 14.6 KB
/
vrlabConfig.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
"""
This is designed to load in a system configuration file based on the name of the computer it's being run
on (as determined by platform.node()). If that file does not exist, defaultSys.cfg is loaded. It also sets up
that system in a way that tries not to be tied to a particular experiment to avoid each experiment replicating
this work (potentially with subtle differences). Finally, it reads in an experiment config file, which must conform
with the configspec in expCfgSpec.ini.
V 1.0 Matthew H. Tong (adapted from other code from Dmitry Kit)
V 1.1 Matthew H. Tong - Made it so VRLabConfig could be created without an experiment config, making it easier to use purely to handle the system config.
"""
import platform
import os.path
import sys
import viz
#Set the resources path
viz.res.addPath('resources')
sys.path.append('utils')
from configobj import ConfigObj
from configobj import flatten_errors
from validate import Validator
import vizact
import vizconnect
class VRLabConfig:
"""
This class represents the configuration for a particular experiment. It has two main components: VRLabConfig.sysCfg
and VRLabConfig.expCfg that contain the system configuration and the experiment configuration respectively.
VRLabCong.start(): Final initialization after viz.go()
VRLabConfig.sysCfg: The system configuration (a ConfigObj)
VRLabConfig.expCfg: The experiment configuration (a ConfigObj)
VRLabConfig.writables: A list of variables to be written to the .mov each frame
VRLabConfig.HMD: The HMD (defined in this file). Is still an HMD even if not using HMD, just disabled.
VRLabConfig.writer: The DVR writer. None if the writer is not being used or has not been initialized.
VRLabConfig.eyeTrackingCal: The eyetracking interface. None if we aren't eyetracking
VRLabConfig.camera: The virtual camera, positioned by headtracking. None if no such camera.
VRLabConfig.bodyCam: A second virtual camera or tracker
VRLabConfig.phase_space_markers: Markers for phasespace. Undefined if use_phasespace is false.
VRLabConfig.phasespace_server: Server for phasespace. Undefined if use_phasespace is false.
VRLabConfig.use_phasespace: True if phasespace is enabled
VRLabConfig.use_HMD: True if HMD is being used (otherwise configure just for screen)
VRLabConfig.use_hiball: True if hiball is enabled.
VRLabConfig.use_eyetracking: True if eyetracking is enabled
VRLabConfig.use_DVR: True if DVR should record the experiment
"""
def __init__(self, expCfgName = ""):
"""
Opens and interprets both the system config (as defined by the <platform>.cfg file) and the experiment config
(as defined by the file in expCfgName). Both configurations MUST conform the specs given in sysCfgSpec.ini and
expCfgSpec.ini respectively. It also initializes the system as specified in the sysCfg.
"""
self.writables = list()
if expCfgName:
self.__createExpCfg(expCfgName)
else:
self.expCfg = None
self.__createSysCfg()
for pathName in self.sysCfg['set_path']:
viz.res.addPath(pathName)
self.__setupSystem()
def __createSysCfg(self):
"""
Set up the system config section (sysCfg)
"""
sysCfgName = platform.node()+".cfg"
if not(os.path.isfile(sysCfgName)):
sysCfgName = "defaultSys.cfg"
print "Loading system config file: " + sysCfgName
sysCfg = ConfigObj(sysCfgName, configspec='sysCfgSpec.ini', raise_errors = True)
validator = Validator()
sysCfgOK = sysCfg.validate(validator)
if sysCfgOK == True:
print "System config file parsed correctly"
else:
print 'System config file validation failed!'
res = sysCfg.validate(validator, preserve_errors=True)
for entry in flatten_errors(sysCfg, res):
# each entry is a tuple
section_list, key, error = entry
if key is not None:
section_list.append(key)
else:
section_list.append('[missing section]')
section_string = ', '.join(section_list)
if error == False:
error = 'Missing value or section.'
print section_string, ' = ', error
sys.exit(1)
self.sysCfg = sysCfg
#self.writables.append(self.sysCfg)
def __createExpCfg(self, expCfgName):
"""
Set up the experiment config section (expCfg)
"""
print "Loading experiment config file: " + expCfgName
# This is where the parser is called.
expCfg = ConfigObj(expCfgName, configspec='expCfgSpec.ini', raise_errors = True, file_error = True)
validator = Validator()
expCfgOK = expCfg.validate(validator)
if expCfgOK == True:
print "Experiment config file parsed correctly"
else:
print 'Experiment config file validation failed!'
res = expCfg.validate(validator, preserve_errors=True)
for entry in flatten_errors(expCfg, res):
# each entry is a tuple
section_list, key, error = entry
if key is not None:
section_list.append(key)
else:
section_list.append('[missing section]')
section_string = ', '.join(section_list)
if error == False:
error = 'Missing value or section.'
print section_string, ' = ', error
sys.exit(1)
if expCfg.has_key('_LOAD_'):
for ld in expCfg['_LOAD_']['loadList']:
print 'Loading: ' + ld + ' as ' + expCfg['_LOAD_'][ld]['cfgFile']
curCfg = ConfigObj(expCfg['_LOAD_'][ld]['cfgFile'], configspec = expCfg['_LOAD_'][ld]['cfgSpec'], raise_errors = True, file_error = True)
validator = Validator()
expCfgOK = curCfg.validate(validator)
if expCfgOK == True:
print "Experiment config file parsed correctly"
else:
print 'Experiment config file validation failed!'
res = curCfg.validate(validator, preserve_errors=True)
for entry in flatten_errors(curCfg, res):
# each entry is a tuple
section_list, key, error = entry
if key is not None:
section_list.append(key)
else:
section_list.append('[missing section]')
section_string = ', '.join(section_list)
if error == False:
error = 'Missing value or section.'
print section_string, ' = ', error
sys.exit(1)
expCfg.merge(curCfg)
self.expCfg = expCfg
def __setupSystem(self):
# Set up the wiimote
################################################################
################################################################
## Misc. Design specific items here.
if( self.sysCfg['use_wiimote']):
# Create wiimote holder
self.wiimote = 0
self._connectWiiMote()
################################################################
## HMD
#Set up the HMD
if self.sysCfg['use_hmd']:
self.hmd = HMD(self.sysCfg['hmd'], True, displayList = self.sysCfg['displays'])
self.use_HMD = True
else:
self.hmd = HMD(self.sysCfg['hmd'], False)
self.use_HMD = False
viz.setMultiSample(self.sysCfg['antiAliasPasses'])
viz.MainWindow.clip(0.01 ,200)
#viz.vsync(1)
viz.setOption("viz.glfinish", 1)
viz.setOption("viz.dwm_composition", 0)
################################################################
## Recording
if self.sysCfg['use_DVR'] == 1:
self.use_DVR = True
else:
self.use_DVR = False
self.writer = None #Will get initialized later when the system starts
#Set up the eye tracking callibration/configuration (eyeTrackingCal)
################################################################
## Eyetracking
if self.sysCfg['use_eyetracking']:
self.use_eyeTracking = True
if self.sysCfg['hmd']['type'] == 'nvis':
import EyeTrackerCalibrationNVIS_MT
self.eyeTrackingCal = EyeTrackerCalibrationNVIS_MT.EyeTrackerCalibrationNVIS(self.sysCfg['eyetracker']['settingsDir'])
self.eyeTrackingCal.changeDisplayNum(self.sysCfg['displays'][0])
print "Eye tracking enabled using NVIS visor"
else:
print "Error in VRLabConfig: Eye-tracking not setup for this HMD."
sys.exit(1)
else:
self.use_eyeTracking = False
self.eyeTrackingCal = None
################################################################
## Mocap
#self.writables.append(self.eyeTrackingCal)
self.mocap = None
self.bodyCam = None
if self.sysCfg['use_phasespace']:
#from mocapInterface import phasespaceInterface
#self.mocap = phasespaceInterface(self.sysCfg);
from mocapInterface import phasespaceInterface
self.mocap = phasespaceInterface(self.sysCfg);
self.use_phasespace = True
else:
self.use_phasespace = False
if self.sysCfg['use_hiball']:
from HiBallCameraMT import HiBallCamera
#self.mocap = HiBallCamera(self.sysCfg['hiball']['origin'], self.sysCfg['hiball']['scale'], None, None, self.sysCfg, None);
self.mocap = HiBallCamera(self.sysCfg['hiball']['origin'], particle=None, sensorNum=self.sysCfg['hiball']['headCam'], attachTo=viz.MainView, preTrans = self.sysCfg['hiball']['preTransHead'])
if self.sysCfg['hiball']['bodyCam'] != -1:
self.bodyCam = HiBallCamera(self.sysCfg['hiball']['origin'], particle=None, sensorNum=self.sysCfg['hiball']['bodyCam'], attachTo=None, preTrans = self.sysCfg['hiball']['preTransBody'])
else:
self.bodyCam = None
self.use_hiball = True
else:
self.use_hiball = False
self.writables.append(self.mocap)
self.writables.append(self.bodyCam)
if self.sysCfg['use_fullscreen']:
viz.go(viz.FULLSCREEN)
else:
viz.go()
#self._setWinPriority(priority=5)
def start(self):
if self.use_DVR:
print "Starting DVR"
from DVRwriter import DVRwriter
from datetime import datetime
metadata = 'unused per-file meta data' #Can be filled in with useful metadata if desired.
if None == self.writer: #need to lazy initialize this because it has to be called after viz.go()
sz = viz.window.getSize()
self.now = datetime.now()
nameRoot = '%s%d.%d.%d.%d-%d' % (self.sysCfg['writer']['outFileDir'], self.now.year, self.now.month, self.now.day, self.now.hour, self.now.minute)
outFile = '%s.%s' % (nameRoot, self.sysCfg['writer']['outFileName'])
self.expCfg.filename = '%s.expCfg.cfg' % (nameRoot)
self.sysCfg.filename = '%s.sysCfg.cfg' % (nameRoot)
if 'L' == self.sysCfg['eyetracker']['eye']:
viewport = (0, 0,sz[0]/2,sz[1])
else:
viewport = (sz[0]/2,0,sz[0]/2,sz[1])
#fi
print "OutfileName:" + self.sysCfg['writer']['outFileName']
print "Metadata:" + metadata
print "Viewport:" + str(viewport)
print "Eyetracking:" + str(self.use_eyeTracking)
self.writer = DVRwriter(outFile, metadata, viewport, self.use_eyeTracking)
self.expCfg.write()
self.sysCfg.write()
self.writer.turnOn()
def __record_data__(self, e):
if self.use_DVR and self.writer != None:
#print "Writing..."
self.writer.write(self.writables)
def _connectWiiMote(self):
wii = viz.add('wiimote.dle')#Add wiimote extension
# Replace old wiimote
if( self.wiimote ):
print 'Wiimote removed.'
self.wiimote.remove()
self.wiimote = wii.addWiimote()# Connect to first available wiimote
vizact.onexit(self.wiimote.remove) # Make sure it is disconnected on quit
self.wiimote.led = wii.LED_1 | wii.LED_4 #Turn on leds to show connection
def _setWinPriority(self,pid=None,priority=1):
""" Set The Priority of a Windows Process. Priority is a value between 0-5 where
2 is normal priority. Default sets the priority of the current
python process but can take any valid process ID. """
import win32api,win32process,win32con
priorityclasses = [win32process.IDLE_PRIORITY_CLASS,
win32process.BELOW_NORMAL_PRIORITY_CLASS,
win32process.NORMAL_PRIORITY_CLASS,
win32process.ABOVE_NORMAL_PRIORITY_CLASS,
win32process.HIGH_PRIORITY_CLASS,
win32process.REALTIME_PRIORITY_CLASS]
if pid == None:
pid = win32api.GetCurrentProcessId()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, priorityclasses[priority])
class HMD:
class HMDStats:
def __init__(self, offset, overlap):
self.offset = offset
self.overlap = overlap
def __init__(self, cfg, enabled=1,displayList = None):
type = cfg['type']
offset = cfg['offset']
overlap = cfg['overlap']
fov = cfg['fov']
#self.hmdstats = self.HMDStats(offset, overlap)
self.enabled = enabled
if enabled:
if 'nvis' == type:
import nvis
self.hmd = nvis.nvisorSX111()
#vizconfig.register(self.hmd)
print "HMD type: NVIS SX111"
print '*** Offset:' + str( viz.MainWindow.getViewOffset() )
elif 'oculus' == type:
import oculus
self.hmd = oculus.Rift()
print "HMD type: Oculus Rift"
#vizconfig.register(self.hmd)
#self.updateOverlap(self.hmdstats.overlap-self.hmd._overlap)
elif 'DK2' == type:
self.setupOculusMon(displayList)
self.hmd = vizconnect.getTracker('rift')
else:
print "Unsupported HMD type when starting HMD"
sys.exit(1)
# import vizconfig
# vizconfig.register(self.hmd)
if(overlap > -1 ):
self.updateOverlap(self.hmdstats.overlap-self.hmd._overlap)
else:
defaultOverlap = 100
self.hmdstats = self.HMDStats(viz.MainWindow.getViewOffset, defaultOverlap)
#print 'After: ' + str(viz.MainWindow.getViewOffset()) + str(viz.MainWindow.stereoOverlap())
#self.hmdstats = self.HMDStats(viz.MainWindow.getViewOffset, viz.MainWindow.stereoOverlap)
else:
self.hmd = None
print "HMD disabled"
def updateOverlap(self, amount):
if self.enabled:
self.hmd._overlap = self.hmd._overlap + amount
offset = (self.hmd._hfov - self.hmd._overlap) / 2.0
viz.MainWindow.setViewOffset(viz.Matrix.euler(-offset,0.0,self.hmd._leftRollShift), eye=viz.LEFT_EYE)
viz.MainWindow.setViewOffset(viz.Matrix.euler( offset,0.0,self.hmd._rightRollShift),eye=viz.RIGHT_EYE)
self.hmdstats.offset = offset
self.hmdstats.overlap = self.hmd._overlap
print "Overlap", self.hmdstats.overlap, "Offset", self.hmdstats.offset
def setupOculusMon(self,displayList):
vizconnect.go('setupDK2Cluster.py')
#viz.window.setFullscreenMonitor(self.sysCfg['displays'])
#displayList = self.sysCfg['displays'];
if len(displayList) < 2:
print 'Display list is <1. Need two displays.'
else:
print 'Using display number' + str(displayList[0]) + ' for oculus display.'
print 'Using display number' + str(displayList[1]) + ' for mirrored display.'
### Set the rift and exp displays
riftMon = []
expMon = displayList[1]
with viz.cluster.MaskedContext(viz.MASTER):
# Set monitor to the oculus rift
monList = viz.window.getMonitorList()
for mon in monList:
if mon.name == 'Rift DK2':
riftMon = mon.id
viz.window.setFullscreen(riftMon)
with viz.cluster.MaskedContext(viz.CLIENT1):
count = 1
while( riftMon == expMon ):
expMon = count
viz.window.setFullscreenMonitor(expMon)
viz.window.setFullscreen(1)