def showImage(screen, img, duration=1):
def quitKey(event):
if event.key == pygame.locals.K_SPACE:
quit()
def click(event):
quit()
def quit(dummy_arg=None):
image.parameters.go_duration = (0, 'frames')
img = Image.open(img)
#create textures
tex = Texture(img)
x = screen.size[0] / 2
y = screen.size[1] / 2
stimulus = TextureStimulus(texture=tex, position=(x, y), anchor='center')
#create viewports
viewport = Viewport(screen=screen, stimuli=[stimulus])
if duration:
image = Presentation(go_duration=(duration, 'seconds'),
viewports=[viewport])
else:
image = Presentation(go_duration=('forever', ''), viewports=[viewport])
image.parameters.handle_event_callbacks = [
(pygame.locals.QUIT, quit), (pygame.locals.KEYDOWN, quitKey),
(pygame.locals.MOUSEBUTTONDOWN, click)
]
image.go()
def showInstructions(screen, text, textSize=60, textcolor=(255, 255, 255)):
#create our instruction screen
#load up the instruction text
insStim, insView = printText(screen, text, textSize, textcolor)
instructions = Presentation(go_duration=('forever', ), viewports=[insView])
#add a quit function and a handler to go with it
def quitKey(event):
if event.key == pygame.locals.K_SPACE:
quit()
def click(event):
quit()
def quit(dummy_arg=None):
instructions.parameters.go_duration = (0, 'frames')
instructions.parameters.handle_event_callbacks = [
(pygame.locals.QUIT, quit), (pygame.locals.KEYDOWN, quitKey),
(pygame.locals.MOUSEBUTTONDOWN, click)
]
#show instructions
instructions.go()
def showStimulus(screen, text, colour):
word, viewport = printWord(screen, text, 200, colour)
p = Presentation(go_duration=(0.5, 'seconds'), viewports=[viewport])
p.go()
start = time.clock()
exit = 0
while not exit:
data = raw_lpt_module.inp(0x379) & 0x20
if not data:
RT = time.clock()
p.parameters.go_duration = (0.032, 'seconds')
#dataList.append ([text, colour, start, RT])
exit = 1
else:
pass
def showStimulus(screen, text, colour, useLPT=True): word, viewport = printWord(screen, text, 200, colour) p = Presentation(go_duration=(stroopDuration,'seconds'),viewports=[viewport]) if useLPT: p.go() start = time.clock() exit = 0 while not exit: data = raw_lpt_module.inp(0x379) & 0x20 #print data if not data: #print "hello" RT = time.clock() p.parameters.go_duration = (blank, 'seconds') subject.inputData(trial, "text", text) subject.inputData(trial, "colour", colour) subject.inputData(trial, "RT", RT) exit = 1 else: pass
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])
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=0,
size=scaled_static_size,
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,
anchor='center',
size=(300.0, 300.0),
signal_fraction=cohLevel,
signal_direction_deg=dirx,
velocity_pixels_per_sec=100.0,
dot_lifespan_sec=0.08,
dot_size=3.0,
num_dots=200)
# Create a Viewport instance
viewport = Viewport(
screen=screen,
stimuli=[str_instruct_1, fixation, dotStim, str_instruct_2, sampleFix])
p = Presentation(
go_duration=(exp_length, 'seconds'),
trigger_go_if_armed=0, #wait for trigger
viewports=[viewport])
#initialize log file
logname = time.strftime('_%m-%d-%Y_%Hh-%Mm.csv')
logname = 'log_' + ss_num + logname
logfile = open(logname, 'w')
logfile.write("# LOGFILE: {0}\n".format(logname))
logfile.write("# Coherence,Direction,Response\n")
#################################
# Main procedure #
#################################
def getState(t):
VisionEgg.start_default_logging()
VisionEgg.watch_exceptions()
from VisionEgg.Core import *
from VisionEgg.FlowControl import Presentation
from VisionEgg.Textures import *
import pygame.image
import OpenGL.GL as gl
filename = os.path.join(VisionEgg.config.VISIONEGG_SYSTEM_DIR, "data",
"visionegg.bmp")
pygame_surface = pygame.image.load(filename)
texture = Texture(pygame_surface)
screen = get_default_screen()
# Create the instance of TextureStimulus
stimulus = TextureStimulus(texture=texture,
position=(screen.size[0] / 2.0,
screen.size[1] / 2.0),
anchor='center',
size=texture.size,
mipmaps_enabled=0,
texture_min_filter=gl.GL_LINEAR,
shrink_texture_ok=1)
viewport = Viewport(screen=screen, stimuli=[stimulus])
p = Presentation(go_duration=(5.0, 'seconds'), viewports=[viewport])
p.go()
#default strategy
strategy = None
trial = 1
#STIMULI
#Fixation Cross
fixText, fixCross = printWord(screen, '*', 120, (255, 255, 255))
errorText, errorPort = printWord(screen, 'X', 120, (1., .1, .1))
print "PRESS SPACE TO START"
pause = Presentation(go_duration=('forever', ), viewports=[fixCross])
pause.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN,
pause_handler)]
pause.go()
problemQ = []
while len(mag_problems):
if problemQ:
stim = problemQ[2]
n1 = problemQ[0]
n2 = problemQ[1]
else:
p = mag_problems.pop(0)
n1 = p[0]
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() 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)
taskend = Text(text=' ',
color=(1.0, 1.0, 1.0),
position=(d_screen_half_x, d_screen_half_y + 160),
font_size=60,
anchor='center')
viewportIntro = Viewport(screen=screen)
viewport = Viewport(screen=screen,
stimuli=[
title, title2, left_choice, right_choice, left_choice2,
right_choice2, newset, taskend, fixation
])
p = Presentation(
go_duration=(2000, 'seconds'), # run for longer than needed
trigger_go_if_armed=0, #wait for trigger
viewports=[viewport, viewportIntro])
def getState(t):
global qIndex, screenText, screenText2, ip, question, gn_keystroke, subQ, amountRow, delay, krow, blocknum, amount, amountD, amountI, currentdelay, trialnum
global isi, isi_index, now, firsttime, response, stim_onset, newseton, goodRow, taskendon, fixon, customdelays, amtText, amtText0I, amtText0D
if (t > isi + isi_array[isi_index]):
newseton = 0
fixon = 0
taskendon = 0
if firsttime:
now = int(round(random()))
stim_onset = t
firsttime = 0
initial_controller=ConstantController(during_go_value=(10,'seconds'))
)
go_controller = tcp_listener.create_tcp_controller(
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)
"Error: Use MPEG file as command line argument - Press Esc to quit",
position=(screen.size[0] / 2, screen.size[1]),
anchor='top',
font_size=24,
color=(1.0, 0.0, 0.0))
text2 = Text(
text="(If you have a free MPEG to contribute, it could go here.)",
position=(screen.size[0] / 2, screen.size[1] / 2),
anchor='center',
font_size=20,
color=(1.0, 1.0, 1.0))
viewport = Viewport(screen=screen, stimuli=[text, text2])
p = Presentation(
go_duration=('forever', ),
viewports=[viewport],
handle_event_callbacks=[(pygame.locals.QUIT, quit),
(pygame.locals.KEYDOWN, keydown)],
)
p.go()
sys.exit(1)
movie = pygame.movie.Movie(filename)
width, height = movie.get_size()
scale_x = screen.size[0] / float(width)
scale_y = screen.size[1] / float(height)
scale = min(scale_x, scale_y) # maintain aspect ratio
# create pygame surface (buffer to draw uncompressed movie data into)
pygame_surface = pygame.surface.Surface((width, height))
trial = 1
experiment = "numbers"
enoughPractice = False
while not enoughPractice:
pracList = stroop.makePracticeList()
for item in pracList:
showStimulus(screen, item[0], item[1])
trial += 1
#experimenter prompt
pracText, pracView = printWord(screen, 'Press SPACE TO CONTINUE, R TO REDO', 60, (255, 255, 255))
pause = Presentation(go_duration=('forever', ), viewports=[pracView])
pause.parameters.handle_event_callbacks=[(pygame.locals.KEYDOWN, practice_handler)]
pause.go()
"""
TRADITIONAL STROOP
1. run trad stroop, 32 trials, 8 colour words
"""
trials = 32
colourWords = ["red", "blue", "green", "white", "yellow", "pink", "orange", "grey"]
colours = [[255, 0, 0], [0, 0, 255], [0, 255, 0], [255, 255, 255], [255, 255, 0], [255, 0, 255], [255, 153, 51], [100, 100, 100]]
Stroop = stroop.Stroop(colourWords, True, colours)
acc = 0 pressed = 1 ACC = 0 RT = p.time_sec_since_go ###SET SCREEN screen = get_default_screen() screen.parameters.bgcolor = (0, 0, 0) pygame.font.init() c, cv = printWord(screen, 'O', 48, [0, 255, 0]) ic, icv = printWord(screen, '+', 48, [255, 0, 0]) f, fv = printWord(screen, '', 48, [0, 0, 0]) cp = Presentation(go_duration=[0.1, 'seconds'], viewports=[cv]) icp = Presentation(go_duration=[0.1, 'seconds'], viewports=[icv]) fix = Presentation(go_duration=[0.05, 'seconds'], viewports=[fv]) trial = 0 for block in blockorder: for gowords in ([block, 'neutral'], ['neutral', block]): ACC = 0 while ACC <= maxACC: trial+=1 RT = 0 pressed = 0 signal = gng.getSignal() print signal
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()
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()
from VisionEgg.Textures import *
import math, os
import numpy
numpy.seterr(all='raise')
def projection_matrix_f(t):
# This bit of code is from the "movingPOV" demo and can be used to
# gain a moving external view of the texture-mapped sphere by
# uncommenting the appropriate line below.
projection = SimplePerspectiveProjection(fov_x=55.0,aspect_ratio=(screen.size[0]/2.)/screen.size[1])
eye = (0.0,t*0.3+1.0,-2.0)
camera_look_at = (0.0,0.0,0.0)
camera_up = (0.0,1.0,0.0)
projection.look_at( eye, camera_look_at, camera_up)
return projection.get_matrix()
screen = get_default_screen()
screen.parameters.bgcolor = (1.0,1.0,1.0,1.0)
projection = SimplePerspectiveProjection(fov_x=90.0)
text_viewport = Viewport(screen=screen)
stimulus = AzElGrid()
viewport = Viewport(screen=screen,
projection=projection,
stimuli=[stimulus])
stimulus.parameters.my_viewport = viewport # set afterwards
p = Presentation(go_duration=(10.0,'seconds'),viewports=[viewport])#,text_viewport])
#p.add_controller(projection,'matrix', FunctionController(during_go_func=projection_matrix_f))
p.go()
def __init_presentation(self):
""" Provide a standard presentation object. """
self.presentation = Presentation(
handle_event_callbacks=self._event_handlers)
drum = SpinningDrum(texture=texture, shrink_texture_ok=1)
# Create a perspective projection for the spinning drum
perspective = SimplePerspectiveProjection(fov_x=90.0)
# Create a viewport with this projection
drum_viewport = Viewport(screen=screen, projection=perspective, stimuli=[drum])
##################################################
# Create an instance of the Presentation class #
##################################################
# Add target_viewport last so its stimulus is drawn last. This way the
# target is always drawn after (on top of) the drum and is therefore
# visible.
p = Presentation(go_duration=(10.0, 'seconds'),
viewports=[drum_viewport, target_viewport])
########################
# Define controllers #
########################
# 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 target position as a function of time
def get_target_position(t):
global mid_x, mid_y, max_vel
return (
pygame.font.init()
pygame.mixer.init()
sound = pygame.mixer.Sound("beep.wav")
sound.play()
for s in stimList:
trial += 1
print s
RT = 0
acc = 0
w, v = printWord(screen, str(s), 48, [255, 255, 255])
p = Presentation(go_duration=[0.675, 'seconds'], viewports=[v])
p.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN, key_handler)
]
p.go()
sub.inputData(trial, "RT", RT)
sub.inputData(trial, "acc", acc)
sub.inputData(trial, "s", s)
sub.inputData(trial, "target", target)
sub.printData()
sound.play()
sub.printData()
def __init_screen(self):
## create screen:
if not self.fullscreen:
os.environ['SDL_VIDEO_WINDOW_POS'] = '%d, %d' % (self.geometry[0],
self.geometry[1])
self._screen = Screen(size=(self.geometry[2], self.geometry[3]),
fullscreen=self.fullscreen,
bgcolor=self.bg_color,
sync_swap=True)
## create letter box on top:
self._ve_letterbox = Target2D(position=(self._centerPos[0],
self.geometry[3] * (1 - 0.01) -
self.letterbox_size[1] / 2.),
size=(self.letterbox_size[0],
self.letterbox_size[1]),
color=self.phrase_color)
self._ve_innerbox = Target2D(position=(self._centerPos[0],
self.geometry[3] * (1 - 0.01) -
self.letterbox_size[1] / 2.),
size=(self.letterbox_size[0] - 6,
self.letterbox_size[1] - 6),
color=self.bg_color)
self._current_letter_position = (self._centerPos[0],
self.geometry[3] * (1 - 0.015) -
self.letterbox_size[1] / 2.)
self._ve_current_letter = Text(
position=self._current_letter_position,
text=(len(self._desired_letters[:1]) == 0 and " "
or self._desired_letters[:1]),
font_size=self.font_size_current_letter,
color=self.current_letter_color,
anchor='center')
self._ve_desired_letters = Text(
position=(self._centerPos[0] + 5 + self.letterbox_size[0] / 2.,
self._current_letter_position[1]),
text=(len(self._desired_letters[1:]) == 0 and " "
or self._desired_letters[1:]),
font_size=self.font_size_phrase,
color=self.phrase_color,
anchor='left')
self._ve_spelled_phrase = Text(
position=(self._centerPos[0] - 5 - self.letterbox_size[0] / 2.,
self._current_letter_position[1]),
text=(len(self._spelled_phrase) == 0 and " "
or self._spelled_phrase),
font_size=self.font_size_phrase,
color=self.phrase_color,
anchor='right')
# if we're in free spelling mode, we hide all text fields but
# the _ve_spelled_phrase. we also need a multiline
# _ve_spelled_phrase instead of the single lined one
if self.offline == self.copy_spelling == False:
self._spelled_phrase = " "
self._ve_spelled_phrase = WrappedText(
position=(0, self._current_letter_position[1]),
text=(len(self._spelled_phrase) == 0 and " "
or self._spelled_phrase),
font_size=self.font_size_phrase,
color=self.phrase_color,
size=(float(self.geometry[2]), float(self.geometry[3])))
for i in self._ve_letterbox, self._ve_innerbox, self._ve_current_letter, self._ve_desired_letters:
i.set(on=False)
## add word box to elementlist:
self._ve_elements.extend([
self._ve_letterbox, self._ve_innerbox, self._ve_current_letter,
self._ve_desired_letters, self._ve_spelled_phrase
])
## create countdown:
self._ve_countdown = Text(position=self._centerPos,
text=" ",
font_size=self.font_size_countdown,
color=self.countdown_color,
anchor='center',
on=False)
## create countdown shapes
self._ve_countdown_shape = self.countdown_shapes[
self.countdown_shape_select](radius=90,
position=self._centerPos,
color=self.countdown_shape_color,
on=False)
## create oscillator circle:
self._ve_oscillator = FilledCircle(position=(self.osc_size / 2 + 10,
self.osc_size / 2 + 10),
radius=self.osc_size / 2,
color=self.osc_color,
on=False)
## create shapes and letters:
self.init_screen_elements()
## add remaining elements to element list:
self._ve_elements.extend([
self._ve_countdown_shape, self._ve_countdown, self._ve_oscillator
])
## add elements to viewport:
self._viewport = Viewport(screen=self._screen,
stimuli=self._ve_elements)
self._presentation = Presentation(viewports=[self._viewport],
handle_event_callbacks=[
(pygame.KEYDOWN,
self.keyboard_input),
(pygame.QUIT, self.__stop)
])
gamma_scale += 0.05
do_gamma()
elif event.key in [pygame.locals.K_KP_MINUS, pygame.locals.K_MINUS]:
gamma_scale -= 0.05
do_gamma()
def do_gamma():
global gamma_scale, text2
r = (np.arange(256) * 256 * gamma_scale).astype('i')
g = r
b = r
worked = pygame.display.set_gamma_ramp(r, g, b)
if worked:
text2.parameters.text = "set_gamma_ramp(r,g,b): success"
else:
text2.parameters.text = "set_gamma_ramp(r,g,b): failure"
do_gamma() # set gamma once initially
handle_event_callbacks = [(pygame.locals.QUIT, quit),
(pygame.locals.KEYDOWN, keydown)]
# Create an instance of the Presentation class
p = Presentation(viewports=[viewport],
handle_event_callbacks=handle_event_callbacks)
# Go!
p.run_forever()
random.shuffle(ns_list2)
if ns_list1[-1] != ns_list2[0]:
ns_list = ns_list1 + ns_list2
badshuffle = False
print len(ns_list)
print ns_list
lastSoln = 0
mems = 0
calcs = 0
print "PRESS SPACE TO START"
pause = Presentation(go_duration=('forever', ), viewports=[fixCross])
pause.parameters.handle_event_callbacks = [(pygame.locals.KEYDOWN,
pause_handler)]
pause.go()
for ns in ns_list:
#reset state vars
misfire = 0
verify = 0
problem = None
soln = None
orig_strat = ns[1]
problem = Problem(ns[0])
ns = problem.row['ns']
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
target_bottom = 0.2 * screen.size[1] - shift_unit
stim_range_half = (target_top - target_bottom) / 2.0
score_factor = 90.0 / (30.0 * 0.5) # assume 30 maximum TRs at maximum -.5
# "score" to go from 90 to 0 deg
# Create a Viewport instance
viewport = Viewport(screen=screen, \
stimuli=[arrowStimulus,textAA,centerStim,taskStimulus,\
tach1,tach2,tach3,tach4,tach5,tach6,tach7,tach8,\
tach9,tach10,tach11,tach12,tach13,tach14,tach15,\
tach12,tach16,tach17,tach18,tach19,tachLabelR,\
tachLabelL])
# the Vision Egg's runtime control abilities.
p = Presentation( go_duration=(Num_Secs,'seconds'), \
trigger_go_if_armed=0, \
viewports=[viewport])
# calculate a few variables we need
next_stim_time = 0
direction = 1.0
last_direction = 1.0
arrow_scale = 0
arrowColor = 0
score = 90.0
first_loop = 1
start_time = 0
StimCount = -1
stimVis = 0
fbVis = 0
stimText = "+"
def keyup(event):
global up, down, left, right
if event.key == pygame.locals.K_UP:
up = 0
elif event.key == pygame.locals.K_DOWN:
down = 0
elif event.key == pygame.locals.K_RIGHT:
right = 0
elif event.key == pygame.locals.K_LEFT:
left = 0
# Create an instance of the Presentation class. This contains the
# the Vision Egg's runtime control abilities.
p = Presentation(go_duration=('forever', ), viewports=[viewport])
def quit(event):
p.parameters.go_duration = (0, 'frames')
p.parameters.handle_event_callbacks = [(pygame.locals.QUIT, quit),
(pygame.locals.KEYDOWN, keydown),
(pygame.locals.KEYUP, keyup)]
#############################################################
# Connect the controllers with the variables they control #
#############################################################
p.add_controller(None, None,
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()
#####################
## RUNTIME CONTROL ##
#####################
count = 0
while (count<len(introTexts)): # DJ CHANGE 4/23/12
# Create a Viewport instance (initialized just to display instructions)
viewport = Viewport(screen=screen, stimuli=[introTexts[count], introTexts_bottomline[count]])
# Create an instance of the Presentation class. (Runtime control)
# note that timeBetweenBlocks/2 is used here to match the time of each between-block frame.
p = Presentation(go_duration=(timeBetweenBlocks/2,'seconds'), viewports=[viewport])
# Register Event Handlers so we can speed things up or quit early if we need to
p.parameters.handle_event_callbacks = \
[(pygame.locals.QUIT, quit), (pygame.locals.KEYDOWN, keydown), (pygame.locals.KEYUP, keyup)]
p.between_presentations()
p.go()
count = count+1
#####################################################################
## Here the intro text is complete, entering the image block loop ##
#####################################################################
# Get a texture
filename = os.path.join(config.VISIONEGG_SYSTEM_DIR, "data/panorama.jpg")
texture = Texture(filename)
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(
