anchor = 'center',
size = (width*scale,height*scale),
mipmaps_enabled = 0,
texture_min_filter=gl.GL_LINEAR)
texture_object = stimulus.parameters.texture.get_texture_object()
def update_movie():
# While movie.play() decompresses the movie to pygame surface
# in a separate thread, this sends the data to OpenGL.
texture_object.put_sub_image( pygame_surface )
viewport = Viewport(screen=screen,
stimuli=[stimulus,text])
p = Presentation(go_duration=('forever',),
viewports=[viewport],
handle_event_callbacks=[(pygame.locals.QUIT, quit),
(pygame.locals.KEYDOWN, keydown)],
)
p.add_controller(None,None,FunctionController(during_go_func=update_movie,
temporal_variables=TIME_INDEPENDENT))
movie.play()
#p.go()
import cProfile,pstats
cProfile.run('p.go()','mpeg_profile')
p = pstats.Stats('mpeg_profile')
p.sort_stats('cumulative')
p.print_stats()
coherence_controller = FunctionController(during_go_func=setCoherence)
direction_controller = FunctionController(during_go_func=setDirection)
inst_controller = FunctionController(during_go_func=changeInstructions)
inst_on_controller = FunctionController(during_go_func=setInstructions)
inst3_on_controller = FunctionController(during_go_func=setTimeOn)
inst3_position_controller = FunctionController(during_go_func=setTimePos)
fixation_texture_controller = FunctionController(
during_go_func=setFixationTexture)
samplefix_controller = FunctionController(during_go_func=setSampleFix)
state_controller = FunctionController(during_go_func=getState)
#######################################################
# Connect the controllers with objects they control #
#######################################################
p.add_controller(p, 'trigger_go_if_armed', trigger_in_controller)
# on or off before pres
p.add_controller(str_instruct_1, 'on', stimulus_off_controller)
p.add_controller(str_instruct_2, 'text', inst_controller)
p.add_controller(str_instruct_2, 'on', stimulus_on_controller)
p.add_controller(str_instruct_2, 'on', inst_on_controller)
p.add_controller(dotStim, 'on', stimulus_on_controller)
p.add_controller(fixation, 'on', stimulus_on_controller)
# on or off during pres
p.add_controller(fixation, 'max_alpha', fixation_controller)
p.add_controller(dotStim, 'on', dot_controller)
p.add_controller(dotStim, 'signal_fraction', coherence_controller)
p.add_controller(dotStim, 'signal_direction_deg', direction_controller)
p.add_controller(fixation, 'texture', fixation_texture_controller)
print "----------------------"
print "PROBLEM: %s" % problem
print "SOLUTION: %s " % solution
print "----------------------"
ns = [n1, n2]
# default values for misfiring voice key
misfire = 0
ACC = 1
# BLOCK 1 - Problem & RESPONSE
p = Presentation(go_duration=("forever",), viewports=[expPort])
p.add_controller(
None, None, FunctionController(during_go_func=problem_controller, temporal_variables=FRAMES_ABSOLUTE)
)
p.go()
# BLOCK 2 - STRATEGY SELECTION & GRADING
p2 = Presentation(go_duration=(1.5, "seconds"), viewports=[fixCross])
p2.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, key_handler)]
p2.go()
if ACC == 0:
problemQ = [n1, n2, stim]
error = Presentation(go_duration=(1, "seconds"), viewports=[errorPort])
error.go()
else:
problemQ = []
problem.go()
p3 = Presentation(go_duration=(blankTime, 'seconds'), viewports=[fixCross])
p3.go()
p = Presentation(go_duration=('forever', ), viewports=[vr])
p.parameters.handle_event_callbacks=[(pygame.locals.KEYDOWN, key_handler)]
p.go()
subject.inputData(trial, "RT", RT)
subject.inputData(trial, "ACC", ACC)
#BLOCK 2 - STRATEGY SELECTION
p2 = Presentation(go_duration=('forever', ), viewports=[stratPort])
p2.add_controller(None, None, FunctionController(during_go_func=strategy_controller, temporal_variables = FRAMES_ABSOLUTE))
p2.parameters.handle_event_callbacks=[(pygame.locals.KEYDOWN, key_handler)]
p2.go()
subject.inputData(trial, "cur_strat", strategy)
#BLOCK 3 - BLANK SCREEN
p3 = Presentation(go_duration=(0.5, 'seconds'), viewports=[fixCross])
p3.go()
trial = trial + 1
subject.printData()
subject.preserve()
import VisionEgg
VisionEgg.start_default_logging(); VisionEgg.watch_exceptions()
from VisionEgg.Core import *
from VisionEgg.FlowControl import Presentation
from VisionEgg.Gratings import *
import VisionEgg.Daq
from VisionEgg.DaqLPT import *
# Normal stuff (from grating demo):
screen = get_default_screen()
stimulus = SinGrating2D(position = ( screen.size[0]/2.0, screen.size[1]/2.0 ),
anchor = 'center',
size = ( 300.0 , 300.0 ),
spatial_freq = 10.0 / screen.size[0], # units of cycles/pixel
temporal_freq_hz = 5.0,
orientation = 45.0 )
viewport = Viewport( screen=screen, stimuli=[stimulus] )
p = Presentation(go_duration=(5.0,'seconds'),viewports=[viewport])
# Create a trigger output controller
trigger_out_controller = LPTTriggerOutController()
# Add the trigger output controller to the presentation's list of controllers
p.add_controller(None,None,trigger_out_controller)
# Go!
p.go()
class Simulation:
def __init__(self, screen):
self.state = SimulationState()
self.state.v = 15
self.screen = screen
self.center = screen.size[0] / 2.0
self.doneSetup = False
self.quit = False
def init_state(self):
self.state.th = 0
self.state.x = 0
self.state.z = 0
def wait_for_key(self, t):
#event = pygame.event.poll()
#while event != pygame.NOEVENT:
# if event == pygame.KEYDOWN:
# self.askForNext.quit = True
# event = pygame.event.poll()
pygame.event.pump()
if any(pygame.key.get_pressed()):
print "Got key"
self.askForNext.parameters.quit = True
self.askForNext.parameters.enter_go_loop = True
def update(self, t):
# Estimate the current frame rate
try:
dt = self.frame_timer.get_average_ifi_sec()
except RuntimeError:
dt = 0.01
# Map the pointer position to angular velocity of +/- 90 degrees/s
curr_pos = pygame.mouse.get_pos()
self.pos_ring.add(curr_pos[0])
pos = self.pos_ring.head()
center = self.center
self.state.th = self.state.th + dt * (-(math.pi) / 2.0 *
(pos - center) / center)
# Update steering wheel
self.wheel.set(angle=-90.0 * (curr_pos[0] - center) / center)
th = self.state.th
x = self.state.x
z = self.state.z
self.outf.write("%f\t%u\t%u\t%u\t%f\t%f\t%f\n" %
(t, curr_pos[0], curr_pos[1], pos, th, x, z))
# this is a left handed camera transform, the right handed ones that are
# built in to visionegg were not working for me.
# Translate, then rotate about the y-axis by our current heading angle
viewXfrm = numpy.matrix([[math.cos(th), 0.0,
math.sin(th), 0.0], [0.0, 1.0, 0.0, 0.0],
[-math.sin(th), 0.0,
math.cos(th), 0.0],
[
-x * math.cos(th) + z * math.sin(th), 0.0,
-x * math.sin(th) - z * math.cos(th), 1.0
]])
# Make a step in the direction of current heading
self.state.x = x + self.state.v * dt * math.sin(-th)
self.state.z = z - self.state.v * dt * math.cos(-th)
self.camera_matrix.parameters.matrix = viewXfrm
def doSim(self, trial, road, duration, tau, doEyetrack):
# Measure sample rate in order to calculate delay buffer
sample_rate = self.screen.measure_refresh_rate(2.0)
print "Sample rate: " + str(sample_rate)
#sample_rate = 60
self.doEyetrack = doEyetrack
self.pos_ring = RingBuffer(self.center,
int(math.floor(tau * sample_rate)) + 1)
print("Ring Buffer:: size: " + str(self.pos_ring.size))
if doEyetrack:
import pylink
from EyeLinkCoreGraphicsVE import EyeLinkCoreGraphicsVE
self.tracker = pylink.EyeLink()
if self.tracker == None:
print "Error: Eyelink is not connected"
sys.exit()
genv = EyeLinkCoreGraphicsVE(self.screen, self.tracker)
pylink.openGraphicsEx(genv)
#Opens the EDF file.
edfFileName = "TRIAL" + str(trial) + ".EDF"
self.tracker.openDataFile(edfFileName)
pylink.flushGetkeyQueue()
self.tracker.sendCommand("screen_pixel_coords = 0 0 %d %d" %
(VisionEgg.config.VISIONEGG_SCREEN_W,
VisionEgg.config.VISIONEGG_SCREEN_H))
tracker_software_ver = 0
eyelink_ver = self.tracker.getTrackerVersion()
if eyelink_ver == 3:
tvstr = self.tracker.getTrackerVersionString()
vindex = tvstr.find("EYELINK CL")
tracker_software_ver = int(
float(tvstr[(vindex + len("EYELINK CL")):].strip()))
if eyelink_ver >= 2:
self.tracker.sendCommand("select_parser_configuration 0")
if eyelink_ver == 2: #turn off scenelink camera stuff
self.tracker.sendCommand("scene_camera_gazemap = NO")
else:
self.tracker.sendCommand("saccade_velocity_threshold = 35")
self.tracker.sendCommand(
"saccade_acceleration_threshold = 9500")
# set EDF file contents
self.tracker.sendCommand(
"file_event_filter = LEFT,RIGHT,FIXATION,SACCADE,BLINK,MESSAGE,BUTTON"
)
if tracker_software_ver >= 4:
self.tracker.sendCommand(
"file_sample_data = LEFT,RIGHT,GAZE,AREA,GAZERES,STATUS,HTARGET"
)
else:
self.tracker.sendCommand(
"file_sample_data = LEFT,RIGHT,GAZE,AREA,GAZERES,STATUS")
# set link data (used for gaze cursor)
self.tracker.sendCommand(
"link_event_filter = LEFT,RIGHT,FIXATION,SACCADE,BLINK,BUTTON")
if tracker_software_ver >= 4:
self.tracker.sendCommand(
"link_sample_data = LEFT,RIGHT,GAZE,GAZERES,AREA,STATUS,HTARGET"
)
else:
self.tracker.sendCommand(
"link_sample_data = LEFT,RIGHT,GAZE,GAZERES,AREA,STATUS")
if not self.doneSetup:
self.tracker.doTrackerSetup()
self.doneSetup = True
else:
while 1:
try:
error = self.tracker.doDriftCorrect(
self.screen.size[0] / 2, self.screen.size[1] / 2,
1, 1)
if error != 27: # ?? from example
break
else:
self.tracker.doTrackerSetup()
except:
break
self.screen.parameters.bgcolor = 106.0 / 255.0, 147.0 / 255.0, 0.0
# Load road data from file and create an image
roadArray = numpy.loadtxt('road' + str(road) + '.txt')
# Convert to a Path
roadPath = ImagePath.Path(
map(lambda xy: (xy[0], xy[1]), roadArray.tolist()))
# Use Path to create a plot of the road
im = Image.new("RGB", (2000, 100), (50, 50, 50))
draw = ImageDraw.Draw(im)
# draw each side of the road separately
draw.line(roadPath[:4000], fill=(200, 200, 200))
draw.line(roadPath[4000:], fill=(200, 200, 200))
del draw
# Lay out a road texture in the x-z plane
roadTexture = Texture(im)
del im
eye_height = 2.5
vertices = [(-10, -eye_height, 0), (-10, -eye_height, -1000),
(10, -eye_height, 0), (10, -eye_height, -1000)]
rect = TextureStimulus3D(texture=roadTexture,
lowerleft=vertices[0],
lowerright=vertices[1],
upperleft=vertices[2],
upperright=vertices[3])
# We will use these later for our camera transforms
self.camera_matrix = ModelView()
self.frame_timer = FrameTimer()
self.outf = open(
'steersim-' + str(trial) + '-' + str(road) + '-out.txt', 'wb')
# Vewport for the road
viewport3D = Viewport(
screen=self.screen,
projection=SimplePerspectiveProjection(fov_x=75.2),
camera_matrix=self.camera_matrix,
stimuli=[rect])
# Construct a sky
sky_l = 0
sky_r = self.screen.size[0]
sky_t = self.screen.size[1]
sky_b = self.screen.size[1] / 2
sky_vertices = [(sky_l, sky_t, 0), (sky_r, sky_t, 0),
(sky_r, sky_b, 0), (sky_l, sky_b, 0)]
sky = Rectangle3D(color=(144.0 / 255.0, 190.0 / 255.0, 1.0),
vertex1=sky_vertices[0],
vertex2=sky_vertices[1],
vertex3=sky_vertices[2],
vertex4=sky_vertices[3])
wheelTexture = Texture('wheel.png')
self.wheel = TextureStimulus(texture=wheelTexture,
internal_format=gl.GL_RGBA,
position=(self.center, -75),
anchor='center')
# display the sky in its own viewport
viewport2D = Viewport(screen=self.screen)
viewport2D.parameters.stimuli = [sky, self.wheel]
self.init_state()
askText = Text(text='Press a key to start',
anchor='center',
position=(self.center, self.screen.size[1] / 2))
splash = Viewport(screen=self.screen)
splash.parameters.stimuli = [askText]
self.askForNext = Presentation(go_duration=(0.5, 'seconds'),
viewports=[splash])
self.askForNext.add_controller(
None, None, FunctionController(during_go_func=self.wait_for_key))
self.askForNext.parameters.enter_go_loop = True
self.askForNext.run_forever()
self.simPres = Presentation(go_duration=(duration, 'seconds'),
viewports=[viewport3D, viewport2D],
handle_event_callbacks=[
(pygame.KEYDOWN, self.check_keypress)
])
self.simPres.add_controller(
None, None, FunctionController(during_go_func=self.update))
if doEyetrack:
startTime = pylink.currentTime()
self.tracker.sendMessage("SYNCTIME %d" %
(pylink.currentTime() - startTime))
error = self.tracker.startRecording(1, 1, 1, 1)
self.tracker.sendMessage("PRES %d START" % (trial))
self.simPres.go()
if doEyetrack:
self.tracker.sendMessage("PRES %d END" % (trial))
self.tracker.stopRecording()
# File transfer and cleanup!
self.tracker.setOfflineMode()
pylink.msecDelay(500)
#Close the file and transfer it to Display PC
self.tracker.closeDataFile()
self.tracker.receiveDataFile(edfFileName, edfFileName)
self.outf.close()
if self.quit:
raise SystemExit
def check_keypress(self, event):
if event.key == pygame.K_q:
self.quit = True
self.simPres.set(go_duration=(0.0, 'seconds'))
elif event.key == pygame.K_n:
self.simPres.set(go_duration=(0.0, 'seconds'))
elif event.key == pygame.K_UP:
self.state.v += 1
elif event.key == pygame.K_DOWN:
self.state.v -= 1
# Normal stuff (from grating demo):
screen = get_default_screen()
stimulus = SinGrating2D(
on=0, # turn grating is off when not in go loop
position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
anchor='center',
size=(300.0, 300.0),
spatial_freq=10.0 / screen.size[0],
temporal_freq_hz=5.0,
orientation=45.0)
viewport = Viewport(screen=screen, stimuli=[stimulus])
p = Presentation(
go_duration=(5.0, 'seconds'),
trigger_go_if_armed=0, # wait for trigger
viewports=[viewport])
# Stimulus on controller
stimulus_on_controller = ConstantController(during_go_value=1,
between_go_value=0)
# Create a trigger input controller
trigger_in_controller = LPTTriggerInController()
# Add the trigger output controller to the presentation's list of controllers
p.add_controller(stimulus, 'on', stimulus_on_controller)
p.add_controller(p, 'trigger_go_if_armed', trigger_in_controller)
# Go!
p.go()
class SimpleVisionEgg:
keyboard_controller = None
trigger_controller = None
screen = None
presentation = None
keys = None
presses = None
releases = None
def __init__(self):
"""We break up initialization a bit as we need to go back and forth with
some information. In this case, we need screen size before specifying
the stimuli"""
# pasted in from where it used to be at the beginning of the script
# used to be outside of any methods...
VisionEgg.start_default_logging()
VisionEgg.watch_exceptions()
# get screen size for setting fullscreen resolution
# comment this block out if you don't want to use full-screen.
screen = pygame.display.set_mode((0,0))
WIDTH, HEIGHT = screen.get_size()
pygame.quit()
VisionEgg.config.VISIONEGG_SCREEN_W = WIDTH
VisionEgg.config.VISIONEGG_SCREEN_H = HEIGHT
self.screen = get_default_screen()
self.keys = []
self.presses = []
self.releases = []
def set_stimuli(self, stimuli, trigger=None, kb_controller=False):
"""Now that we have our stimuli, we initialize everything we can"""
viewport = Viewport(screen=self.screen, size=self.screen.size,
stimuli=stimuli)
# We disable "check_events" so that we don't lose "instantaneous" key
# presses and can check these in our Response classes
self.presentation = Presentation(viewports=[viewport],
check_events=False)
if trigger:
trigger_controller = KeyboardTriggerInController(trigger)
self.presentation.add_controller(self.presentation,
'trigger_go_if_armed', trigger_controller)
self.presentation.set(trigger_go_if_armed=0)
if kb_controller:
self.keyboard_controller = KeyboardResponseController()
self.presentation.add_controller(None, None, self.keyboard_controller)
def set_functions(self, update=None, pause_update=None):
"""Interface for cognac.StimulusController or similar"""
self.presentation.add_controller(None, None,
FunctionController(during_go_func=update,
between_go_func=pause_update,
return_type=NoneType) )
def go(self, go_duration=('forever',)):
self.presentation.parameters.go_duration = go_duration
self.presentation.go()
def pause(self):
self.presentation.parameters.go_duration = (0, 'frames')
def get_new_response(self, t, min_interval=2.0 / 60, releases=False):
"""(key, press) = get_new_response(self, t, min_interval=2.0 / 60)
DEPRECATED!
Use this function to get responses from the keyboard controller in real
time.
Returns (None, None) if no new response is available.
Maintains three instance variables - keys, presses and releases, which
you can also access directly (but they won't be updated during loops
where you don't call this function)
This function makes a number of assumptions and is a little brittle
right now. By not hard-coding the min_interval and maybe using key
presses and release events directly, we'd have a much better function.
But I don't really care right now.
DJC
"""
raise DeprecationWarning("please use pygame directly, as in" +
"StimController.Response")
# Note - this is deprecated anyway, but it'd probably make more sense to
# use the keyboard_controller.get_responses() to simply get the keys
# that are down _right_now_
press_time = self.keyboard_controller.get_time_last_response_since_go()
key = self.keyboard_controller.get_last_response_since_go()
# Our first response!
if len(self.keys) == 0:
if key:
self.keys.append(key)
self.presses.append(press_time)
self.releases.append(None)
if releases:
return (key, None)
else:
return (key, press_time)
else:
return (None, None)
# We haven't seen a key press for min_interval
if t >= press_time + min_interval and not self.releases[-1]:
# This is only approximate!
self.releases[-1] = t
if releases:
return (self.keys[-1], t)
else:
return (None, None)
# We've seen a release, or we see a new key
if (self.releases[-1] and press_time > self.releases[-1]) or \
key != self.keys[-1]:
if not self.releases[-1]:
self.releases[-1] = press_time
self.keys.append(key)
self.presses.append(press_time)
self.releases.append(None)
if releases:
return (key, None)
else:
return (key, press_time)
return (None, None)
def get_responses(self, timeToSubtract=0, min_interval=2.0/60):
"""
Use this function to post-process the results of a KeyboardController
VisionEgg's keyboard libraries records a keypress and timestamp every
time something is down. So if a key is held down for 100 ms, there will
be an entry in the keylist for every sample during that 100ms. This is
a bit much; I'd rather just save onsets and offsets for every key. This
function evaluates that.
"""
'''
If we're using the FORP, this isn't necessary, as events have no duration;
they are represented as instantaneous keypresses.
-- John
'''
response = self.keyboard_controller.get_responses_since_go()
responseTime = self.keyboard_controller.get_time_responses_since_go()
# If I've only got one item in my response list, then it's silly to worry about onset/offset. Just keep it.
if len(response) < 2:
return (response,responseTime)
# Save the first response, as by definition that's the first onset:
goodResp = [response[0]]
goodRespTime = [responseTime[0]-timeToSubtract]
# Now step through every other item in the response list to check for unique-ness.
for i in range(1,len(responseTime)):
if (not(response[i] == response[i-1]) or \
(responseTime[i] - responseTime[i-1] > \
min_interval)):
# ie, if something changed, or we have a long gap:
offsetResp = [] # we might want to save an offset
for item in response[i-1]: # loop through last item's data
if (responseTime[i] - responseTime[i-1] < \
min_interval) and \
not(item in response[i]):
# Bit clunky. Basically, holding down a key while pressing another creates
# a unique response. So if you only let up one of those keys, code the
# offset just for that key.
offsetResp.append(item+'_Off')
else:
# it's been long enough that everything that was on should be called off.
offsetResp.append(item+'_Off')
if len(offsetResp) > 0:
# If there's offset stuff to worry about, save it.
goodResp.append(offsetResp)
goodRespTime.append(responseTime[i-1]-timeToSubtract)
# Save the new (onset) response.
goodResp.append(response[i])
goodRespTime.append(responseTime[i]-timeToSubtract)
# The final event should be an offset for whatever was down.
offsetResp = []
for item in response[-1]:
offsetResp.append(item+'_Off')
goodResp.append(offsetResp) #goodResp.append(response[-1]+'_Off')
goodRespTime.append(responseTime[-1]-timeToSubtract)
return (goodResp, goodRespTime)
color2 = (1.0, 0.5, 0.1), # RGB (alpha ignored if given)
contrast = 0.2,
pedestal = 0.1,
mask = mask, # optional
position = ( screen.size[0]/2.0, screen.size[1]/2.0 ),
anchor = 'center',
size = ( 300.0 , 300.0 ),
spatial_freq = 20.0 / screen.size[0], # units of cycles/pixel
temporal_freq_hz = 1.0,
orientation = 270.0 )
def pedestal_func(t):
# Calculate pedestal over time. (Pedestal range [0.1,0.9] and
# contrast = 0.2 limits total range to [0.0,1.0])
temporal_freq_hz = 0.2
return 0.4 * sin(t*2*pi * temporal_freq_hz) + 0.5
###############################################################
# Create viewport - intermediary between stimuli and screen #
###############################################################
viewport = Viewport( screen=screen, stimuli=[stimulus] )
########################################
# Create presentation object and go! #
########################################
p = Presentation(go_duration=(10.0,'seconds'),viewports=[viewport])
p.add_controller(stimulus,'pedestal',FunctionController(during_go_func=pedestal_func))
p.go()
VisionEgg.start_default_logging() VisionEgg.watch_exceptions() from VisionEgg.Core import * from VisionEgg.FlowControl import Presentation from VisionEgg.Gratings import * from VisionEgg.PyroHelpers import * pyro_server = PyroServer() # get visionegg stimulus ready to go screen = get_default_screen() stimulus = SinGrating2D(temporal_freq_hz=0.0) viewport = Viewport(screen=screen, stimuli=[stimulus]) p = Presentation(go_duration=(5.0, 'seconds'), viewports=[viewport]) # make a controller, serve it via pyro, and glue it to the Presentation tf_controller = PyroConstantController(during_go_value=0.0) pyro_server.connect(tf_controller, 'tf_controller') p.add_controller(stimulus, 'temporal_freq_hz', tf_controller) quit_controller = PyroConstantController(during_go_value=0) pyro_server.connect(quit_controller, 'quit_controller') p.add_controller(p, 'quit', quit_controller) # get listener controller and register it p.add_controller(None, None, pyro_server.create_listener_controller()) # initialize graphics to between presentations state p.run_forever()
viewport = Viewport(
screen=screen,
stimuli=[static_checkerboard, dynamic_checkerboard, fixation_spot])
p = Presentation(go_duration=(dynamic_time + static_time, 'seconds'),
viewports=[viewport])
# Use a controller to hook into go loop, but control texture buffer
# through direct manipulation.
dynamic_texture_object = dynamic_checkerboard.parameters.texture.get_texture_object(
)
width, height = dynamic_checkerboard_size
# (Note: numpy arrays have indices flipped from images, thus the re-ordering)
flipped_shape = (height, width)
def control_dynamic(t):
if t <= dynamic_time:
random_data = numpy.random.randint(
0,
2,
size=(dynamic_checkerboard_size[1],
dynamic_checkerboard_size[0])) * 255
dynamic_texture_object.put_sub_image(random_data)
p.add_controller(None, None,
FunctionController(during_go_func=control_dynamic))
p.go()
drum = SpinningDrum(texture=texture, shrink_texture_ok=1)
fixation_spot = FixationSpot(position=(screen.size[0] / 2, screen.size[1] / 2),
anchor='center')
perspective = SimplePerspectiveProjection(fov_x=90.0)
perspective_viewport = Viewport(screen=screen,
projection=perspective,
stimuli=[drum])
flat_viewport = Viewport(screen=screen, stimuli=[fixation_spot])
p = Presentation(viewports=[perspective_viewport, flat_viewport])
gui_window = DrumGui(idle_func=p.between_presentations)
p.add_controller(
fixation_spot, 'on',
FunctionController(during_go_func=lambda t: gui_window.fixation_spot.get(),
eval_frequency=Controller.TRANSITIONS))
p.add_controller(
p, 'go_duration',
FunctionController(during_go_func=lambda t:
(gui_window.duration.get(), 'seconds'),
eval_frequency=Controller.TRANSITIONS))
p.add_controller(
drum, 'angular_position',
FunctionController(during_go_func=gui_window.positionFunction))
p.add_controller(
drum, 'contrast',
FunctionController(during_go_func=gui_window.contrastFunction))
gui_window.mainloop()
anchor='center',
position=(screen.size[0] / 2, screen.size[1] / 2),
)
cur_time = Text(
text="",
font_size=15,
color=(.75, .75, .75),
anchor='lowerleft',
position=(0, 0),
)
viewport_instructions = Viewport(screen=screen,
stimuli=[instructions, cur_time])
p1 = Presentation(go_duration=('forever', ), viewports=[viewport_instructions])
p1.add_controller(None, None, FunctionController(during_go_func=displayTime))
p1.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, waitForTrigger)
]
# setup main experimental loop
loadStims = 0
wrote_response = 0
stimulus = TextureStimulus(
anchor='center',
size=stimuli_size,
position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
texture_min_filter=gl.GL_LINEAR,
shrink_texture_ok=1,
# PW 2012/11/26
mipmaps_enabled=False)
class TRStimController:
"""This is a relatively simple controller that simply updates what's on the
screen every TR (which is the next occurrence of keyboard input of '5' after
the TR length is exceeded. Currently it sets one stimulus on, and all
others off, though we may want to change that to turn a list of stimuli on
eventually"""
# 3T laptop forp sends TTL pulses as "5"; buttons as "1","2","3","4"
# John used to do things this way:
# trigger_in_controller = KeyboardTriggerInController(pygame.locals.K_5)
# Expected length of 1 TR
TR = 2.0
# Time interval after which we assume we missed the trigger
eps = 0.1
t = 0
trial_times = None
missed_trigs = None
stim_list = []
stim_dict = {}
stim_seq = []
keyboard_controller = None
presentation = None
screen = None
def __init__(self, TR=None, eps=None):
# Get the initial setup
if TR:
self.TR = TR
if eps:
self.eps = eps
self.trial_times = []
self.missed_trigs = []
self.state = self.state_generator()
self.screen = get_default_screen()
# background black (RGBA)
self.screen.parameters.bgcolor = (0.0,0.0,0.0,0.0)
self.keyboard_controller = KeyboardResponseController()
self.firstTTL_trigger = KeyboardTriggerInController(K_5)
def set_stims(self, stim_list, stim_dict, stim_seq_file):
self.stim_list = stim_list
self.stim_dict = stim_dict
self.stim_seq = yaml.load(stim_seq_file)
viewport = Viewport(screen=self.screen,
size=self.screen.size,
stimuli=self.stim_list)
# Need to at least wait for the first trigger if this is going to work.
go_duration = (self.TR * len(self.stim_seq), 'seconds')
self.presentation = Presentation(go_duration=go_duration,
trigger_go_if_armed=0,
viewports=[viewport])
self.presentation.add_controller(None, None,
FunctionController(during_go_func=self.update) )
self.presentation.add_controller(None, None, self.keyboard_controller)
# Adding this so that we can start the stimuli ahead of time
self.presentation.add_controller(self.presentation,'trigger_go_if_armed',
self.firstTTL_trigger)
def run(self):
self.presentation.go()
self.screen.close()
def update(self, t):
self.t = t
try:
self.state.next()
except StopIteration:
# shouldn't really happen, what with epsilon and all...
self.blank_all_stims()
def blank_all_stims(self):
for stim in self.stim_list:
stim.parameters.on=False
def state_generator(self):
for stim_info in self.stim_seq:
self.trial_times.append(self.t)
self.blank_all_stims()
try:
for stim_name, params in stim_info.items():
stim = self.stim_dict[stim_name]
stim.parameters.on = True
try:
for name, value in params.items():
setattr(stim.parameters, name, value)
except AttributeError:
# params was None or something else we don't deal with
pass
except AttributeError:
# We assume a no-colon single token / key
self.stim_dict[stim_info].parameters.on = True
# Don't even bother 'til we're close to the expected TR time
while self.t - self.trial_times[-1] < self.TR - 2*self.eps:
yield
while self.t - self.trial_times[-1] < self.TR + self.eps:
# Handle the rare case when a key might register between
# function calls - THIS WOULD NEVER HAPPEN WITH VisionEgg as
# written!
while True:
keys = self.keyboard_controller.get_responses_since_go()
times = \
self.keyboard_controller.get_time_responses_since_go()
if len(keys) == len(times):
break
i = None
try:
# Find the last value of '5' without inline reversal of keys/times
# VisionEgg returns "responses" as a list of lists of chars, not just a list of chars...
i = len(keys)-1-list(reversed(keys)).index(['5'])
except ValueError:
pass
# If anybody presses the escape key, quit entirely.
try:
needToQuit = keys.index(['escape'])
#self.presentation = None
#exit()
except ValueError:
pass
if i and times[i] > self.trial_times[-1]:
break
else:
yield
if self.t - self.trial_times[-1] >= self.TR + self.eps:
# We missed a TR (we think)
self.missed_trigs.append(self.t)
self.t = self.trial_times[-1] + self.TR
def get_responses(self, timeToSubtract=0, min_interval=2.0/60):
"""
This function isn't especially elegant, but it's functional.
VisionEgg's keyboard libraries records a keypress and timestamp every
time something is down. So if a key is held down for 100 ms, there will
be an entry in the keylist for every sample during that 100ms. This is
a bit much; I'd rather just save onsets and offsets for every key. This
function evaluates that.
"""
'''
If we're using the FORP, this isn't necessary, as events have no duration;
they are represented as instantaneous keypresses.
-- John
'''
response = self.keyboard_controller.get_responses_since_go()
responseTime = self.keyboard_controller.get_time_responses_since_go()
# If I've only got one item in my response list, then it's silly to worry about onset/offset. Just keep it.
if len(response) < 2:
return (response,responseTime)
# Save the first response, as by definition that's the first onset:
goodResp = [response[0]]
goodRespTime = [responseTime[0]-timeToSubtract]
# Now step through every other item in the response list to check for unique-ness.
for i in range(1,len(responseTime)):
if (not(response[i] == response[i-1]) or \
(responseTime[i] - responseTime[i-1] > \
min_interval)):
# ie, if something changed, or we have a long gap:
offsetResp = [] # we might want to save an offset
for item in response[i-1]: # loop through last item's data
if (responseTime[i] - responseTime[i-1] < \
min_interval) and \
not(item in response[i]):
# Bit clunky. Basically, holding down a key while pressing another creates
# a unique response. So if you only let up one of those keys, code the
# offset just for that key.
offsetResp.append(item+'_Off')
else:
# it's been long enough that everything that was on should be called off.
offsetResp.append(item+'_Off')
if len(offsetResp) > 0:
# If there's offset stuff to worry about, save it.
goodResp.append(offsetResp)
goodRespTime.append(responseTime[i-1]-timeToSubtract)
# Save the new (onset) response.
goodResp.append(response[i])
goodRespTime.append(responseTime[i]-timeToSubtract)
# The final event should be an offset for whatever was down.
offsetResp = []
for item in response[-1]:
offsetResp.append(item+'_Off')
goodResp.append(offsetResp) #goodResp.append(response[-1]+'_Off')
goodRespTime.append(responseTime[-1]-timeToSubtract)
return (goodResp, goodRespTime)
p3 = Presentation(go_duration=(blankTime, 'seconds'), viewports=[fixCross])
p3.go()
p = Presentation(go_duration=('forever', ), viewports=[vr])
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, key_handler)
]
p.go()
subject.inputData(trial, "RT", RT)
subject.inputData(trial, "ACC", ACC)
#BLOCK 2 - STRATEGY SELECTION
p2 = Presentation(go_duration=('forever', ), viewports=[stratPort])
p2.add_controller(
None, None,
FunctionController(during_go_func=strategy_controller,
temporal_variables=FRAMES_ABSOLUTE))
p2.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN,
key_handler)]
p2.go()
#BLOCK 3 - BLANK SCREEN
p3 = Presentation(go_duration=(0.5, 'seconds'), viewports=[fixCross])
p3.go()
subject.inputData(trial, "ACC", ACC)
subject.inputData(trial, "strategy", strategy)
ns.sort()
lastns = copy.deepcopy(ns)
lastlastns = copy.deepcopy(lastns)
from VisionEgg.Core import *
from VisionEgg.FlowControl import Presentation, FunctionController
from VisionEgg.Textures import *
import math, os
max_speed = 100.0 # degrees per second
def angle_as_function_of_time(t):
return max_speed*math.cos(t)
def contrast_as_function_of_time(t):
return abs(math.cos(2*math.pi*t*0.2))
filename = os.path.join(config.VISIONEGG_SYSTEM_DIR,"data","panorama.jpg")
texture = Texture(filename)
screen = get_default_screen()
projection = SimplePerspectiveProjection(fov_x=90.0)
stimulus = SpinningDrum(texture=texture,shrink_texture_ok=1)
viewport = Viewport(screen=screen,
size=screen.size,
projection=projection,
stimuli=[stimulus])
p = Presentation(go_duration=(10.0,'seconds'),viewports=[viewport])
p.add_controller(stimulus,'angular_position', FunctionController(during_go_func=angle_as_function_of_time))
p.add_controller(stimulus,'contrast', FunctionController(during_go_func=contrast_as_function_of_time))
p.go()
def aplicacion():
global p, inten, coord
pos = [0.4, 0.5, 0.6, 0.7, 0.8]
pos2 = [1.3, 1.4, 1.5, 1.6, 1.7, 1.8]
rellenar()
shuffle(coord)
i = len(coord) - 1
target.parameters.position = coord[i][:2]
(xpos, ypos) = target.parameters.position
x = xpos - screen.size[0] / 2
y = ypos - screen.size[1] / 2
anrad = math.atan2(y, x)
angrad = math.degrees(anrad)
if angrad >= 0:
if angrad <= 90:
orientacion = -45
xx = 2.0
yy = 2.0
else:
orientacion = -135
xx = -2.0
yy = 2.0
else:
aux = angrad * (-1)
if aux <= 90:
orientacion = 45
xx = 2.0
yy = -2.0
else:
orientacion = 135
xx = -2.0
yy = -2.0
fixpoint.parameters.position = ((screen.size[0] / 2.0) + xx,
(screen.size[1] / 2.0) + yy)
fixpoint.parameters.orientation = orientacion
viewport = Viewport(screen=screen, stimuli=[fixpoint, fixcirc])
p = Presentation(go_duration=(1.0, 'seconds'), viewports=[viewport])
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, keydown),
(pygame.locals.KEYUP, keyup),
(pygame.locals.QUIT, quit_app)]
p.add_controller(None, None, FunctionController(during_go_func=settings))
#winsound.PlaySound('instruccion',winsound.SND_FILENAME)
p.go()
while len(coord) != 0:
if end:
break
i = len(coord) - 1
target.parameters.position = coord[i][:2]
dur = pos[random.randrange(0, 4, 1)]
(xpos, ypos) = target.parameters.position
x = xpos - screen.size[0] / 2
y = ypos - screen.size[1] / 2
anrad = math.atan2(y, x)
angrad = math.degrees(anrad)
#fixpoint.parameters.orientation=(-angrad)
if angrad >= 0:
if angrad <= 90:
orientacion = -45
xx = 2.0
yy = 2.0
else:
orientacion = -135
xx = -2.0
yy = 2.0
else:
aux = angrad * (-1)
if aux <= 90:
orientacion = 45
xx = 2.0
yy = -2.0
else:
orientacion = 135
xx = -2.0
yy = -2.0
fixpoint.parameters.position = ((screen.size[0] / 2.0) + xx,
(screen.size[1] / 2.0) + yy)
fixpoint.parameters.orientation = orientacion
viewport = Viewport(screen=screen, stimuli=[fixpoint, fixcirc])
p = Presentation(go_duration=(dur, 'seconds'), viewports=[viewport])
p.parameters.handle_event_callbacks = [(pygame.locals.QUIT, quit_app)]
p.add_controller(None, None,
FunctionController(during_go_func=settings))
p.go()
inten = coord[i][-1]
target.parameters.color = (
1.0, 1.0, 1.0, inten
) #Se muestra el estimulo Duracion 0.3 segundos
viewport = Viewport(screen=screen, stimuli=[target, fixpoint, fixcirc])
p = Presentation(go_duration=(0.3, 'seconds'), viewports=[viewport])
p.parameters.handle_event_callbacks = [(pygame.locals.QUIT, quit_app)]
p.add_controller(None, None,
FunctionController(during_go_func=settings))
p.go()
target.parameters.color = (
0.0, 0.0, 0.0, 1.0) #Desaparece el estimulo tiempo para registrar
viewport = Viewport(screen=screen, stimuli=[target, fixpoint, fixcirc])
dur2 = pos[random.randrange(0, 4, 1)]
p = Presentation(go_duration=(dur2, 'seconds'), viewports=[viewport])
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN,
keydown),
(pygame.locals.KEYUP, keyup),
(pygame.locals.QUIT, quit_app)]
p.add_controller(None, None,
FunctionController(during_go_func=settings))
p.go()
coord.pop()
import VisionEgg VisionEgg.start_default_logging(); VisionEgg.watch_exceptions() from VisionEgg.Core import * from VisionEgg.FlowControl import Presentation from VisionEgg.Gratings import * from VisionEgg.PyroHelpers import * pyro_server = PyroServer() # get visionegg stimulus ready to go screen = get_default_screen() stimulus = SinGrating2D(temporal_freq_hz=0.0) viewport = Viewport(screen=screen,stimuli=[stimulus]) p = Presentation(go_duration=(5.0,'seconds'),viewports=[viewport]) # make a controller, serve it via pyro, and glue it to the Presentation tf_controller = PyroConstantController(during_go_value=0.0) pyro_server.connect(tf_controller,'tf_controller') p.add_controller(stimulus,'temporal_freq_hz', tf_controller) quit_controller = PyroConstantController(during_go_value=0) pyro_server.connect(quit_controller,'quit_controller') p.add_controller(p,'quit', quit_controller) # get listener controller and register it p.add_controller(None,None, pyro_server.create_listener_controller()) # initialize graphics to between presentations state p.run_forever()
anchor = 'center',
position = (screen.size[0]/2, screen.size[1]/2),
)
cur_time = Text(
text = "",
font_size = 15,
color = (.75,.75,.75),
anchor = 'lowerleft',
position = (0,0),
)
viewport_instructions = Viewport( screen=screen, stimuli = [ instructions, cur_time ] )
p1 = Presentation(go_duration=('forever',), viewports=[viewport_instructions])
p1.add_controller(None,None,FunctionController(during_go_func=displayTime))
p1.parameters.handle_event_callbacks = [ (pygame.locals.KEYDOWN, waitForTrigger) ]
# setup main experimental loop
loadStims = 0
wrote_response = 0
stimulus = TextureStimulus(
anchor = 'center',
size = stimuli_size,
position = (screen.size[0]/2.0, screen.size[1]/2.0),
texture_min_filter = gl.GL_LINEAR,
shrink_texture_ok = 1,
# PW 2012/11/26
mipmaps_enabled = False
)
stimulus_on_controller = ConstantController(during_go_value=1,
between_go_value=0)
stimulus_off_controller = ConstantController(during_go_value=0,
between_go_value=1)
left_choice_controller = FunctionController(during_go_func=replaceLeftText)
right_choice_controller = FunctionController(during_go_func=replaceRightText)
left_choice2_controller = FunctionController(during_go_func=replaceLeftText2)
right_choice2_controller = FunctionController(during_go_func=replaceRightText2)
state_controller = FunctionController(during_go_func=getState)
fixation_controller = FunctionController(during_go_func=controlFix,
between_go_func=hideStim)
newset_controller = FunctionController(during_go_func=showNewSet,
between_go_func=hideStim)
taskend_controller = FunctionController(during_go_func=showTaskEnd)
p.add_controller(p, 'trigger_go_if_armed', trigger_in_controller)
p.add_controller(title, 'on', stimulus_off_controller)
p.add_controller(title2, 'on', stimulus_off_controller)
p.add_controller(left_choice, 'on', stimulus_on_controller)
p.add_controller(right_choice, 'on', stimulus_on_controller)
p.add_controller(left_choice2, 'on', stimulus_on_controller)
p.add_controller(right_choice2, 'on', stimulus_on_controller)
p.add_controller(left_choice, 'text', left_choice_controller)
p.add_controller(left_choice2, 'text', left_choice2_controller)
p.add_controller(right_choice, 'text', right_choice_controller)
p.add_controller(right_choice2, 'text', right_choice2_controller)
p.add_controller(fixation, 'on', fixation_controller)
p.add_controller(newset, 'on', newset_controller)
p.add_controller(taskend, 'on', taskend_controller)
p.add_controller(p, 'trigger_go_if_armed', state_controller)
))
other_text = []
other_text.append(
Text(
text='Pixel positions (x,y) calculated from 3D coordinates',
position=(screen.size[0] / 2, screen.size[1]),
anchor='top',
))
other_text.append(Text(
text='----> x',
position=(10, 10),
anchor='left',
))
other_text.append(
Text(
text='----> y',
angle=90.0,
position=(10, 10),
anchor='left',
))
viewport2D.parameters.stimuli = vertex_labels + other_text
p = Presentation(go_duration=(10.0, 'seconds'),
viewports=[viewport3D, viewport2D])
p.add_controller(None, None, FunctionController(during_go_func=update))
p.go()
from VisionEgg.Gratings import *
import VisionEgg.Daq
from VisionEgg.DaqLPT import *
# Normal stuff (from grating demo):
screen = get_default_screen()
stimulus = SinGrating2D(on = 1, # turn grating is off when not in go loop
position = ( screen.size[0]/2.0, screen.size[1]/2.0 ),
anchor = 'center',
size = ( 300.0 , 300.0 ),
spatial_freq = 10.0 / screen.size[0],
temporal_freq_hz = 5.0,
orientation = 45.0 )
viewport = Viewport( screen=screen, stimuli=[stimulus] )
p = Presentation(go_duration=(5.0,'seconds'),
trigger_go_if_armed=0, # wait for trigger
viewports=[viewport])
# Stimulus on controller
stimulus_on_controller = ConstantController(during_go_value=0,between_go_value=1)
# Create a trigger input controller
trigger_in_controller = LPTTriggerInController()
# Add the trigger output controller to the presentation's list of controllers
p.add_controller(stimulus,'on',stimulus_on_controller)
p.add_controller(p,'trigger_go_if_armed',trigger_in_controller)
# Go!
p.go()
projection2 = SimplePerspectiveProjection(fov_x=55.0,
aspect_ratio=(float(mid_x)/screen.size[1]))
camera_matrix = ModelView() # Parameters set in realtime, so no need to specify here
# Get a texture
filename = os.path.join(config.VISIONEGG_SYSTEM_DIR,"data","panorama.jpg")
texture = Texture(filename)
stimulus = SpinningDrum(texture=texture,shrink_texture_ok=1)
viewport1 = Viewport(screen=screen,
position=(0,0),
anchor='lowerleft',
size=(mid_x,screen.size[1]),
projection=projection1,
stimuli=[stimulus])
viewport2 = Viewport(screen=screen,
position=(mid_x,0),
anchor='lowerleft',
size=(mid_x,screen.size[1]),
projection=projection2,
camera_matrix=camera_matrix,
stimuli=[stimulus])
p = Presentation(go_duration=(10.0,'seconds'),viewports=[viewport1,viewport2])
p.add_controller(stimulus,'angular_position', FunctionController(during_go_func=angle_as_function_of_time))
p.add_controller(camera_matrix,'matrix', FunctionController(during_go_func=cam_matrix_f))
p.go()
print "----------------------"
print "PROBLEM: %s" % problem
print "SOLUTION: %s " % solution
print "----------------------"
ns = [n1, n2]
#default values for misfiring voice key
misfire = 0
ACC = 1
#BLOCK 1 - Problem & RESPONSE
p = Presentation(go_duration=('forever', ), viewports=[expPort])
p.add_controller(
None, None,
FunctionController(during_go_func=problem_controller,
temporal_variables=FRAMES_ABSOLUTE))
p.go()
#BLOCK 2 - STRATEGY SELECTION & GRADING
p2 = Presentation(go_duration=(1.5, 'seconds'), viewports=[fixCross])
p2.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN,
key_handler)]
p2.go()
if ACC == 0:
problemQ = [n1, n2, stim]
error = Presentation(go_duration=(1, 'seconds'), viewports=[errorPort])
error.go()
else:
problemQ = []
"""Use frame information to display stimuli."""
import VisionEgg
VisionEgg.start_default_logging(); VisionEgg.watch_exceptions()
from VisionEgg.Core import get_default_screen, Viewport
from VisionEgg.FlowControl import Presentation, FunctionController, FRAMES_ABSOLUTE
from VisionEgg.Text import Text
screen = get_default_screen()
screen.parameters.bgcolor = (0.0,0.0,1.0) # background blue (RGB)
textvar = Text(color=(1.0,1.0,1.0), # alpha is ignored (set with max_alpha_param)
position=(screen.size[0]/4,screen.size[1]/2),
font_size=50,
anchor='left')
def text_func(f_abs):
return "framecount: % 4d"%f_abs
t_controller = FunctionController(during_go_func=text_func,
temporal_variables = FRAMES_ABSOLUTE)
viewport = Viewport(screen=screen,
size=screen.size,
stimuli=[textvar])
p = Presentation(go_duration=(5.0,'seconds'),viewports=[viewport])
p.add_controller(textvar,'text',t_controller)
p.go()
sub.inputData(trial, "blueButton", blueB)
print color
if block == "overlapping":
phase = ""
fname = "%s_%s_%s_%s_%s_OL.bmp" % (ratio, n1, color, size,
exemplar)
t = Texture(Image.open(os.path.join(stimLib, fname)))
s = TextureStimulus(texture=t, position=(x, y), anchor='center')
texture_object = s.parameters.texture.get_texture_object()
v = Viewport(screen=screen, stimuli=[s])
p = Presentation(go_duration=('forever', ), viewports=[v])
p.add_controller(
None, None,
FunctionController(during_go_func=put_image_overlapping,
temporal_variables=TIME_SEC_ABSOLUTE))
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN,
keyFunc)]
p.go()
else:
if side == "large":
fname1 = "%s_%s_%s_%s_%s_S2.bmp" % (ratio, n1, color, size,
exemplar)
fname2 = "%s_%s_%s_%s_%s_S1.bmp" % (ratio, n1, color, size,
exemplar)
else:
fname1 = "%s_%s_%s_%s_%s_S1.bmp" % (ratio, n1, color, size,
exemplar)
fname2 = "%s_%s_%s_%s_%s_S2.bmp" % (ratio, n1, color, size,
class Stimulation:
global TopRate, BotRate, LeftRate, RightRate, HSize, VSize
global numTrial, order_appear
global duration_init, duration_cue, duration_target, duration_trial, total_time
# Set up stimulus's frequency
TopRate = 5 # Hz
BotRate = 10
LeftRate = 15
RightRate = 20
# Set dimension of the targets
HSize = 100
VSize = 50
# Experiment parameters
numTrial = 4
order_appear = np.uint16(4*np.random.random(numTrial)+1)
duration_init = 2
duration_target = 3
duration_cue = 2
duration_trial = duration_target + duration_cue
total_time = duration_init + duration_trial*numTrial
def __init__(self):
global w, h
self._running = True
# Initialize screen
# TODO
# Set fullscreen
self.screen = get_default_screen()
# Get dimension of the screen
w = self.screen.size[0]
h = self.screen.size[1]
# Initialize Targets
self.TopTarget = Target2D()
self.BotTarget = Target2D()
self.LeftTarget = Target2D()
self.RightTarget = Target2D()
# Message
self.mess = Text(text='Please wait for next trial...',
color=(1.0, 0.5, 0.5),
position=(w/2, h*0.8),
font_size=50,
anchor='center',
on=True)
# Arrows
self.arrow = TextureStimulus()
# Viewports to stick graphical objects to screen
self.viewport1 = Viewport(screen=self.screen,
stimuli=[self.TopTarget, self.BotTarget, self.LeftTarget, self.RightTarget]) # For Targets
self.viewport2 = Viewport(screen=self.screen,
stimuli=[self.arrow]) # For cue (and other things)
self.viewport3 = Viewport(screen=self.screen,
stimuli=[self.mess]) # For cue (and other things)
# Presentations (for controlling timing)
self.initialize = Presentation(go_duration=(duration_init, 'seconds'), viewports=[self.viewport3])
self.targetShow = Presentation(go_duration=(duration_target, 'seconds'), viewports=[self.viewport1])
self.cueShow = Presentation(go_duration=(duration_cue, 'seconds'), viewports=[self.viewport2])
# For result
self.TargetLog = np.zeros((numTrial, 2)) # First column: target code,
def on_init(self):
# Set screen's background color
self.screen.set(bgcolor=(0., 0., 0.)) # black
# Set target's properties
self.TopTarget.set(size=(HSize, VSize),
color= (1.0, 1.0, 1.0, 1.0),
position=(w/2, h*0.8))
self.BotTarget.set(size=(HSize, VSize),
color=(1.0, 1.0, 1.0, 1.0),
position=(w/2, h*0.2))
self.LeftTarget.set(size=(VSize, HSize),
color=(1.0, 1.0, 1.0, 1.0),
position=(w*0.2, h/2))
self.RightTarget.set(size=(VSize, HSize),
color=(1.0, 1.0, 1.0, 1.0),
position=(w*0.8, h/2))
# Message
# self.text.set(text='Please wait for next trial...',
# color=(1.0, 0.5, 0.5),
# position=(w/2, h*0.8),
# font_size=50,
# anchor='center',
# on=False)
# Arrows
self.arrow.set(texture=Texture('images\left2.bmp'),
position=(w/2, h/2),
anchor='center',
on=False)
# Show initializing message
self.initialize.add_controller(self.mess, 'text', FunctionController(during_go_func=self.showMess))
# Set control's parameters and corresponding function. Controlling targers
self.targetShow.add_controller(self.TopTarget, 'on', FunctionController(during_go_func=self.topFlick))
self.targetShow.add_controller(self.BotTarget, 'on', FunctionController(during_go_func=self.botFlick))
self.targetShow.add_controller(self.LeftTarget, 'on', FunctionController(during_go_func=self.leftFlick))
self.targetShow.add_controller(self.RightTarget, 'on', FunctionController(during_go_func=self.rightFlick))
# Controlling others
# self.p2.add_controller(self.text, 'on', FunctionController(during_go_func=self.appear))
self.cueShow.add_controller(self.arrow, 'on', FunctionController(during_go_func=self.arrow_appear))
self.cueShow.add_controller(self.arrow, 'texture', FunctionController(during_go_func=self.random_cue))
def on_execute(self):
if self.on_init() == False:
self._running = False
# Prompting
self.initialize.go()
# Experiment goes..
for i in range(0,numTrial):
self.cueShow.go()
self.targetShow.go()
self.on_writing()
# TODO
# Maybe we need a method for closing the program
#################################################
# Controlling methods: Flickering #
#################################################
def topFlick(self,t):
return int(t*TopRate*2.0) % 2
def botFlick(self,t):
return int(t*BotRate*2.0) % 2
def leftFlick(self,t):
return int(t*LeftRate*2.0) % 2
def rightFlick(self,t):
return int(t*RightRate*2.0) % 2
def arrow_appear(self, t):
flag = True
if flag:
#self.writedata(t, 1)
flag = False
if self.targetShow.is_in_go_loop():
return False
else:
return True
def random_cue(self,t):
start_time = self.cueShow.last_go_loop_start_time_absolute_sec
# TODO
# Add try catch to handle errors regarding start_time's type problem
# TODO
# Add event so that the transition processes only taken place once
if not isinstance(start_time, type(None)):
i = int((start_time-duration_init)/duration_trial) # eliminate initializing duration factor
cur_target = order_appear[i] # current target
self.TargetLog[i, :] = np.array([cur_target, start_time]) # return real time
if cur_target == 1:
return Texture('images/up2.bmp')
elif cur_target == 2:
return Texture('images/left2.bmp')
elif cur_target == 3:
return Texture('images/right2.bmp')
elif cur_target == 4:
return Texture('images/down2.bmp')
else:
return Texture('images/left2.bmp') # Just return something, add_controller need it
def showMess(self, t):
return 'Ready ...'
#################################################
# Writing data methods #
#################################################
def on_writing(self):
# Open file for writing data
file = open("Recordingfile.txt", "w")
for i in range(self.TargetLog.shape[0]):
target = self.TargetLog[i, 0]
time = self.TargetLog[i, 1]
line = str(target) + '\t' + str(time) + '\n'
file.write(line)
right_label_controller = FunctionController(during_go_func=myRightLabel)
left_label_controller = FunctionController(during_go_func=myLeftLabel)
task_controller = FunctionController(during_go_func=myFixation)
arrow_direction_controller = FunctionController( \
during_go_func=get_arrow_direction)
arrow_position_controller = FunctionController( \
during_go_func=get_arrow_position)
arrow_color_controller = FunctionController(during_go_func=get_arrow_color)
myArrowOnControl = FunctionController(during_go_func=myArrowOn)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
# Actually listens to the TCP socket
if TCPIP: p.add_controller(None, None, tcp_listener)
p.add_controller(p,'trigger_go_if_armed',trigger_in_controller)
p.add_controller(textAA,'on', stimulus_off_controller )
#p.add_controller(textA,'on', stimulus_off_controller )
#p.add_controller(textB,'on', stimulus_off_controller )
#p.add_controller(textC,'on', stimulus_off_controller )
#p.add_controller(textD,'on', stimulus_off_controller )
p.add_controller(taskStimulus,'on', stimulus_on_controller)
p.add_controller(centerStim,'on', stimulus_on_controller)
p.add_controller(taskStimulus,'text', task_controller)
p.add_controller(p, 'trigger_go_if_armed', state_controller)
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, keydown)]
#######################
# Run the stimulus! #
import math, os
max_speed = 100.0 # degrees per second
def angle_as_function_of_time(t):
return max_speed * math.cos(t)
def contrast_as_function_of_time(t):
return abs(math.cos(2 * math.pi * t * 0.2))
filename = os.path.join(config.VISIONEGG_SYSTEM_DIR, "data", "panorama.jpg")
texture = Texture(filename)
screen = get_default_screen()
projection = SimplePerspectiveProjection(fov_x=90.0)
stimulus = SpinningDrum(texture=texture, shrink_texture_ok=1)
viewport = Viewport(screen=screen,
size=screen.size,
projection=projection,
stimuli=[stimulus])
p = Presentation(go_duration=(10.0, 'seconds'), viewports=[viewport])
p.add_controller(stimulus, 'angular_position',
FunctionController(during_go_func=angle_as_function_of_time))
p.add_controller(
stimulus, 'contrast',
FunctionController(during_go_func=contrast_as_function_of_time))
p.go()
viewport = Viewport(screen=screen, stimuli=[stimulus])
########################################
# Create presentation object and go! #
########################################
p = Presentation(go_duration=(5.0, 'seconds'), viewports=[viewport])
##############################################
# Connect the controller with the stimulus #
##############################################
keyboard_response = KeyboardResponseController()
# Add the keyboard controller to the presentation's list of controllers
p.add_controller(None, None, keyboard_response)
########
# Go #
########
for i in range(3):
p.go()
# Print responses collected during the presentation
# print "all =",keyboard_response.get_responses_since_go()
# print "all_time =",keyboard_response.get_time_responses_since_go()
print "first =", keyboard_response.get_first_response_since_go()
print "first_time=", keyboard_response.get_time_first_response_since_go()
# print "last =",keyboard_response.get_last_response_since_go()
# print "last_time =",keyboard_response.get_time_last_response_since_go()
import VisionEgg
VisionEgg.start_default_logging()
VisionEgg.watch_exceptions()
from VisionEgg.Core import *
from VisionEgg.FlowControl import Presentation
from VisionEgg.Gratings import *
import VisionEgg.Daq
from VisionEgg.DaqLPT import *
# Normal stuff (from grating demo):
screen = get_default_screen()
stimulus = SinGrating2D(
position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
anchor='center',
size=(300.0, 300.0),
spatial_freq=10.0 / screen.size[0], # units of cycles/pixel
temporal_freq_hz=5.0,
orientation=45.0)
viewport = Viewport(screen=screen, stimuli=[stimulus])
p = Presentation(go_duration=(5.0, 'seconds'), viewports=[viewport])
# Create a trigger output controller
trigger_out_controller = LPTTriggerOutController()
# Add the trigger output controller to the presentation's list of controllers
p.add_controller(None, None, trigger_out_controller)
# Go!
p.go()
tcp_name="go",
initial_controller=ConstantController(during_go_value=0)
)
# Create the instance SinGrating with appropriate parameters
stimulus = SinGrating2D(anchor='center')
# Create a viewport (with default pixel coordinate system)
# with stimulus
viewport = Viewport( screen=screen, stimuli=[stimulus] )
# Create an instance of the Presentation class
p = Presentation(viewports=[viewport],check_events=1)
# Register the controller functions, connecting them with the parameters they control
p.add_controller(None,None, tcp_listener) # Actually listens to the TCP socket
p.add_controller(stimulus,'on', on_controller)
p.add_controller(stimulus,'contrast', contrast_controller)
p.add_controller(stimulus,'position', center_controller)
p.add_controller(stimulus,'size', size_controller)
p.add_controller(stimulus,'spatial_freq', spatial_freq_controller)
p.add_controller(stimulus,'temporal_freq_hz', temporal_freq_controller)
p.add_controller(stimulus,'phase_at_t0', phase_controller)
p.add_controller(stimulus,'orientation', orientation_controller)
p.add_controller(stimulus,'num_samples', num_samples_controller)
p.add_controller(stimulus,'bit_depth', bit_depth_controller)
p.add_controller(p,'go_duration', go_duration_controller)
p.add_controller(p,'enter_go_loop', go_controller)
# Go!
p.run_forever()
texture_min_filter=gl.GL_NEAREST,
texture_mag_filter=gl.GL_NEAREST,
)
fixation_spot = FixationSpot(position=(screen.size[0]/2,screen.size[1]/2),
anchor='center',
color=(255,0,0,0),
size=(4,4))
viewport = Viewport(screen=screen,
stimuli=[static_checkerboard,
dynamic_checkerboard,
fixation_spot])
p = Presentation(go_duration=(dynamic_time+static_time,'seconds'),
viewports=[viewport])
# Use a controller to hook into go loop, but control texture buffer
# through direct manipulation.
dynamic_texture_object = dynamic_checkerboard.parameters.texture.get_texture_object()
width,height = dynamic_checkerboard_size
# (Note: numpy arrays have indices flipped from images, thus the re-ordering)
flipped_shape = (height,width)
def control_dynamic(t):
if t <= dynamic_time:
random_data = numpy.random.randint(0,2,size=(dynamic_checkerboard_size[1],dynamic_checkerboard_size[0]))*255
dynamic_texture_object.put_sub_image( random_data )
p.add_controller(None,None,FunctionController(during_go_func=control_dynamic))
p.go()
texture_object = stimulus.parameters.texture.get_texture_object()
def update_movie():
# While movie.play() decompresses the movie to pygame surface
# in a separate thread, this sends the data to OpenGL.
texture_object.put_sub_image(pygame_surface)
viewport = Viewport(screen=screen, stimuli=[stimulus, text])
p = Presentation(
go_duration=('forever', ),
viewports=[viewport],
handle_event_callbacks=[(pygame.locals.QUIT, quit),
(pygame.locals.KEYDOWN, keydown)],
)
p.add_controller(
None, None,
FunctionController(during_go_func=update_movie,
temporal_variables=TIME_INDEPENDENT))
movie.play()
#p.go()
import cProfile, pstats
cProfile.run('p.go()', 'mpeg_profile')
p = pstats.Stats('mpeg_profile')
p.sort_stats('cumulative')
p.print_stats()
# calculate a few variables we need
mid_x = screen.size[0] / 2.0
mid_y = screen.size[1] / 2.0
max_vel = min(screen.size[0], screen.size[1]) * 0.4
# define position as a function of time
def get_target_position(t):
global mid_x, mid_y, max_vel
return (
max_vel * sin(0.1 * 2.0 * pi * t) + mid_x, # x
max_vel * sin(0.1 * 2.0 * pi * t) + mid_y) # y
# Create an instance of the Controller class
target_position_controller = FunctionController(
during_go_func=get_target_position)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
p.add_controller(target, 'position', target_position_controller)
#######################
# Run the stimulus! #
#######################
p.go()
from VisionEgg.FlowControl import Presentation from VisionEgg.Gratings import * from VisionEgg.PyroHelpers import * pyro_server = PyroServer() # get visionegg stimulus ready to go screen = get_default_screen() stimulus = SinGrating2D() viewport = Viewport(screen=screen,stimuli=[stimulus]) p = Presentation(viewports=[viewport]) # make a controller, serve it via pyro, and glue it to the Presentation tf_controller = PyroConstantController(during_go_value=0.0) pyro_server.connect(tf_controller,'tf_controller') p.add_controller(stimulus,'temporal_freq_hz', tf_controller) sf_controller = PyroConstantController(during_go_value=0.0) pyro_server.connect(sf_controller,'sf_controller') p.add_controller(stimulus,'spatial_freq', sf_controller) contrast_controller = PyroConstantController(during_go_value=0.0) pyro_server.connect(contrast_controller,'contrast_controller') p.add_controller(stimulus,'contrast', contrast_controller) orient_controller = PyroConstantController(during_go_value=0.0) pyro_server.connect(orient_controller,'orient_controller') p.add_controller(stimulus,'orientation', orient_controller) duration_controller = PyroConstantController(during_go_value=(5.0,'seconds')) pyro_server.connect(duration_controller,'duration_controller')
mid_x = screen.size[0]/2.0
mid_y = screen.size[1]/2.0
max_vel = min(screen.size[0],screen.size[1]) * 0.4
# define target position as a function of time
def get_target_position(t):
global mid_x, mid_y, max_vel
return ( max_vel*sin(0.1*2.0*pi*t) + mid_x , # x
max_vel*sin(0.1*2.0*pi*t) + mid_y ) # y
def get_drum_angle(t):
return 10.0*t
# Create instances of the Controller class
target_position_controller = FunctionController(during_go_func=get_target_position)
drum_angle_controller = FunctionController(during_go_func=get_drum_angle)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
p.add_controller(target,'position', target_position_controller )
p.add_controller(drum,'angular_position', drum_angle_controller )
#######################
# Run the stimulus! #
#######################
p.go()
dot_controller = FunctionController(during_go_func=setDots) coherence_controller = FunctionController(during_go_func=setCoherence) direction_controller = FunctionController(during_go_func=setDirection) inst_controller = FunctionController(during_go_func=changeInstructions) inst_on_controller = FunctionController(during_go_func=setInstructions) inst3_on_controller = FunctionController(during_go_func=setTimeOn) inst3_position_controller = FunctionController(during_go_func=setTimePos) fixation_texture_controller = FunctionController(during_go_func=setFixationTexture) samplefix_controller = FunctionController(during_go_func=setSampleFix) state_controller = FunctionController(during_go_func=getState) ####################################################### # Connect the controllers with objects they control # ####################################################### p.add_controller(p,'trigger_go_if_armed',trigger_in_controller) # on or off before pres p.add_controller(str_instruct_1,'on', stimulus_off_controller) p.add_controller(str_instruct_2,'text', inst_controller) p.add_controller(str_instruct_2,'on', stimulus_on_controller) p.add_controller(str_instruct_2,'on', inst_on_controller) p.add_controller(dotStim,'on', stimulus_on_controller) p.add_controller(fixation,'on', stimulus_on_controller) # on or off during pres p.add_controller(fixation,'max_alpha', fixation_controller) p.add_controller(dotStim,'on', dot_controller) p.add_controller(dotStim,'signal_fraction', coherence_controller) p.add_controller(dotStim,'signal_direction_deg', direction_controller) p.add_controller(fixation,'texture', fixation_texture_controller)
)
cur_time = Text(
text="",
font_size=15,
color=(.75, .75, .75),
anchor='lowerleft',
position=(0, 0),
)
viewport_instructions = Viewport(screen=screen,
stimuli=[instructions, cur_time])
attend_face = Viewport(screen=screen, stimuli=[instructions_attendFACE])
attend_scene = Viewport(screen=screen, stimuli=[instructions_attendSCENE])
p1 = Presentation(go_duration=('forever', ), viewports=[viewport_instructions])
p1.add_controller(None, None, FunctionController(during_go_func=displayTime))
p1.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, waitForTrigger)
]
# setup main experimental loop
loadStims = 0
wrote_response = 0
stimulus = TextureStimulus(
anchor='center',
size=stimuli_size,
position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
texture_min_filter=gl.GL_LINEAR,
shrink_texture_ok=1,
# PW 2012/11/26
mipmaps_enabled=False)
def aplicacion():
global p,inten,coord
pos=[0.4,0.5,0.6,0.7,0.8]
pos2=[1.3,1.4,1.5,1.6,1.7,1.8]
rellenar()
shuffle(coord)
i = len(coord)-1
target.parameters.position = coord[i][:2]
(xpos,ypos)=target.parameters.position
x=xpos-screen.size[0]/2
y=ypos-screen.size[1]/2
anrad=math.atan2(y, x)
angrad=math.degrees(anrad)
if angrad>=0:
if angrad<=90:
orientacion=-45
xx=2.0
yy=2.0
else:
orientacion=-135
xx=-2.0
yy=2.0
else:
aux=angrad*(-1)
if aux<=90:
orientacion=45
xx=2.0
yy=-2.0
else:
orientacion=135
xx=-2.0
yy=-2.0
fixpoint.parameters.position=((screen.size[0]/2.0)+xx, (screen.size[1]/2.0)+yy)
fixpoint.parameters.orientation=orientacion
viewport = Viewport(screen=screen, stimuli=[fixpoint,fixcirc])
p = Presentation(go_duration=(1.0,'seconds'),viewports=[viewport])
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, keydown),
(pygame.locals.KEYUP, keyup),
(pygame.locals.QUIT, quit_app)]
p.add_controller(None, None, FunctionController(during_go_func=settings))
#winsound.PlaySound('instruccion',winsound.SND_FILENAME)
p.go()
while len(coord)!= 0:
if end:
break
i = len(coord)-1
target.parameters.position = coord[i][:2]
dur=pos[random.randrange(0,4,1)]
(xpos,ypos)=target.parameters.position
x=xpos-screen.size[0]/2
y=ypos-screen.size[1]/2
anrad=math.atan2(y, x)
angrad=math.degrees(anrad)
#fixpoint.parameters.orientation=(-angrad)
if angrad>=0:
if angrad<=90:
orientacion=-45
xx=2.0
yy=2.0
else:
orientacion=-135
xx=-2.0
yy=2.0
else:
aux=angrad*(-1)
if aux<=90:
orientacion=45
xx=2.0
yy=-2.0
else:
orientacion=135
xx=-2.0
yy=-2.0
fixpoint.parameters.position=((screen.size[0]/2.0)+xx, (screen.size[1]/2.0)+yy)
fixpoint.parameters.orientation=orientacion
viewport = Viewport(screen=screen, stimuli=[fixpoint,fixcirc])
p = Presentation(go_duration=(dur,'seconds'),viewports=[viewport])
p.parameters.handle_event_callbacks = [ (pygame.locals.QUIT, quit_app)]
p.add_controller(None, None, FunctionController(during_go_func=settings))
p.go()
inten = coord[i][-1]
target.parameters.color = (1.0,1.0,1.0,inten) #Se muestra el estimulo Duracion 0.3 segundos
viewport = Viewport(screen=screen, stimuli=[target,fixpoint,fixcirc])
p = Presentation(go_duration=(0.3,'seconds'),viewports=[viewport])
p.parameters.handle_event_callbacks = [ (pygame.locals.QUIT, quit_app)]
p.add_controller(None, None, FunctionController(during_go_func=settings))
p.go()
target.parameters.color = (0.0,0.0,0.0,1.0) #Desaparece el estimulo tiempo para registrar
viewport = Viewport(screen=screen, stimuli=[target,fixpoint,fixcirc])
dur2=pos[random.randrange(0,4,1)]
p = Presentation(go_duration=(dur2,'seconds'),viewports=[viewport])
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, keydown),
(pygame.locals.KEYUP, keyup),
(pygame.locals.QUIT, quit_app)]
p.add_controller(None, None, FunctionController(during_go_func=settings))
p.go()
coord.pop()
fname2 = "%s_%s_%s_%s_%s_S2.bmp" % (ratio, n1, color, size, exemplar)
####
t1 = Texture(Image.open(os.path.join(stimLib,fname1)))
t2 = Texture(Image.open(os.path.join(stimLib,fname2)))
phase = ""
s1 = TextureStimulus(texture = t1, position = (x, y), anchor = 'center')
s2 = TextureStimulus(texture = t2, position = (x * 3, y), anchor = 'center')
texture_object1 = s1.parameters.texture.get_texture_object()
texture_object2 = s2.parameters.texture.get_texture_object()
v = Viewport(screen=screen, stimuli=[s1,s2])
p = Presentation(go_duration=('forever', ), viewports=[v])
p.add_controller(None, None, FunctionController(during_go_func=put_image_dual, temporal_variables = TIME_SEC_ABSOLUTE))
if response == "voice":
p.parameters.handle_event_callbacks=[(pygame.locals.MOUSEBUTTONDOWN, mouseGrade), (pygame.locals.KEYDOWN, quitHandler)]
else:
p.parameters.handle_event_callbacks=[(pygame.locals.MOUSEBUTTONDOWN, mouseFunc), (pygame.locals.KEYDOWN, quitHandler)]
p.go()
if response == "voice":
sub.inputData(trial, "misfire", misfire)
if trial % break_trial == 0 and trial != trials:
print trial, "BREAK TIME"
experiments.showImage(screen, os.path.join(basePath, "break.BMP"), 0)
instructions_attendSCENE = Text(
text="Attend to SCENES",
font_size=32,
color=(1, 1, 1),
anchor="center",
position=(screen.size[0] / 2, screen.size[1] / 2),
)
cur_time = Text(text="", font_size=15, color=(0.75, 0.75, 0.75), anchor="lowerleft", position=(0, 0))
viewport_instructions = Viewport(screen=screen, stimuli=[instructions, cur_time])
attend_face = Viewport(screen=screen, stimuli=[instructions_attendFACE])
attend_scene = Viewport(screen=screen, stimuli=[instructions_attendSCENE])
p1 = Presentation(go_duration=("forever",), viewports=[viewport_instructions])
p1.add_controller(None, None, FunctionController(during_go_func=displayTime))
p1.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, waitForTrigger)]
# setup main experimental loop
loadStims = 0
wrote_response = 0
stimulus = TextureStimulus(
anchor="center",
size=stimuli_size,
position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
texture_min_filter=gl.GL_LINEAR,
shrink_texture_ok=1,
# PW 2012/11/26
mipmaps_enabled=False,
)
# define target position as a function of time
def get_target_position(t):
global mid_x, mid_y, max_vel
return (
max_vel * sin(0.1 * 2.0 * pi * t) + mid_x, # x
max_vel * sin(0.1 * 2.0 * pi * t) + mid_y) # y
def get_drum_angle(t):
return 50.0 * math.cos(0.2 * 2 * math.pi * t)
# Create instances of the Controller class
target_position_controller = FunctionController(
during_go_func=get_target_position)
drum_angle_controller = FunctionController(during_go_func=get_drum_angle)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
p.add_controller(target, 'position', target_position_controller)
p.add_controller(drum, 'angular_position', drum_angle_controller)
#######################
# Run the stimulus! #
#######################
p.go()
# Generate some images
image_list = []
for i in range(num_images):
image = Image.new("RGB",image_size,(0,0,255)) # Blue background
draw = ImageDraw.Draw(image)
line_x = image_size[0]/float(num_images) * i
draw.line((line_x, 0, line_x, image_size[1]), fill=(255,255,255))
image_list.append(image)
texture_list = map(Texture,image_list) # create instances of Texture from images
screen = get_default_screen()
stimulus = TextureStimulus(texture=texture_list[0],
position = (screen.size[0]/2.0,screen.size[1]/2.0),
anchor='center',
size=image_size)
viewport = Viewport(screen=screen,
stimuli=[stimulus])
p = Presentation(go_duration=(num_images*duration_per_image,'seconds'),viewports=[viewport])
def put_image(t):
i = int(t/duration_per_image) # choose image
stimulus.parameters.texture = texture_list[i]
p.add_controller(None,None,FunctionController(during_go_func=put_image))
p.go()
right_label_controller = FunctionController(during_go_func=myRightLabel)
left_label_controller = FunctionController(during_go_func=myLeftLabel)
task_controller = FunctionController(during_go_func=myFixation)
arrow_direction_controller = FunctionController( \
during_go_func=get_arrow_direction)
arrow_position_controller = FunctionController( \
during_go_func=get_arrow_position)
arrow_color_controller = FunctionController(during_go_func=get_arrow_color)
myArrowOnControl = FunctionController(during_go_func=myArrowOn)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
# Actually listens to the TCP socket
if TCPIP: p.add_controller(None, None, tcp_listener)
p.add_controller(p,'trigger_go_if_armed',trigger_in_controller)
p.add_controller(textAA,'on', stimulus_off_controller )
#p.add_controller(textA,'on', stimulus_off_controller )
#p.add_controller(textB,'on', stimulus_off_controller )
#p.add_controller(textC,'on', stimulus_off_controller )
#p.add_controller(textD,'on', stimulus_off_controller )
p.add_controller(taskStimulus,'on', stimulus_on_controller)
p.add_controller(centerStim,'on', stimulus_on_controller)
p.add_controller(tach1,'on', stimulus_on_controller)
p.add_controller(tach2,'on', stimulus_on_controller)
p.add_controller(tach3,'on', stimulus_on_controller)
p.add_controller(tach4,'on', stimulus_on_controller)
p.add_controller(tach5,'on', stimulus_on_controller)
p.add_controller(tach6,'on', stimulus_on_controller)
viewport = Viewport(screen=screen, stimuli=[stimulus])
########################################
# Create presentation object and go! #
########################################
p = Presentation(go_duration=(5.0,'seconds'), viewports=[viewport])
##############################################
# Connect the controller with the stimulus #
##############################################
keyboard_response = KeyboardResponseController()
# Add the keyboard controller to the presentation's list of controllers
p.add_controller(None, None, keyboard_response)
########
# Go #
########
for i in range(3):
p.go()
# Print responses collected during the presentation
# print "all =",keyboard_response.get_responses_since_go()
# print "all_time =",keyboard_response.get_time_responses_since_go()
print "first =",keyboard_response.get_first_response_since_go()
print "first_time=",keyboard_response.get_time_first_response_since_go()
# print "last =",keyboard_response.get_last_response_since_go()
# print "last_time =",keyboard_response.get_time_last_response_since_go()
right_label_controller = FunctionController(during_go_func=myRightLabel)
left_label_controller = FunctionController(during_go_func=myLeftLabel)
task_controller = FunctionController(during_go_func=myFixation)
arrow_direction_controller = FunctionController( \
during_go_func=get_arrow_direction)
arrow_position_controller = FunctionController( \
during_go_func=get_arrow_position)
arrow_color_controller = FunctionController(during_go_func=get_arrow_color)
myArrowOnControl = FunctionController(during_go_func=myArrowOn)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
# Actually listens to the TCP socket
if TCPIP: p.add_controller(None, None, tcp_listener)
p.add_controller(p, 'trigger_go_if_armed', trigger_in_controller)
p.add_controller(textAA, 'on', stimulus_off_controller)
#p.add_controller(textA,'on', stimulus_off_controller )
#p.add_controller(textB,'on', stimulus_off_controller )
#p.add_controller(textC,'on', stimulus_off_controller )
#p.add_controller(textD,'on', stimulus_off_controller )
p.add_controller(taskStimulus, 'on', stimulus_on_controller)
p.add_controller(centerStim, 'on', stimulus_on_controller)
p.add_controller(tach1, 'on', stimulus_on_controller)
p.add_controller(tach2, 'on', stimulus_on_controller)
p.add_controller(tach3, 'on', stimulus_on_controller)
p.add_controller(tach4, 'on', stimulus_on_controller)
p.add_controller(tach5, 'on', stimulus_on_controller)
p.add_controller(tach6, 'on', stimulus_on_controller)
max_vel = min(screen.size[0],screen.size[1]) * 0.4
# define position as a function of time
def get_target_position(t):
global mid_x, mid_y, max_vel
return ( max_vel*sin(0.1*2.0*pi*t) + mid_x , # x
max_vel*sin(0.1*2.0*pi*t) + mid_y ) # y
# Create an instance of the Controller class
target_position_controller = FunctionController(during_go_func=get_target_position)
#############################################################
# Connect the controllers with the variables they control #
#############################################################
p.add_controller(target,'position', target_position_controller )
#######################
# Run the stimulus! #
#######################
base_dir = VisionEgg.config.VISIONEGG_USER_DIR
if not os.path.isdir(base_dir):
base_dir = VisionEgg.config.VISIONEGG_SYSTEM_DIR
save_directory = os.path.join(base_dir,'movie')
if not os.path.isdir(save_directory):
os.mkdir(save_directory)
if not os.path.isdir(save_directory):
print "Error: cannot make movie directory '%s'."%save_directory
print "Saving movie to directory '%s'."%save_directory
basename = "movie_"+os.path.splitext(os.path.basename(sys.argv[0]))[0]
draw = ImageDraw.Draw(image)
line_x = image_size[0] / float(num_images) * i
draw.line((line_x, 0, line_x, image_size[1]), fill=(255, 255, 255))
image_list.append(image)
texture_list = map(Texture,
image_list) # create instances of Texture from images
screen = get_default_screen()
stimulus = TextureStimulus(texture=texture_list[0],
position=(screen.size[0] / 2.0,
screen.size[1] / 2.0),
anchor='center',
size=image_size)
viewport = Viewport(screen=screen, stimuli=[stimulus])
p = Presentation(go_duration=(num_images * duration_per_image, 'seconds'),
viewports=[viewport])
def put_image(t):
i = int(t / duration_per_image) # choose image
stimulus.parameters.texture = texture_list[i]
p.add_controller(None, None, FunctionController(during_go_func=put_image))
p.go()
# indicate begining of a block
sendCommand(beginBlock,0)
p.go()
#par.setData(fixationOnOffTrig)
#time.sleep(.001)
imageStim = TextureStimulus(texture=imageTex,
position = (screen.size[0]/2.0,screen.size[1]/2.0),
anchor='center', size=(width*scale,height*scale),
mipmaps_enabled = 0, texture_min_filter=gl.GL_LINEAR)
texture_object = imageStim.parameters.texture.get_texture_object()
texture_object.put_sub_image( curImList[0] )
p.add_controller(None, None, FunctionController(during_go_func=every_frame_func) )
# p.parameters.go_duration = ((numImsPerBlock + 1)/float(presentationFreq),'seconds')
p.parameters.go_duration = (3*(numImsPerBlock + 1)/float(presentationFreq),'seconds') # DJ: Why *3?
viewport.parameters.stimuli=[imageStim]
p.go();
if (run_as_standalone == 0):
par.setData(0)
# indicate the results
sendCommand(endBlock,0)
internalState = 0
# fixation cross
p.parameters.go_duration = (1,'seconds')
p.controllers = []
viewport.parameters.stimuli=[fixPt]
)
other_text = []
other_text.append(
Text(text='Pixel positions (x,y) calculated from 3D coordinates',
position=(screen.size[0]/2,screen.size[1]),
anchor='top',
)
)
other_text.append(
Text(text='----> x',
position=(10,10),
anchor='left',
)
)
other_text.append(
Text(text='----> y',
angle=90.0,
position=(10,10),
anchor='left',
)
)
viewport2D.parameters.stimuli = vertex_labels + other_text
p = Presentation(go_duration=(10.0,'seconds'),viewports=[viewport3D,viewport2D])
p.add_controller(None, None, FunctionController(during_go_func=update))
p.go()
