def raisestop(sign):
print("stop flag raised")
endflag.set()
t1.join()
t2.join()
# t4.join()
viz.quit()
def raisestop(biggle): global stopevent1 global stopevent2 stopevent1.set() stopevent2.set() viz.quit()
def raisestop(sign):
#the sign passed in doesn't do anything, I just didn't know how to make this work without passing something in...
print("stop flag raised")
endflag.set()
t1.join(5)
t2.join(5)
t4.join(5)
viz.quit()
def raisestop(sign):
#the sign passed in doesn't do anything, I just didn't know how to make this work without passing something in...
print("stop flag raised")
endflag.set()
t1.join()
t2.join()
t3.join()
t4.join()
viz.quit()
def experiment():
for trialN in range(10):
if trialN < 9:
datafile = 'Trial0' + str(trialN + 1) + '.txt'
respfile = 'RT_Trial0' + str(trialN + 1) + time.strftime(
"_%d-%b-%y_%H-%M") + '.csv'
else:
datafile = 'Trial' + str(trialN + 1) + '.txt'
respfile = 'RT_Trial' + str(trialN + 1) + time.strftime(
"_%d-%b-%y_%H-%M") + '.csv'
colors = []
with open(datafile, 'rb') as csvfile:
csvreader = csv.reader(csvfile, delimiter=' ')
for row in csvreader:
colors.append(row)
colors = numpy.asarray(colors, dtype=uInt8)
# colors = colors[0]
strobes = Strobes(x, 100)
leds = LEDs(colors, 0.05, 0.9403)
vizact.onkeydown('.', leds.recordResp)
sensor_Target = vizproximity.Sensor(
vizproximity.RectangleArea([4, 0.1],
center=[0, real_tg_dist[(-1)**trialN]]),
None)
manager.addSensor(sensor_Target)
# Show where the target is and ask them to face to the target
yield viztask.waitKeyDown('a')
standBy = viztask.schedule(leds.standby(trialN % 2))
# Turn of the LED to get the experiment ready to start
yield viztask.waitKeyDown('s')
standBy.kill()
leds.all_off()
leds.stop()
monitor_record_Network.send('Start!')
strobes.StartTask()
f = viztask.schedule(leds.flashing())
monitor_record_Network.send('Start!')
yield vizproximity.waitEnter(
sensor_Target) # flash until they enter the target zone
f.kill()
# Once reach the target turn off both the LEDs and strobes
strobes.StopTask()
strobes.ClearTask()
leds.all_off()
leds.stop()
leds.clear()
# Save the data into a csv file
leds.saveAsFile(respfile)
manager.clearSensors()
yield viztask.waitTime(10)
viz.quit()
def EXPERIMENT(ITI,runs): for r in range(runs): runNum = r+1 context = ContextGen(runNum) yield StartRun(runNum,1,0) yield Replace() yield StartRun(runNum,0,1) viz.quit()
def CloseConnections(EYETRACKING):
"""Shuts down EYETRACKING and wheel threads then quits viz"""
print ("Closing connections")
if EYETRACKING:
comms.stop_trial() #closes recording
#kill automation
viz.quit()
def luigiStatusCheck():
a = True
while luigiact.alive():
if luigi.getAnimationTime(4) >= 12 and a == True:
import vizfx.postprocess
from vizfx.postprocess.blur import FragmentBlurEffect
effect = FragmentBlurEffect(distance=4)
vizfx.postprocess.addEffect(effect)
a = False
elif luigi.getAnimationTime(4) >= 18:
viz.quit()
def MainTask():
"""Top level task that controls the game"""
# Display instructions and wait for key press to continue
yield DisplayInstructionsTask()
# Create panel to display trial results
resultPanel = vizinfo.InfoPanel('',align=viz.ALIGN_CENTER,fontSize=25,icon=False,key=None)
resultPanel.visible(False)
while True:
# Randomly choose hiding spots from list
locations = random.sample(HIDING_SPOTS,TRIAL_COUNT)
# Reset score
score = 0
UpdateScore(score)
# Go through each position
for pos in locations:
# Perform a trial
found = yield TrialTask(pos)
# Update score and display status text
if found:
viz.playSound('sounds/pigeon_catch.wav')
score += 1
UpdateScore(score)
tracker.runAction(vizact.spinTo(point=pos,time=0.8,interpolate=vizact.easeOutStrong))
resultPanel.setText(TRIAL_SUCCESS)
else:
viz.playSound('sounds/pigeon_fly.wav')
viztask.schedule(FadeToGrayTask())
resultPanel.setText(TRIAL_FAIL)
#Display success/failure message
resultPanel.visible(True)
# Add delay before starting next trial
yield viztask.waitTime(TRIAL_DELAY)
resultPanel.visible(False)
# Disable gray effect
gray_effect.setEnabled(False)
viz.quit()
#Display results and ask to quit or play again
resultPanel.setText(RESULTS.format(score,TRIAL_COUNT))
resultPanel.visible(True)
yield viztask.waitKeyDown(' ')
resultPanel.visible(False)
def onKeyDown(self, key):
if self.win or self.lose:
viz.quit()
if not self.picking:
if (key == viz.KEY_UP):
#increase velocity
self.scaleValue += .1
elif (key == viz.KEY_DOWN):
#decrease velocity
self.scaleValue = self.scaleValue - .1 if self.scaleValue > 2 else 2
elif key == 's':
self.pitch += 5
#incorporate +5 degree more pitch
v = self.rotmatrix.preMultVec([1, 0, 0])
self.rotmatrix.postAxisAngle(
v[0], v[1], v[2], self.rotateValue
if self.model.id == self.xWing.id else -self.rotateValue)
elif key == 'w':
self.pitch -= 5
#incorporate -5 degree more pitch
v = self.rotmatrix.preMultVec([1, 0, 0])
self.rotmatrix.postAxisAngle(
v[0], v[1], v[2], -self.rotateValue
if self.model.id == self.xWing.id else self.rotateValue)
elif key == 'd':
self.roll -= 5
#incorporate -5 degree more roll
v = self.rotmatrix.preMultVec([0, 0, 1])
self.rotmatrix.postAxisAngle(
v[0], v[1], v[2], -self.rotateValue
if self.model.id == self.xWing.id else self.rotateValue)
elif key == 'a':
self.roll += 5
#incorporate +5 degree more roll
v = self.rotmatrix.preMultVec([0, 0, 1])
self.rotmatrix.postAxisAngle(
v[0], v[1], v[2], self.rotateValue
if self.model.id == self.xWing.id else -self.rotateValue)
elif key == 'q':
self.yaw -= 5
#incorporate -5 degree more yaw
v = self.rotmatrix.preMultVec([0, 1, 0])
self.rotmatrix.postAxisAngle(v[0], v[1], v[2],
-self.rotateValue)
elif key == 'e':
self.yaw += 5
#incorporate +5 degree more yaw
v = self.rotmatrix.preMultVec([0, 1, 0])
self.rotmatrix.postAxisAngle(v[0], v[1], v[2],
self.rotateValue)
self.setOrientation()
def experiment():
yield viztask.waitNetwork(serverName)
# the first baseline
yield baseline(1)
# following offset and baseline conditions
yield testing()
# finish the experiment
info.setText('End of the Experiment.')
info.visible(viz.ON)
yield viztask.waitTime(45)
viz.quit()
def onButton(self,obj,state): if obj==self.myButton: if state == viz.DOWN: self.continu=True #print continu self.done.send(data=self.continu) elif obj==self.myquit: self.continu=False viz.quit() self.done.send(data=self.continu)
def Next(self, train):
print "Give Directions: ", self.runnum
if self.dialog.filename:
train.log("# Direction confidence following " +
self.dialog.filename)
train.log(getEvaluation(1, 1))
if len(self.directions) == 0:
tkMessageBox.showinfo(
"Finished!", "Finished with this part of the experiment.")
viz.quit()
else:
self.popDirection(train)
train.onFinish = self.Dialog
self.runnum += 1
def CloseConnections(self):
"""Shuts down EYETRACKING and wheel threads then quits viz"""
print("Closing connections")
if self.EYETRACKING:
self.comms.stop_trial() #closes recording
#self.pupil_killer()
#kill automation
if self.AUTOWHEEL:
self.Wheel.thread_kill(
) #This one is mission critical - else the thread will keep going
self.Wheel.shutdown()
viz.quit()
def Next(self, train):
print "Direction set ", self.runnum
if self.runnum > 0:
if self.dialog.filename:
train.log("# Direction confidence giving " +
self.dialog.filename)
train.log(getEvaluation(1, 1))
if len(self.QuizList) == 0:
tkMessageBox.showinfo(
"Finished!", "Finished with this part of the experiment.")
viz.quit()
else:
(self.startPos, self.endPos) = self.QuizList.pop()
train.MoveToNext(self.startPos)
train.onFinish = self.Dialog
self.runnum += 1
def experiment():
yield viztask.waitNetwork(serverName)
yield Baseline(1)
if Exp_Sequence == 'RP':
yield Direction_Exp(1)
yield Distance_Exp(4)
else:
yield Distance_Exp(1)
yield Direction_Exp(3)
info.setText('End of the Experiment.')
info.visible(viz.ON)
yield viztask.waitTime(60)
viz.quit()
def runtrials():
for i, trialtype in enumerate(TRIALSEQ):
print("Trial: ", str(i))
print("TrialType: ", str(i))
trial_targetoccurence_prob = ConditionList_targetoccurence_prob[
trialtype] #set occurence parameter for the trial.
trial_targetnumber = ConditionList_targetnumber[
trialtype] #set target number for the trial.
print(str([trial_targetoccurence_prob, trial_targetnumber]))
Distractor.StartTrial(trial_targetoccurence_prob,
trial_targetnumber,
trialn=i) #starts trial
print("Called Start Trial, now waiting")
#yield viztask.waitTime(TotalTrialTime+.5) #this should always wait a little longer than the TrialTime, allowing the EndOfTrial function to get called in Count_Adjustable.
def MonitorDistactor():
"""will return true if it is the end of trial"""
EoTFlag = Distractor.getFlag() # True if it's the end of the trial
return (EoTFlag)
yield viztask.waitTrue(MonitorDistactor)
###interface with End of Trial Screen
pressed = 0
while pressed < trial_targetnumber:
#keep looking for gearpad presses until pressed reaches trial_targetnumber
print("waiting for gear press")
d = yield viztask.waitAny([waitButton1, waitButton2])
pressed += 1
print('pressed ' + str(pressed))
Distractor.gearpaddown(d.condition) #call gearpaddown.
yield viztask.waitTime(.5)
#Distractor.EoTScreen_Visibility(viz.OFF)
Distractor.RecordCounts()
#Finished = True
else:
viz.quit() ##otherwise keeps writting data onto last file untill ESC
def sensorEnterEnd(sensor):
print("Enter end sensor")
global appendagesItterator
global start
global timeEnd
global timeA
global trialTimeList
global leftEarly
global enterSensorCount
enterSensorCount[7] = enterSensorCount[7] + 1
if (
manager.getActiveTargets() == manager.getActiveTargets(
sensor=endSensor)
): # Used to provent potential issues when trying to record data. If a tracker is inside of another sensor then there could be time or count issues.
if (start == True
): # used to protect from doubling the effects of the sensor
print("End sensor only active")
print(len(appendages))
# End timers
timeEnd = time.clock() - timeA
print(timeEnd)
# Add to the list
trialTimeList.append(timeEnd)
trialTimeList.append(leftEarly)
print(trialTimeList)
#~ we can either print to a text file here, or we can store the variables for later.
#print to text = trialTimeList
#print to text = enterSensorCount
del trialTimeList[:] # Restart list for use in next trial
if (len(appendages) > 1):
start = False
else:
viz.quit()
else:
print("Please check appendages")
def tester2(self,name): print "*****Looking around*****" viz.waitTime(3) if None is self.first: self.first = "smith" print "\nAgent SMITH: I WILL KILL YOU ALLLLLL!!!\n" viz.waitTime(2) if(False == self.yo): self.flag = True viz.waitTime(2) viz.quit() else: viz.waitTime(2) print "Agent SMITH: Wait waaa!!" viz.waitTime(2) print "*****NEO beats up Agent SMITH and destroys him*****" viz.waitTime(2) print "Agent SMITH: Damn you NEOOOOO!!\nAgent SMITH: NOW Fall Agent SMITH"
def experimentProcedure(self):
self.response = None
self.STARTTIME = viz.tick()
self.STATE = 'Start Vection'
#Define the Vection
def motion():
# Create Fixation Dot
viz.startLayer(viz.POINTS)
viz.pointSize(self.POINTSIZE)
viz.vertexColor(viz.GRAY)
viz.vertex(0, 1.8, 4)
points = viz.endLayer()
points.disable(viz.CULLING)
# Create the circles
sphere = self.createCircles(26, 1, 30, -26)
sphere2 = self.createCircles(22, 0.8, 30, -26)
sphere3 = self.createCircles(18, 0.6, 30, -26)
sphere4 = self.createCircles(14, 0.4, 30, -26)
sphere5 = self.createCircles(10, 0.2, 30, -26)
viz.MainView.move([0, 0, 3])
def keydown(key):
if key == 'f':
self.response = 'self motion'
self.keyPressTime = viz.tick() # get time for keypress
print(self.response, self.keyPressTime)
self.STATE = 'State - self Motion'
if key == 'j':
self.response = 'object motion'
self.keyPressTime = viz.tick() # get time for keypress
print(self.response, self.keyPressTime)
self.STATE = 'State - Object Motion'
viz.callback(viz.KEYDOWN_EVENT, keydown)
# A function to record thfe responses
yield motion()
yield viztask.waitTime(10)
viz.quit()
def __init__(self, xx = None, yy = None, zz = None): if xx != None and yy == None and zz == None: #xx is a vector, we create a new vector passing #xx values as arguments self.x = xx.x self.y = xx.y self.z = xx.z elif xx != None and yy != None and zz == None: #two points to create a vector from xx to yy self.x = yy.x-xx.x self.y = yy.y-xx.y self.z = yy.z-xx.z elif xx != None and yy != None and zz != None: self.x = xx self.y = yy self.z = zz else: print "Vector Creation Error!" viz.quit()
def onbutton(obj,state):
#Use our starting time variable to find out how much
#time has elapsed.
elapsed_time = viz.tick() - start_time
#Create string lines to put in the data file, depending on which
#button was pushed.
if obj == yes_button:
data = 'Subject ' + str(subject) + ' saw a pigeon.\t'
if obj == no_button:
data = 'Subject ' + str(subject) + ' did not see a pigeon.\t'
#add elapsed time to data
data = data + 'Elapsed time was: ' + str(round(elapsed_time,2)) + ' seconds\n'
#Write the data to our file.
question_data.write(data)
#Flush the internal buffer.
question_data.flush()
#Close the world.
viz.quit()
def experiment(): # -- Launch the vizinfo panel global subj, trigger subj = CrossSubject() yield subj.grab_info() # -- Where will the trigger pulses be coming from? yield get_trigger() # -- Load the timings for this experiment subj.get_experiment() # -- Start the experiment, waiting for a trigger for nblock,block in enumerate(subj.blocks): blockdata = yield cross_block(block,training=subj.is_training) subj.add_block_data(nblock,blockdata) # -- write the data we just collected to text subj.write_data() # -- Close the program viz.quit()
def Instruction(objName,ITI,endMessage):
viz.MainWindow.setScene(4)
if endMessage!=1:
collectMessage = 'Replace ' + objName
#info
info = viz.addText(collectMessage,viz.SCREEN,scene=4)
info.fontSize(36)
info.color(viz.WHITE)
info.setPosition([0.4,0.5,0])
info.visible(1)
#wait for iti
yield viztask.waitTime(ITI)
yield viztask.waitTime(numpy.random.randint(4)) #add random jitter, eventually add a wait for t here as well
info.visible(0)
else:
error = objName
threshold = [3,5,7,9]
if error < threshold[0]:
feedback = 1
elif error > threshold[0] and error < threshold[1]:
feedback = 2
elif error > threshold[1] and error < threshold[2]:
feedback = 3
elif error > threshold[2] and error < threshold[3]:
feedback = 4
elif error > threshold[3]:
feedback = 5
smile = viz.add('smile' + str(feedback) + '.tif')
feed = viz.addTexQuad(parent=viz.SCREEN,scene=4,size=[500,400])
feed.setPosition([0.5, 0.5, 0]) #put quad in view
feed.texture(smile)
yield viztask.waitTime(ITI+2)
viz.quit()
def raisestop(biggle): global endflag endflag.set() viz.quit()
def CloseConnections(wheel): wheel.thread_kill() wheel.shutdown() viz.quit()
def raiseandquit(warn): print(warn.upper()) viz.quit()
##OPEN DATA FILE ##
###################
global runNum
subject = vizinput.input('What is the sub number?')
runNum = vizinput.input('What is the run rumber?')
dpath = '..\Data\TestingData\\'
runNum = int(runNum)
runLength = 8.075*60 #in seconds
fname = dpath + 'TEST_tracking_'+str(subject)+'_'+ str(runNum)+'.txt'
###check for existing data file <-uncomment for actual testing, along with input function above
if os.path.isfile(fname):
print('file name already exists')
viz.quit()
#open data file
tracking_data = open(fname, 'a')
###############
## VARIABLES ##
###############
#tuple of test objects
TestObjects = ['cone', 'beachball', 'plant','pumpkin']
TestObjectLocs = [[(-4,0.07,9),(2,0.29,5),(-7,0.07,-4),(10,0.05,-5)] , [(4,0.07,9),(-2,0.29,5),(7,0.07,-4),(-10,0.05,-5)]]
scaleFactors = [0.15,1.8,1.25,1.8]
def raisestop(sign):
print("stop flag raised")
endflag.set()
t1.join()
t2.join()
viz.quit()
def raisestop(biggle):
global endflag
endflag.set()
viz.quit()
def onTimer(self, num):
# Main game loop
if num == 1:
# Check for balls colliding with the window borders
for i in range(0, len(self.ballList)):
if self.ballList[i].x + self.ballList[i].radius >= 100:
self.ballList[i].vx = abs(self.ballList[i].vx) * -1
if not self.mute:
viz.playSound(self.pickSound(1))
elif self.ballList[i].x - self.ballList[i].radius <= -100:
self.ballList[i].vx = abs(self.ballList[i].vx)
if not self.mute:
viz.playSound(self.pickSound(1))
elif self.ballList[i].y + self.ballList[i].radius >= 100:
self.ballList[i].vy = abs(self.ballList[i].vy) * -1
if not self.mute:
viz.playSound(self.pickSound(1))
elif self.ballList[i].y <= -100 - self.ballList[i].radius:
self.ballList.pop(i)
self.ballsOnScreen -= 1
# Shift all the blocks on screen down
if self.ballsOnScreen == 0:
for i in range (0, len(self.blockList)):
localRow = self.blockList[i].getRow()
localCol = self.blockList[i].getCol()
self.blockPositions[localRow][localCol] = 0
self.blockList[i].shiftDown()
self.blockPositions[localRow + 1][localCol] = 1
# Check if a block has reached the bottom of the window
for z in range(0, len(self.blockList)):
if self.blockList[z].getRow() == 9:
self.failState = True
# Prompt for restart or quit
break
print("You lost!")
# Give the player another ball if they broke twice the amount of blocks as their number of balls
if self.contactCount >= self.clickCount * 2:
self.clickCount += 1
self.contactCount = 0
if not self.failState:
self.addBlocks()
self.roundCount += 1
break
# Check for balls colliding with blocks
else:
contact = False
for j in range(0, len(self.blockList)):
if self.blockList[j].contains(self.ballList[i].getX() + self.ballList[i].radius, self.ballList[i].getY()):
self.ballList[i].vx = abs(self.ballList[i].vx) * -1
contact = True
elif self.blockList[j].contains(self.ballList[i].getX() - self.ballList[i].radius, self.ballList[i].getY()):
self.ballList[i].vx = abs(self.ballList[i].vx)
contact = True
elif self.blockList[j].contains(self.ballList[i].getX(), self.ballList[i].getY() + self.ballList[i].radius):
self.ballList[i].vy = abs(self.ballList[i].vy) * -1
contact = True
elif self.blockList[j].contains(self.ballList[i].getX(), self.ballList[i].getY() - self.ballList[i].radius):
self.ballList[i].vy = abs(self.ballList[i].vy)
contact = True
# Remove block from position and block lists if hit
if contact:
self.contactCount += 1
self.blockPositions[self.blockList[j].getRow()][self.blockList[j].getCol()] = 0
self.blockList[j].vertices.remove()
self.blockList.pop(j)
viz.playSound(self.pickSound(2))
break
self.ballList[i].x += self.ballList[i].vx
self.ballList[i].y += self.ballList[i].vy
self.ballList[i].setXY(self.ballList[i].x, self.ballList[i].y)
# Handle the pause between launching balls
elif num == 2:
ball = Ball(self.launcher.getAngle())
ball.setXY(self.launcher.getX(), self.launcher.getY())
self.ballList.append(ball)
ball.setVXVY(ball.getVX() * self.worldMultiplier, ball.getVY() * self.worldMultiplier)
self.ballsOnScreen += 1
viz.playSound(self.pickSound(6))
# Charge launcher
elif num == 3:
if self.charging:
self.worldMultiplier += .25
self.chargeCount += 1
if self.chargeCount == 9:
viz.playSound(self.pickSound(5))
self.chargeCount = 0
else:
viz.playSound(self.pickSound(4))
# Prompt player if they failed
if self.failState:
self.killtimer(1)
response = vizinput.ask("You survived {} rounds. Play again?".format(self.roundCount))
if response == 1:
self.reset()
else:
viz.quit()
def runtrials():
global trialtype, trialtype_signed, groundplane, radiiPool, out
#yield viztask.waitTime(5.0) #allow me to get into the seat.
setStage() # texture setting. #likely to have to be expanded.
driver.reset() # initialization of driver
[leftbends, rightbends] = BendMaker(radiiPool)
viz.MainScene.visible(viz.ON, viz.WORLD)
#add text to denote conditons.
txtCondt = viz.addText("Condition", parent=viz.SCREEN)
txtCondt.setPosition(.7, .2)
txtCondt.fontSize(36)
out = ""
def updatePositionLabel():
global driver, trialtype_signed, trialtype
##WHAT DO I NEED TO SAVE?
# get head position(x, y, z)
pos = viz.get(viz.HEAD_POS)
pos[1] = 0.0 # (x, 0, z)
# get body orientation
ori = viz.get(viz.BODY_ORI)
steeringWheel = driver.getPos()
#what data do we want? RoadVisibility Flag. SWA. Time, TrialType. x,z of that trial These can be reset in processing by subtracting the initial position and reorienting.
SaveData(pos[0], pos[2], ori, steeringWheel) ##.
vizact.ontimer((1.0 / 60.0), updatePositionLabel)
for j in range(0, TotalN):
#import vizjoy
trialtype = abs(TRIALSEQ_signed[j])
trialtype_signed = TRIALSEQ_signed[j]
txtDir = ""
# Define a function that saves data
def SaveData(pos_x, pos_z, ori, steer):
global out
#what data do we want? RoadVisibility Flag. SWA. Time, TrialType. x,z of that trial These can be reset in processing by subtracting the initial position and reorienting.
if out != '-1':
# Create the output string
currTime = viz.tick()
out = out + str(float(
(currTime))) + '\t' + str(trialtype_signed) + '\t' + str(
pos_x) + '\t' + str(pos_z) + '\t' + str(
ori) + '\t' + str(steer) + '\t' + str(
radius) + '\t' + str(occlusion) + '\t' + str(
int(trialbend.getVisible())) + '\n'
radiipick = 1
occlpick = 1
L = len(radiiPool)
L2 = L * 2
print trialtype, L, L2
if trialtype > L and trialtype <= L2:
print 'here'
radiipick = trialtype - L #reset trialtype and occl index
occlpick = 2
elif trialtype > L2:
print 'here too'
radiipick = trialtype - L2
occlpick = 3
print radiipick
#pick correct object
if trialtype_signed > 0: #right bend
trialbend = rightbends[radiipick - 1]
txtDir = "R"
else:
trialbend = leftbends[radiipick - 1]
txtDir = "L"
radius = radiiPool[radiipick - 1]
occlusion = occlPool[occlpick - 1]
if radius > 0:
msg = "Radius: " + str(radius) + txtDir + '_' + str(occlusion)
else:
msg = "Radius: Straight" + txtDir + '_' + str(occlusion)
txtCondt.message(msg)
#translate bend to driver position.
driverpos = viz.MainView.getPosition()
print driverpos
trialbend.setPosition(driverpos[0], 0, driverpos[2])
#now need to set orientation
driverEuler = viz.MainView.getEuler()
trialbend.setEuler(driverEuler, viz.ABS_GLOBAL)
#will need to save initial vertex for line origin, and Euler. Is there a nifty way to save the relative position to the road?
driver.setSWA_invisible()
yield viztask.waitTime(occlusion) #wait an occlusion period
trialbend.visible(1)
yield viztask.waitTime(
2.5 - occlusion
) #after the occlusion add the road again. 2.5s to avoid ceiling effects.
trialbend.visible(0)
#driver.setSWA_visible()
def checkCentred():
centred = False
while not centred:
x = driver.getPos()
if abs(x) < .5:
centred = True
break
# centred = False
# while not centred:
# x = driver.getPos()
# print x
##wait a while
print "waiting"
yield viztask.waitDirector(checkCentred)
print "waited"
driver.setSWA_visible()
yield viztask.waitTime(2) #wait for input .
else:
#print file after looped through all trials.
fileproper = ('Pilot_CDM.dat')
# Opens nominated file in write mode
path = viz.getOption('viz.publish.path/')
file = open(path + fileproper, 'w')
file.write(out)
# Makes sure the file data is really written to the harddrive
file.flush()
#print out
file.close()
#exit vizard
viz.quit() ##otherwise keeps writting data onto last file untill ESC
def TrackTask():
prevPos = None
allData = []
tRegained = 0
stage = 0 # 0: wait for track loss, 1: wait for track regained, 2: wait for trigger pull, 3: trigger pulled. check optical heading position ok, 4: trigger released, ready for next trigger pull that will start actual data collection
t = 0.
opticalHeadScrewed = False
tCount = -1
while True:
# wait for track regained
stage = 0
while True:
pos = setup.trackerDataFun()
if prevPos is not None and pos['vive'] == prevPos['vive']:
# position didn't change at all, not tracking
if stage is not 1:
setup.sounds.trialStart.play()
print 'track lost'
stage = 1
else:
# get here only once vive position/orientation starts changing again
if stage == 1:
setup.sounds.trialCompleted.play()
print 'track regained'
tRegained = t
stage = 2 if qCheckOptHeading else 4 # if not qCheckOptHeading, skip the check
if stage == 2 and t - tRegained > nSecWait and (
steamvr.getControllerList()[0].isButtonDown(2)
or viz.key.isDown('c', immediate=True)):
# first press, check if optical heading position is ok
stage = 3
if stage == 3 and not (
steamvr.getControllerList()[0].isButtonDown(2)
or viz.key.isDown('c', immediate=True)):
# button/trigger released
stage = 4
if stage == 4 and (
steamvr.getControllerList()[0].isButtonDown(2)
or viz.key.isDown('c', immediate=True)):
# second press: time to record some data
tCount += 1
break
prevPos = pos
# check position of optical heading markers is within expected range. Otherwise markers probably switched
if qCheckOptHeading and stage in [3, 4] and any([
abs(p - m) > l for p, m, l in zip(
pos['optical_heading'][:3], optHeadingPos, optHeadLims)
]):
# optical markers screwed, notify
if not opticalHeadScrewed:
print 'optical heading error. current pose: ' + str(
pos['optical_heading'])
setup.sounds.alarm.play()
opticalHeadScrewed = True
else:
opticalHeadScrewed = False
# limit to update rate
d = yield viztask.waitDraw()
t = d.time
# report position
print 'capturing track data'
setup.sounds.trialStart.play()
count = 0
data = []
while count < trackRate * nSec:
ti = setup.trackerDataFun()
ti['timeStamp'] = d.time
data.append(ti)
count += 1
d = yield viztask.waitDraw()
# store for later
allData.append(data)
setup.sounds.trialCompleted.play()
# make filename
if tCount + 1 == nTrial:
time = datetime.datetime.now()
fname = ''.join(
(str(time.year) + str(time.month).zfill(2) +
str(time.day).zfill(2) + str(time.hour).zfill(2) +
str(time.minute).zfill(2) + str(time.second).zfill(2)))
saveData = {}
saveData['data'] = allData
scio.savemat('data/' + fname,
saveData,
long_field_names=True,
do_compression=True,
oned_as='column')
# done
viz.quit()
def exitGame(self): viz.quit() print 'Visual Anatomy Trainer has closed'
def onTimer(self, num):
if self.frameNumber < len(self.rawDataStruct['frameTime']) - 1:
#pointCounter[calibrationCounter[self.frameNumber]] = pointCounter[calibrationCounter[self.frameNumber]] + 1
self.frameNumber = self.frameNumber + 1
else:
#self.frameNumber = 0
print 'Data = ', errorArray
MatFile = {'Data':errorArray}
MatFileName = 'ErrorData'
sio.savemat(MatFileName + '.mat', MatFile)
viz.quit()
if (self.rawDataStruct['eventFlag'][self.frameNumber] == 1):
self.PD = 0.8
self.BD = 0.3
self.PBD = 0.7
self.timer = 0
# StartIndex = TrialStartIndex[counter]
# EndIndex = TrialEndIndex[counter]
# for self.frameNumber in range(StartIndex, EndIndex):
#print 'F=', self.frameNumber,'P=', Ball_Pos_XYZ[:,self.frameNumber],'Q=',View_Quat_WXYZ[:,self.frameNumber], '\n'
self.ball.setPosition(*self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber]) # X[:,self.frameNumber])#
self.Hand.setPosition(*self.rawDataStruct['paddle_Pos_XYZ'][:,self.frameNumber])
self.Hand.setQuat(*self.rawDataStruct['paddle_Quat_WXYZ'][:,self.frameNumber])
#self.headBone.setQuat(self.cyclopEyeNode.getQuat())
#self.male.setEuler([0, 0, 0], viz.ABS_GLOBAL)
self.V1 = self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber] - self.rawDataStruct['view_Pos_XYZ'][:,self.frameNumber]
self.V1 = np.hstack((self.V1,1))
self.V1.reshape(4,1)
self.cyclopEyeNode.setPosition(*self.rawDataStruct['view_Pos_XYZ'][:,self.frameNumber])
self.cyclopEyeNode.setQuat(*self.rawDataStruct['view_Quat_WXYZ'][:,self.frameNumber])
self.rightGazePoint_XYZ = [ -self.rawDataStruct['rightGazeDir_XYZ'][0,self.frameNumber], self.rawDataStruct['rightGazeDir_XYZ'][1,self.frameNumber], self.rawDataStruct['rightGazeDir_XYZ'][2,self.frameNumber]]
self.rightScale = np.linalg.norm(self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber] - self.rightEyeNode.getPosition(viz.ABS_GLOBAL))
self.rightGazePoint_XYZ = np.multiply(self.rightGazePoint_XYZ, self.rightScale)
self.rightGazeSphere.setPosition(self.rightGazePoint_XYZ[0], self.rightGazePoint_XYZ[1], self.rightGazePoint_XYZ[2], viz.ABS_PARENT)
self.rightGazeVector.setVertex(0, self.rightEyeNode.getPosition(mode = viz.ABS_GLOBAL), viz.ABS_GLOBAL)
self.rightGazeVector.setVertex(1, self.rightGazeSphere.getPosition(viz.ABS_GLOBAL), viz.ABS_GLOBAL)
self.leftGazePoint_XYZ = [ -self.rawDataStruct['leftGazeDir_XYZ'][0,self.frameNumber], self.rawDataStruct['leftGazeDir_XYZ'][1,self.frameNumber], self.rawDataStruct['leftGazeDir_XYZ'][2,self.frameNumber]]
self.leftScale = np.linalg.norm(self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber] - self.leftEyeNode.getPosition(viz.ABS_GLOBAL))
self.leftGazePoint_XYZ = np.multiply(self.leftGazePoint_XYZ, self.leftScale)
self.leftGazeSphere.setPosition(self.leftGazePoint_XYZ[0], self.leftGazePoint_XYZ[1], self.leftGazePoint_XYZ[2], viz.ABS_PARENT)
self.leftGazeVector.setVertex(0, self.leftEyeNode.getPosition(mode = viz.ABS_GLOBAL), viz.ABS_GLOBAL)
self.leftGazeVector.setVertex(1, self.leftGazeSphere.getPosition(viz.ABS_GLOBAL), viz.ABS_GLOBAL)
self.EyeBallLine.setVertex(0, self.rawDataStruct['view_Pos_XYZ'][0,self.frameNumber], self.rawDataStruct['view_Pos_XYZ'][1,self.frameNumber], self.rawDataStruct['view_Pos_XYZ'][2,self.frameNumber], viz.ABS_GLOBAL)
self.EyeBallLine.setVertex(1, self.rawDataStruct['ball_Pos_XYZ'][0,self.frameNumber], self.rawDataStruct['ball_Pos_XYZ'][1,self.frameNumber], self.rawDataStruct['ball_Pos_XYZ'][2,self.frameNumber], viz.ABS_GLOBAL)
self.ballPlane.setPosition(*self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber])
self.V1 = self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber] - self.cyclopEyeNode.getPosition()
self.V2 = self.leftGazePoint_XYZ - self.leftEyeNode.getPosition(viz.ABS_GLOBAL) + self.rightGazePoint_XYZ - self.rightEyeNode.getPosition(viz.ABS_GLOBAL)
self.V3 = self.leftGazePoint_XYZ + self.rightGazePoint_XYZ
self.eyeGazeVector.setVertex(0,0,0, viz.ABS_PARENT)
self.eyeGazeVector.setVertex(1, self.V3[0]/2.0, self.V3[1]/2.0, self.V3[2]/2.0, viz.ABS_PARENT)
self.eyeGazeSphere.setPosition(self.eyeGazeVector.getVertex(1), viz.ABS_PARENT)
self.V1 = self.rawDataStruct['ball_Pos_XYZ'][:,self.frameNumber] - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
#V2 = eyeGazeSphere.getPosition(viz.ABS_GLOBAL) - cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
self.V2 = [a - b for a, b in zip(self.eyeGazeSphere.getPosition(viz.ABS_GLOBAL), self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL))]
# XYZ = [l1[idx][0] - l2[idx][0] , l1[idx][1] - l2[idx][1], l1[idx][2] - l2[idx][2] for idx in range(len(l1))]
errorAngle = np.multiply(self.angle(self.V2, self.V1), 180/np.pi)
#print 'Angle = ', errorAngle
#if (calibrationStatus[self.frameNumber] == 1):
#errorArray[calibrationCounter[self.frameNumber], pointCounter[calibrationCounter[self.frameNumber]]] = errorAngle
#viz.MainView.setPosition(*Ball_Pos_XYZ[:,self.frameNumber] + [0.0, 0.4, -1.5])
#if (calibrationStatus[self.frameNumber] == 0):
string = 'PerForM Lab'#'Before Calibration'
#else:
# string = 'Eye Tracking in VR'#'After Calibration'
self.wall_text_object.message(string)
def check_steps(): global stp, stp_counter, step_range, Lstp_flag, Rstp_flag, belt, belt_vec, ptb_max, ptb, elapse_time_R, elapse_time_L,start_L, start_R FPtemp = qtm_receive() GRF = [FPtemp[2], FPtemp[8]] # ground reaction forces [left, right] if stp_counter==80: check_step_timing(start_L,start_R) if (stp_counter > stp): # wait for the desired amount of steps # LEFT LEG if ( GRF[0]<=80 ): # left swing phase if (Lstp_flag == 0): # toe off event Lstp_flag = 1 # swing now #print "toe off left" elif ( 80<GRF[0]<2000 ): # left stance phase Lstp_flag = 0 if (belt == 'R'): # accelerate right time.sleep(elapse_time) # labjack_impulse() viz.director(perturbation) elif (belt == '0' and belt_vec[ptb-1] == 'R'): # 2nd toe off // decelerate viz.director(perturbation) if (ptb > ptb_max): time.sleep(0.2) # give time to the treadmill to stabilize out = serializepacket(0,0,100,100,0) # stop treadmill s.sendall(out) print "THE END - STOPPING" time.sleep(0.3) # give time to the treadmill to stabilize viz.quit() else: # resetting belt = belt_vec[ptb-1] # 0 < ptb <= ptb_max # stp = random.randint(step_range[0], step_range[1]) # stp_counter = 0 #print "stp", stp # RIGHT LEG if ( GRF[1]<=80 ): # right swing phase if (Rstp_flag == 0): # toe off event Rstp_flag = 1 # swing now #print "toe off right" elif ( 80<GRF[1]<2000 ): # right stance phase Rstp_flag = 0 if (belt == 'L'): # accelerate left time.sleep(elapse_time-0.02) labjack_impulse() viz.director(perturbation) elif (belt == '0' and belt_vec[ptb-1] == 'L'): # 2nd toe off // decelerate viz.director(perturbation) if (ptb > ptb_max): time.sleep(0.2) # give time to the treadmill to stabilize out = serializepacket(0,0,100,100,0) # stop treadmill s.sendall(out) print "THE END - STOPPING" time.sleep(0.3) # give time to the treadmill to stabilize viz.quit() else: # resetting belt = belt_vec[ptb-1] # 0 < ptb <= ptb_max # stp = random.randint(step_range[0], step_range[1]) # stp_counter = 0 #print "stp", stp else: # count steps # LEFT LEG if ( 80<GRF[0]<2000 ): # left stance phase if (Lstp_flag == 1): # one more step Lstp_flag = 0 stp_counter += 1 print stp-stp_counter+1 #print "L", stp_counter elif ( GRF[0]<=80 ): # left swing phase Lstp_flag = 1 # RIGHT LEG if ( 80<GRF[1]<2000 ): # right stance phase if(Rstp_flag == 1): # one more step Rstp_flag = 0 stp_counter += 1 print stp-stp_counter+1 #print "R", stp_counter elif ( GRF[1]<=80 ): # left swing phase Rstp_flag = 1
def EXPERIMENT(trials_per_object, initial_collect_per_object, TestObjects,
TestObjectLocsALL, ITI, scaleFactors, runs):
for r in range(runs):
runNum = r + 1
context = ContextGen(runNum)
#test object locations for this world
TestObjectLocs = TestObjectLocsALL[context - 1]
yield StartRun(runNum, 1, 0)
#initial training, just collects
if runNum < 3:
Init_trials = []
for n in range(initial_collect_per_object):
Init_trials = numpy.random.permutation(
len(TestObjects)).tolist() + Init_trials
for nn in Init_trials:
#get target object for collection
objName = TestObjects[nn]
objLoc = TestObjectLocs[nn]
S = scaleFactors[nn]
yield Instruction(objName, ITI, 1, 0)
data = 'Start collect\n'
tracking_data.write(data)
yield Collect(objName, objLoc, S, 1)
data = objName + ' Collected Initial' + '\n'
tracking_data.write(data)
#post-initial training, replace/collect phases
Trials = []
for n in range(trials_per_object):
Trials = numpy.random.permutation(
len(TestObjects)).tolist() + Trials
replaceError = []
for nn in Trials:
#get target object for replace/collect
objName = TestObjects[nn]
objLoc = TestObjectLocs[nn]
S = scaleFactors[nn]
#show instructions
yield Instruction(objName, ITI, 0, 0)
data = 'Start replace\n'
tracking_data.write(data)
#replace phase
yield Replace()
error, feedback = computeError(viz.MainView.getPosition(), objLoc)
data = 'Replaced ' + objName + ', ' + str(error) + '\n'
tracking_data.write(data)
replaceError.append(
error
) #store replace error in a list, just to compute the mean at the end
yield Instruction(objName, ITI, 1, feedback)
data = 'Start collect\n'
tracking_data.write(data)
yield Collect(objName, objLoc, S,
1) #have feedback every trial no matter what
data = 'Collected ' + objName + '\n'
tracking_data.write(data)
#all done, shut down, printing mean error just for experimenter to check if needed
print('Info: ' + str(numpy.mean(replaceError)))
yield StartRun(runNum, 0, 0)
yield StartRun(runNum, 0, 1)
viz.quit()
def onTimer(self, num):
if self.frameNumber < len(self.rawDataStruct['frameTime']) - 1:
#pointCounter[calibrationCounter[self.frameNumber]] = pointCounter[calibrationCounter[self.frameNumber]] + 1
self.frameNumber = self.frameNumber + 1
if(self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.internalCounter = self.internalCounter + 1
else:
self.internalCounterBall = self.internalCounterBall + 1
else:
#self.frameNumber = 0
#print 'Data = ', errorArray
MatFile = {'Data':errorArray}
self.rawDataStruct['truePOR_XY'] = self.truePOR_XY.T
self.rawDataStruct['rightEyePOR_XY'] = self.rightEyePOR_XY.T
self.rawDataStruct['leftEyePOR_XY'] = self.leftEyePOR_XY.T
self.rawDataStruct['cyclopeanPOR_XY'] = self.cyclopeanPOR_XY.T
MatFileName = 'preProcessedData'+ self.textFileName
sio.savemat(MatFileName + '.mat', self.rawDataStruct)
print 'PreProcessed Data saved into mat file', MatFileName + '.mat'
print 'Mat File Saving Quit!!'
viz.quit()
if (self.rawDataStruct['eventFlag'][self.frameNumber] == 1):
self.PD = 0.8
self.BD = 0.3
self.PBD = 0.7
self.timer = 0
# StartIndex = TrialStartIndex[counter]
# EndIndex = TrialEndIndex[counter]
# for self.frameNumber in range(StartIndex, EndIndex):
#print 'F=', self.frameNumber,'P=', Ball_Pos_XYZ[:,self.frameNumber],'Q=',View_Quat_WXYZ[:,self.frameNumber], '\n'
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.ball.setPosition(*self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter])
else:
self.ball.setPosition(*self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall], mode = viz.ABS_GLOBAL) # X[:,self.frameNumber])#
self.Hand.setPosition(*self.rawDataStruct['paddle_Pos_XYZ'][:,self.frameNumber])
self.Hand.setQuat(*self.rawDataStruct['paddle_Quat_WXYZ'][:,self.frameNumber])
#self.headBone.setQuat(self.cyclopEyeNode.getQuat())
#self.male.setEuler([0, 0, 0], viz.ABS_GLOBAL)
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.V1 = self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter] - self.rawDataStruct['view_Pos_XYZ'][:,self.frameNumber]
else:
self.V1 = self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall] - self.rawDataStruct['view_Pos_XYZ'][:,self.frameNumber]
self.V1 = np.hstack((self.V1,1))
self.V1.reshape(4,1)
viz.MainView.setPosition(*self.rawDataStruct['view_Pos_XYZ'][:,self.frameNumber])
viz.MainView.setQuat(*self.rawDataStruct['view_Quat_WXYZ'][:,self.frameNumber])
self.cyclopEyeNode.setPosition(*self.rawDataStruct['view_Pos_XYZ'][:,self.frameNumber])
self.cyclopEyeNode.setQuat(*self.rawDataStruct['view_Quat_WXYZ'][:,self.frameNumber])
x = self.rawDataStruct['eyePOR_XY'][0,self.frameNumber]
y = self.rawDataStruct['eyePOR_XY'][1,self.frameNumber]
x = (x /1920.0)*0.126 - 0.126/2.0
y = -(y/1080.0)*0.071 + 0.071/2.0
z = self.eyePOR.getPosition()[2]
self.eyePOR.setPosition([x, y, z])
self.cyclopeanPOR_XY = np.vstack((self.cyclopeanPOR_XY, [x, y]))
rx = self.rawDataStruct['rightPOR_XY'][0,self.frameNumber]
ry = self.rawDataStruct['rightPOR_XY'][1,self.frameNumber]
rx = (rx /1920.0)*0.126 - 0.126/2.0
ry = -(ry/1080.0)*0.071 + 0.071/2.0
rz = self.rightPOR.getPosition()[2]
self.rightPOR.setPosition([rx, ry, rz])
self.rightEyePOR_XY = np.vstack((self.rightEyePOR_XY, [rx, ry]))
lx = self.rawDataStruct['leftPOR_XY'][0,self.frameNumber]
ly = self.rawDataStruct['leftPOR_XY'][1,self.frameNumber]
lx = (lx /1920.0)*0.126 - 0.126/2.0
ly = -(ly/1080.0)*0.071 + 0.071/2.0
lz = self.leftPOR.getPosition()[2]
self.leftPOR.setPosition([lx, ly, lz])
self.leftEyePOR_XY = np.vstack((self.leftEyePOR_XY, [lx, ly]))
self.rightGazePoint_XYZ = [ -self.rawDataStruct['rightGazeDir_XYZ'][0,self.frameNumber], self.rawDataStruct['rightGazeDir_XYZ'][1,self.frameNumber], self.rawDataStruct['rightGazeDir_XYZ'][2,self.frameNumber]]
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.rightScale = np.linalg.norm(self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter] - self.rightEyeNode.getPosition(viz.ABS_GLOBAL))
else:
self.rightScale = np.linalg.norm(self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall] - self.rightEyeNode.getPosition(viz.ABS_GLOBAL))
self.rightGazePoint_XYZ = np.multiply(self.rightGazePoint_XYZ, self.rightScale)
self.rightGazeSphere.setPosition(self.rightGazePoint_XYZ[0], self.rightGazePoint_XYZ[1], self.rightGazePoint_XYZ[2], viz.ABS_PARENT)
self.rightGazeVector.setVertex(0, self.rightEyeNode.getPosition(mode = viz.ABS_GLOBAL), viz.ABS_GLOBAL)
# This was the method to use gaze direction vector to draw gaze vector
#self.rightGazeVector.setVertex(1, self.rightGazeSphere.getPosition(viz.ABS_GLOBAL), viz.ABS_GLOBAL)
# This was the method to use Screen Coordinates to draw gaze vector from Eye to screen
#self.rightGazeVector.setVertex(1, self.rightPOR.getPosition( mode = viz.ABS_GLOBAL), viz.ABS_GLOBAL)
rightEyeToScreenLine = createLine(self.rightPOR.getPosition( mode = viz.ABS_GLOBAL), self.rightEyeNode.getPosition( mode = viz.ABS_GLOBAL))
pos = self.rightEyeNode.getPosition(mode = viz.ABS_GLOBAL) + np.multiply(rightEyeToScreenLine, self.rightScale)
self.rightGazeVector.setVertex(1,[pos[0], pos[1], pos[2]] , viz.ABS_GLOBAL)
point0 = np.array([0.0,0.0,0.0])
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
line = self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter]# - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
else:
line = self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall]# - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
planeNormal = np.array([0.0,0.0,1.0])
point1 = np.array([0.0,0.0,0.0725])
pos = findLinePlaneIntersection( point0, line, planeNormal, point1)
self.pixelatedBall.setPosition(pos[0], pos[1], 0)
self.truePOR_XY = np.vstack((self.truePOR_XY, [pos[0], pos[1]]))
self.leftGazePoint_XYZ = [ -self.rawDataStruct['leftGazeDir_XYZ'][0,self.frameNumber], self.rawDataStruct['leftGazeDir_XYZ'][1,self.frameNumber], self.rawDataStruct['leftGazeDir_XYZ'][2,self.frameNumber]]
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.leftScale = np.linalg.norm(self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter] - self.leftEyeNode.getPosition(viz.ABS_GLOBAL))
else:
self.leftScale = np.linalg.norm(self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall] - self.leftEyeNode.getPosition(viz.ABS_GLOBAL))
self.leftGazePoint_XYZ = np.multiply(self.leftGazePoint_XYZ, self.leftScale)
self.leftGazeSphere.setPosition(self.leftGazePoint_XYZ[0], self.leftGazePoint_XYZ[1], self.leftGazePoint_XYZ[2], viz.ABS_PARENT)
self.leftGazeVector.setVertex(0, self.leftEyeNode.getPosition(mode = viz.ABS_GLOBAL), viz.ABS_GLOBAL)
# This was the method to use gaze direction vector to draw gaze vector
#self.leftGazeVector.setVertex(1, self.leftGazeSphere.getPosition(viz.ABS_GLOBAL), viz.ABS_GLOBAL)
# This was the method to use Screen Coordinates to draw gaze vector from Eye to screen
#self.leftGazeVector.setVertex(1, self.leftPOR.getPosition(mode = viz.ABS_GLOBAL), viz.ABS_GLOBAL)
leftEyeToScreenLine = createLine(self.leftPOR.getPosition( mode = viz.ABS_GLOBAL), self.leftEyeNode.getPosition( mode = viz.ABS_GLOBAL))
pos = self.leftEyeNode.getPosition(mode = viz.ABS_GLOBAL) + np.multiply(leftEyeToScreenLine, self.leftScale)
self.leftGazeVector.setVertex(1,[pos[0], pos[1], pos[2]] , viz.ABS_GLOBAL)
self.EyeBallLine.setVertex(0, self.rawDataStruct['view_Pos_XYZ'][0,self.frameNumber], self.rawDataStruct['view_Pos_XYZ'][1,self.frameNumber], self.rawDataStruct['view_Pos_XYZ'][2,self.frameNumber], viz.ABS_GLOBAL)
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.EyeBallLine.setVertex(1, self.rawDataStruct['calibration_Pos_XYZ'][0,self.internalCounter], self.rawDataStruct['calibration_Pos_XYZ'][1,self.internalCounter], self.rawDataStruct['calibration_Pos_XYZ'][2,self.internalCounter], viz.ABS_GLOBAL)
else:
self.EyeBallLine.setVertex(1, self.rawDataStruct['ball_Pos_XYZ'][0,self.internalCounterBall], self.rawDataStruct['ball_Pos_XYZ'][1,self.internalCounterBall], self.rawDataStruct['ball_Pos_XYZ'][2,self.internalCounterBall], viz.ABS_GLOBAL)
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.ballPlane.setPosition(*self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter])
else:
self.ballPlane.setPosition(*self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall])
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.V1 = self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter] - self.cyclopEyeNode.getPosition()
else:
self.V1 = self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall] - self.cyclopEyeNode.getPosition()
self.V2 = self.leftGazePoint_XYZ - self.leftEyeNode.getPosition(viz.ABS_GLOBAL) + self.rightGazePoint_XYZ - self.rightEyeNode.getPosition(viz.ABS_GLOBAL)
self.V3 = self.leftGazePoint_XYZ + self.rightGazePoint_XYZ
self.eyeGazeVector.setVertex(0,0,0, viz.ABS_PARENT)
# This was the method to use right and left Gaze sphere to draw the cyclopean eye
#self.eyeGazeVector.setVertex(1, self.V3[0]/2.0, self.V3[1]/2.0, self.V3[2]/2.0, viz.ABS_PARENT)
cyclopEyeToScreenLine = createLine(self.eyePOR.getPosition( mode = viz.ABS_GLOBAL), self.cyclopEyeNode.getPosition( mode = viz.ABS_GLOBAL))
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.cyclopScale = np.linalg.norm(self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter] - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL))
else:
self.cyclopScale = np.linalg.norm(self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall] - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL))
pos = self.cyclopEyeNode.getPosition(mode = viz.ABS_GLOBAL) + np.multiply(cyclopEyeToScreenLine, self.cyclopScale)
self.eyeGazeVector.setVertex(1,[pos[0], pos[1], pos[2]] , viz.ABS_GLOBAL)
self.eyeGazeSphere.setPosition(self.eyeGazeVector.getVertex(1), viz.ABS_PARENT)
if (self.rawDataStruct['calibrationFlag'][self.frameNumber] == 1 ):
self.V1 = self.rawDataStruct['calibration_Pos_XYZ'][:,self.internalCounter] - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
else:
self.V1 = self.rawDataStruct['ball_Pos_XYZ'][:,self.internalCounterBall] - self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
#V2 = eyeGazeSphere.getPosition(viz.ABS_GLOBAL) - cyclopEyeNode.getPosition(viz.ABS_GLOBAL)
self.V2 = [a - b for a, b in zip(self.eyeGazeSphere.getPosition(viz.ABS_GLOBAL), self.cyclopEyeNode.getPosition(viz.ABS_GLOBAL))]
# XYZ = [l1[idx][0] - l2[idx][0] , l1[idx][1] - l2[idx][1], l1[idx][2] - l2[idx][2] for idx in range(len(l1))]
errorAngle = np.multiply(angle(self.V2, self.V1), 180/np.pi)
#print 'Angle = ', errorAngle
#if (calibrationStatus[self.frameNumber] == 1):
#errorArray[calibrationCounter[self.frameNumber], pointCounter[calibrationCounter[self.frameNumber]]] = errorAngle
#viz.MainView.setPosition(*Ball_Pos_XYZ[:,self.internalCounterBall] + [0.0, 0.4, -1.5])
#if (calibrationStatus[self.frameNumber] == 0):
string = 'PerForM Lab'#'Before Calibration'
#else:
# string = 'Eye Tracking in VR'#'After Calibration'
self.wall_text_object.message(string)
def ContextGen(runNum):
if runNum % 2 == 0:
if subject % 2 == 0:
context = 1
else:
context = 2
else:
if subject % 2 == 0:
context = 2
else:
context = 1
fname = dpath + 'TRAIN_tracking_' + str(subject) + '_' + str(
context) + '_' + str(runNum) + '.txt'
#check for existing data file <-uncomment for actual testing, along with input function above
if os.path.isfile(fname):
print('file name already exists')
viz.quit()
#open data file
global tracking_data
tracking_data = open(fname, 'a')
##############################
## ENVIRONMENT AND CONTROLS ##
##############################
##distal cues: add some trees
#distal cues
if runNum < 2:
global cue1 #sloppy making global but it works
global cue2
global cue3
global cue4
global cue5
global cue6
global cue7
global cue8
cue1 = viz.add('tree4.osgb')
cue1.setPosition(-20, -10, 70)
cue1.setScale([2, 2, 2])
cue2 = viz.add('tree6.osgb')
cue2.setPosition(20, -1, -50)
cue2.setScale([3, 3, 3])
cue3 = viz.add('tree2.osgb')
cue3.setPosition(20, -2, 60)
cue3.setScale([3, 3, 3])
cue4 = viz.add('tree5.osgb')
cue4.setPosition(-20, -1, -60)
cue4.setScale([3, 3, 3])
cue5 = viz.add('tree10.osgb')
cue5.setPosition(60, 0, 20)
cue5.setScale([2.5, 2.5, 2.5])
cue6 = viz.add('tree11.osgb')
cue6.setPosition(-60, 0, -20)
cue6.setScale([5, 5, 5])
cue7 = viz.add('tree12.osgb')
cue7.setPosition(60, -5, -20)
cue7.setScale([4, 4, 4])
cue8 = viz.add('tree13.osgb')
cue8.setPosition(-60, -5, 20)
cue8.setScale([4, 4, 4])
if context == 1: #context 1 is circle world
cue3.visible(0)
cue4.visible(0)
cue1.visible(1)
cue2.visible(1)
cue5.visible(1)
cue6.visible(1)
cue7.visible(0)
cue8.visible(0)
else:
cue3.visible(1)
cue4.visible(1)
cue1.visible(0)
cue2.visible(0)
cue5.visible(0)
cue6.visible(0)
cue7.visible(1)
cue8.visible(1)
#boundary elements - may need to adjust x,y positions of Square boundaries slightly to get rid of line between segments (this seems monitor dependent)
if runNum < 2:
global boundary1
global boundary2
global boundary3
global boundary4
global boundary5
global boundary6
global boundary7
global boundary8
boundary1 = viz.add('CIRCLE.osgb')
boundary1.setPosition(0.05, 0, -0.05)
boundary2 = viz.add('CIRCLE.osgb')
boundary2.setEuler([90, 0, 0])
boundary2.setPosition(-0.05, 0, -0.05)
boundary3 = viz.add('CIRCLE.osgb')
boundary3.setEuler([-90, 0, 0])
boundary3.setPosition(0.05, 0, 0.05)
boundary4 = viz.add('CIRCLE.osgb')
boundary4.setEuler([180, 0, 0])
boundary4.setPosition(-0.05, 0, 0.05)
boundary5 = viz.add('SQUARE.osgb')
# boundary5.setPosition(0.05,0,-0.05)
boundary6 = viz.add('SQUARE.osgb')
boundary6.setEuler([90, 0, 0])
# boundary6.setPosition(-0.05,0,-0.05)
boundary7 = viz.add('SQUARE.osgb')
boundary7.setEuler([-90, 0, 0])
# boundary7.setPosition(0.05,0,0.05)
boundary8 = viz.add('SQUARE.osgb')
boundary8.setEuler([180, 0, 0])
# boundary8.setPosition(-0.05,0,0.05)
##add boundary
if (context == 1): #context 1 is circle world
boundary1.visible(1)
boundary2.visible(1)
boundary3.visible(1)
boundary4.visible(1)
boundary5.visible(0)
boundary6.visible(0)
boundary7.visible(0)
boundary8.visible(0)
else: #context 2 is square world:
boundary5.visible(1)
boundary6.visible(1)
boundary7.visible(1)
boundary8.visible(1)
boundary1.visible(0)
boundary2.visible(0)
boundary3.visible(0)
boundary4.visible(0)
return context
def task_choice():
# ensure that the mouse is turned on
viz.mouse(viz.ON)
viz.mouse.setVisible(viz.ON)
# load condition_box
condition_box = vizinfo.add('')
condition_box.title('SNAP')
condition_box.scale(2, 2)
condition_box.translate(0.85, 0.65)
condition_box.drag(viz.OFF)
# add different options
condition_one = condition_box.add(viz.BUTTON, 'Condition 1')
condition_two = condition_box.add(viz.BUTTON, 'Condition 2')
practice = condition_box.add(viz.BUTTON, 'Practice Program')
expertise = condition_box.add(viz.BUTTON, 'Visuomotor Expertise Program')
maze_quit = condition_box.add(viz.BUTTON, 'Quit Maze Program')
# add variables for user chocies
condition_one_pressed = viztask.waitButtonDown(condition_one)
condition_two_pressed = viztask.waitButtonDown(condition_two)
practice_pressed = viztask.waitButtonDown(practice)
expertise_pressed = viztask.waitButtonDown(expertise)
maze_quit_pressed = viztask.waitButtonDown(maze_quit)
# data variable to hold user choices
data = viz.Data()
# setup globals
global condition
global maze_root
global start_coords
global start_ori
global end_coords
# While statment that will run a different maze based on user choice.
# Will keep looping until the user selects quit and ends the program
while True:
yield viztask.waitAny([
condition_one_pressed, condition_two_pressed, practice_pressed,
expertise_pressed, maze_quit_pressed
], data)
condition_box.remove()
if data.condition is condition_one_pressed:
condition = 1
yield maze_choice()
yield run_condition_one()
yield task_choice()
elif data.condition is condition_two_pressed:
condition = 2
yield maze_choice()
yield run_condition_two()
yield task_choice()
elif data.condition is practice_pressed:
viz.mouse(viz.OFF)
viz.mouse.setVisible(viz.OFF)
maze_root = 'C:\Experiments\Bike_Extend_Pilot\SNAP\PMS'
start_coords = (0, 40, 0)
start_ori = (3.5, 0, 0)
yield practice_maze()
yield task_choice()
elif data.condition is expertise_pressed:
viz.mouse(viz.OFF)
viz.mouse.setVisible(viz.OFF)
maze_root = 'C:\Experiments\Bike_Extend_Pilot\SNAP\VMS'
start_coords = (0, 40, 0)
start_ori = (0, 0, 0)
end_coords = [1150, 1275, -190, -100]
yield expertise_maze()
yield task_choice()
elif data.condition is maze_quit_pressed:
viz.quit()
viz.quit()
def runtrials(): global trialtype, trialtype_signed, groundplane, fixation_counter, inside_edge, outside_edge setStage() # texture setting addfix() # fixation setting driver.reset() # initialization of driver def updatePositionLabel(): global driver, trialtype_signed, fixation, fixation_counter, rdsize, outside_edge, inside_edge, trialtype, groundplane # get head position(x, y, z) pos = viz.get(viz.HEAD_POS) pos[1] = 0.0 # (x, 0, z) # get body orientation ori = viz.get(viz.BODY_ORI) steeringWheel = driver.getPos() ######Fixation. This section makes sure the fixation is moved with the observer. fpheight = .12 fixation.setEuler((ori, 0.0, 0.0),viz.ABS_GLOBAL) ##fixation point always faces observer if trialtype_signed > 0: ##fixations for right bends while fixation_counter < 3142: fix_dist = mt.sqrt( ( ( pos[0] - x_right_mid[fixation_counter] )**2 ) + ( ( pos[2] - z_right_mid[fixation_counter] )**2 ) ) if ( (fix_dist < 16.0) | (fix_dist > 16.3) ): fixation_counter += 1 continue elif ( (fix_dist > 16.0) and (fix_dist < 16.3) ): fpx = x_right_mid[fixation_counter] fpz = z_right_mid[fixation_counter] centre_x = x_right_mid[fixation_counter] centre_z = z_right_mid[fixation_counter] break else: ##if you move more than 16m away from any possible fixation, fixation goes back to 0,0,0 fixation_counter = 0 ##if you end up finding your path again, there is a brand new fixation for you! fpx = 0 fpz = 0 centre_x = 0 centre_z = 0 else: ##fixations for left bends while fixation_counter < 3142: fix_dist = mt.sqrt( ( ( pos[0] - x_left_mid[fixation_counter] )**2 ) + ( ( pos[2] - z_left_mid[fixation_counter] )**2 ) ) if ( (fix_dist < 16.0) | (fix_dist > 16.3) ): fixation_counter += 1 #compCount += 1 continue elif ( (fix_dist > 16.0) and (fix_dist < 16.3) ): fpx = x_left_mid[fixation_counter] fpz = z_left_mid[fixation_counter] centre_x = x_left_mid[fixation_counter] centre_z = z_left_mid[fixation_counter] #print fix_dist break else: fixation_counter = 0 fpx = 0 fpz = 0 centre_x = 0 centre_z = 0 ############################ ## added by Yuki # insert variables in driver class driver.function_insert(centre_x, centre_z, pos[0], pos[2], fix_dist) ############################ # fixation coordinate(X, eye height, Z) fixation.translate(fpx, fpheight, fpz) eyedata = 9999 #SaveData(pos[0], pos[1], pos[2], ori, steeringWheel, eyedata) ##. # start action ontimer(rate, function) vizact.ontimer((1.0/60.0),updatePositionLabel) for j in range(0,TotalN): #import vizjoy global outside_edge, inside_edge, trialtype, trialtype_signed trialtype=abs(TRIALSEQ_signed[j]) trialtype_signed = TRIALSEQ_signed[j] viz.MainScene.visible(viz.OFF,viz.WORLD) ## # Define a function that saves data ## def SaveData(pos_x, pos_y, pos_z, ori, steer, eye): ## # Create the output string ## currTime = viz.tick() ## #out = str(float((currTime))) + '\t' + str(pos_x) + '\t' + str(pos_z)+ '\t' + str(ori)+ '\t' + str(trialtype_signed) + '\n' ## ## out = str(float((currTime))) + '\t' + str(pos_x) + '\t' + str(pos_z)+ '\t' + str(ori)+ '\t' + str(steer) + '\t' + str(trialtype_signed) + '\n' ## #out = str(float((currTime))) + '\t' + str(pos_x) + '\t' + str(pos_z)+ '\t' + str(ori)+ '\t' + str(steer) + '\t' + str(eye[0]) + '\t' + str(eye[1]) + '\t' + str(eye[2]) + '\t' + str(eye[3]) + '\t' + str(eye[4]) + '\t' + str(trialtype_signed) + '\n' ## # Write the string to the output file ## file.write(out) ## # Makes sure the file data is really written to the harddrive ## file.flush() ## #print out roadEdges() driver.reset() viz.MainScene.visible(viz.ON,viz.WORLD) yield viztask.waitTime(10) #Trial Time if edge == 1: inside_edge.remove() outside_edge.remove() else: viz.quit() ##otherwise keeps writting data onto last file untill ESC
