def add_grid(dimensions, euler, position, stepsize):
"""
Creates a 4-walled vertical grid for the chaperone.
Args:
dimensions: dimensions (length/height) of one grid/wall for the chaperone
stepsize: distance between the lines in the grid in meters
Returns: A grid wall.
"""
grid = vizshape.addGrid(dimensions, stepsize, 0, vizshape.AXIS_X)
grid.setEuler(euler)
grid.setPosition(position)
return grid
def __init__(self, bldList):
self.info = PointInfo()
self.buildings = bldList
self.trials = []
self.cTrial = None
self.trialCtr = -1
self.trgAngle = None
self.hideBuildings()
self.trialData = {}
# add vertex to measure true target angel
viz.startLayer(viz.POINTS)
viz.vertexColor(1,0,0)
viz.pointSize(30)
viz.vertex(0,0,0)
self.refVert = viz.endLayer()
self.refVert.disable(viz.RENDERING)
# add grid to orient subject during
# pointing
viz.startLayer(viz.LINES)
viz.lineWidth(6)
viz.vertexColor(0,0.6,0)
viz.vertex(-100, 0.01, 0)
viz.vertex( 100, 0.01, 0)
viz.vertex( 0, 0.01,-100)
viz.vertex( 0, 0.01, 100)
self.cross90 = viz.endLayer()
self.cross90.visible(viz.OFF)
self.grid = vizshape.addGrid(size=[200,200], step=10.0, boldStep=None)
self.grid.color([0,.6,0])
self.grid.visible(viz.OFF)
# add logger
self.fields2log = {'trialNr' : 'i8', 'srcBuilding' : 'S10', 'trgBuilding' : 'S10', 'refAngle' : 'f4', 'measAngle' : 'f4', 'trueAngle' : 'f4', 'trialOnset' : 'f8', 'tChoiceMade' : 'f8', 'srcXZ' : [('x', 'f4'), ('z', 'f4')], 'trgXZ' : [('x', 'f4'), ('z', 'f4')], 'srcCtxt' : 'S1', 'trgCtxt' :'S1'}
self.logHdl = lg.LogData(self.fields2log)
# handle exit
vizact.onexit( self.saveOnExit )
def setup():
global lhPPT, rhPPT, headPPT, headLink;
global lhSphere, rhSphere
nvis.nvisorSX111();
#nvis.nvisorSX60();
viz.mouse.setVisible(False)
#viz.cursor(viz.OFF);
view = viz.MainView
isense = viz.add('intersense.dle')
headTracker = isense.addTracker(port=1)
vizact.onkeydown('r',headTracker.resetHeading)
vrpn = viz.add('vrpn7.dle');
PPT_HOSTNAME = '171.64.33.43';
headPPTorig = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 0);
#Merge two links together
headPPT = viz.mergeLinkable(headPPTorig,headTracker)
headLink = viz.link(headPPT, viz.MainView);
headLink.postTrans([EYE_VECTOR[0], EYE_VECTOR[1], EYE_VECTOR[2]]);
#now add the PPT hands tracker
rhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 1)
lhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 2)
grid = vizshape.addGrid();
grid.color([0.5] * 3);
viz.callback(viz.KEYDOWN_EVENT, onKeyDown);
if(DEBUG_MODE):
print "adding spheres";
rhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
rfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
return;
def setup(avatar):
global headSphere, lhSphere, rhSphere, lfSphere, rfSphere;
global rhPos, lhPos, rfPos, lfPos, bodyPos;
rhPos = avatar.getBone('Bip01 R Hand').getPosition(viz.ABS_GLOBAL);
lhPos = avatar.getBone('Bip01 L Hand').getPosition(viz.ABS_GLOBAL);
rfPos = avatar.getBone('Bip01 R Foot').getPosition(viz.ABS_GLOBAL);
lfPos = avatar.getBone('Bip01 L Foot').getPosition(viz.ABS_GLOBAL);
bodyPos = avatar.getBone('Bip01').getPosition(viz.ABS_GLOBAL);
viz.MainView.setPosition(2.2, 0.5, -1.7)
viz.MainView.setEuler(-110, 0, 0)
viz.MainWindow.fov(90)
grid = vizshape.addGrid();
grid.color([0.5] * 3);
global bodyBox;
bodyBox = vizshape.addBox();
bodyBox.setScale(0.45, 1.2, 0.35);
bodyBox.visible(viz.OFF);
viz.callback(viz.KEYDOWN_EVENT, onKeyDown);
#link = viz.link(avatar.getBone('Bip01 Head'), viz.MainView)
#link = viz.link(viz.MainView, avatar.getBone('Bip01 Head'))
#link.postTrans([0, 0, -0.2]);
if(DEBUG_MODE):
print "adding spheres";
rhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
rfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
headSphere = vizshape.addSphere(radius = 0.1, color = viz.YELLOW);
return;
def _setup_clip_plane(self):
"""
Create a plane with a sissors logo, a grid and a grey back.
"""
# Create the white center plane
self._clip_plane = vizshape.addPlane(size=(.103, .103),
axis=vizshape.AXIS_Y,
cullFace=False,
cornerRadius=0.0025,
lighting=False)
# Create the back side
back = vizshape.addPlane(size=(.103, .103),
axis=vizshape.AXIS_Y,
cullFace=False,
cornerRadius=0.0025,
lighting=False,
color=(0.7, 0.7, 0.7),
parent=self._clip_plane)
back.setPosition([0, 0.002, 0])
# Create the front side with the sissors logo
sissors = vizshape.addPlane(size=(.08, .08),
axis=vizshape.AXIS_Y,
cullFace=False,
lighting=False,
parent=self._clip_plane)
sissors.setPosition([0, -0.002, 0])
tex = viz.addTexture('assets/sissors.png')
sissors.texture(tex)
# Create the grid so the user sees better where the cut goes
grid = vizshape.addGrid(size=(.5, .5),
step=.01,
boldStep=0.0,
axis=vizshape.AXIS_Y,
lighting=False,
parent=self._clip_plane)
# Hide the objects until the clipping function is activated
self._clip_plane.visible(False)
# import viztracker
# viztracker.DEFAULT_HANDS = True
# viztracker.go()
#so far so good
viz.setMultiSample(4)
viz.fov(60)
viz.go()
#Add a world axis with X,Y,Z labels
world_axes = vizshape.addAxes()
X = viz.addText3D('X',pos=[1.1,0,0],color=viz.RED,scale=[0.3,0.3,0.3],parent=world_axes)
Y = viz.addText3D('Y',pos=[0,1.1,0],color=viz.GREEN,scale=[0.3,0.3,0.3],align=viz.ALIGN_CENTER_BASE,parent=world_axes)
Z = viz.addText3D('Z',pos=[0,0,1.1],color=viz.BLUE,scale=[0.3,0.3,0.3],align=viz.ALIGN_CENTER_BASE,parent=world_axes)
#grids are good
grid = vizshape.addGrid(color=[0.2]*3)
viz.clearcolor(viz.GRAY)
#Create proximity manager
manager = vizproximity.Manager()
manager.setDebug(viz.ON)
#create our bisecting plane
mid_plane= vizshape.addPlane(size=(.00001,.00001),axis=vizshape.AXIS_X, cullFace=False)
start_node= right_node=vizshape.addCylinder(height, radius=2,topRadius= None,bottomRadius= None, axis=vizshape.AXIS_Y,slices=20,bottom=True,top=True)
left_node=vizshape.addCylinder(height, radius= 3,topRadius= None,bottomRadius= None, axis=vizshape.AXIS_Y,slices=20,bottom=True,top=True)
right_node=vizshape.addCylinder(height, radius=2,topRadius= None,bottomRadius= None, axis=vizshape.AXIS_Y,slices=20,bottom=True,top=True)
import viz
import vizshape
import vizact
import MultiKinectInterface
viz.go()
world = vizshape.addGrid()
#world = viz.addChild("Z:\Environments HD\environments\Cavern gallery.IVE")
world.setPosition([0, -.8, 0])
sensor = MultiKinectInterface.MultiKinectSensor()
viz.MainView.setPosition(0, -.5, -5)
pointNames = ["Hip center",
"Spine",
"Shoulder center",
"Head",
"Left shoulder",
"Left elbow",
"Left wrist",
"Left hand",
"Right shoulder",
"Right elbow",
"Right wrist",
"Right hand",
"Left hip",
"Left knee",
"Left ankle",
"Left foot",
"Right hip",
import viz
import vizact
import vizshape
viz.go()
#viz.clearcolor(viz.SKYBLUE)
#ground = viz.add('tut_ground.wrl')
vizshape.addGrid()
#Kinect Tracker object ID's
#myHead = vrpn.addTracker( 'Tracker0@localhost', HEAD).
HEAD = 0
NECK = 1
TORSO = 2
WAIST = 3
LEFTCOLLAR = 4
LEFTSHOULDER = 5
LEFTELBOW = 6
LEFTWRIST = 7
LEFTHAND = 8
LEFTFINGERTIP = 9
RIGHTCOLLAR = 10
RIGHTSHOULDER = 11
RIGHTELBOW = 12
RIGHTWRIST = 13
RIGHTHAND = 14
RIGHTFINGERTIP = 15
LEFTHIP = 16
LEFTKNEE = 17
LEFTANKLE = 18
LEFTFOOT = 19
Eventually the treadmill will slowly move the displaced foot back to a neutral position...
"""
import viz
import vizshape
import time
viz.go(
viz.FULLSCREEN #run world in full screen
)
#viz.addChild('dojo.osgb')
# code to add the grid to the environment
grid = vizshape.addGrid()
#initExtraWindows()
#viz.MainView.setPosition(0, 0, -1)
#viz.MainView.setEuler(0,0,0)
#set target tolerance for stride length
global targetL
targetL = 0.3
global targetR
targetR = 0.3
global targettol
targettol = 0.05
import viz
import vizshape
import time
viz.go(viz.FULLSCREEN #run world in full screen
)
#viz.addChild('dojo.osgb')
# code to add the grid to the environment
grid = vizshape.addGrid()
#viz.MainView.setPosition(0, 0, -1)
#viz.MainView.setEuler(0,0,0)
#set target tolerance for stride length
global targetL
targetL = 0.3
global targetR
targetR = 0.3
global targettol
targettol = 0.05
global boxPELVIS
boxPELVIS = viz.addChild('box.wrl', color=viz.PURPLE)
boxPELVIS.setPosition([0, 0, 0])
boxPELVIS.setScale([0.05, 0.01, 0.05])
global boxL
boxL = viz.addChild('box.wrl', color=viz.BLUE)
def setup():
global leftWristPPT, rightWristPPT, lfPPT, rfPPT, headPPT, viewLink, navigationNode
global lhSphere, rhSphere
global hmdLink
#add more trackers for trying things out
global rightFingersPPT, leftFingersPPT, leftForeArmPPT, rightForeArmPPT, rightHandViveController, leftHandViveController
#nvis.nvisorSX111();
#nvis.nvisorSX60();
#try the oculus rift
hmd = None
headOriTracker = None
if some_global_variables.PPT1:
vrpn = viz.add('vrpn7.dle')
#trying to connect the vive now
if not some_global_variables.DONT_USE_VIVE:
hmd = steamvr.HMD()
headOriTracker = hmd.getSensor()
headPosTracker = None
headPosLink = None
if headOriTracker is None:
print "HTC Vive is not connected. Trying Oculus Rift now"
hmd = oculus.Rift()
headOriTracker = hmd.getSensor()
if headOriTracker is None:
print "Rift is also not connected!"
else:
print "Connected to Rift!"
vizact.onkeydown('r',headOriTracker.reset)
if some_global_variables.PPT1:
headPosTracker = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_HEAD_VIRTUAL_ID - 1)
headPosTrackerNode = viz.addGroup()
headPosLink = viz.link(headPosTracker, headPosTrackerNode)
headPosLink.preTrans(list(EYE_VECTOR))
else:
print "Connected to Vive!"
#Merge position and orientation links for the head tracker, if needed
if headPosLink is not None:
#using DK2 in PPT1 with a PPT marker for head tracking
headPPT = viz.mergeLinkable(headPosLink,headOriTracker)
else:
#like using vive, or DK2 outside PPT1
headPPT = headOriTracker
if headOriTracker is not None:
some_global_variables.headTrackingActive = True
viz.mouse.setVisible(False)
#viz.cursor(viz.OFF);
view = viz.MainView
viewLink = None
navigationNode = viz.addGroup()
viewLink = viz.link(navigationNode, viz.MainView)
if headPPT is not None:
viewLink.preMultLinkable(headPPT)
if not some_global_variables.PPT1:
viewLink.setOffset([0,1.4,0])
# viewLink = viz.link(headPPT, viz.MainView)
#viewLink.postTrans([EYE_VECTOR[0], EYE_VECTOR[1], EYE_VECTOR[2]])
#hmdLink.preTrans(EYE_VECTOR)
#view.preTrans(EYE_VECTOR)
#headPPT.preTrans([0,10,0]);
#now add the PPT hands tracker
if some_global_variables.PPT1:
rightForeArmPPT = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_RIGHT_FOREARM_VIRTUAL_ID-1)
if rightForeArmPPT is not None: print "right forearm tracker is active with virtual PPT ID = " + str(some_global_variables.PPT_RIGHT_FOREARM_VIRTUAL_ID)
leftForeArmPPT = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_LEFT_FOREARM_VIRTUAL_ID-1)
if leftForeArmPPT is not None: print "left forearm tracker is active with virtual PPT ID = " + str(some_global_variables.PPT_LEFT_FOREARM_VIRTUAL_ID)
appendageControlWithVive = vizinput.choose('Using Vive controllers or a bunch of PPT markers?', ['Vive','4 extra PPT marker!'])
if appendageControlWithVive == 0: #using vive hand controllers
some_global_variables.usingViveHandControllers = True
viveHandControllerList = steamvr.getControllerList()
controllerCount = 0
for controller in steamvr.getControllerList():
controllerCount += 1
#Right Hand Controller Setup
if controllerCount == 1:
rightHandViveController = viveHandControllerList[0]
#Left Hand Controller Setup
elif controllerCount == 2:
leftHandViveController = viveHandControllerList[1]
else: #using four extra PPT markers - could be noisy due to interference
rightFingersPPT = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_RIGHT_FINGERS_VIRTUAL_ID-1)
if rightFingersPPT is not None: print "right fingers tracker is active with virtual PPT ID = " + str(some_global_variables.PPT_RIGHT_FINGERS_VIRTUAL_ID)
leftFingersPPT = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_LEFT_FINGERS_VIRTUAL_ID-1)
if leftFingersPPT is not None: print "left fingers tracker is active with virtual PPT ID = " + str(some_global_variables.PPT_LEFT_FINGERS_VIRTUAL_ID)
rightWristPPT = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_RIGHT_WRIST_VIRTUAL_ID-1)
if rightWristPPT is not None: print "right wrist tracker is active with virtual PPT ID = " + str(some_global_variables.PPT_RIGHT_WRIST_VIRTUAL_ID)
leftWristPPT = vrpn.addTracker('PPT0@' + some_global_variables.PPT_HOSTNAME, some_global_variables.PPT_LEFT_WRIST_VIRTUAL_ID-1)
if leftWristPPT is not None: print "left wrist tracker is active with virtual PPT ID = " + str(some_global_variables.PPT_LEFT_WRIST_VIRTUAL_ID)
grid = vizshape.addGrid()
grid.color([0.5] * 3)
viz.callback(viz.KEYDOWN_EVENT, onKeyDown)
if(DEBUG_MODE):
print "adding spheres";
rhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
rfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
return
def setup(isLeftHanded):
global lhPPT, rhPPT, lfPPT, rfPPT, headPPT, headLink, headPPTmarker, rhPPTlink, lhPPTlink, offsetTimerEvent
global lhSphere, rhSphere
global riftLink
#nvis.nvisorSX111();
#nvis.nvisorSX60();
viz.mouse.setVisible(False)
#viz.cursor(viz.OFF);
view = viz.MainView
#isense = viz.add('intersense.dle')
#headTracker = isense.addTracker(port=1)
vrpn = viz.add('vrpn7.dle');
PPT_HOSTNAME = '171.64.33.43';
#ading the headPPT marker
# headPPTmarker = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 0);
headPPTmarker = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, some_global_variables.headPPTmarkerVirtualID - 1);
headMarkerNode = viz.addGroup()
headMarker = viz.link(headPPTmarker, headMarkerNode)
# headMarker.preTrans(list(EYE_VECTOR))
# headMarker.setOffset(some_global_variables.pptMarkerWeirdOffset)
#now add the PPT hands tracker
if isLeftHanded == 0:
#user right-handed
# rhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 1)
# rhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, some_global_variables.rhPPTmarkerVirtualID - 1)
rhPPTmarker = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, some_global_variables.rhPPTmarkerVirtualID - 1)
# lhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 2)
lhPPTmarker = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, some_global_variables.lhPPTmarkerVirtualID - 1)
else:
#user left-handed
# rhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 2)
rhPPTmarker = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, some_global_variables.rhPPTmarkerVirtualID)
# lhPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 1)
lhPPTmarker = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, some_global_variables.lhPPTmarkerVirtualID)
if USE_LEG:
rfPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 3)
lfPPT = vrpn.addTracker('PPT0@' + PPT_HOSTNAME, 4)
headPPT = None
headTracker = None
#loading rift
#rift = oculus.Rift()
#headTracker = rift.getSensor()
if headTracker is None:
#DK2 not found, trying the vive now
hmd = steamvr.HMD()
headTracker = hmd.getSensor()
headPPT = headTracker
#activating a timer to adjust the PPT-Vive offset at runtime
if some_global_variables.ADJUST_PPT_VIVE_OFFSET_AT_RUNTIME:
offsetTimerEvent = vizact.ontimer(0, offsetTimer)
else:
vizact.onkeydown('r',headTracker.reset)
headPPT = viz.mergeLinkable(headMarker,headTracker)
#if rift is not available
#Merge two links together
#headPPT = viz.mergeLinkable(headPPTmarker,headTracker)
headLink = viz.link(headPPT, viz.MainView);
#headLink.postTrans([EYE_VECTOR[0], EYE_VECTOR[1], EYE_VECTOR[2]]);
riftLink = headLink
#riftLink.preTrans(EYE_VECTOR)
#view.preTrans(EYE_VECTOR)
#headPPT.preTrans([0,10,0]);
rhPPT = viz.addGroup()
rhPPTlink = viz.link(rhPPTmarker, rhPPT)
# rhPPTlink.setOffset(some_global_variables.pptMarkerWeirdOffset)
lhPPT = viz.addGroup()
lhPPTlink = viz.link(lhPPTmarker, lhPPT)
# lhPPTlink.setOffset(some_global_variables.pptMarkerWeirdOffset)
grid = vizshape.addGrid();
grid.color([0.5] * 3);
viz.callback(viz.KEYDOWN_EVENT, onKeyDown);
if(DEBUG_MODE):
print "adding spheres";
rhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lhSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
rfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
lfSphere = vizshape.addSphere(radius = 0.1, color = viz.WHITE);
return;
def __init__(self,color=viz.CYAN,textColor=viz.WHITE,shadowColor=viz.BLACK):
super(self.__class__, self).__init__()
# Create front grid
self._grid_front = vizshape.addGrid(size=(20,10))
self._grid_front.color(color)
self._grid_front.setPosition(0,5,-5)
self._grid_front.setEuler(0,90,0)
self._grid_front.setParent(self._root)
# Create back grid
self._grid_back = vizshape.addGrid(size=(20,10))
self._grid_back.color(color)
self._grid_back.setPosition(0,5,-5-24)
self._grid_back.setEuler(0,90,0)
self._grid_back.setParent(self._root)
# Create bottom grid
self._grid_bottom = vizshape.addGrid(size=(20,24))
self._grid_bottom.color(color)
self._grid_bottom.setPosition(0,0,-17)
self._grid_bottom.setParent(self._root)
# Create left grid
self._grid_left = vizshape.addGrid(size=(10,24))
self._grid_left.color(color)
self._grid_left.setPosition(-10,5,-17)
self._grid_left.setEuler(0,0,90)
self._grid_left.setParent(self._root)
# Create right grid
self._grid_right = vizshape.addGrid(size=(10,24))
self._grid_right.color(color)
self._grid_right.setPosition(10,5,-17)
self._grid_right.setEuler(0,0,-90)
self._grid_right.setParent(self._root)
# # Floating controls
# self._controlsQuad = viz.addTexQuad(size=[20,20])
# controlsPic = viz.addTexture('resources/gui/merged_mapping_truss.png',parent=self._controlsQuad)
# self._controlsQuad.texture(controlsPic)
# self._grid_bottom.setPosition(0,0.1,-30)
# self._controlsQuad.setEuler(0,90,0)
# self._controlsQuad.setParent(self._root)
## self._controlsQuad.disable(viz.LIGHTING)
# Create floating measurements
self._span_text = viz.addText3D('< 20 meters >',pos=[0,11,-5],scale=[1,1,1],parent=self._root,align=viz.ALIGN_CENTER)
self._span_text_shadow = viz.addText3D('< 20 meters >',parent=self._span_text,align=viz.ALIGN_CENTER)
self._span_text_shadow.setPosition([0,0,0.2])
self._span_text_shadow.color(shadowColor)
self._span_text_shadow.alpha(0.75)
self._height_text = viz.addText3D('< 10 meters >',pos=[-11,5,-5],scale=[1,1,1],euler=[0,0,90],parent=self._root,align=viz.ALIGN_CENTER)
self._height_text_shadow = viz.addText3D('< 10 meters >',parent=self._height_text,align=viz.ALIGN_CENTER)
self._height_text_shadow.setPosition([0,0,0.2])
self._height_text_shadow.color(shadowColor)
self._height_text_shadow.alpha(0.75)
#--Create orientation info text
self._orientation_text = viz.addText3D('< View >',pos=[0,14,-5],scale=(2,2,.5),parent=self._root,align=viz.ALIGN_CENTER)
self._orientation_text.color(textColor)
self._orientation_text_shadow = viz.addText3D('< View >',parent=self._orientation_text,align=viz.ALIGN_CENTER)
self._orientation_text_shadow.setPosition([0,0,0.2])
self._orientation_text_shadow.color(shadowColor)
self._orientation_text_shadow.alpha(0.75)
self._info_text = viz.addText3D('< Info >',pos=[0,12.25,-5],scale=(.5,.5,.5),parent=self._root,align=viz.ALIGN_CENTER)
self._info_text.color(textColor)
self._info_text_shadow = viz.addText3D('< Info >',parent=self._info_text,align=viz.ALIGN_CENTER)
self._info_text_shadow.setPosition([0,0,0.2])
self._info_text_shadow.color(shadowColor)
self._info_text_shadow.alpha(0.75)
def __init__(self, enable=False, hotkey=viz.KEY_F12):
self._enable = enable
self._hotkey = hotkey
self._next_screenshot = 1
self._points = []
# Visualization parameters
self.GRID_COLOR = [1, 1, 1]
self.DEBUG_ALPHA = 0.6
self.LABEL_SCALE = 0.05
self.VALUE_SCALE = 0.015
self.MARKER_SIZE = 0.05
self.HUD_POS = [0.4, 0.3, 1] # Works for Vive / Vive Pro
# SteamVR devices
self.hmd = {}
self.controllers = {}
self.trackers = {}
self.lighthouses = {}
self.nodes = {}
# Set up scene objects
self._root = viz.addGroup()
self._obj = []
self._obj.append(vizshape.addGrid((100, 100), color=self.GRID_COLOR, pos=[0.0, 0.001, 0.0], parent=self._root))
self._obj.append(vizshape.addAxes(pos=(0,0,0), scale=(0.5, 0.5, 0.5), parent=self._root))
# Set up possible marker objects
self._markers = {'sphere_red': vizshape.addSphere(radius=self.MARKER_SIZE / 2, color=viz.RED, parent=self._root),
'sphere_green': vizshape.addSphere(radius=self.MARKER_SIZE / 2, color=viz.GREEN, parent=self._root),
'sphere_blue': vizshape.addSphere(radius=self.MARKER_SIZE / 2, color=viz.BLUE, parent=self._root),
'sphere_yellow': vizshape.addSphere(radius=self.MARKER_SIZE / 2, color=viz.YELLOW, parent=self._root),
'cube_red': vizshape.addCube(size=self.MARKER_SIZE, color=viz.RED, parent=self._root),
'cube_green': vizshape.addCube(size=self.MARKER_SIZE, color=viz.GREEN, parent=self._root),
'cube_blue': vizshape.addCube(size=self.MARKER_SIZE, color=viz.BLUE, parent=self._root),
'cube_yellow': vizshape.addCube(size=self.MARKER_SIZE, color=viz.YELLOW, parent=self._root)
}
for marker in self._markers.keys():
self._markers[marker].visible(False)
# Note: X/Z axis rays moved up (y) by 1 mm to avoid z-fighting with the ground plane
self._obj.append(addRayPrimitive(origin=[0,0.001,0], direction=[1, 0.001, 0], color=viz.RED, parent=self._root)) # x
self._obj.append(addRayPrimitive(origin=[0,0.001,0], direction=[0, 0.001, 1], color=viz.BLUE, parent=self._root)) # z
self._obj.append(addRayPrimitive(origin=[0,0,0], direction=[0, 1, 0], color=viz.GREEN, parent=self._root)) # y
# Set up UI
txt = 'Hotkeys:\nS - Save collected points data\nC - Clear point data\nL - Toggle Lighthouse rays\nX - Export debug scene\n\n'
txt += 'Controller Buttons:\nTrigger - place point axes\nA - Save point data\nB - Take screenshot'
self._ui = vizinfo.InfoPanel(txt, icon=True, align=viz.ALIGN_RIGHT_TOP, title='SteamVR Debug Tool')
self._ui.renderToEye(viz.RIGHT_EYE)
self._ui.addSeparator()
self._obj.append(self._ui)
# Register key callbacks
self._callbacks = []
self._callbacks.append(vizact.onkeydown('s', self.savePoints))
self._callbacks.append(vizact.onkeydown('c', self.clearPoints))
self._callbacks.append(vizact.onkeydown('l', self.showLighthouseRays, viz.TOGGLE))
self._callbacks.append(vizact.onkeydown('x', self.saveDebugScene))
self.findDevices()
self.enable(self._enable)
self._hotkey_callback = vizact.onkeydown(self._hotkey, self.enable, viz.TOGGLE)
self._ui_callback = vizact.onupdate(viz.PRIORITY_LINKS+1, self._updateUI)
print('* SteamVR Debug Overlay initialized.')
#Create proximity manager to manage sensors____________________________________
manager = vizproximity.Manager()
manager.setDebug(
viz.OFF) #Turn on to add wireframe, done below with keypress 'l'
vizact.onkeydown('l', manager.setDebug, viz.TOGGLE)
# Setting hand tracked position as target
right_hand = vizproximity.Target(handTracker)
left_hand = vizproximity.Target(leftHand)
manager.addTarget(left_hand)
manager.addTarget(right_hand)
# Visual grid that appears on floor
grid = vizshape.addGrid(color=[0.2] * 3)
viz.clearcolor(viz.GRAY)
#~ can be removed, kept for reference of spacial dimensions
#table= vizshape.addBox([1.05,.000000001,.495],right=True,left=True,top=True,bottom=True, front=True,back=True, splitFaces=False, color= viz.PURPLE)
#table.setPosition(0,.76-.001,.23)
#Timer Functions___________________________________________________________________________________
"""
Used to check if participant left the start sensor early.
Currently not in use!
"""
def scheduleTimer(sensor):
