def initialise_display(): # viz.message('Calibration on Pupil Capture must be set to Manual Marker') #load scene for luminance. # start empty world EH = 1.2 #metres from ground. Eye_ScreenDist = 1 #distance from screen of ocular point Proj_V = 1.12 #measured on 18/01/18 #vertical extent of projection (m) Proj_H = 1.965 #horizontal extent of projection (m) # setting Field-of-View fov(vertical degree, horizontal ratio(vertical*ratio[deg])) vfov = ((np.arctan((Proj_V/2)/Eye_ScreenDist))*2) * (180/np.pi) h2v = Proj_H/Proj_V #viz.setDisplayMode(1920,1080) viz.go() viz.window.setSize(1920,1080) #viz.fov(vfov,h2v) #sets window aspect ratio. viz.fov(vfov,h2v) #sets window aspect ratio. #viz.window.setSize([1920,1080]) #viz.window.setBorder(viz.BORDER_NONE) #viz.window.setFullscreen(1) #viz.window.setFullscreenMonitor(2) #viz.window.setFullscreenRectangle( [0,0,1920,1080] ) viz.eyeheight(1.2)#viz.MainView.setPosition(0,EH,0) viz.clip(1,60) #clips world at 60m # background color viz.clearcolor(viz.SKYBLUE)
def fwdMovementCallback(self): if self.movement != Movement: self.outputMove('ContMv') print 'Continuous: Mode', self.mode, 'Moves = ', self.movement.GetNumForwardMoves( ) if self.mode == 'Explore' and HotSpots.InHotSpot(): self.VisitedHotSpots.mark(HotSpots.InHotSpot()) if self.VisitedHotSpots.all(): if not self.positionList: endPos = None else: positionPair = self.positionList.pop() endPos = positionPair[1] while endPos == HotSpots.InHotSpot( ) and self.positionList.count(endPos) < len( self.positionList): #only get another position if the list contains a position other than endPos self.positionList.insert(0, endPos) s, endPos = self.positionList.pop() HotSpots.StartTrials(numtrials=1, callback=self.callback, targetHotspot=endPos, AnnounceLater=0) elif self.mode == 'BoundedWander': if (self.movement.GetNumForwardMoves() > self.moveBound): SoundQueue.PlaySound('SharedMedia/Sounds/Finished.wav') viz.clearcolor(1, 1, 1) self.closeCurtain() self.openCurtain() viz.clearcolor(0, 0, 0) print "Finished BoundedWander after", self.movement.GetNumForwardMoves( ), "moves" if self.onFinish: self.onFinish(self)
def EvalTest(self, train): if (train.numSuccess >= train.numGoodTrials and (train.numGoodTrials == 1 or train.VisitedHotSpots.all())): print "Achieved competency" train.log("### Achieved competency\n") dir = GetDirections(self.prefix, self.env, group=self.group) train.onFinish = next.Next next.setTrain(train) next.Next(train) # Director will have more inefficient routes than efficient, or has too many failures. elif (((self.numTrials + train.numGoodTrials) > (self.maxTrials + train.numSuccess)) or (train.numFailures > 3)): print "Failed test" train.log("### Failed competency\n") self.setTrain(train) #reset (self.startPos, self.endPos) = self.QuizList.pop() train.onFinish = self.Prep viz.clearcolor(0, 0, 0) train.numSuccess = 0 train.numOK = 0 train.numFailures = 0 train.MoveToNext(self.startPos, 'BoundedWander') else: print "Continue test with trial ", self.numTrials, " and successes ", train.numSuccess self.Prep(train)
def mykeyboard(whichKey): print 'The following key was pressed: ', whichKey global color color = color ^ 1 if whichKey == viz.KEY_F1: print 'Fkey 1 pressed' elif whichKey == viz.KEY_F2: print 'Fkey 2 pressed' elif whichKey == viz.KEY_F3: print 'Fkey 2 pressed' elif whichKey == viz.KEY_F4: print 'Fkey 2 pressed' elif whichKey == viz.KEY_UP: print 'Up arrow pressed' elif whichKey == viz.KEY_DOWN: print 'Down arrow pressed' elif whichKey == viz.KEY_LEFT: print 'Left arrow pressed' elif whichKey == viz.KEY_RIGHT: print 'Right arrow pressed' elif whichKey == viz.KEY_ESCAPE: print '===================================================' print '===================================================' print '===================================================' print '===================================================' print '===================================================' print '===================================================' print '===================================================' print '===================================================' print '===================================================' viz.clearcolor(color, color, color)
def createEnvironment(): #create 2D environment if parameters.DreiDEnvironment: viz.clearcolor(viz.WHITE) #look from above viz.MainView.setPosition([0,50,0]) viz.MainView.setEuler([0,90,0]) goal.setEuler(0,90,0) goal.color(viz.GREEN) point.setEuler(0,90,0) point.setPosition(0,20,0) point.color(viz.RED) arrow.setPosition(0,20,0) arrow.color(viz.BLUE) #or create 3d environment else: piazza = viz.addChild('piazza.osgb') #look from above viz.MainView.setPosition([0,1.8,0]) #viz.MainView.setEuler([0,90,0]) goal.setEuler(0,90,0) goal.color(viz.GREEN) point.setEuler(0,90,0) point.setPosition(0,20,0) point.color(viz.RED) arrow.setPosition(0,20,0) arrow.color(viz.BLUE)
def efficiencyTest(self): start = HotSpots.GetCurrentStart() target = HotSpots.GetCurrentTarget() accuracy = float(self.hotspotdist[start, target]) / float( self.movement.GetNumForwardMoves()) success = (accuracy >= self.trialAccuracy) if self.mode == 'EfficiencyTest': self.VisitedHotSpots.mark(HotSpots.InHotSpot()) if success: self.numSuccess += 1 viz.clearcolor(0, 1, 0) else: self.numOK += 1 viz.clearcolor(0, 0, 1) if self.numOK >= 3: self.numSuccess = 0 self.numOK = 0 print "Efficiency: ", accuracy, " Succ: ", self.numSuccess, " OK: ", self.numOK, "Fail:", self.numFailures print 'Visited HotSpots', self.VisitedHotSpots, self.VisitedHotSpots.all( ) OUTFILE = open(self.logdir + self.outfile, 'a') OUTFILE.write(">E;\t%d to %d;\t" % (start, target)) OUTFILE.write("%d / %d" % (self.movement.GetNumForwardMoves(), self.hotspotdist[start, target])) OUTFILE.write(" = %f;\t" % (accuracy)) OUTFILE.write("Successes %d;\t" % (self.numSuccess)) OUTFILE.write("OK %d;\t" % (self.numOK)) OUTFILE.write("Failures %d;\t" % (self.numFailures)) OUTFILE.write("\n") OUTFILE.close() return success
def setStage(): """Creates grass textured groundplane""" ###should set this hope so it builds new tiles if you are reaching the boundary. fName = 'C:/VENLAB data/shared_modules/textures/strong_edge.bmp' #fName = 'strong_edge.bmp' # add groundplane (wrap mode) groundtexture = viz.addTexture(fName) groundtexture.wrap(viz.WRAP_T, viz.REPEAT) groundtexture.wrap(viz.WRAP_S, viz.REPEAT) groundtexture.anisotropy(16) groundplane = viz.addTexQuad() ##ground for right bends (tight) tilesize = 500 #planesize = tilesize/5 planesize = 40 groundplane.setScale(tilesize, tilesize, tilesize) groundplane.setEuler((0, 90, 0), viz.REL_LOCAL) #groundplane.setPosition((0,0,1000),viz.REL_LOCAL) #move forward 1km so don't need to render as much. matrix = vizmat.Transform() matrix.setScale(planesize, planesize, planesize) groundplane.texmat(matrix) groundplane.texture(groundtexture) groundplane.visible(1) viz.clearcolor(viz.SKYBLUE) return groundplane
def setStage(TILING=True): """Creates grass textured groundplane""" global gtexture # background color viz.clearcolor(viz.SKYBLUE) #CODE UP TILE-WORK WITH GROUNDPLANE. ##should set this up so it builds new tiles if you are reaching the boundary. #fName = 'textures\\strong_edge_redoutline.bmp' fName = 'textures\\strong_edge.bmp' gtexture = viz.addTexture(fName) gtexture.wrap(viz.WRAP_T, viz.REPEAT) gtexture.wrap(viz.WRAP_S, viz.REPEAT) # #add groundplane (wrap mode) ###UNCOMMENT FOR TILING # Tiling saves memory by using two groundplane tiles instead of a massive groundplane. Since the drivers are essentially driving linearly forward, they cover a lot of distance across the z axis. gplane1 = viz.addTexQuad() ## tilesize = 3000 texture_z_size = tilesize * 2 #planesize = tilesize/5 planesize = tilesize / 5.0 gplane1.setScale(tilesize, tilesize * 2, tilesize) gplane1.setEuler((0, 90, 0), viz.REL_LOCAL) #groundplane.setPosition((0,0,1000),viz.REL_LOCAL) #move forward 1km so don't need to render as much (was originally commented out) matrix = vizmat.Transform() matrix.setScale(planesize, planesize * 2, planesize) gplane1.texmat(matrix) #gplane1.texture(gtexture) gplane1.texture(gtexture) gplane1.visible(1) # if TILING: # fName2 = 'textures\\strong_edge_blueoutline.bmp' #fName2 = 'textures\\strong_edge_blueoutline.bmp' fName2 = 'textures\\strong_edge.bmp' gtexture2 = viz.addTexture(fName2) gtexture2.wrap(viz.WRAP_T, viz.REPEAT) gtexture2.wrap(viz.WRAP_S, viz.REPEAT) gplane2 = gplane1.copy() #create duplicate. gplane2.setScale(tilesize, tilesize * 2, tilesize) gplane2.setEuler((0, 90, 0), viz.REL_LOCAL) #groundplane.setPosition((0,0,1000),viz.REL_LOCAL) #move forward 1km so don't need to render as much. gplane2.texmat(matrix) #gplane1.texture(gtexture) gplane2.texture(gtexture2) gplane2.visible(1) gplane2.setPosition(0, 0, tilesize * 2) gplane2.zoffset(-1) else: gplane2 = [] return (gplane1, gplane2, texture_z_size)
def openCurtain(self): self.room.visible(viz.ON) self.cues.showAllCues(1) viz.visible(viz.ON) viz.clearcolor(0, 0, 0) self.curtain = 0 if self.mode != 'TurnAround' and self.movement != Movement: self.movement.AllowMotion(forward=True) for name in self.envs.keys(): if name != self.layout: self.envs[name].visible(viz.OFF) for cue in self.envCues[name]: cue.Object.visible(viz.OFF)
def fadingFadeThing(): yield viztask.waitTime(1) globals_oa.fadingSphere.addAction(fadeOutSphere) yield viztask.waitActionEnd(globals_oa.fadingSphere, fadeOutSphere) globals_oa.terrainZone3.visible(viz.OFF) globals_oa.ocean.visible(viz.OFF) # globals_oa.terrainZone1.visible(viz.ON) globals_oa.globeScene.enable(viz.RENDERING) globals_oa.user.setPosition(0.0,-0.05,0.0) viz.fogcolor(viz.BLACK) viz.fog(0.2) viz.clearcolor(viz.BLACK) globals_oa.fader.fadeOutTask() globals_oa.fader.fadeInTask() # yield viztask.waitTime(2) yield globals_oa.fadingSphere.addAction(fadeInSphere)
def setupLighting(self): viz.MainView.getHeadLight().remove() # Create Sky viz.clearcolor(viz.SKYBLUE) sky = viz.add('sky_day.osgb') sky.setScale(2, 2, 2) sky.setPosition(0, 0, 0) lightColor = [0.8, 0.7, 0.6] # Create directional lights sun = vizfx.addDirectionalLight(euler=([-120.00000, 24.50000, 0.00000]), color=lightColor) # Adjust ambient color vizfx.setAmbientColor([0.95, 0.95, 0.95])
def failedToDetect(self): print 'Failed to detect' viz.clearcolor(viz.RED) # Temporarily stop presenting numbers self.stopPresentingNumbers() vizact.ontimer2(self.updateRateSecs,0,viz.clearcolor,viz.BLACK) vizact.ontimer2(self.updateRateSecs,0,self.startPresentingNumbers) import winsound Freq = 200 # Set Frequency To 2500 Hertz Dur = 150 # Set Duration To 1000 ms == 1 second winsound.Beep(Freq,Dur) if( networkingOn ): netClient.send(message='numberTaskError')
def toggleEyeCalib(self): """ Toggles the calibration for eye tracking. Note, that for this to work, toggling # self.config.camera must turn off your world model # This is setup in testRoom.init(). # Example of what's needed in testRoom.init self.room = viz.addGroup() self.model = viz.add('pit.osgb',parent = self.room) """ if not self.config.mocap: pass #elif (self.config.mocap.isOn() == 1): elif( self.config.mocap.mainViewUpdateAction == False): #self.config.mocap.turnOff() self.config.mocap.enableHMDTracking() #self.config.mocap.turnOn() else: self.config.mocap.disableHMDTracking() viz.mouse.setOverride(viz.TOGGLE) self.config.eyeTrackingCal.toggleCalib() self.inCalibrateMode = not self.inCalibrateMode if self.inCalibrateMode: viz.clearcolor(.5, .5, .5) viz.MainView.setPosition(0,0,0) viz.MainView.setAxisAngle(0, 1, 0, 0) viz.MainView.velocity([0,0,0]); else: viz.clearcolor(0, 0, 0) if self.room: #self.room.visible(viz.disable) self.room.walls.visible(viz.TOGGLE) self.room.objects.visible(viz.TOGGLE)
def addGroundPlane(): """adds a scene""" fName = 'C:/VENLAB data/shared_modules/textures/strong_edge.bmp' # add groundplane (wrap mode) groundtexture = viz.addTexture(fName) groundtexture.wrap(viz.WRAP_T, viz.REPEAT) groundtexture.wrap(viz.WRAP_S, viz.REPEAT) groundplane = viz.addTexQuad() ##ground for right bends (tight) tilesize = 300 planesize = tilesize / 5 groundplane.setScale(tilesize, tilesize, tilesize) groundplane.setEuler((0, 90, 0), viz.REL_LOCAL) matrix = vizmat.Transform() matrix.setScale(planesize, planesize, planesize) groundplane.texmat(matrix) groundplane.texture(groundtexture) groundplane.visible(1) viz.clearcolor(viz.SKYBLUE)
# Used to gain access to the entire Vizard library import viz import vizshape import vizact # Enable full screen anti-aliasing FSAA to smooth edges viz.setMultiSample(4) # Increase the field of view(fov) to 60 degrees from default 40 degress viz.fov(74.73,1.77) # viz.go starts an empty world viz.go() viz.clearcolor(viz.SKYBLUE) #Setting the background color viz.MainView.getHeadLight().enable() cam = viz.MainView cam.setPosition([0,1.06,0]) ## s = 1 focalLen = 0.00081566 * s planeWidth = 0.00126 * s planeHeight = 0.0022 * s camcenter_dX = (640-606.3966)*1.75*(10^-6) * s camcenter_dY = (360-310.6875)*1.75*(10^-6) * s ImagePlane = vizshape.addPlane( size = [planeWidth,planeHeight], axis = -vizshape.AXIS_Z, cullFace = False
TotalN = NCndts * TrialsPerCondition TRIALSEQ = range(0, NCndts) * TrialsPerCondition np.random.shuffle(TRIALSEQ) direc = [1, -1] * (TotalN / 2) #makes half left and half right. np.random.shuffle(direc) TRIALSEQ_signed = np.array(direc) * np.array(TRIALSEQ) return (TRIALSEQ_signed, ConditionList_heading, ConditionList_dots) # background color viz.clearcolor( viz.SKYBLUE ) # comment out for black sky plane but might be best to leave sky blue in order # ground texture setting def setStage(TILING=True): global ndots, tilesize fName = 'textures\\black.jpg' gtexture = viz.addTexture(fName) gtexture.wrap(viz.WRAP_T, viz.REPEAT) gtexture.wrap(viz.WRAP_S, viz.REPEAT) # #add groundplane (wrap mode) ###UNCOMMENT FOR TILING
def mykey(self, key): if self.curtain: if key != ' ': return print "Mode:", self.mode, " jump: ", self.jump if self.jump: self.jump = 0 if self.mode == 'TurnAround': HotSpots.AnnounceHotSpots(1) HotSpots.SayCurrentHotSpot( 'SharedMedia/Sounds/TurnAround.wav') else: if not self.starttime: self.starttime = time.time() if self.mode in ('Explore', 'BoundedWander'): HotSpots.ResetHotSpots() self.MoveToNext( random.randint(1, len(HotSpots.GetHotSpots())), self.mode) self.jump = 0 self.VisitedHotSpots.reset(HotSpots.InHotSpot()) elif self.mode in ('HotspotQuiz', 'EfficiencyTest'): self.endTrial() if self.mode in ('Directions', ): if self.onFinish: return self.onFinish(self) else: HotSpots.AnnounceHotSpots(1) self.openCurtain() elif key in ('0', 'm', 'M', ' ') and self.mode == 'TurnAround' and self.onFinish: return self.onFinish(self) elif not self.movement.OkMove(): return print key, self.movement.GetNumForwardMoves( ), self.mode, 'HotSpot', HotSpots.InHotSpot() if key in ('w', 'W'): self.outputMove('WchHS') HotSpots.SayCurrentHotSpot() elif key in ('t', 'T', 'd', 'D') and self.mode in ('HotspotQuiz', 'EfficiencyTest'): self.outputMove('CurrTgt') HotSpots.SayCurrentTarget() elif key in ('d', 'D') and self.mode == 'Directions': self.outputMove('ReDirct') DirectionDialog(filename=self.directions, dir=self.directionDir) elif key == ' ': if self.mode in ('HotspotQuiz', 'EfficiencyTest', 'Directions'): done = 0 if HotSpots.GetCurrentTarget() == HotSpots.InHotSpot(): self.outputMove('CorrTgt') self.efficiencyTest() if self.mode == 'EfficiencyTest': #SoundQueue.PlaySound('SharedMedia/Sounds/correct.wav') if (self.numSuccess >= self.numGoodTrials and (self.numGoodTrials == 1 or self.VisitedHotSpots.all())): HotSpots.StopTrials() self.closeCurtain() done = 1 else: self.outputMove('IncrTgt') if self.mode == 'EfficiencyTest': SoundQueue.PlaySound( 'SharedMedia/Sounds/Incorrect.wav') self.numSuccess = 0 self.numOK = 0 self.numFailures += 1 viz.clearcolor(1, 0, 0) self.movement.ResetNumMoves() self.endTrial(done) if self.movement != Movement: # Are we using discrete motion keys? return if key in ('8', '*'): if self.mode == 'TurnAround': SoundQueue.PlaySound('SharedMedia/Sounds/TurnAround.wav') elif self.movement.GoForward(self.fwdMovementCallback): self.outputMove('Forward') elif key in ('4', 'u', 'U'): if self.movement.RotateLeft(): self.outputMove('Left') elif key in ('6', 'o', 'O'): if self.movement.RotateRight(): self.outputMove('Right')
def goCG(): bgcolor = [0.15*1.2, 0.67*1.2, 0.95*1.2] viz.clearcolor(bgcolor) global skipKey, egg flagPile = globals_oa.terrainZone1.getChild('flagPile.OSGB', viz.CHILD_REPLACE_TRANSFORM) fishZone1 = schooling.initialize(1) # yield viztask.waitEvent(globals_oa.VIDEO_END_EVENT) # loadStuffAtStartAndHideThemALL() vizact.onsensorup(globals_oa.rhViveTracker, steamvr.BUTTON_TRIGGER, printRightHandPosition) vizact.onsensorup(globals_oa.lhViveTracker, steamvr.BUTTON_TRIGGER, printLeftHandPosition) globals_oa.terrainZone1.visible(viz.ON) globals_oa.ocean.visible(viz.ON) # schooling.hidePercentage(0) # schooling.chromis_chromis.hidePercentage(0) # schooling.diplodus_annularis.hidePercentage(0) # schooling.labrus_viridis.hidePercentage(0) # schooling.sarpa_salpa.hidePercentage(0) # schooling.show(fishZone1) # fog = vizfx.addFogEffect(colorRamp=viz.addTexture(globals_oa.MODEL_DIRECTORY + 'FogRamp.tif'), height=1, density=(.09)) # fog = vizfx.addFogEffect(colorRamp=viz.addTexture(globals_oa.MODEL_DIRECTORY + 'FogRamp.tif'), height=1, density=(10)) # vizfx.getComposer().addEffect(fog) # viz.MainScene.enable(viz.FOG, op=viz.OP_ROOT) viz.fogcolor(viz.AZURE) viz.fog(0.025) # worldvizcode.initVFXforDC(globals_oa.terrainZone1) # should moved into loadAndHide? worldvizcode.startEffects(globals_oa.terrainZone1) #not needed? #positioning the user on the terrain # offsetting the user on the terrain y_offset = -1.5 userPos = globals_oa.user.getPosition(viz.ABS_GLOBAL) globals_oa.user.setPosition([userPos[0], y_offset, userPos[2]]) #####** Healthy CG zone fades in** # terrain1Child = globals_oa.terrainZone1.getChild('Terrain_Zone009') # posToMoveUserTo = terrain1Child.getBoundingBox().center # print "posToMoveUserTo = " + str(posToMoveUserTo) if globals_oa.fader is None: globals_oa.fader = View_Fader.addFader(fadeTime=5) globals_oa.fader.fadeIn() ##### #This is a healthy reef, where carbon dioxide has not yet altered seawater chemistry. # ##### #When scientists measure the health and biodiversity of a reef, they perform something called a species count. ##### #Today, you will be counting the number of sea snails on this part of the reef. Look at your right hand # globals_oa.TRANSITION_TO_CG.play() yield viztask.waitAny([viztask.waitTime(10), skipKey]) globals_oa.CG_SCENE1_1.play() # getAllChildrenZone1 = viz.MainScene.getChildren(all=True) def fadeAllZone1(): globals_oa.terrainZone1.alpha(0) globals_oa.terrainZone1.visible(viz.ON) worldvizcode.stopEffects() viz.fog(0) fadeInZone1 = vizact.fadeTo(1, time=2) yield globals_oa.terrainZone1.addAction(fadeInZone1) # for child in getAllChildrenZone1: # child.addAction(fadeInZone1) yield viztask.waitAny([viztask.waitTime(17), skipKey]) # globals_oa.CG_SCENE1_1.stop() #*participant sees 3D model of sea snail rotating like a hologram* # if globals_oa.rhViveTracker is not None: # vizact.ontimer2(0.004, 25, scavengerhunt.vibrateHandController, 2) # leftHandVibrateTimer.setEnabled(True) # rightHandVibrateTimer.setEnabled(True) rotatingSnail.visible(viz.ON) snailLink = None vizact.ontimer2(.004, 50, vibrateRightHand) if globals_oa.rhViveTracker is not None: snailLink = viz.link(globals_oa.rhViveTracker, rotatingSnail) snailLink.setOffset([0.0, y_offset, 0.0]) snailLink.preTrans([0.01,-0.03,-0.13]) snailLink.preEuler([0,0,180]) yield viztask.waitTime(11) ##### #*hologram disappears, species count begins* if snailLink is not None: snailLink.remove() rotatingSnail.visible(viz.OFF) rotatingSnail.remove() ##### flashing the flag pile ###### egg.visible(viz.ON) flashOn = vizact.fadeTo(1, time=1, interpolate=vizact.easeInOut) flashOff = vizact.fadeTo(0, time=1, interpolate=vizact.easeInOut) flashSequence = vizact.sequence(flashOn, flashOff, 5) egg.add(flashSequence) yield viztask.waitTime(11) globals_oa.CG_SCENE1_2.play() print "playing CG_SCENE1_2 now" # yield viztask.waitAny([viztask.waitMediaEnd(globals_oa.CG_SCENE1_2), skipKey]) yield viztask.waitAny([viztask.waitTime(17), skipKey]) # scavengerhunt.initialize(globals_oa.terrainZone1, globals_oa.filePathToSpeciesForScavengerHuntInZone1) # scavengerhunt.hideBasketAndStuffAttachedToIt() print "waiting for the species hunt end event, or for a timer to run out" # yield viztask.waitAny([viztask.waitEvent(scavengerhunt.ZONE1_OVER_EVENT), viztask.waitTime(60), skipKey]) yield viztask.waitAny([viztask.waitTime(35), skipKey]) print "species hunt is over" # leftHandVibrateTimer.setEnabled(False) # rightHandVibrateTimer.setEnabled(False) # scavengerhunt.endScavengerHunt() # yield viztask.waitEvent(scavengerhunt.ZONE1_OVER_EVENT) # scavengerhunt.disableGrabber() #waiting for the audio to end print "waiting for the narration to end" yield viztask.waitAny([viztask.waitTime(5), skipKey]) #healthy zone fading out # print "fading out from zone-1 begin" # globals_oa.fader.fadeOutTask() globals_oa.fader.fadeOut() # print "fading out from zone-1 complete" yield viztask.waitAny([viztask.waitTime(5), skipKey]) ##### #**Unhealthy CG zone fades in** # globals_oa.terrainZone1.disable(viz.RENDERING) globals_oa.terrainZone1.visible(viz.OFF) if globals_oa.lhModelFlag is not None: globals_oa.lhModelFlag.visible(viz.OFF) if globals_oa.rhModelFlag is not None: globals_oa.rhModelFlag.visible(viz.OFF) schooling.hide(fishZone1) # userPos = globals_oa.user.getPosition() # globals_oa.user.setPosition(userPos[0] + globals_oa.zone3_X_offset, userPos[1], userPos[2]) # globals_oa.user.setPosition(userPos[0], userPos[1], userPos[2]) # globals_oa.basket.setPosition(globals_oa.basketPosInCGscene3) # globals_oa.terrainZone3.setPosition(-60.73, 0.0, 0.0) # scavengerhunt.hideBasketAndStuffAttachedToIt() globals_oa.terrainZone3.visible(viz.ON) # worldvizcode.stopEffects() worldvizcode.startEffects(globals_oa.terrainZone3) # schooling.show(fishZone2) # print "fading into zone-3 begin" # globals_oa.fader.fadeInTask() globals_oa.fader.fadeIn() # print "fading into zone-3 complete" ##### Observe the changes that have occurred as acidity has increased. Reach out and touch one of the streams of bubbles rising from the sea floor globals_oa.CG_SCENE2_1.play() print "playing CG_SCENE2_1 now" # yield viztask.waitAny([viztask.waitMediaEnd(globals_oa.CG_SCENE2_1), skipKey]) #adding proximity handling for touching the bubbles global bubbleVibratorManager bubbleVibratorManager = vizproximity.Manager() # bubbleVibratorManager.setDebug(viz.ON) vizact.onkeydown('b', bubbleVibratorManager.setDebug, viz.TOGGLE) #adding bounding box sensors around the bubbles updateVibrationSensors() # vizact.onkeydown('u',updateVibrationSensors) #adding boxes around the hands as targets global rhandtar, lhandtar # rhsphere = vizshape.addSphere(radius = 0.07) rhsphere = vizshape.addBox(size=(0.1,0.1,0.3)) rhsphere.setParent(globals_oa.rightHand) rhsphere.setPosition([0,0,-0.15]) rhsphere.disable(viz.RENDERING) # lhsphere = vizshape.addSphere(radius = 0.07) lhsphere = vizshape.addBox(size=(0.1,0.1,0.3)) lhsphere.setParent(globals_oa.leftHand) lhsphere.setPosition([0,0,-0.15]) lhsphere.disable(viz.RENDERING) # if globals_oa.rhModel is not None: rhandtar = vizproximity.Target(rhsphere)#globals_oa.rhModel) # if globals_oa.lhModel is not None: lhandtar = vizproximity.Target(lhsphere)#globals_oa.lhModel) bubbleVibratorManager.addTarget(rhandtar) bubbleVibratorManager.addTarget(lhandtar) bubbleVibratorManager.onEnter(None, vibrateHandInBubbles) bubbleVibratorManager.onExit(None, stopVibrationOfHandInBubbles) print "*********************************** SENSORS ADDED FOR VIBRATING BUBBLES ***********************************" yield viztask.waitAny([viztask.waitTime(globals_oa.CG_SCENE2_1.getDuration()), skipKey]) ##### **wait until participant touches a stream of bubbles** ##### ** repeat last sentence until they do so** #####The vents here in Ischia are releasing carbon dioxide, which is making the water more acidic. #####You study this part of the reef to predict how human carbon dioxide emissions will affect #####our world’s oceans and the species that live within them. #####Look at your right hand. globals_oa.CG_SCENE2_2.play() print "playing CG_SCENE2_2 now" yield viztask.waitAny([viztask.waitTime(16), skipKey]) if globals_oa.rhViveTracker is not None: corrodedRotatingSnail.visible(viz.ON) vizact.ontimer2(.004, 50, vibrateRightHand) print '***********linking cooroded snail' snailLink = viz.link(globals_oa.rhViveTracker, corrodedRotatingSnail) snailLink.setOffset([0.0, y_offset, 0.0]) snailLink.preTrans([0.01, -0.03, -0.13]) snailLink.preEuler([0, 0, 180]) snailLink.setMask(viz.LINK_POS) spinForever = vizact.spin(0,1,0, 90, dur = viz.FOREVER) corrodedRotatingSnail.runAction(spinForever) yield viztask.waitTime(10) corrodedRotatingSnail.visible(viz.OFF) yield viztask.waitAny([viztask.waitTime(40), skipKey]) if bubbleVibratorManager is not None: bubbleVibratorManager.clearSensors() bubbleVibratorManager.clearTargets() if rightHandVibrateTimer is not None: rightHandVibrateTimer.setEnabled(False) if leftHandVibrateTimer is not None: leftHandVibrateTimer.setEnabled(False) globals_oa.finalTransitionSound.play() # yield viztask.waitTime(1) bubbleStreams = globals_oa.terrainZone3.getChild('zone2_smaller.OSGB') bubbleStreams.setAnimationSpeed(0.1) globals_oa.UNDERWATER_AMBIENT.stop() yield viztask.waitTime(3) globals_oa.FINAL_SCENE.play() yield viztask.waitAny([viztask.waitTime(10), skipKey]) fadeInSphere = vizact.fadeTo(0, time=2) fadeOutSphere = vizact.fadeTo(1, time=2) def fadingFadeThing(): yield viztask.waitTime(1) globals_oa.fadingSphere.addAction(fadeOutSphere) yield viztask.waitActionEnd(globals_oa.fadingSphere, fadeOutSphere) globals_oa.terrainZone3.visible(viz.OFF) globals_oa.ocean.visible(viz.OFF) # globals_oa.terrainZone1.visible(viz.ON) globals_oa.globeScene.enable(viz.RENDERING) globals_oa.user.setPosition(0.0,-0.05,0.0) viz.fogcolor(viz.BLACK) viz.fog(0.2) viz.clearcolor(viz.BLACK) globals_oa.fader.fadeOutTask() globals_oa.fader.fadeInTask() # yield viztask.waitTime(2) yield globals_oa.fadingSphere.addAction(fadeInSphere) viztask.schedule(fadingFadeThing) globals_oa.fader.fadeOutTask()
import viz import viztask import steamvr import datetime import scipy.io as scio import math import utils nSecWait = 6 # number of seconds of data to capture to determine noise in the tracker output multiplier = 100 # set thresholds at mean+lambda*SD times the noise recorded, where lmbda is the multiplier set here qHaveSimultaneous = True # use setup with Vive and simultaneous PPT and Intersense (True), or not (False)? setup = utils.init(qHaveSimultaneous) viz.clearcolor(viz.WHITE) def TrackTask(): prevPos = None tracking = True allData = [] tRegained = 0. waitingForTrack = True t = 0. while True: # wait for trigger press while not (steamvr.getControllerList()[0].isButtonDown(2) or viz.key.isDown('c', immediate=True)): # limit to update rate d = yield viztask.waitDraw()
def createEnvironment(): global point global arrow global goal global thrust global shadow #create 3D environment if parameters.dreiDEnvironment: piazza = viz.addChild('piazza.osgb') #look from above viz.MainView.setPosition([0,1.8,-5]) viz.MainView.setEuler([0,20,0]) viz.collision(viz.ON) # gorund for collision ground = viz.add('tut_ground.wrl') # Add ground ground.collidePlane() # Make collideable plane ground.disable(viz.RENDERING) ground.disable(viz.DEPTH_WRITE) # point #point = viz.add('ball.wrl') point = vizshape.addSphere(radius = parameters.pointRadius, slices = 20, stacks = 20, axis = vizshape.AXIS_Y) pointPhys = point.collideSphere() # Define ball's physical properties point.setEuler(0,90,0) point.setPosition(0,parameters.point_height,0) point.color(viz.RED) point.setScale(0.5,0.5,0.5) point.enable( viz.COLLIDE_NOTIFY ) #goal goal = vizshape.addCircle(slices=100, radius=0.3) goal.setEuler(0,90,0) goal.color(viz.GREEN) goal.setPosition(0,parameters.goal_height,0) goal.setScale(parameters.goal_scale3D,parameters.goal_scale3D,parameters.goal_scale3D) #shadow shadow = vizshape.addCircle(slices=100, radius=0.3) shadow.setEuler(0,90,0) shadow.color(viz.GRAY) shadow.setPosition(0,parameters.shadow_height,0) shadow.setScale(parameters.shadow_scale3D,parameters.shadow_scale3D,parameters.shadow_scale3D) #arrow arrow = vizshape.addArrow() arrow.setPosition(0,parameters.arrow_height3D,0) arrow.color(viz.BLUE) #thrust thrust = point.addThruster(force=[0,0,0]) #or create 2d environment else: viz.clearcolor(viz.WHITE) #look from above viz.MainView.setPosition([0,8,0]) viz.MainView.setEuler([0,90,0]) #point = viz.add('ball.wrl') point = vizshape.addSphere(radius = parameters.pointRadius, slices = 20, stacks = 20, axis = vizshape.AXIS_Y) pointPhys = point.collideSphere() # Define ball's physical properties point.setEuler(0,90,0) point.setPosition(0,parameters.point_height,0) point.color(viz.RED) point.visible(False) point.enable( viz.COLLIDE_NOTIFY ) #wind force thrust = point.addThruster(force=[0,0,0]) #goal goal = vizshape.addCircle(slices=100, radius=0.2) goal.setEuler(0,90,0) goal.color(viz.GREEN) goal.visible(False) goal.setScale(parameters.goal_scale2D,parameters.goal_scale2D,parameters.goal_scale2D) #arrow arrow = vizshape.addArrow() viz.mouse(viz.OFF) arrow.setPosition(0,parameters.arrow_height2D,0) arrow.color(viz.BLUE) arrow.visible(False)
import viz import vizmat viz.go() #create two textures # background color viz.clearcolor(viz.SKYBLUE) fName = 'textures\\strong_edge_redoutline.bmp' gtexture = viz.addTexture(fName) gtexture.wrap(viz.WRAP_T, viz.REPEAT) gtexture.wrap(viz.WRAP_S, viz.REPEAT) gplane1 = viz.addTexQuad() ## tilesize = 5 planesize = tilesize / 5.0 gplane1.setScale(tilesize, tilesize * 2, tilesize) gplane1.setEuler((0, 90, 0), viz.REL_LOCAL) texture_z_size = tilesize * 2 matrix = vizmat.Transform() matrix.setScale(planesize, planesize * 2, planesize) gplane1.texmat(matrix) gplane1.texture(gtexture) gplane1.visible(1) #create second texture fName2 = 'textures\\strong_edge_blueoutline.bmp'
viz.window.setFullscreenMonitor([2, 1]) clock = 0 GRAVITY = 9.81 num = 0 NUM_AVATARS = 2 headLocation = viz.addGroup() ########################## #### Scene Creation #### ########################## light = viz.MainView.getHeadLight().ambient(1, 1, 1) light2 = viz.addLight() roomGroup = None viz.clearcolor(0.1, 0.1, 0.3) link = None # list of limbs to check for collision body COLLISION_LIMBS = [ "Bip01 Head", "Bip01 L UpperArm", "Bip01 L Forearm", "Bip01 L Thigh", "Bip01 L Calf", "Bip01 R UpperArm", "Bip01 R Forearm", "Bip01 R Thigh", "Bip01 R Calf", "Bip01 Spine", "Bip01 Spine1",
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()
import viz import vizact viz.setMultiSample(4) viz.fov(60) viz.go() viz.clearcolor( viz.SLATE ) viz.addChild('room.osgb')
def run(CL, tracks, grounds, backgrounds, cave, driver, autofiles, wheel, save_prefix): DEBUG = False trialtime = tracks[list(tracks.keys())[0]].trialtime if DEBUG: trialtime = 6 wait_texture = setStage('dusk.png') wait_col = list(np.mean(np.array([viz.BLACK,viz.SKYBLUE]).T, axis = 1)) #add audio files manual_audio = 'C:\\VENLAB data\\shared_modules\\textures\\490_200ms.wav' viz.playSound(manual_audio, viz.SOUND_PRELOAD) def SingleBeep(): """play single beep""" viz.playSound(manual_audio) """ datacolumns = ('autofile_i','bend','maxyr', 'onsettime','ppid','trialn','block','timestamp_exp','timestamp_trial', 'world_x','world_z','world_yaw','swa', 'yawrate_seconds','turnangle_frames', 'distance_frames','dt','wheelcorrection', 'steeringbias', 'autoflag', 'autofile') """ """ UpdateValues = [] UpdateValues.append(yawrate) UpdateValues.append(turnangle) UpdateValues.append(distance) UpdateValues.append(dt) UpdateValues.append(SteeringWheelValue) UpdateValues.append(self.__Wheel_yawrate_adjustment) """ expid, ppid, block = save_prefix.split('_') columns = ('ppid','block','world_x','world_z','world_yaw','timestamp_exp','timestamp_trial','maxyr', 'onsettime', 'bend','dn','autoflag','yr_sec','yr_frames','distance_frames','dt','sw_value','wheelcorrection','sw_angle') def update(num): if UPDATE: trialtimer = viz.tick() - trialstart if DEBUG: txtmode.message(str(onset) +'\n' + str(yr) + '\n' + str(round(trialtimer,2))) if AUTOFLAG: #read the corresponding entry on the playback_data if trialtimer <= onset: i, auto_row = next(playback_iter) #print(i, auto_row) dir = auto_row.bend new_swa = auto_row.swa * dir * bend #these columns are named slightly differently to the final experiment data new_yr = auto_row.yr * dir * bend #move the wheel. wheel.set_position(new_swa) #set steering wheel to else: #driver.setAutomation(False) new_yr = 0 #off-tangent failure else: new_yr = None #update position updatevals = driver.UpdateView(new_yr) #return the values used in position update #retrieve position and orientation pos = cave.getPosition() yaw = vizmat.NormAngle(cave.getEuler()[0]) #record data #columns = ('ppid', 'block','world_x','world_z','world_yaw','timestamp_exp','timestamp_trial','maxyr', 'onsettime', 'bend','dn','autoflag','yr_sec','yr_frames','distance_frames','dt','sw_value','wheelcorrection','sw_angle') output = (ppid, block, pos[0], pos[2], yaw, viz.tick(), trialtimer, yr, onset, bend, dn, int(AUTOFLAG), updatevals[0], updatevals[1],updatevals[2], updatevals[3],updatevals[4],updatevals[5], updatevals[4]*90) #output array #print(output) #self.OutputWriter.loc[self.Current_RowIndex,:] = output #this dataframe is actually just one line. OutputWriter.writerow(output) #output to csv. any quicker? #call update every frame UPDATE = False viz.callback(viz.TIMER_EVENT, update) viz.starttimer(0,1.0/60.0,viz.FOREVER) txtmode = viz.addText("Mode",parent=viz.SCREEN) #set above skyline so I can easily filter glances to the letter out of the data txtmode.setPosition(.05,.52) txtmode.fontSize(36) txtmode.color(viz.WHITE) if not DEBUG: txtmode.message('A') print(CL) for trial_i, (idx, trial) in enumerate(CL.iterrows()): #reset key trial variables trialstart = viz.tick() AUTOFLAG = True driver.setAutomation(AUTOFLAG) #set up dataframe and csv writer OutputFile = io.BytesIO() OutputWriter = csv.writer(OutputFile) OutputWriter.writerow(columns) #write headers. bend = int(trial['Bend']) yr = trial['maxYR'] dn = trial['Day/Night'] onset = trial['OnsetTime'] key = str(bend)+'_'+str(yr)+'_' + dn #retrieve playback playback = autofiles[str(yr)] playback_iter = playback.iterrows() #only switch on update loop after retrieving parameters #pick track and make visible track = tracks[key] track.ToggleVisibility(1) ground = grounds[dn] ground.visible(viz.ON) viz.clearcolor(backgrounds[dn]) if trial_i == 0: yield viztask.waitTime(2) else: yield viztask.waitTime(.5) #start the trial proper UPDATE = True #run trial def PlaybackReached(): """checks for playback limit or whether automation has been disengaged""" end = False #print(viz.tick() - trialstart) if (viz.tick() - trialstart) > trialtime: end = True return(end) def CheckDisengage(): """checks automation status of driver class """ end = False auto = driver.getAutomation() if auto == False: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 ('end of trial reached') elif d.condition is waitDisengage: print ('Automation Disengaged') if not DEBUG: txtmode.message('M') AUTOFLAG = False wheel.FF_on(.2) SingleBeep() yield viztask.waitTime(trialtime - (viz.tick()-trialstart)) #END OF STEERING TASK #reset trial track.ToggleVisibility(0) ground.visible(viz.OFF) driver.reset() wait_texture.visible(1) viz.clearcolor(wait_col) UPDATE = False if not DEBUG: txtmode.message('A') yield viztask.waitTime(.5) wait_texture.visible(0) UPDATE = True savename = save_prefix +'_'+str(trial_i) SaveData(OutputFile, savename) CloseConnections(wheel)
import timeit import time import vizconnect import steamvr from vizconnect.util import view_collision viz.setMultiSample(4) viz.fov(60) vizconnect.go('vizconnect_config_htcvive.py') #run htc vive config script viz.go() viz.phys.enable() #set lab environment and light viz.clearcolor(0.7,0.7,0.8) viz.MainView.setPosition([9,3,15]) viz.MainView.setEuler(180, 0, 0) lab = viz.addChild('lab.osgb') lab.setPosition([0,0,0]) vizfx.addDirectionalLight(euler=(0,45,0)) env = viz.add(viz.ENVIRONMENT_MAP,'sky.jpg') dome = viz.add('skydome.dlc') dome.texture(env) #set up collider and avatar ground = lab.getChild('ground') # get ground ground.collidePlane(bounce = 0, friction = 0.01) # Make collideable plane #get table for experiment
{} pigeons flew the coop and are hiding out in the piazza. You have {} seconds to catch each one before it flys away. Listen carefully and you might be able to hear where they are hiding. Use the mouse and WASD keys to move around. Press spacebar to begin the hunt!""".format(TRIAL_COUNT,TRIAL_DURATION) RESULTS = """You found {} of {} pigeons. Press spacebar to start over or escape to exit.""" TRIAL_SUCCESS = 'You caught the pigeon!' TRIAL_FAIL = 'The pigeon flew away!' viz.setMultiSample(4) viz.fov(60) viz.go(viz.FULLSCREEN) viz.clearcolor(viz.PURPLE) # Setup directional light viz.MainView.getHeadLight().disable() sky_light = viz.addDirectionalLight(euler=(0,20,0)) sky_light.color(viz.WHITE) sky_light.ambient([0.8]*3) viz.setOption('viz.lightModel.ambient',[0]*3) # Setup keyboard/mouse tracker tracker = vizcam.addWalkNavigate(moveScale=2.0) tracker.setPosition([0,1.8,0]) viz.link(tracker,viz.MainView) viz.mouse.setVisible(False)
def main(): # global variables global debug global pieces global shape global sidebar global sidebarBG global blockState global cursor global cursorPos global highlightedObj global highlightedObjType global selectedObj global selectedObjType global animRot global identity global selectedIndex global won global is900Sensor1 global old_data global all_data global iSenseMode # --------------------------------------------------------------------------- # init vizard # initialize pdb if debugging is needed # pdb.set_trace() # init intersense tracker iSenseMode = False # isense = viz.add('intersense.dle') # # wand. # if isense.valid() == True : # iSenseMode = True # is900Sensor1 = isense.addTracker(port=1,station=2) # viz.add('court.ive') """ Set the pivot point 2 meters above the origin. Set the rotation mode to blend its orientation from its current orientation to that associated with the pivot. """ # gotoRight = vizact.goto([2,1,-2],rotate_mode=viz.BLEND_ROTATE,pivot=[0,2,0],ori_mask=viz.BODY_ORI) # gotoLeft = vizact.goto([-2,2,-2],rotate_mode=viz.BLEND_ROTATE,pivot=[0,2,0],ori_mask=viz.BODY_ORI) # Use keyboard actions to move the viewpoint. # vizact.onkeydown(viz.KEY_ALT_L, viz.MainView.runAction, gotoRight ) # # vizact.onkeydown(viz.KEY_ALT_R, viz.MainView.runAction, gotoLeft ) # cam = vizcam.PivotNavigate(center=[0,1,0],distance=4) # viz.cam.setHandler(cam) # # cam.enabled = True # viz.cam.setHandler(vizcam.KeyboardCamera()) # vizcam.PivotNavigate(center=[0,1,0],distance=5) # assign space mouse callbacks # viz.callback(vizspace.ROTATE_EVENT,spaceRot) old_data = [] all_data = [] # set the maximum frame rate to something lower than the minimum the application runs # so that the FPS is constant throughout the run viz.setOption("viz.max_frame_rate", "60") # set the full screen monitor to 1 viz.setOption("viz.fullscreen.monitor", 2) # start in full screen # viz.go(viz.FULLSCREEN) viz.go() # vizcam.PivotNavigate(center=[0,1,0],distance=5) # set cursor visibility # viz.mouse.setVisible(viz.OFF) # enable backface culling viz.enable(viz.CULL_FACE) # set clear color for raster viz.clearcolor(Colors.WHITE) # --------------------------------------------------------------------------- # init variables # flag to toggle debug breakpoints - Use 'x' to toggle debug = False # list of pieces available pieces = [] # won the game won = False # group with all cubes in their final position - read from file shape = viz.add(viz.GROUP, viz.WORLD) # input file with description of pieces and # input_file = open('puzzle.txt','r') # parseInputFile(input_file) # since we still don't have an input format, we build the puzzle manually buildPuzzle(3, 3, 3) # create sidebar to indicate existing pieces/possibilities sidebar = [] sidebarBG = createQuad([0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]) sidebarBG.depthFunc(viz.GL_ALWAYS) sidebarBG.drawOrder(100) buildSideBar() animRot = 0 identity = vizmat.Transform() identity.makeIdent() cursor = vizshape.addSphere(radius=0.2) cursor.color(Colors.LIGHT_BLUE) cursorPos = [0.0, 0.0, 3.0] selectedObj = None selectedObjType = None selectedIndex = -1 highlightedObj = None highlightedObjType = None # assign keyDown and keyUp as callback functions for events viz.callback(viz.KEYDOWN_EVENT, keyDown) viz.callback(viz.KEYUP_EVENT, keyUp) # register the update function to be called every iteration of the main loop vizact.ontimer(0, update)
# loads experimental conditions inputFile = INPUT_DIR + NICKNAME + '_subject' + subject + '.csv' with open(inputFile, 'rb') as data: rows = csv.reader(data) conditions = [row for row in rows] condition = '' # loads practice conditions if conditions[1][3] == 'avatar': inputFile = INPUT_DIR + NICKNAME + '_practice_avatar.csv' else: inputFile = INPUT_DIR + NICKNAME + '_practice_pole.csv' with open(inputFile, 'rb') as data: rows = csv.reader(data) practice_conditions = [row for row in rows] viz.clearcolor(0,0.4,1.0) # blue world models = {} models['homePole'] = viz.add(MODEL_DIR + 'pole_blue.osgb') models['orientPole'] = viz.add(MODEL_DIR + 'pole_red.osgb') models['targetPole'] = viz.add(MODEL_DIR + 'pole_green.osgb') # Consist of three green poles with their original size [0.4, 3, 0.4] models['leaderPole'] = viz.add(MODEL_DIR + 'pole_yellow.osgb') models['ground'] = viz.add(MODEL_DIR + 'Tomato3_ground.osgb') # load avatars such as "CC2_f001_hipoly_A0.cfg", "CC2_m001_hipoly_A0.cfg" # The stride length of avatars are around 1 meter, frequency is 0.6 second per step, 5/3 step per second. avatars = [] for i in range(20): avatars.append(viz.add(AVATAR_DIR + 'CC2_f' + str(i+1).zfill(3) + '_hipoly_A0.cfg')) for i in range(20): avatars.append(viz.add(AVATAR_DIR + 'CC2_m' + str(i+1).zfill(3) + '_hipoly_A0.cfg'))
def startBoatOutro(): global skipKey #yield viztask.waitEvent(scavengerhunt.ZONE3_OVER_EVENT) yield viztask.waitAny([viztask.waitTime(52), skipKey]) globals_oa.ZONE3_AUDIO_1.stop() yield fader.fadeOutTask() globals_oa.user.setPosition([0,0,0]) killOceanScene() yield fader.fadeOutTask() globals_oa.AUDIO_SPHERICAL_TRANSITION.play() result = yield viztask.waitAny([viztask.waitMediaEnd(globals_oa.AUDIO_SPHERICAL_TRANSITION), skipKey]) if result.condition is skipKey: globals_oa.AUDIO_SPHERICAL_TRANSITION.stop() # Gets rid of all the fish for school in schooling.all_fish_schools: school.hidePercentage(100) # Stops swimming # transport_vhil.onKeyDown('g') # viz.MainScene.disable(viz.FOG, op=viz.OP_ROOT) # Change parameters to False, True for PPT 1 vhilGo(True, False, keyboardcontrol=False) player = spherical_player_Vive.Player(globals_oa.SPHERICAL_VIDEO, PPT1=False, radius=2.7, playPauseKey=' ') screenPosition = player.screen.getPosition() viz.MainView.setPosition([screenPosition[0], 1.82, screenPosition[1]]) player.toggleLooping() player.play() yield fader.fadeInTask() yield viztask.waitAny([viztask.waitTime(2), skipKey]) globals_oa.AUDIO_SPHERICAL_1.play() result = yield viztask.waitAny([viztask.waitMediaEnd(globals_oa.AUDIO_SPHERICAL_1), skipKey]) if result.condition is skipKey: globals_oa.AUDIO_SPHERICAL_1.stop() yield viztask.waitTime(1) globals_oa.AUDIO_SPHERICAL_2.play() result = yield viztask.waitAny([viztask.waitMediaEnd(globals_oa.AUDIO_SPHERICAL_2), skipKey]) if result.condition is skipKey: globals_oa.AUDIO_SPHERICAL_2.stop() # Waits until the video is done playing result = yield viztask.waitAny([viztask.waitTime(player.getVideoDuration() - globals_oa.AUDIO_SPHERICAL_1.getDuration() - globals_oa.AUDIO_SPHERICAL_2.getDuration() - 3.5), skipKey]) if result.condition is skipKey: player.pause() yield fader.fadeOutTask() player.screen.visible(viz.OFF) globals_oa.AUDIO_ZONE3_AMBIENT.pause() # killOceanScene() boatscene.revealScene() boatscene.unhideBoatAndIschia() yield viztask.waitAny([viztask.waitTime(3), skipKey]) globals_oa.AUDIO_BOAT_AMBIENT_OUTRO.play() yield fader.fadeInTask() yield viztask.waitAny([viztask.waitTime(3), skipKey]) playAudioAndSaveGlobalPointer(globals_oa.BOAT_AUDIO_OUTRO_2) result = yield viztask.waitAny([viztask.waitMediaEnd(globals_oa.BOAT_AUDIO_OUTRO_2), skipKey]) markAudioPlayAsEnded() if result.condition is skipKey: globals_oa.BOAT_AUDIO_OUTRO_2.stop() viz.clearcolor(0, 0, 0) yield fader.fadeOutTask() boatscene.killScene() yield viztask.waitTime(3) viztask.schedule(loadAcknowledgment) yield fader.fadeInTask() #1.5 yield viztask.waitTime(globals_oa.BETWEEN_FADING_TIME) #4 yield fader.fadeOutTask() #1.5
#timing ITI = 2 #intertrial interval, in seconds ##env shape global radius radius = 14.5 #in meters, made global for convenience so be careful ##ground ground = vizshape.addPlane(size=(40.0, 40.0), axis=vizshape.AXIS_Y) ground.setPosition(0, 0, 0) t1 = viz.addTexture('tex2.jpg', wrap=viz.REPEAT) ground.texture(t1) ground.texmat(viz.Matrix.scale(20, 20, 1)) ##sky color viz.clearcolor(0.1, 0.1, 0.2) ###CONTEXT GEN FUNCTION#### def ContextGen(runNum): if runNum % 2 == 0: if subject % 2 == 0: context = 1 else: context = 2 else: if subject % 2 == 0: context = 2 else:
def trials(block_no, isPoles='None', trialNo=10, trialtype='Offset', continued=False): info.setText("Hurrah!! Please wait for the experimenter.") if isPoles in ['flipped', 'staying']: poles, polelist = poleCreator(ground, pole_wd, pole_dep, pole_ht, pole_no) writePolePos(isPoles, polelist) for m in range(trialNo): # Set up the response recording file global sub_rt if continued: sub_rt = open( 'VRrt_' + str(id) + '_Block_' + str(block_no) + '_Trial_' + str(m + 9) + '_' + time.strftime("%d-%b-%y_%H-%M") + '.csv', 'a') else: sub_rt = open( 'VRrt_' + str(id) + '_Block_' + str(block_no) + '_Trial_' + str(m + 1) + '_' + time.strftime("%d-%b-%y_%H-%M") + '.csv', 'a') data = 'frameNo,Color,TimeStamp,Response' sub_rt.write('\n' + data) # Set up the real target sensor area sensor_Target = vizproximity.Sensor( vizproximity.RectangleArea([6, 0.1], center=[0, real_tg_dist[(-1)**(m + 1)]]), None) manager.addSensor(sensor_Target) # Set up poles if they change between trials if isPoles == 'changing': poles, polelist = poleCreator(ground, pole_wd, pole_dep, pole_ht, pole_no) writePolePos(isPoles, polelist) elif isPoles == 'flipped': poles.setEuler([(90 * (1 - (-1)**m)), 0, 0], mode=viz.ABS_PARENT) poles.setPosition([0, 0, polePos[(-1)**(m)]], mode=viz.ABS_PARENT) # Stand by yield viztask.waitNetwork(serverName) # choose target depending on walking direction if isPoles == 'flipped': if flippedTarget == 'BO': if m % 2 == 0: Target2.alpha(0) Target1.color(tg2Color) else: Target1.alpha(0) Target2.color(tg2Color) else: if m % 2 == 0: Target2.alpha(0) Target1.color(tg1Color) else: Target1.alpha(0) Target2.color(tg1Color) viz.window.screenCapture('flipped_Image_' + str(m) + '.jpg') else: if m % 2 == 0: Target2.alpha(0) Target1.color(tg1Color) else: Target1.alpha(0) Target2.color(tg2Color) viz.window.screenCapture(isPoles + '_Image_' + str(m) + '.jpg') ground.visible(viz.ON) labNetwork.send('Ready') # Start walking yield viztask.waitNetwork(serverName) metronome.play() if isPoles == 'flipped': if flippedTarget == 'BO': if m % 2 == 0: colorChange = viztask.schedule(changeColor2(Target1)) else: colorChange = viztask.schedule(changeColor2()) else: if m % 2 == 0: colorChange = viztask.schedule(changeColor1()) else: colorChange = viztask.schedule(changeColor1(Target2)) else: if m % 2 == 0: colorChange = viztask.schedule(changeColor1()) else: colorChange = viztask.schedule(changeColor2()) labNetwork.send('Block' + str(block_no) + ' Trial ' + str(m)) yield viztask.waitTime(0.25) # reach the target yield vizproximity.waitEnter(sensor_Target) alert.play() metronome.stop() viz.clearcolor(viz.BLACK) ground.visible(viz.OFF) colorChange.kill() labNetwork.send('Reach Target!') manager.clearSensors() print Target1.getPosition(viz.ABS_GLOBAL) print Target2.getPosition(viz.ABS_GLOBAL) # Set up the information for participants at the end of trial if m < trialNo - 1: info.visible(viz.ON) yield viztask.waitTime(3) info.visible(viz.OFF) if isPoles == 'changing': poles.remove() else: # finish writing the response info.setText('End of Block ' + str(block_no)) info.visible(viz.ON) yield viztask.waitTime(3) info.visible(viz.OFF) if isPoles != 'None': poles.remove() # reset the targets if m % 2 == 0: Target2.alpha(1) else: Target1.alpha(1)
def reset(): viz.MainView.setPosition([10.2,22.92,-34.8]) viz.MainView.setEuler([-179.16,0,0]) def viewCar(): viz.MainView.setPosition([0,130,-150]) viz.MainView.setEuler([0,50,0]) if __name__ == '__main__': viz.go() SCENE = viz.Scene2 viz.MainView.setScene(SCENE) viz.MainView.setPosition([10.2*0.2,22.92*0.2,-34.8*0.2]) viz.MainView.setEuler([-179.16,0,0]) #day = viz.addChild('sky_day.osgb', scene=viz.Scene2) car = vizfx.addChild("Sept11_Car.OSGB", scene=SCENE) car.setScale(0.2,0.2,.2) head = viz.MainView.getHeadLight() head.disable() control.control(viz.MainView) addDirectionalLights(0.2,SCENE) addFog(SCENE) vizact.onkeydown('r', reset) vizact.onkeydown('v', viewCar) viz.clearcolor([.1,.1,.1])
def addFog(scene=viz.MainScene): viz.clearcolor([.1,.1,.1]) #viz.fogcolor(viz.GRAY) vizfx.addFogEffect(color=viz.GRAY,start=5,end=0)
import vizshape import vizfx import vizinfo import oculus import time import projector #Oculus setup code hmd = oculus.Rift() viz.link(hmd.getSensor(), viz.MainView) viz.MainView viz.setMultiSample(8) viz.go() viz.clearcolor(.5, .5, .5) #For testing without headset #view = viz.MainView #view.eyeheight(1.65) # Setup navigation node and link to main view navigationNode = viz.addGroup() viewLink = viz.link(navigationNode, viz.MainView) viewLink.preMultLinkable(hmd.getSensor()) #Oculus will automatically sense the height of the participant and adjust the view profile = hmd.getProfile() global height height = profile.eyeHeight - .13 #after much testing, this seems to be most accurate to real world height navigationNode.setPosition([0, height, 0])
import viz import vizact viz.go() viz.clearcolor(viz.SLATE) #Create a quad to display texture quad = viz.addTexQuad(pos=[0,1.8,3]) #Create texture with repeating wrap mode tex = viz.addTexture('images/tile_grass.jpg', wrap=viz.REPEAT) tex.pos = 0 #Apply texture to quad quad.texture(tex) ANIMATE_SPEED = 0.1 def animateTexture(): #Increment texture position tex.pos += ANIMATE_SPEED * viz.elapsed() #Create transform for texture mat = viz.Transform() mat.setTrans(tex.pos,0,0) #Apply transform to texture quad.texmat(mat) vizact.ontimer(0,animateTexture)
MOVE_SPEED = .005 ROTATION_SPEED = 5 SUB_GROUP_SPACING = 20 for i in range(0, NUM_DOTS): x = random.random() - 0.5 y = random.random() / 2 z = random.random() - 0.5 length = math.sqrt(x*x + y*y + z*z) x = x / length * RADIUS y = y / length * RADIUS z = z / length * RADIUS particleGroup = viz.addGroup() particleGroup.setPosition([x, y, z]) particleGroup.setEuler([random.random()*360, random.random()*360, random.random()*360]) particleGroup.addAction(vizact.spin(random.random(),random.random(),random.random(), random.random()*ROTATION_SPEED,viz.FOREVER)) particleGroup.addAction(vizact.move(random.random()*MOVE_SPEED,random.random()*MOVE_SPEED,random.random()*MOVE_SPEED,viz.FOREVER), 1) for i in range(10): clone = particle.clone() clone.parent(particleGroup) clone.setScale([SCALE]*3) clone.setEuler([random.random()*360, random.random()*360, random.random()*360]) clone.setPosition([random.random()*SUB_GROUP_SPACING, random.random()*SUB_GROUP_SPACING, random.random()*SUB_GROUP_SPACING]) if __name__ == '__main__': viz.go() viz.add('tut_ground.wrl') viz.clearcolor(viz.BLUE)
#env = viz.add(viz.ENVIRONMENT_MAP, 'eucalyptus\eucalyptus.jpg',scene=viz.MainScene) env = viz.add(viz.ENVIRONMENT_MAP, 'sky.jpg',scene=viz.MainScene) sky = viz.add('skydome.dlc') sky.texture(env) TRANSLATE_INC = .2 ROTATION_INC = 2 SCALE = [0.03, 0.03, 0.03] room = viz.add("../models/room2/room2.wrl") room.setScale(SCALE) ground = viz.add('tut_ground.wrl') ground.setScale([5,1,5]) #viz.translate(viz.HEAD_POS,0,20,-20) #viz.lookat(0,0,0) viz.clearcolor(viz.SKYBLUE) vizact.whilekeydown(viz.KEY_UP,viz.move,0,0,TRANSLATE_INC) #Move forward while up key is pressed vizact.whilekeydown(viz.KEY_DOWN,viz.move,0,0,-TRANSLATE_INC) #Move backward while down key is pressed vizact.whilekeydown(viz.KEY_LEFT,viz.rotate,viz.BODY_ORI,-ROTATION_INC,0,0) #Turn left while left arrow pressed vizact.whilekeydown(viz.KEY_RIGHT,viz.rotate,viz.BODY_ORI,ROTATION_INC,0,0) #Turn right while right arrow pressed def onCollideBegin(e): global pg if pg.abe.avatar == e.obj1: pg.abe.collision() viz.callback(viz.COLLIDE_BEGIN_EVENT, onCollideBegin) pg = path.PathGenerator()
def main(): # global variables global debug global pieces global shape global sidebar global sidebarBG global blockState global cursor global cursorPos global highlightedObj global highlightedObjType global selectedObj global selectedObjType global animRot global identity global selectedIndex global won #--------------------------------------------------------------------------- # init vizard # initialize pdb if debugging is needed #pdb.set_trace() # set the maximum frame rate to something lower than the minimum the application runs # so that the FPS is constant throughout the run viz.setOption('viz.max_frame_rate','60') # set the full screen monitor to 1 viz.setOption('viz.fullscreen.monitor',2) # start in full screen #viz.go(viz.FULLSCREEN) viz.go() # set cursor visibility #viz.mouse.setVisible(viz.OFF) # enable backface culling viz.enable(viz.CULL_FACE) # set clear color for raster viz.clearcolor(Colors.WHITE) #--------------------------------------------------------------------------- # init variables # flag to toggle debug breakpoints - Use 'x' to toggle debug = False # list of pieces available pieces = [] # won the game won = False # group with all cubes in their final position - read from file shape = viz.add(viz.GROUP,viz.WORLD) # input file with description of pieces and #input_file = open('puzzle.txt','r') #parseInputFile(input_file) # since we still don't have an input format, we build the puzzle manually buildPuzzle(3,3,3) # create sidebar to indicate existing pieces/possibilities sidebar = [] sidebarBG = createQuad([0,0,0],[0,0,0],[0,0,0],[0,0,0]) sidebarBG.depthFunc(viz.GL_ALWAYS) sidebarBG.drawOrder(100) buildSideBar() animRot = 0 identity = vizmat.Transform() identity.makeIdent() cursor = vizshape.addSphere(radius=0.2) cursor.color(Colors.LIGHT_BLUE) cursorPos = [0.0,0.0,3.0] selectedObj = None selectedObjType = None selectedIndex = -1 highlightedObj = None highlightedObjType = None # assign keyDown and keyUp as callback functions for events viz.callback(viz.KEYDOWN_EVENT, keyDown) viz.callback(viz.KEYUP_EVENT, keyUp) # register the update function to be called every iteration of the main loop vizact.ontimer(0,update)
yield viztask.waitTime(globals_oa.BETWEEN_FADING_TIME) #4 yield fader.fadeOutTask() #1.5 # yield viztask.waitTime(globals_oa.CREDITS_TIME) # yield fader.fadeOutTask() # sys.exit('exiting now!') #Load ALL assets for both scenes #GodRay.init() #boatscene.initFog() #loadBoatScene2() loadBoatScene() globals_oa.user.setPosition([0,0,0]) loadDisabledOceanScene() scavengerhunt.loadStuff() viz.clearcolor(0, 0, 0) #createSphereScene() #schedule master scene manager audiocache.loadAudioAssets() viztask.schedule(loadOpeningTitle()) #viztask.schedule(loadBoatScene()) #viztask.schedule(boatscene.unhideBoatAndIschia()) #removeSphere() viztask.schedule(startBoatIntro) def playAudioAndSaveGlobalPointer(audioFilePointer): print "playing audio - " + str(audioFilePointer) globals_oa.audioFilePlaying = audioFilePointer # if globals_oa.audioMixer is not None:
viztask.returnValue(descr) def cross_block(list_of_trials,training=False): # keep track of trial results results = [] successes = 0 block_text.message("DEADLINE: %.2f"%list_of_trials[0][2]) vizact.ontimer2(rate=MESSAGE_TIME, repeats=0,func=clear_text) # Loop over the rest of the trials for trial in list_of_trials[1:]: res = yield cross_trial(*trial,training=training) results.append(res) successes += results[-1]["success"] # Display successes at the end yield end_block(successes,len(list_of_trials)) yield viztask.waitTime(4) # Clear the message block_text.message("") viztask.returnValue( results ) if __name__ == "__main__": viz.go() viz.clearcolor(viz.GRAY) from design.sequence import create_full_experiment def multitrial(): results = [] blocks = create_full_experiment([0.3, 0.2, 0.4, 0.5]) for block in blocks: results += yield cross_block(block,training=True) viztask.returnValue(results) res = viztask.schedule(multitrial())
viz.clip(.1,100000) ocean = vizfx.addChild(ART_DIRECTORY + './art/environment/OceanFloor.osgb') # Change properties to enable the god ray. water = ocean.getChild('Water') water.disable(viz.DEPTH_WRITE) water.drawOrder(101) # Create and apply global fog effect. # fog = vizfx.addFogEffect( colorRamp=viz.addTexture(ART_DIRECTORY + './art/texture/FogRamp.tif'), height=1, density=(.09)) fog = vizfx.addFogEffect( colorRamp=viz.addTexture(globals_oa.MODEL_DIRECTORY + 'FogRamp.tif'), height=1, density=(.09)) vizfx.getComposer().addEffect(fog) bgcolor = [0.15*1.2, 0.67*1.2, 0.95*1.2] viz.clearcolor(bgcolor) # Enable fog on main scene. # viz.MainScene.enable(viz.FOG, op=viz.OP_ROOT) # Add sun light. lightSun = vizfx.addPointLight() lightSun.constantAttenuation(0) lightSun.linearAttenuation(0) lightSun.quadraticAttenuation(.3) lightSun.setPosition([0.123,0.84911,-1.929]) lightSun.color( viz.WHITE ) lightSun.specular( viz.WHITE ) lightSun.ambient( viz.BLACK )
# 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) left_plane1= vizshape.addPlane(size=(1*scale_x,1*scale_y,),axis=vizshape.AXIS_Y, cullFace=False)
import viz import vizcam import vizact import cgi import vizinfo import vizhtml viz.go() viz.cam.setHandler(vizcam.KeyboardCamera()) viz.phys.enable() viz.MainView.setPosition(-4, 1, -3) viz.MainView.setEuler(30, 0, 0) ground = viz.add('tut_ground.wrl') viz.clearcolor([.5, .6, 1]) lab = viz.add('Living_Lab_Blinds_V2.OSGB', scale=[0.002] * 3) lab.setPosition([0, 0.258, 5]) #Pagina de test: http://localhost:8080/vizhtml/custom_handler/ # Display form submitted message on screen info = vizinfo.InfoPanel('') code = """ <html> <head> <title>vizhtml Custom Handler Example</title> </head> <body onload="document.the_form.message.focus();"> <img src='ball.jpg'> <form name="the_form" method="post"> <table>
logging.info(str(tformOutString + posOutString + mPositionOutString)) if __name__ == "__main__": mocap = phasespaceInterface() mocap.start_thread() #import vizshape #vizshape.addGrid() piazza = viz.addChild('piazza.osgb') viz.window.setFullscreenMonitor(2) viz.go(viz.FULLSCREEN) viz.clearcolor(viz.BLACK) ####### sg = mocap.returnPointerToRigid('shutter') import vizshape sgSphere = vizshape.addSphere(radius=0.02) # First, link visual to rigid body sg.link_pose(sgSphere) ####### import matplotlib matplotlib.use('agg')
def createEnvironment(): global point global arrow global goal global thrust global shadow #create 3D environment if parameters.dreiDEnvironment: piazza = viz.addChild('piazza.osgb') #look from above viz.MainView.setPosition([0, 1.8, -5]) viz.MainView.setEuler([0, 20, 0]) viz.collision(viz.ON) # gorund for collision ground = viz.add('tut_ground.wrl') # Add ground ground.collidePlane() # Make collideable plane ground.disable(viz.RENDERING) ground.disable(viz.DEPTH_WRITE) # point #point = viz.add('ball.wrl') point = vizshape.addSphere(radius=parameters.pointRadius, slices=20, stacks=20, axis=vizshape.AXIS_Y) pointPhys = point.collideSphere() # Define ball's physical properties point.setEuler(0, 90, 0) point.setPosition(0, parameters.point_height, 0) point.color(viz.RED) point.setScale(0.5, 0.5, 0.5) point.enable(viz.COLLIDE_NOTIFY) #goal goal = vizshape.addCircle(slices=100, radius=0.3) goal.setEuler(0, 90, 0) goal.color(viz.GREEN) goal.setPosition(0, parameters.goal_height, 0) goal.setScale(parameters.goal_scale3D, parameters.goal_scale3D, parameters.goal_scale3D) #shadow shadow = vizshape.addCircle(slices=100, radius=0.3) shadow.setEuler(0, 90, 0) shadow.color(viz.GRAY) shadow.setPosition(0, parameters.shadow_height, 0) shadow.setScale(parameters.shadow_scale3D, parameters.shadow_scale3D, parameters.shadow_scale3D) #arrow arrow = vizshape.addArrow() arrow.setPosition(0, parameters.arrow_height3D, 0) arrow.color(viz.BLUE) #thrust thrust = point.addThruster(force=[0, 0, 0]) #or create 2d environment else: viz.clearcolor(viz.WHITE) #look from above viz.MainView.setPosition([0, 8, 0]) viz.MainView.setEuler([0, 90, 0]) #point = viz.add('ball.wrl') point = vizshape.addSphere(radius=parameters.pointRadius, slices=20, stacks=20, axis=vizshape.AXIS_Y) pointPhys = point.collideSphere() # Define ball's physical properties point.setEuler(0, 90, 0) point.setPosition(0, parameters.point_height, 0) point.color(viz.RED) point.visible(False) point.enable(viz.COLLIDE_NOTIFY) #wind force thrust = point.addThruster(force=[0, 0, 0]) #goal goal = vizshape.addCircle(slices=100, radius=0.2) goal.setEuler(0, 90, 0) goal.color(viz.GREEN) goal.visible(False) goal.setScale(parameters.goal_scale2D, parameters.goal_scale2D, parameters.goal_scale2D) #arrow arrow = vizshape.addArrow() viz.mouse(viz.OFF) arrow.setPosition(0, parameters.arrow_height2D, 0) arrow.color(viz.BLUE) arrow.visible(False)