def togRecording(): recSound.play() if(file != None): newthread = viz.director(hf_playback.saveUpdateLoop, avatar, file) vizact.onkeydown(viz.KEY_ESCAPE, hf_playback.cleanup, file, newthread) touchcube.wakeTouchCubes() hf_playback.toggleRecording()
def loadMeshes(self, meshes = [], animate = False):
"""Load all of the files from the dataset into puzzle.mesh instances"""
self.unknownFiles = 0
model.threads = 0
self.printNoticeable('start of rendering process')
for i, fileName in enumerate(meshes):
# This is the actual mesh we will see
if not model.ds.getMetaData(file = fileName):
print "WARNING, UNKNOWN FILE ", fileName
self.unknownFiles += 1
continue
#Wait to add thread if threadThrottle conditions are not met
model.threads += 1 #Add 1 for each new thread added --- new render started
yield viztask.waitTrue(self.threadThrottle, self._maxThreads)
yield viz.director(self.renderMeshes, fileName)
model.menu.updateLoad(len(self._meshes), len(self._meshesToLoad))
self.printNoticeable('end of rendering process')
def startCollecting(self, collectRate=.1): if self.locked: return self.collectRate = collectRate viz.director(self._collectPeriodically)
def setKinectAngle(angle):
viz.director(sensor.setKinectElevation, 0, angle)
print sensor.getKinectElevation(0)
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
__author__ = 'MrLapTop'
import viz
from TestClassEmulateJEvents import EmulateJEvents
import thread
from JasonEventModule import JassonCam
from JasonEventModule import JasonEventRegister
from JasonEventModule import JasonEventSender
if __name__ == "__main__":
jEventRegister = JasonEventRegister()
jCam = JassonCam(jEventRegister)
jEvSen = JasonEventSender()
#jEventEmulator1 = EmulateJEvents(jEventRegister,{"JASON_KEYDOWN_EVENT":[{"key":"w"},{"key":"a"},{"key":"s"},{"key":"d"}]})
#jEventEmulator2 = EmulateJEvents(jEventHandler,{"JASON_KEYDOWN_EVENT":{"key":"w"}})
viz.go()
viz.addChild('piazza.osgb')
#vizcam.KeyboardCamera()
viz.director(jEvSen.run)
#viz.director(jEventEmulator2.startJEvents,1)
def __init__(self, jasonEventRegister):
self.jEventReg = jasonEventRegister
self.sender = JasonEventSender()
viz.director(self.sender.run)
self.mreDict = self.createDicti()
def runtrials(self):
"""Loops through the trial sequence"""
viz.MainScene.visible(viz.ON, viz.WORLD)
viz.mouse.setVisible(viz.OFF) #switch mouse off
viz.clearcolor(
viz.SKYBLUE) #HACK, since eyetracker background is white.
if self.EYETRACKING:
#pass it the filename, and also the timestamp.
et_file = str(self.EXP_ID) + '_' + str(
self.PP_id) #one file for the whole task.
self.comms.start_trial(fname=et_file, timestamp=viz.tick())
if self.EYETRACKING:
#viz.MainScene.visible(viz.OFF,viz.WORLD)
#remove straight
self.Straight.ToggleVisibility(0)
filename = str(self.EXP_ID) + "_Calibration_" + str(
self.PP_id
) #+ str(demographics[0]) + "_" + str(demographics[2]) #add experimental block to filename
print(filename)
# Start logging the pupil data
pupilfile = gzip.open(
os.path.join("Data", filename + ".pupil.jsons.gz"), 'a')
closer = pupil_logger.start_logging(pupilfile,
timestamper=viz.tick)
def stop_pupil_logging():
closer()
pupilfile.close()
EXIT_CALLBACKS.insert(0, stop_pupil_logging)
yield run_calibration(self.comms, filename)
yield run_accuracy(self.comms, filename)
#put straight visible
self.Straight.ToggleVisibility(1)
#add message after calibration to give the experimenter and participant time to prepare for the simulation.
self.markers = Markers()
#set up distractor task
if self.DISTRACTOR_TYPE is not None:
distractorfilename = str(self.EXP_ID) + '_' + str(
self.PP_id) + '_distractor_'
Distractor = Count_Adjustable.Distractor(
distractorfilename,
self.targetnumber,
ppid=1,
startscreentime=self.StartScreenTime,
triallength=np.inf,
ntrials=len(self.TRIALSEQ_df.index))
else:
Distractor = None
#set up scene before eyetracking
self.driver = vizdriver.Driver(self.caveview, Distractor)
viz.message(
'\t\tYou will now begin the experiment \n\n The automated vehicle will attempt to navigate a series of bends. \nYour task as the supervisory driver is to make sure the vehicle stays within the road edges. \nDuring automation please keep your hands loosely on the wheel. \nYou may take control by pressing the gear pads. \nOnce pressed, you will immediately be in control of the vehicle \n\n Please fixate the centre of the calibration point in between trials'
)
self.ToggleTextVisibility(viz.ON)
for i, trial in self.TRIALSEQ_df.iterrows():
#if half-way through do accuracy test.
#Trial loop has finished.
if i == int(np.round(self.total_trials / 2, 0)):
if self.EYETRACKING:
self.markers.markers_visibility(
0) #remove markers for calibration
self.Straight.ToggleVisibility(0)
accuracy_filename = filename + '_middle'
yield run_accuracy(self.comms, accuracy_filename)
yield viztask.waitTime(
1) #a second pause before going into
self.markers.markers_visibility(
1) #remove markersthe next trial
self.Straight.ToggleVisibility(1)
#import vizjoy
print("Trialn: ", str(i))
print("current trial:", trial)
#trial is now a row from a dataframe
print("current trial radius:", trial["radius"])
trial_radii = trial['radius']
trial_yawrate_offset = trial['sab']
trial_dir = trial['bend']
print(str([trial_radii, trial_yawrate_offset]))
txtDir = ""
#print ("Length of bend array:", len(self.rightbends))
self.driver.setAutomation(True)
self.AUTOMATION = True
self.txtMode.message('A')
if self.AUTOWHEEL:
self.Wheel.control_on()
if self.DISTRACTOR_TYPE is not None:
if i == 0: #the first trial.
#annotate eyetracking
if self.EYETRACKING:
self.comms.annotate("DistractorScreen")
#switch texts off for the first trial.
self.ToggleTextVisibility(viz.OFF)
Distractor.StartTrial(self.targetoccurence_prob,
self.targetnumber,
trialn=i,
displayscreen=True) #starts trial
yield viztask.waitTrue(Distractor.getPlaySoundFlag)
self.ToggleTextVisibility(viz.ON)
else:
Distractor.StartTrial(self.targetoccurence_prob,
self.targetnumber,
trialn=i,
displayscreen=False) #starts trial
radius_index = self.FACTOR_radiiPool.index(trial_radii)
#choose correct road object.
if trial_dir > 0: #right bend
trialbend = self.rightbends[radius_index]
txtDir = "R"
else:
trialbend = self.leftbends[radius_index]
txtDir = "L"
#trialbend = self.rightbends[radius_index]
#txtDir = "R"
trialbend.ToggleVisibility(viz.ON)
if trial_radii > 0: #if trial_radii is above zero it is a bend, not a straight
msg = "Radius: " + str(trial_radii) + txtDir + '_' + str(
trial_yawrate_offset)
else:
msg = "Radius: Straight" + txtDir + '_' + str(
trial_yawrate_offset)
# txtCondt.message(msg)
#pick radius
self.Trial_radius = trial_radii
#pick file. Put this in dedicated function. TODO: Should open all of these at the start of the file to save on processing.
self.Trial_autofile_i = int(trial['autofile_i'])
self.Trial_YR_readout = self.YR_readouts_80[self.Trial_autofile_i]
self.Trial_SWA_readout = self.SWA_readouts_80[
self.Trial_autofile_i]
self.Trial_playbackfilename = self.PlaybackPool80[
self.Trial_autofile_i]
"""
if self.Trial_radius == 40:
i = random.choice(range(len(self.YR_readouts_40)))
self.Trial_YR_readout = self.YR_readouts_40[i]
self.Trial_SWA_readout = self.SWA_readouts_40[i]
self.Trial_playbackfilename = self.PlaybackPool40[i]
elif self.Trial_radius == 80:
i = random.choice(range(len(self.YR_readouts_80)))
self.Trial_YR_readout = self.YR_readouts_80[i]
self.Trial_SWA_readout = self.SWA_readouts_80[i]
self.Trial_playbackfilename = self.PlaybackPool80[i]
else:
raise Exception("Something bad happened")
"""
#update class#
self.Trial_simulatedttlc = trial['simulated_ttlc']
self.Trial_design = trial['design']
self.Trial_dir = trial_dir
self.Trial_N = i
self.Trial_YawRate_Offset = trial_yawrate_offset
self.Trial_BendObject = trialbend
self.Trial_trialtype_signed = trial_dir
self.Trial_playbacklength = len(self.Trial_YR_readout)
self.Trial_midline = np.vstack(
(self.Straight.midline, self.Trial_BendObject.midline))
self.Trial_OnsetTime = trial['onsettime']
#self.Trial_OnsetTime = np.random.choice(self.OnsetTimePool, size=1)[0]
self.Trial_SaveName = str(self.EXP_ID) + '_' + str(
self.PP_id) + '_' + str(self.Trial_N)
#renew data frame.
#self.OutputWriter = pd.DataFrame(index = range(self.TrialLength*60), columns=self.datacolumns) #make new empty EndofTrial data
#renew csv writer
self.OutputFile = io.BytesIO()
self.OutputWriter = csv.writer(self.OutputFile)
self.OutputWriter.writerow(self.datacolumns) #write headers.
#annotate eyetracking
if self.EYETRACKING:
self.comms.annotate('Start_' + self.Trial_SaveName)
yield viztask.waitTime(.5) #pause at beginning of trial
#annotate eyetracking
if self.EYETRACKING:
#remove calib_pt and wait a further .5 s
#TODO: add 1 s calibration dot.
self.calib_pt.visible(1)
yield viztask.waitTime(1.5) #pause at beginning of trial
self.calib_pt.visible(0)
yield viztask.waitTime(.5) #pause at beginning of trial
if self.DEBUG:
conditionmessage = 'SAB: ' + str(self.Trial_YawRate_Offset) + \
'\nRadius: ' +str(self.Trial_radius) + \
'\nOnsetTime: ' + str(self.Trial_OnsetTime) + \
'\nAutoFile: ' + str(self.Trial_autofile_i) + \
'\nsim TTLC: ' + str(self.Trial_simulatedttlc) + \
'\nDesign: ' + str(self.Trial_design) + \
'\nTask: ' + str(self.DISTRACTOR_TYPE)
self.txtTrial.message(conditionmessage)
if self.DEBUG_PLOT:
#realtime plot.
self.line_midline.set_data(self.Trial_midline[:, 0],
self.Trial_midline[:, 1])
self.dot_origin.set_data(
self.Trial_BendObject.CurveOrigin[0],
self.Trial_BendObject.CurveOrigin[1])
self.plot_ax.axis([
min(self.Trial_midline[:, 0]) - 10,
max(self.Trial_midline[:, 0]) + 10,
min(self.Trial_midline[:, 1]) - 10,
max(self.Trial_midline[:, 1]) + 10
]) #set axis limits
self.plot_positionarray_x, self.plot_positionarray_z, self.plot_closestpt_x, self.plot_closestpt_z = [], [], [], [] #arrays to store plot data in
self.UPDATELOOP = True #
def PlaybackReached():
"""checks for playback limit or whether automation has been disengaged"""
end = False
#check whether automation has been switched off.
if self.Current_playbackindex >= self.Trial_playbacklength:
end = True
return (end)
def CheckDisengage():
"""checks automation status of driver class """
end = False
auto = self.driver.getAutomation()
if auto == False:
self.AUTOMATION = auto
self.txtMode.message('M')
#switch wheel control off, because user has disengaged
#begin = timer()
if self.AUTOWHEEL:
self.Wheel.control_off()
if self.EYETRACKING:
self.comms.annotate('Disengage_' + self.Trial_SaveName)
#pass
#print ("WheelControlOff", timer() - begin)
end = True
return (end)
#create viztask functions.
waitPlayback = viztask.waitTrue(PlaybackReached)
waitDisengage = viztask.waitTrue(CheckDisengage)
d = yield viztask.waitAny([waitPlayback, waitDisengage])
if d.condition is waitPlayback:
print('Playback Limit Reached')
elif d.condition is waitDisengage:
print('Automation Disengaged')
self.SingleBeep()
def RoadRunout():
"""temporary HACK function to check whether the participant has ran out of road"""
end = False
if self.Trial_Timer > self.TrialLength:
end = True
return (end)
#waitRoad = viztask.waitTrue (RoadRunout)
#waitManual = viztask.waitTime(5)
#d = yield viztask.waitAny( [ waitRoad, waitManual ] )
yield viztask.waitTrue(RoadRunout)
print("Run out of Road")
#if d.condition is waitRoad:
# print ('Run out of Road')
#elif d.condition is waitManual:
# print ('Manual Time Elapsed')
##### END STEERING TASK ######
self.UPDATELOOP = False
self.Trial_BendObject.ToggleVisibility(viz.OFF)
##reset trial. Also need to annotate each eyetracking trial.
viz.director(self.SaveData, self.OutputFile, self.Trial_SaveName)
self.ResetTrialAndDriver(
) #reset parameters for beginning of trial
##### INITIALISE END OF TRIAL SCREEN FOR DISTRACTOR TASK #######
if self.DISTRACTOR_TYPE is not None:
#annotate eyetracking
if self.EYETRACKING:
self.comms.annotate('Distractor_' + self.Trial_SaveName)
if self.AUTOWHEEL:
self.Wheel.control_off()
#switch text off
self.ToggleTextVisibility(viz.OFF)
Distractor.EndofTrial() #throw up the screen to record counts.
# Pause before the query screen to avoid
# spurious presses carrying over from the
# task.
# Hack the screen to be blank
Distractor.EoTScreen.visible(viz.ON)
Distractor.Question.visible(viz.OFF)
Distractor.lblscore.visible(viz.OFF)
yield viztask.waitTime(1.0)
Distractor.EoTScreen_Visibility(viz.ON)
###interface with End of Trial Screen
pressed = 0
while pressed < self.targetnumber:
#keep looking for gearpad presses until pressed reaches trial_targetnumber
print("waiting for gear press")
yield viztask.waitTrue(self.driver.getGearPressed)
pressed += 1
print('pressed ' + str(pressed))
Distractor.gearpaddown()
self.driver.setGearPressed(False)
yield viztask.waitTime(.5)
#Distractor.EoTScreen_Visibility(viz.OFF)
Distractor.RecordCounts()
self.ToggleTextVisibility(viz.ON)
#annotate eyetracking
if self.EYETRACKING:
self.comms.annotate('End_' + self.Trial_SaveName)
#Trial loop has finished.
if self.EYETRACKING:
self.markers.remove_markers() #remove markers
self.Straight.ToggleVisibility(0)
accuracy_filename = filename + '_end'
yield run_accuracy(self.comms, accuracy_filename)
self.CloseConnections()
# if viewport yaw between 160-180
if viz.MainView.getEuler() >= [
170.0, -0.0, 0.0
] and viz.MainView.getEuler() <= [180.0, -0.0, 0.0]:
vizfx.postprocess.removeEffect(effect)
# if viewport yaw between 160-180
elif viz.MainView.getEuler() >= [
-180.0, -0.0, 0.0
] and viz.MainView.getEuler() <= [-170.0, -0.0, 0.0]:
vizfx.postprocess.removeEffect(effect)
else:
vizfx.postprocess.addEffect(effect)
# puts the function on a different thread to allow the while loop to run as the scene keeps going
viz.director(pause)
# load and play the binaural recording
sound = viz.addAudio('resources/barber.mp3')
sound.play()
# load guitar model
guitar = viz.addChild('resources/guitar.osgb')
# load the avatars and set starting position
manuel = viz.addAvatar('vcc_male.cfg')
manuel.setPosition(-0.3, 0, -2.82)
luigi = viz.addChild('vcc_male2.cfg')
luigi.setPosition([-2, 0, 6])
class MainThread():
def __init__(self):
viz.go()
vizcam.AUTO_REGISTER = 0
self.court = viz.addChild('piazza.osgb')
def stopThread(self,thread):
viz.waitTime(10)
thread.stop()
return
def manageThread(self,thread):
lsAll =[["a","b","c"],[1,2,3],[4,5,6],[]]
for ls in lsAll:
thread.changeData(ls)
viz.waitTime(5)
thread.stop()
if __name__ == "__main__":
wtf = MainThread()
subThread = SubThread()
viz.director(subThread.run)
viz.director(wtf.manageThread,subThread)
