def prepfortrial(t):
cue_ind = cueseq[t]
prb_ind = prbseq[t]
con_ind = conseq[t]
timing = frames[timseq[t]]
# select cue
cue_buffer = cue_list[con_ind][cue_ind]
# set target letters
shuffle(letters)
stiml = letters[0:4]
if t in B3TRIALS:
[
stim_display[i].setPos((xcoo[i], ycoo[xyconfigs[conseq[t]][i]]))
for i in range(len(xcoo))
]
[
mask_display[i].setPos((xcoo[i], ycoo[xyconfigs[conseq[t]][i]]))
for i in range(len(xcoo))
] # random masks
[stim_display[i].setText(stiml[i]) for i in range(len(stiml))]
stim_buffer = visual.BufferImageStim(win, stim=stim_display + [fixation])
# set masks
# mask_buffer = mask_display[con_ind][t%len(mask_display[0])]
shuffle(mask_imgs)
[mask_display[i].setImage(mask_imgs[i]) for i in range(len(xcoo))]
mask_buffer = visual.BufferImageStim(win, stim=mask_display + [fixation])
# find probe letter
probe_letter = letters[prb_ind]
probe_display.setText(probe_letter)
sts = str(t+1)+"\t"+str(cue_ind)+"\t"+ \
str(prb_ind)+"\t"+str(timseq[t])+"\t"+str(timing)+"\t"+str(con_ind)+"\tT:"+''.join(stiml)+"\tP:"+probe_letter
return cue_buffer, stim_buffer, mask_buffer, probe_display, timing, sts
def setCup(pp):
global button
global cupBuffer
sN = pp
rtClock = core.Clock()
while True:
key = event.getKeys(keyList = ['q','escape'])
if len(key) > 0:
core.quit()
mX, mY = mouse.getPos()
if mX > buttonX[0] and mX < buttonX[1] and mY > buttonY[0] and mY < buttonY[1]: #Checks to see if "Next" button was pressed
set_mouse_position(win,0,0)
break
if mY < (slotY-(slotHeight/2)) and mY > -(screenY*.2):
sN1 = getSlot(mX,mY,slotSpread)
if sN1 !=None:
sN = sN1
if sN == 0:
sN = 1
elif sN == 40:
sN = 39
plinkoTable.draw()
button.draw()
buttonText.draw()
ball.draw()
drawCup(slotPos[sN][0])
drawPbar(totalPoints,maxScore)
win.flip()
rt = rtClock.getTime()
plinkoTable.draw()
drawCup(slotPos[sN][0])
drawPbar(totalPoints,maxScore)
cupBuffer = visual.BufferImageStim(win)
return sN,rt
def _targetStim(self, tloc, tdir, flank):
"""Return a complete buffer of specified target at position tloc (top or down)
with flankers (congruent, neutral, or incongruent) in direction tdir (left or right)
ready to flip
"""
sz = self.arrowSize
pw = self.allWidthDeg
p = self.arrowSize + self.arrowSep
y = self.targetDist if tloc=='top' else -self.targetDist
if self.runDummy:
lines = [ self._drawLine((x, y), sz, pw, False, None) for x in (-2*p, -p, 0, p, 2*p) ]
heads = []
elif flank=='neutral':
lines = [ self._drawLine((x, y), sz, pw, False, None) for x in (-2*p, -p, p, 2*p) ]
lines = lines + [self._drawLine((0, y), sz, pw, True, tdir)]
heads = [ self._drawHead((0, y), sz, pw, tdir) ]
elif flank=='congruent':
lines = [ self._drawLine((x, y), sz, pw, True, tdir) for x in (-2*p, -p, 0, p, 2*p) ]
heads = [ self._drawHead((x, y), sz, pw, tdir) for x in (-2*p, -p, 0, p, 2*p) ]
elif flank=='incongruent':
rdir = 'left' if tdir=='right' else 'right'
lines = [ self._drawLine((x, y), sz, pw, True, rdir) for x in (-2*p, -p, p, 2*p) ]
heads = [ self._drawHead((x, y), sz, pw, rdir) for x in (-2*p, -p, p, 2*p) ]
lines = lines + [ self._drawLine((0, y), sz, pw, True, tdir) ]
heads = heads + [ self._drawHead((0, y), sz, pw, tdir) ]
return visual.BufferImageStim(self.win, stim=(lines + heads))
def doTrial():
im = []
for frame in range(240):
[slot, local] = divmod(frame, framesPerSlot)
if local == 0:
piece = []
for place in range(numPlaces):
piece.append(
visual.ImageStim(win=window,
pos=(posX[place], 0),
image=digImg[digits[slot][place]],
opacity=(frame % freq[place]) /
(freq[place] - 1)))
else:
for place in range(numPlaces):
piece[place].opacity = (frame % freq[place]) / (freq[place] -
1)
im.append(visual.BufferImageStim(win=window, stim=piece))
myTimesB = []
myTimesA = []
for frame in range(240):
myTimesA.append(timer.getTime())
im[frame].draw()
myTimesB.append(timer.getTime())
window.flip()
del (im)
return (myTimesA, myTimesB)
def drawConfLines(clines,
ctext_stim,
ctext,
items,
cross,
positions,
prevBeads,
trialNum,
beadPoses,
predText=False,
subSlider=False):
# Draw options to select
if predText != False:
predText.draw()
for i in np.arange(len(items)):
items[i].setPos(positions[i])
items[i].draw()
p = positions[i]
#Draw and buffer confidence lines
for cl in clines:
cl.draw()
for i in np.arange(len(ctext)):
ctext_stim[i].setText(ctext[i])
ctext_stim[i].draw()
if subSlider != False:
subSlider.draw()
drawSeenBeads(trialNum, beadRem, prevBeads, beadPoses)
cline_image = visual.BufferImageStim(win)
return (cline_image)
def prepare_figure(trial, pos=(0, 0)):
"""Prepare a figure given settings in a trial."""
# A hack to not present figures on auditory-only trials
if trial['any_visual']:
# If the figure's current flip-state is not desired, flip it horizontally.
figure_template.pos = pos
figure_template.flipped = int(
not figure_template.flipped) # Now opposite
# Draw fill
figure_template.image = path.join(
'stimuli', '%(shape)s_%(complexity)s.png' % trial)
figure_template.color = colors[trial['hue']][
trial['lightness']] # Select correct color
figure_template.draw()
# Draw outline
figure_template.color = (255, 255, 255) # Preserve original color
figure_template.image = path.join(
'stimuli', '%(shape)s_%(complexity)s_outline.png' % trial)
figure_template.draw()
# Screenshot
figure = visual.BufferImageStim(win) # Screenshot
# Clean up and return
figure.draw() # First draw is slower
win.clearBuffer() # Wipe screen
figure_template.pos = (0, 0) # back to center
return figure
else:
return figure_blank
def doTrial(cond):
myCol=[[1,-1,-1],[-1,1,-1]]
blank=visual.TextStim(win=window,text="")
cross=visual.TextStim(win=window,text="+")
[targ,flank]=decode(cond)
start=np.random.randint(-20,20,size=2)
im=[]
for x in range(3):
for y in range(3):
im.append(visual.ShapeStim(win=window,
vertices=makeVertices(pX=posX[x]+start[0],pY=posY[y]+start[1]),
fillColor=myCol[flank],
lineColor=(0,0,0)))
im[4]=visual.ImageStim(win=window,
image=makeArray(targVal[targ],resX,resY),
pos=start)
full=visual.BufferImageStim(win=window,stim=im)
correct=int(targVal[targ]>.5)
cross.pos=start
cross.draw()
window.flip()
core.wait(.2)
blank.draw()
window.flip()
core.wait(.5)
timer.reset()
full.draw()
window.flip()
# window.getMovieFrame(buffer='front')
keys=event.waitKeys(keyList=['z','slash','9'],timeStamped=timer)
blank.draw()
window.flip()
resp=keys[0][0]
rt=keys[0][1]
if resp=='9':
window.close()
core.quit()
exit()
if resp=='z':
respInt=0
else:
respInt=1
if respInt==correct:
correct1.play()
core.wait(0.1)
correct2.play()
else:
error.play()
core.wait(.5)
return(respInt,rt)
def make_ring(self, text_size=45):
""" create the ring
20210518 - use images instead to match eprime experiment
makes self.ringimg['rew'] and self.ringimg['neu']
see
https://discourse.psychopy.org/t/the-best-way-to-draw-many-text-objects-rsvp/2758
"""
# color and symbol for ring reward
cues = {
'neu': {
'color': 'gray',
'sym': '#'
},
'rew': {
'color': 'green',
'sym': '$'
}
}
n_in_ring = 12
el_rs = 250 # TODO: make relative to screen size?
el_thetas = np.linspace(0, 360, n_in_ring, endpoint=False)
el_xys = np.array(misc.pol2cart(el_thetas, el_rs)).T
ringtext = visual.TextStim(win=self.win,
units='pix',
bold=True,
height=text_size,
text='$') # '$' will be changed
cap_rect_norm = [
-(text_size / 2.0) / (self.win.size[0] / 2.0), # left
+(text_size / 2.0) / (self.win.size[1] / 2.0), # top
+(text_size / 2.0) / (self.win.size[0] / 2.0), # right
-(text_size / 2.0) / (self.win.size[1] / 2.0) # bottom
]
for k in ['rew', 'neu']:
ringtext.text = cues[k]['sym']
ringtext.color = cues[k]['color']
buff = visual.BufferImageStim(win=self.win,
stim=[ringtext],
rect=cap_rect_norm)
# img = (np.flipud(np.array(buff.image)[..., 0]) / 255.0 * 2.0 - 1.0)
self.ringimg[k] = visual.ElementArrayStim(
win=self.win,
units="pix",
nElements=n_in_ring,
sizes=buff.image.size,
xys=el_xys,
# colors=cues[k]['color'],
elementMask=None,
elementTex=buff.image)
def test_bufferImage(self):
"""BufferImage inherits from ImageStim, so test .ori. .pos etc there not here
"""
win = self.win
gabor = visual.PatchStim(win, mask='gauss', ori=-45,
pos=[0.6*self.scaleFactor, -0.6*self.scaleFactor],
sf=2.0/self.scaleFactor, size=2*self.scaleFactor,
interpolate=True)
bufferImgStim = visual.BufferImageStim(self.win, stim=[gabor],
interpolate=True)
bufferImgStim.draw()
utils.compareScreenshot('bufferimg_gabor_%s.png' %(self.contextName), win, crit=8)
win.flip()
def show_instruction():
global win
instr = visual.SimpleImageStim(win,
image='instruction.png',
units='',
pos=(0.0, 0.0),
flipHoriz=False,
flipVert=False,
name=None,
autoLog=None)
instrStim = visual.BufferImageStim(win, stim=[instr])
instrStim.draw()
win.flip()
while True:
if len(event.getKeys()) > 0: break
event.clearEvents()
def createPsychoGraphicsWindow(io):
#create a window
psychoStim = OrderedDict()
psychoWindow = visual.Window(io.devices.display.getPixelResolution(),
monitor=io.devices.display.getPsychopyMonitorName(),
units=io.devices.display.getCoordinateType(),
color=[128,128,128], colorSpace='rgb255',
fullscr=True, allowGUI=False,
screen=io.devices.display.getIndex()
)
currentPosition= io.devices.mouse.setPosition((0,0))
psychoWindow.setMouseVisible(False)
fixation = visual.PatchStim(psychoWindow, size=25, pos=[0,0], sf=0,
color=[-1,-1,-1], colorSpace='rgb')
title = visual.TextStim(win=psychoWindow,
text="ioHub getEvents Delay Test", pos = [0,125],
height=36, color=[1,.5,0], colorSpace='rgb',
wrapWidth=800.0)
instr = visual.TextStim(win=psychoWindow,
text='Move the mouse around, press keyboard keys and mouse buttons',
pos = [0,-125], height=32, color=[-1,-1,-1],
colorSpace='rgb', wrapWidth=800.0)
psychoStim['static'] = visual.BufferImageStim(win=psychoWindow,
stim=(fixation, title, instr))
psychoStim['grating'] = visual.PatchStim(psychoWindow,
mask="circle", size=75,pos=[-100,0],
sf=.075)
psychoStim['keytext'] = visual.TextStim(win=psychoWindow,
text='key', pos = [0,300], height=48,
color=[-1,-1,-1], colorSpace='rgb',
wrapWidth=800.0)
psychoStim['mouseDot'] = visual.GratingStim(win=psychoWindow,
tex=None, mask="gauss",
pos=currentPosition,size=(50,50),
color='purple')
psychoStim['progress'] = visual.ShapeStim(win=psychoWindow,
vertices=[(0,0),(0,0),(0,0),(0,0)],
pos=(400, -300))
return psychoWindow, psychoStim
def doTrial(cond):
blank = visual.TextStim(win=window, text="")
[targ, flank] = decode(cond)
im = []
for x in range(3):
for y in range(3):
t = makeArray(flankVal[flank], resX, resY)
im.append(
visual.ImageStim(win=window, pos=(posX[x], posY[y]), image=t))
im[4].image = makeArray(targVal[targ], resX, resY)
full = visual.BufferImageStim(win=window, stim=im)
correct = int(targVal[targ] > .5)
blank.draw()
window.flip()
core.wait(.5)
timer.reset()
full.draw()
window.flip()
window.getMovieFrame(buffer='front')
keys = event.waitKeys(keyList=['z', 'slash', '9'], timeStamped=timer)
blank.draw()
window.flip()
resp = keys[0][0]
rt = keys[0][1]
if resp == '9':
window.close()
core.quit()
exit()
if resp == 'z':
respInt = 0
else:
respInt = 1
if respInt == correct:
correct1.play()
core.wait(0.1)
correct2.play()
else:
error.play()
core.wait(.5)
return (respInt, rt)
def play_movie(win, movie, timing, trigger=None):
mov = visual.MovieStim3(win,
'movies/' + movie,
size=[1080, 637.5],
flipVert=False,
flipHoriz=False,
loop=False,
noAudio=True)
timer = core.CountdownTimer(timing)
mov_start = core.getTime()
if trigger:
trigger.flicker(1)
event.clearEvents(eventType='keyboard')
while mov.status != visual.FINISHED and timer.getTime() > 0:
mov.draw()
win.flip(clearBuffer=False)
last_frame = visual.BufferImageStim(win,
buffer='front',
rect=(-.8, 0.8, 0.8, -0.8))
last_frame.autoDraw = True
return mov_start, last_frame
def doTrial(targ, flank, crit):
digits = []
a = list(range(10))
for i in range(numPlaces):
random.shuffle(a)
digits.append(a[-numSlots:])
for place in range(numPlaces):
digits[place][crit] = 10 + flank
digits[center][crit] = 10 + targ
im = []
for frame in range(numFrames):
[slot, local] = divmod(frame, framesPerSlot)
if local == 0:
piece = []
for place in range(numPlaces):
piece.append(
visual.ImageStim(win=window,
pos=(posX[place], 0),
image=digImg[digits[place][slot]],
opacity=(frame % freq[place]) /
(freq[place] - 1)))
else:
for place in range(numPlaces):
piece[place].opacity = (frame % freq[place]) / (freq[place] -
1)
im.append(
visual.BufferImageStim(win=window,
stim=piece,
rect=[-.3, .1, .3, -.1]))
for a in range(preRSVP):
if (a // fBlank1 == 0):
Blank.draw()
window.flip()
elif (a // (fBlank1 + fFix) == 0):
fix.draw()
window.flip()
else:
Blank.draw()
window.flip()
myTimesB = []
myTimesA = []
timer.reset()
for frame in range(numFrames):
myTimesA.append(timer.getTime())
im[frame].draw()
myTimesB.append(timer.getTime())
window.flip()
for frame in [0, 1]:
Blank.draw()
window.flip()
keys = event.getKeys(keyList=['q', 'p', abortKey], timeStamped=timer)
if len(keys) == 0:
Reminder.draw()
window.flip()
keys = event.waitKeys(keyList=['q', 'p', abortKey], timeStamped=timer)
resp = keys[0][0]
rt = keys[0][1]
if resp == abortKey:
for i in range(framesPerSlot):
Quit.draw()
window.flip()
exit()
if resp == 'q':
respInt = 0
else:
respInt = 1
if (respInt == targ):
correct1.play()
core.wait(0.1)
correct2.play()
else:
error.play()
frameSkipped = 0
for a in range(numFrames):
if myTimesB[a] - myTimesA[a] > (1 / refreshRate - .001):
frameSkipped += 1
del (im)
core.wait(.5)
return (respInt, rt, frameSkipped)
for i in range(10):
fname.append(setDir + '/' + setPre + str(i) + setPost)
digImg.append(Image.open(fname[i]))
digImg.append(Image.open(setDir + '/' + setPre + 'AH-0.00' + setPost))
digImg.append(Image.open(setDir + '/' + setPre + 'AH-1.00' + setPost))
digImg.append(Image.open(setDir + '/' + setPre + '+' + setPost))
Xfix = []
for place in range(numPlaces):
Xfix.append(
visual.ImageStim(win=window,
pos=(posX[place], 0),
image=digImg[12],
opacity=1.0))
fix = visual.BufferImageStim(win=window, stim=Xfix, rect=[-.3, .1, .3, -.1])
Blank = visual.TextStim(window, text="", pos=(0, 0))
Welcome = visual.TextStim(
window,
text=
"Identify the letter that appears at the center of the screen\n\n\n Press the 'q' key for A\n\n Press the 'p' key for H\n\n\n\n Press any key to begin",
pos=(0, 0))
Pause = visual.TextStim(
window,
text="Press any key to continue to the next block of trials",
pos=(0, 0))
Reminder = visual.TextStim(window,
text="Please enter your response",
pos=(0, 0))
Quit = visual.TextStim(window, text="Quiting experiment...", pos=(0, 0))
def setup_visuals(self):
self.targets = list()
# all possible targets
tmp = list(self.static_settings['symbol_options'])
# compute per-person mapping
self.subject_rng = np.random.RandomState(
seed=int(self.settings['subject']))
self.subject_rng.shuffle(tmp)
tmp = ''.join(tmp) # convert from list to string
self.settings.update({'reordered_symbols': tmp})
tmp = tmp[:int(self.static_settings['n_choices'])]
if self.settings['stim_type'] == 'symbol':
for i in tmp:
self.targets.append(
visual.TextStim(self.win,
i,
height=0.25,
autoLog=True,
font='FreeMono',
name='stim ' + i))
elif self.settings['stim_type'] == 'letter':
for i in list(self.static_settings['key_options']):
self.targets.append(
visual.TextStim(self.win,
i,
height=0.25,
autoLog=True,
font='FreeMono',
name='stim ' + i))
elif self.settings['stim_type'] == 'hand':
right_hand = visual.ImageStim(self.win,
image='media/hand.png',
size=(0.3, 0.3),
pos=(0.14, 0))
left_hand = visual.ImageStim(self.win,
image='media/hand.png',
size=(0.3, 0.3),
pos=(-0.14, 0),
flipHoriz=True)
self.background = visual.BufferImageStim(
self.win, stim=[left_hand, right_hand])
# pinky, ring, middle, index, thumb
pos_l = [[-0.255, 0.0375], [-0.2075, 0.08875], [-0.1575, 0.1125],
[-0.095, 0.09], [-0.03, -0.0075]]
pos_r = [[-x, y] for x, y in pos_l]
pos_r.reverse()
pos_l.extend(pos_r)
pos_l = pos_l[:int(self.static_settings['n_choices'])]
self.targets = [
visual.Circle(self.win,
fillColor=(1, 1, 1),
pos=x,
size=0.03,
opacity=1.0,
name='stim %d' % c) for c, x in enumerate(pos_l)
]
else:
raise ValueError('Unknown stimulus option...')
if self.settings['remap']:
# remap heterologous, homologous, and same-finger pairs?
# swap the stimuli
for i, j in self.all_swaps:
self.targets[j], self.targets[i] = self.targets[
i], self.targets[j]
# push feedback
self.push_feedback = visual.Rect(self.win,
width=0.6,
height=0.6,
lineWidth=3,
name='push_feedback',
autoLog=False)
# text
self.instruction_text = visual.TextStim(self.win,
text='Press a key to start.',
pos=(0, 0),
units='norm',
color=(1, 1, 1),
height=0.1,
alignHoriz='center',
alignVert='center',
name='wait_text',
autoLog=False,
wrapWidth=2)
self.instruction_text.autoDraw = True
self.pause_text = visual.TextStim(self.win,
text=u'Take a break!',
pos=(0, 0.8),
units='norm',
color=(1, 1, 1),
height=0.1,
alignHoriz='center',
alignVert='center',
autoLog=True,
name='pause_text')
self.pause_text2 = visual.TextStim(
self.win,
text=u'Press ten times to continue.',
pos=(0, 0.7),
units='norm',
color=(1, 1, 1),
height=0.1,
alignHoriz='center',
alignVert='center',
autoLog=True,
name='pause_text')
choice_marker = visual.Rect(win, fillColor='gray', lineColor=None, width=SELECT_SIZE, height=SELECT_SIZE)
instruct = visual.TextStim(win, height=TEXT_HEIGHT, pos=(0, 2))
# Other stuff
writer = csvWriter(str(VARS['subject']), saveFolder=SAVE_FOLDER) # writer.write(trial) will write individual trials with low latency
# Make grid into a stimulus and make a list of coordinates to present the shapes
grid_coords = []
square_grid = visual.Rect(win, width=GRID_SIZE, height=GRID_SIZE, lineWidth=2, lineColor='white')
for y in range(GRID_LENGTH -1, -1, -1): # from top to bottom
for x in range(GRID_LENGTH): # left to right
grid_coords += [(GRID_SIZE*(x + 0.5 - 0.5*GRID_LENGTH),
GRID_SIZE*(y + 0.5 - 0.5*GRID_LENGTH))]
square_grid.pos = grid_coords[-1] # set to this x, y coordinate
square_grid.draw()
grid = visual.BufferImageStim(win) # "screenshot"
win.clearBuffer() # blank screen - we don't want to show it later
"""
PRESENT STIMULI
"""
def show_choice(volition):
""" Select color - either yourself (volition==True) or not (volition==False) """
# Instruction
instruct.text = TEXT_CHOICE_VOLITION if volition else TEXT_CHOICE_NONVOLITION
# Choose a pair of attributes
selected = random.randint(0, N_CHOICES - 1) # pre-select a random color
options = random.sample(attribute_choices, N_CHOICES)
rect = [-1, 1, 1, -1]
# rect is what rectangle to grab, here whole-screen (same as default).
# rect is a list of the edges: Left Top Right Bottom, norm units; try [-.5,.5,.5,-.5]
# No need to be symmetrical, but it works better for the demo.
# NB. If you change the rect and there was flickering on screen during the demo,
# it was likely due to alternating between drawing a partial screenshot
# interleaved with drawing all stimuli that went into it (only done for timing purposes).
# Such flicker is NOT intrinsic to BufferImageStim.
# In general, you do need to ensure that you
# take a snapshot of everything you want, which might not be whole-screen.
myClock = core.Clock()
t0 = myClock.getTime()
# and take a screen shot, from the back buffer by default:
screenshot = visual.BufferImageStim(myWin, rect=rect)
t1 = myClock.getTime() - t0 # record set-up time
# set up to display the screen-shot, img, plus moving text
wordsAnim = visual.TextStim(
myWin,
text=
'''everything static is a single .draw() %s\n\npress any key to quit.''' %
(str(screenshot.size)))
wordsAnim.pos[0] = -.25
drawTimeSingle = [] # accumulate draw times of the BufferImageStim
drawTimeMulti = [] # draw times of the pieces, as drawn separately (slowly)
frameCounter = 0
step = .002
event.clearEvents()
def doRSVPStim(trial):
'''
ONLY DOES ONE CUE AT THE MOMENT
This function generates the stimuli for each trial. The word "frame" here refers to a set of simultaneous RSVP stimuli. I'll use "refresh" to refer to monitor refreshes.
Using the parameters for the current trial:
- Work out the temporal position of the cue(s)
- Shuffle the order of the letters
- Calculate the position and cortically-magnified size for each stream
- draw and buffer preCues
- Capture each stream's pixels on each frame using bufferImageStim
- Collate each frame's pixels so that all stimuli are represented by the same matrix of pixels. Put the cue in there if it's the cued frame
- pass the matrix of pixels to elementarraystim
'''
global cue
nStreams = trial['nStreams']
numTargets = trial['numToCue']
cuedFrame = trial['cue0temporalPos']
cuedStream = np.random.choice(np.arange(nStreams), 1)
cue.pos = calcStreamPos(
trial = trial,
cueOffsets = cueOffsets,
streami = cuedStream,
streamOrNoise = False
)
cue = corticalMagnification.corticalMagnification(cue, 0.9810000000000002, cue = True) #this is the cuesize from the original experiment
preCues = list()
preCues.append(cue)
if trial['cueSpatialPossibilities'] == 2:
preCue = visual.Circle(myWin,
radius=cueRadius,#Martini used circles with diameter of 12 deg
lineColorSpace = 'rgb',
lineColor=letterColor,
lineWidth=2.0, #in pixels
units = 'deg',
fillColorSpace = 'rgb',
fillColor=None, #beware, with convex shapes fill colors don't work
pos= [-5,-5], #the anchor (rotation and vertices are position with respect to this)
interpolate=True,
autoLog=False)#this stim changes too much for autologging to be useful
preCue.pos = calcStreamPos(
trial = trial,
cueOffsets = cueOffsets,
streami = cuedStream-4,
streamOrNoise = False
)
preCue = corticalMagnification.corticalMagnification(preCue, 0.9810000000000002, cue = True)
preCues.append(preCue)
elif trial['cueSpatialPossibilities'] == 8:
for i in range(1,8):
preCue = visual.Circle(myWin,
radius=cueRadius,#Martini used circles with diameter of 12 deg
lineColorSpace = 'rgb',
lineColor=letterColor,
lineWidth=2.0, #in pixels
units = 'deg',
fillColorSpace = 'rgb',
fillColor=None, #beware, with convex shapes fill colors don't work
pos= [-5,-5], #the anchor (rotation and vertices are position with respect to this)
interpolate=True,
autoLog=False)#this stim changes too much for autologging to be useful
preCue.pos = (calcStreamPos(
trial = trial,
cueOffsets = cueOffsets,
streami = cuedStream-i,
streamOrNoise = False
))
preCue = corticalMagnification.corticalMagnification(preCue, 0.9810000000000002, cue = True)
preCues.append(preCue)
print('cueFrame = ' + str(cuedFrame))
preCueStim = preTrial[int(baseAngleCWfromEast/anglesMustBeMultipleOf)] + preCues + [fixatnPoint]
preCueFrame = visual.BufferImageStim(
win = myWin,
stim = preCueStim)
preCueFrame = np.flipud(np.array(preCueFrame.image)[..., 0]) / 255.0 * 2.0 - 1.0 #Via djmannion. This converts the pixel values from [0,255] to [-1,1]. I think 0 is middle grey. I'll need to change this to match the background colour eventually
preCueFrame = np.pad(
array=preCueFrame,
pad_width=pad_amounts, #See 'Buffered image size dimensions' section
mode="constant",
constant_values=0.0
)
preCueFrame =visual.ElementArrayStim(
win = myWin,
units = 'pix',
nElements=1,
xys = [[0,0]],
sizes=preCueFrame.shape,
elementTex=preCueFrame,
elementMask = 'none'
)
streamPositions = list() #Might need to pass this to elementArrayStim as xys. Might not though
streamLetterIdxs = np.empty( #use an array so I can select columns (frames) for buffering. This is an empty array that will eventually have the
#letter indexes for each stream. Selecting a column gives us all streams at a particular frame. Selecting a row gives us
#all frames for a particular stream
shape = (nStreams,numLettersToPresent),
dtype = int
)
streamLetterIdentities = np.empty( #Letter identities for these streams
shape = (nStreams,numLettersToPresent),
dtype = str
)
for thisStream in xrange(nStreams):
thisSequence = np.arange(24)
np.random.shuffle(thisSequence)
theseIdentities = [potentialLetters[idx] for idx in thisSequence]
streamLetterIdxs[thisStream,:] = thisSequence
streamLetterIdentities[thisStream,:] = theseIdentities
#print('For stream %(streamN)d the letters are: %(theseLetters)s' % {'streamN':thisStream, 'theseLetters':''.join(theseIdentities)})
correctIdx = streamLetterIdxs[cuedStream,cuedFrame]
print('correctIdx')
print(correctIdx)
correctLetter = alphabetHelpers.numberToLetter(correctIdx, potentialLetters) #potentialLetters is global
frameStimuli = list() #A list of elementArrayStim objects, each represents a frame. Drawing one of these objects will draw the letters and the cue for that frame
for thisFrame in xrange(numLettersToPresent):
theseStimuli = streamLetterIdxs[:,thisFrame] #The alphabetical indexes of stimuli to be shown on this frame
stimuliToDraw = list() #Can pass a list to bufferimageStim!
stimuliToDraw.append(fixatn)
stimuliToDrawCounterPhase = list()
stimuliToDrawCounterPhase.append(fixatnCounterphase)
for thisStream in xrange(nStreams):
cueThisFrame = thisStream == cuedStream and thisFrame == cuedFrame #If true, draw the cue and capture that too
thisLetterIdx = theseStimuli[thisStream] #The letter index for this particular stream on this particular frame
thisStreamStimulus = streamTextObjects[thisStream,thisLetterIdx] #The text object for this stream
thisPos = calcStreamPos(
trial = trial,
cueOffsets = cueOffsets,
streami = thisStream,
streamOrNoise = False
)
thisStreamStimulus.pos = thisPos
stimuliToDraw.append(thisStreamStimulus)
stimuliToDrawCounterPhase.append(thisStreamStimulus)
if cueThisFrame and cueType == 'exogenousRing':
stimuliToDraw.append(cue)
stimuliToDrawCounterPhase.append(cue)
buff = visual.BufferImageStim( #Buffer these stimuli
win = myWin,
stim = stimuliToDraw
)
buff = np.flipud(np.array(buff.image)[..., 0]) / 255.0 * 2.0 - 1.0 #Via djmannion. This converts the pixel values from [0,255] to [-1,1]. I think 0 is middle grey. I'll need to change this to match the background colour eventually
buff = np.pad(
array=buff,
pad_width=pad_amounts, #See 'Buffered image size dimensions' section
mode="constant",
constant_values=0.0
)
thisFrameStimuli = visual.ElementArrayStim( #A stimulus representing this frame with the fixation at full luminance
win = myWin,
units = 'pix',
nElements=1,
xys = [[0,0]],
sizes=buff.shape,
elementTex=buff,
elementMask = 'none'
)
buff = visual.BufferImageStim( #Buffer these stimuli
win = myWin,
stim = stimuliToDrawCounterPhase
)
buff = np.flipud(np.array(buff.image)[..., 0]) / 255.0 * 2.0 - 1.0 #Via djmannion. This converts the pixel values from [0,255] to [-1,1]. I think 0 is middle grey. I'll need to change this to match the background colour eventually
buff = np.pad(
array=buff,
pad_width=pad_amounts, #See 'Buffered image size dimensions' section
mode="constant",
constant_values=0.0
)
thisFrameStimuliCounterPhase = visual.ElementArrayStim( #A stimulus representing this frame with the fixation phase reversed
win = myWin,
units = 'pix',
nElements=1,
xys = [[0,0]],
sizes=buff.shape,
elementTex=buff,
elementMask = 'none'
)
frameStimuli.append([thisFrameStimuli, thisFrameStimuliCounterPhase])
ts = []
waiting = True
myMouse.setVisible(waiting)
while waiting:
startTrialStimuli.draw()
startTrialBox.draw()
myWin.flip()
if myMouse.isPressedIn(startTrialBox):
waiting = False
myMouse.setVisible(waiting)
if eyetracking:
tracker.startEyeTracking(nDone,True,widthPix,heightPix) #start recording with eyetracker
myWin.flip(); myWin.flip()#Make sure raster at top of screen (unless not in blocking mode), and give CPU a chance to finish other tasks
preCueFrame.draw()
myWin.flip()
core.wait(.25)
myWin.flip
core.wait(.5)
fixatn.draw()
myWin.flip()
core.wait(1)
t0 = trialClock.getTime()
for n in xrange(trialDurFrames):
oneFrameOfStim(n, frameStimuli)
myWin.flip()
ts.append(trialClock.getTime() - t0)
if eyetracking:
tracker.stopEyeTracking()
print('stopped tracking')
return streamLetterIdxs, streamLetterIdentities, correctLetter, ts, cuedStream, cuedFrame
digImg.append(Image.open(fname[i])) # png image handle
digImg.append(Image.open(setDir + '/' + setPre + 'AH-0.00' + setPost))
digImg.append(Image.open(setDir + '/' + setPre + 'AH-1.00' + setPost))
digImg.append(Image.open(setDir + '/' + setPre + '+' + setPost))
digImg.append(Image.open(setDir + '/' + setPre + 'rect' + setPost))
Xfix = []
for place in range(numPlaces):
Xfix.append(
visual.ImageStim(win=window,
pos=(posX[place], -200),
image=digImg[12],
opacity=0.5))
fix = visual.BufferImageStim(
win=window, stim=Xfix,
rect=[-.3, 1, .3, -1]) # create a fast bufferimage for fast rendering
Blank = visual.TextStim(window, text="", pos=(0, 0))
Welcome = visual.TextStim(
window,
text=
"Identify the letter that appears at the center of the screen\n\n\n Press the 'q' key using your LEFT hand for A\n\n Press the 'p' key using your RIGHT hand for H\n\n\n\n Press any key to begin",
pos=(0, 0))
Pause = visual.TextStim(
window,
text="Press any key to continue to the next block of trials",
pos=(0, 0))
Reminder = visual.TextStim(window,
text="Please enter your response",
pos=(0, 0))
def _config_screen(self):
width, height = self.win.size
self._L_squS = round(min(width, height) * 0.9 / 18)
# define
mesh_col, mesh_row = np.meshgrid(np.arange(6), np.arange(6))
p_col = (-7.5 + 3 * mesh_col) * self._L_squS
p_row = (6.5 - 3 * mesh_row) * self._L_squS
self.rect_pos = pos = np.stack((p_col, p_row), axis=2)
for i in range(pos.shape[0]):
# i means row
for j in range(pos.shape[1]):
# j means col
rect = visual.Rect(self.win,
width=self._L_squS,
height=self._L_squS,
lineColor='black',
fillColor='white',
pos=(pos[i, j, 0], pos[i, j, 1]),
units='pix')
self._rects.append(rect)
text = visual.TextStim(self.win,
text=chr(word[6 * i + j]),
pos=(pos[i, j, 0], pos[i, j, 1]),
color='black',
height=self._L_squS / 3 * 2,
units='pix')
self._texts.append(text)
# target string
# left for horizontal alignment
display_str = self._split_string(0, self.max_string_display)
self._target_string = visual.TextStim(self.win,
text=display_str,
font='Courier New',
color='black',
height=50,
pos=(self.rect_pos[0, 0, 0], 0.47 * height),
wrapWidth=self.rect_pos[0, -1, 0] - self.rect_pos[0, 0, 0],
alignHoriz='left')
self._result_string = visual.TextStim(self.win,
text='',
font='Courier New',
color='red',
height=50,
pos=(self.rect_pos[0, 0, 0], 0.42 * height),
wrapWidth=self.rect_pos[0, -1, 0] - self.rect_pos[0, 0, 0],
alignHoriz='left',
italic=True)
# left horizontal alignment
# Update its text when getting new result
# 6 bars or 12
bar_num = self.events_per_trial if self._stim_direction is None else self.events_per_trial // 2
for i in range(bar_num):
self._bars.append(visual.Line(self.win,
start=(0, 0),
end=(0, -self._L_squS),
lineColor=self.colors[i % len(self.colors)],
lineColorSpace='rgb255',
lineWidth=5))
self._background = visual.BufferImageStim(self.win, stim=self._rects + self._texts)
def rate_CMC(feature1, feature2):
"""Show alternative CMCs and ask participants which they prefer"""
# Instruction
text = texts['rate_instruct'] % (feature_reminders2[feature1].upper(),
feature_reminders2[feature2].upper())
any_auditory = 'auditory' in (modalities[feature1], modalities[feature2])
if any_auditory:
text += texts['rate_click']
# Get a simgle trial, just to get it's data structure
trials = make_trials(task=feature1, inducer=feature2, phase='rate')
trial = random.choice(trials) # Use one base stimulus
# Show a neutral placeholder, even if there is nothing visual.
if not trial['any_visual']:
trial['any_visual'] = 1
trial['shape'] = trial['complexity'] = trial['hue'] = trial[
'lightness'] = 'neutral'
# SCREENSHOT
# Setting actual features and showing stimuli
# We will address stimuli by their position[column][row]
order = [[[0, 0], [1, 1]],
[[0, 1],
[1,
0]]] # Order of the features in the format: order[column][row]
groups = [0, 1]
examples = [0, 1]
for group in groups:
for example in examples:
# Set trial features
trial[feature1] = features[feature1][
order[group][example][0]] # Some heavy indexing here!
trial[feature2] = features[feature2][order[group][example][1]]
trial['flip'] = 0 # So that figure and outline match
# Prepare figure and show it
figure = prepare_figure(trial,
pos=RATING_POSITIONS[group][example])
figure.draw()
# Take screenshot before drawing
instruction.pos = TEXT_POS
instruction.text = text
instruction.draw()
rating_screen = visual.BufferImageStim(win)
rating_screen.draw() # First draw is slower
win.clearBuffer() # Preparation finished. Delete what's been drawn so far
win.callOnFlip(clock.reset) # Set time=0 on first draw hereafter
# REGISTER RESPONSES WHEN AUDIO IS INVOLVED
# Mouse clicks on trials with an auditory component
if any_auditory:
# Continue until all shapes are pressed
figure_untouched = [[True, True], [True,
True]] # not_clicked[group][row]
awaiting_beeps = True
awaiting_keyboard = True
while awaiting_beeps or awaiting_keyboard:
# Show it. Only show VAS when all sounds have been played
rating_screen.draw()
if not awaiting_beeps:
VAS.draw()
press = event.getKeys(keyList=['escape'])
if press:
core.quit()
# Continue until there is a VAS response
if not VAS.noResponse:
awaiting_keyboard = False # Do not listen for responses anymore
win.flip()
# Virtually loop through figures and listen for mouse presses on them
for group in groups:
for example in examples:
figure_fill.pos = RATING_POSITIONS[group][example]
# Play sound and register
if mouse.isPressedIn(figure_fill):
# Play sound
trial[feature1] = features[feature1][order[group][
example][0]] # Some heavy indexing here!
trial[feature2] = features[feature2][order[group]
[example][1]]
beep = prepare_beep(trial)
beep.play()
# Register click
figure_untouched[group][example] = False
# Wait for mouse release
while mouse.isPressedIn(figure_fill):
pass
# Status: how many touched now?
awaiting_beeps = any(figure_untouched[0]) or any(
figure_untouched[1])
# Simulate responses prematurely
if DIALOGUE['simulation'] == 'yes':
figure_untouched = [[False, False], [False, False]]
VAS.noResponse = False
VAS.FINISHED = True
VAS.decisionTime = random.random()
# REGISTER RESPONSES FOR PURELY VISUAL CMCS
else:
# Simulate responses prematurely
if DIALOGUE['simulation'] == 'yes':
clock.reset(newT=RATING_WAIT + 1)
VAS.noResponse = False
VAS.FINISHED = True
VAS.decisionTime = random.random()
# Get response: new example or rate it?
while VAS.noResponse:
rating_screen.draw()
if clock.getTime() > RATING_WAIT:
VAS.draw()
win.flip()
# SCORE TRIAL
trial['key'] = VAS.getRating()
trial['rt'] = VAS.getRT()
VAS.reset() # Ready for next rating
# Trial info since we messed with these since make_block
trial['left'] = features[feature1][
order[0][0][0]] + ':' + features[feature2][order[0][0][1]]
trial['right'] = features[feature1][
order[1][0][0]] + ':' + features[feature2][order[1][0][1]]
trial['CMC_code'] = '%s:%s' % (trial[feature1], trial[feature2]
) # Update code to match
writer.write(trial)
writer.flush()
# Optionally quit
if event.getKeys(QUIT_KEYS):
check_quit(
QUIT_KEYS[0]
) # Convoluted since we know that any response is a quit response; but consistently runs the same code on quit
def setup_visuals(self):
right_hand = visual.ImageStim(self.win,
image='media/hand.png',
size=(0.4, 0.4),
pos=(0.3, 0),
ori=-90)
left_hand = visual.ImageStim(self.win,
image='media/hand.png',
size=(0.4, 0.4),
pos=(-0.3, 0),
ori=90,
flipHoriz=True)
self.background = visual.BufferImageStim(self.win,
stim=[left_hand, right_hand])
# self.background.autoDraw = True
# thumb, index, middle, ring, pinky
pos_r = [[0.3075, -0.1525], [0.1775, -0.06125], [0.14375, 0.02375],
[0.1775, 0.0925], [0.2475, 0.1525]]
pos_l = [[-x[0], x[1]] for x in pos_r]
pos_l.reverse()
pos_l.extend(pos_r)
self.targets = [
visual.Circle(self.win,
fillColor=(0.3, -0.2, -0.2),
pos=x,
size=0.05,
opacity=1.0) for x in pos_l
]
# push feedback
self.push_feedback = visual.Circle(self.win,
size=0.1,
fillColor=[-1, -1, -1],
pos=(0, 0),
autoDraw=False,
autoLog=False,
name='push_feedback')
# fixation
self.fixation = visual.Circle(self.win,
size=0.05,
fillColor=[1, 1, 1],
pos=(0, 0),
autoDraw=False,
name='fixation')
# text
self.wait_text = visual.TextStim(self.win,
text='Press a key to start.',
pos=(0, 0),
units='norm',
color=(1, 1, 1),
height=0.2,
alignHoriz='center',
alignVert='center',
name='wait_text',
autoLog=False,
wrapWidth=2)
self.wait_text.autoDraw = True
self.good = visual.TextStim(self.win,
text=u'Good timing!',
pos=(0, 0.4),
units='norm',
color=(-1, 1, 0.2),
height=0.1,
alignHoriz='center',
alignVert='center',
autoLog=True,
name='good_text')
self.too_slow = visual.TextStim(self.win,
text=u'Too slow.',
pos=(0, 0.4),
units='norm',
color=(1, -1, -1),
height=0.1,
alignHoriz='center',
alignVert='center',
autoLog=True,
name='slow_text')
self.too_fast = visual.TextStim(self.win,
text=u'Too fast.',
pos=(0, 0.4),
units='norm',
color=(1, -1, -1),
height=0.1,
alignHoriz='center',
alignVert='center',
autoLog=True,
name='fast_text')
units='pix',
bold=True,
height=text_size,
text='$') # '$' will be changed
cap_rect_norm = [
-(text_size / 2.0) / (task.win.size[0] / 2.0), # left
+(text_size / 2.0) / (task.win.size[1] / 2.0), # top
+(text_size / 2.0) / (task.win.size[0] / 2.0), # right
-(text_size / 2.0) / (task.win.size[1] / 2.0) # bottom
]
ringimg = {}
for k in ['rew', 'neu']:
ringtext.text = cues[k]['sym']
ringtext.color = cues[k]['color']
buff = visual.BufferImageStim(win=task.win,
stim=[ringtext],
rect=cap_rect_norm)
# img = (np.flipud(np.array(buff.image)[..., 0]) / 255.0 * 2.0 - 1.0)
ringimg[k] = visual.ElementArrayStim(
win=task.win,
units="pix",
nElements=n_in_ring,
sizes=buff.image.size,
xys=el_xys,
# colors=cues[k]['color'],
elementMask=None,
elementTex=buff.image)
# ----- INSTRUCTIONS ------
if settings['instructions']:
cuesym = cues['rew']['sym']
def doRSVPStim(trial):
'''
ONLY DOES ONE CUE AT THE MOMENT
This function generates the stimuli for each trial. The word "frame" here refers to a set of simultaneous RSVP stimuli. I'll use "refresh" to refer to monitor refreshes.
Using the parameters for the current trial:
- Work out the temporal position of the cue(s)
- Shuffle the order of the letters
- Calculate the position and cortically-magnified size for each stream
- Capture each stream's pixels on each frame using bufferImageStim
- Collate each frame's pixels so that all stimuli are represented by the same matrix of pixels. Put the cue in there if it's the cued frame
- pass the matrix of pixels to elementarraystim
'''
global cue
nStreams = trial['nStreams']
numTargets = trial['numToCue']
cuedFrame = trial['cue0temporalPos']
cuedStream = np.random.choice(np.arange(nStreams), 1)
print('cueFrame = ' + str(cuedFrame))
streamPositions = list(
) #Might need to pass this to elementArrayStim as xys. Might not though
streamLetterIdxs = np.empty( #use an array so I can select columns (frames) for buffering. This is an empty array that will eventually have the
#letter indexes for each stream. Selecting a column gives us all streams at a particular frame. Selecting a row gives us
#all frames for a particular stream
shape=(nStreams, numLettersToPresent),
dtype=int)
streamLetterIdentities = np.empty( #Letter identities for these streams
shape=(nStreams, numLettersToPresent),
dtype=str)
for thisStream in xrange(nStreams):
thisSequence = np.arange(24)
np.random.shuffle(thisSequence)
theseIdentities = [potentialLetters[idx] for idx in thisSequence]
streamLetterIdxs[thisStream, :] = thisSequence
streamLetterIdentities[thisStream, :] = theseIdentities
#print('For stream %(streamN)d the letters are: %(theseLetters)s' % {'streamN':thisStream, 'theseLetters':''.join(theseIdentities)})
correctIdx = streamLetterIdxs[cuedStream, cuedFrame]
correctLetter = alphabetHelpers.numberToLetter(
correctIdx, potentialLetters) #potentialLetters is global
frameStimuli = list(
) #A list of elementArrayStim objects, each represents a frame. Drawing one of these objects will draw the letters and the cue for that frame
for thisFrame in xrange(numLettersToPresent):
theseStimuli = streamLetterIdxs[:,
thisFrame] #The stimuli to be shown on this frame
thisFramePixels = np.zeros(shape=(screenValues['heightPix'],
screenValues['widthPix']))
stimuliToDraw = list() #Can pass a list to bufferimageStim!
for thisStream in xrange(nStreams):
cueThisFrame = thisStream == cuedStream and thisFrame == cuedFrame #If true, draw the cue and capture that too
thisLetterIdx = theseStimuli[
thisStream] #The letter index for this particular stream on this particular frame
thisLtr = alphabetHelpers.numberToLetter(thisLetterIdx,
potentialLetters)
thisStreamStimulus = streamTextObjects[
thisStream] #The text object for this stream
thisStreamStimulus.text = thisLtr
thisPos = calcStreamPos(trial=trial,
cueOffsets=cueOffsets,
streami=thisStream,
streamOrNoise=False)
thisStreamStimulus.pos = thisPos
stimuliToDraw.append(thisStreamStimulus)
if cueThisFrame and cueType == 'exogenousRing':
cue.setPos(thisPos)
cue = corticalMagnification.corticalMagnification(
cue, 0.9810000000000002, cue=True
) #this is the cuesize from the original experiment
stimuliToDraw.append(cue)
buff = visual.BufferImageStim( #Buffer these stimuli
win=myWin, stim=stimuliToDraw)
buff = np.flipud(
np.array(buff.image)[..., 0]
) / 255.0 * 2.0 - 1.0 #Via djmannion. This converts the pixel values from [0,255] to [-1,1]. I think 0 is middle grey. I'll need to change this to match the background colour eventually
new_size = max( #need to pad out the texture to a power of two to use it in elementArrayStim
[
int(np.power(2, np.ceil(np.log(dim_size) / np.log(2))))
for dim_size in buff.shape
])
pad_amounts = []
for i_dim in range(2):
first_offset = int((new_size - buff.shape[i_dim]) / 2.0)
second_offset = new_size - buff.shape[i_dim] - first_offset
pad_amounts.append([first_offset, second_offset])
buff = np.pad(array=buff,
pad_width=pad_amounts,
mode="constant",
constant_values=0.0)
thisFrameStimuli = visual.ElementArrayStim( #A stimulus representing this frame
win=myWin,
units='pix',
nElements=1,
xys=[[0, 0]],
sizes=buff.shape,
elementTex=buff,
elementMask='none')
frameStimuli.append(thisFrameStimuli)
ts = []
myWin.flip()
myWin.flip(
) #Make sure raster at top of screen (unless not in blocking mode), and give CPU a chance to finish other tasks
t0 = trialClock.getTime()
for n in xrange(trialDurFrames):
oneFrameOfStim(n, frameStimuli)
myWin.flip()
ts.append(trialClock.getTime() - t0)
return streamLetterIdxs, streamLetterIdentities, correctLetter, ts
imageList = ['face.jpg', 'beach.jpg']
imageStim = visual.SimpleImageStim(win, imageList[0])
imageStim2 = visual.SimpleImageStim(win, imageList[1], pos=(.300, .20))
wordStim = visual.TextStim(
win,
text=
'Press < escape > to quit.\n\nThere should be no change after 3 seconds.\n\n'
+ 'This is a text stim that is kinda verbose and long, so if it ' +
'were actually really long it would take a while to render completely.',
pos=(0, -.2))
stimlist = [imageStim, imageStim2, wordStim]
# Get and save a "screen shot" of everything in stimlist:
rect = (-1, 1, 1, -1)
t0 = clock.getTime()
screenshot = visual.BufferImageStim(win, stim=stimlist, rect=rect)
# rect is the screen rectangle to grab, (-1, 1, 1, -1) is whole-screen
# as a list of the edges: Left Top Right Bottom, in norm units.
captureTime = clock.getTime() - t0
instr_buffer = visual.TextStim(win, text='BufferImageStim', pos=(0, .8))
drawTimeBuffer = [] # accumulate draw times of the screenshot
for frameCounter in range(200):
t0 = clock.getTime()
screenshot.draw() # draw the BufferImageStim, fast
drawTimeBuffer.append(clock.getTime() - t0)
instr_buffer.draw()
win.flip()
if len(event.getKeys(['escape'])):
core.quit()
def runCSRecallGrid(trial):
"""Recall faces"""
# PREPERATION
# Create a list "itemOptions of items to show as response options. All of targets + some fill-ins
if trial['stimType'] == 'faces': allItems = faceFiles
elif trial['stimType'] == 'lettersGrid': allItems = string.ascii_uppercase
itemFillin = list(set(allItems) - set(
trial['encode'])) # allowable fill-in response options (non-targets)
itemFillin = random.sample(itemFillin,
len(gridCoords) -
trial['span']) # selected fill-in items
itemOptions = trial['encode'] + itemFillin # items for this answer
if trial['stimType'] == 'faces':
itemOptions = random.sample(itemOptions,
len(itemOptions)) # randomize order
if trial['stimType'] == 'lettersGrid':
itemOptions.sort() # sort alphabetically
# Create a BufferImageStim "grid" with an array of target and fill-in faces or letters
for i, item in enumerate(itemOptions):
if trial['stimType'] == 'faces':
recallOption.pos = gridCoords[i] # set position
recallOption.image = item
recallOption.draw()
elif trial['stimType'] == 'lettersGrid':
letterStim.pos = gridCoords[i]
letterStim.text = item
letterStim.draw()
textRecall.text = 'Select ' + str(
trial['span']
) + ' items in their correct position in the presented sequence.\nPress SPACE to select and deselect. Press RETURN to submit answer.'
textRecall.draw()
grid = visual.BufferImageStim(win) # take screenshot of back buffer
win.clearBuffer() # clear back buffer
# ACTUAL RECALL
win.callOnFlip(clock.reset) # reset clock on next flip
selectedCurrent = len(
itemOptions
) / 2 # placeholder for current selected face. Starts in center
selected = [] # placeholder for current answer
while True:
# Draw images
grid.draw()
grid.draw(
) # because it sometimes doesn't work on first draw on bad graphics hardware!
# Overlay current selection state
for i, thisSelection in enumerate(selected):
# Color overlay
recallSelectedOverlay.pos = gridCoords[thisSelection]
recallSelectedOverlay.draw()
# Sequence number
numCoord = gridCoords[thisSelection] + [
1, -1
] * recallOption.size * 0.3 # location off-center
recallSelectedNumber.pos = numCoord
recallSelectedNumber.text = i + 1 # show 1, 2, 3, etc. and not 0, 1, 2
recallSelectedNumber.draw()
# Border around current selected image
recallSelectedCurrent.pos = gridCoords[selectedCurrent]
recallSelectedCurrent.draw()
# Show everything!
win.flip()
# Wait for response. On every keypress, update the textfield until keysAns is pressed
response = event.waitKeys(keyList=keysRecallFaces.keys() + keysSelect +
keysAns + keysQuit + keysQuestionnaire)
eventOnKey(response[0]) # exit or go to questions
# Move current location
if response[0] in keysRecallFaces.keys():
if 0 <= selectedCurrent + keysRecallFaces[response[0]] < len(
itemOptions):
selectedCurrent += keysRecallFaces[response[0]]
# Add or remove an element to the current selection
elif response[0] in keysSelect:
if selectedCurrent in selected:
selected.remove(selectedCurrent)
elif len(selected
) < trial['span']: # only add if series is not filled
selected.append(selectedCurrent)
# Answer submitted. Record and score response
elif response[0] in keysAns and len(selected) == trial['span']:
trial['recallRT'] = clock.getTime()
trial['recallAns'] = [
itemOptions[index] for index in selected
] # convert indicies to image filenames for the datafile
# Score trial and break out of while loop (finished OSPAN)
trial = scoreCS(trial)
break
return trial
def doRSVPStim(trial):
'''
ONLY DOES ONE CUE AT THE MOMENT
This function generates the stimuli for each trial. The word "frame" here refers to a set of simultaneous RSVP stimuli. I'll use "refresh" to refer to monitor refreshes.
Using the parameters for the current trial:
- Work out the temporal position of the cue(s)
- Shuffle the order of the letters
- Calculate the position and cortically-magnified size for each stream
- Capture each stream's pixels on each frame using bufferImageStim
- Collate each frame's pixels so that all stimuli are represented by the same matrix of pixels. Put the cue in there if it's the cued frame
- pass the matrix of pixels to elementarraystim
'''
global cue
global tracker
nStreams = trial['nStreams']
numTargets = trial['numToCue']
cuedFrame = trial['cue0temporalPos']
cuedStream = 0 #np.random.choice(np.arange(nStreams), 1)
maxCueCount = np.ceil(float(trials.nTotal) / float(nStreams) / 2.)
indexOfThisNStreams = nStreamsPossibilities.index(nStreams)
theseCueCounts = countsList[
indexOfThisNStreams] #Get the counts of the number of times each position has been cued
theseCueCountsNotComplete = [
index for index, value in enumerate(theseCueCounts)
if value < maxCueCount
] #Find those counts less than the max possible
print('theseCueCountsNotComplete')
print(theseCueCountsNotComplete)
cuedStream = np.random.choice(theseCueCountsNotComplete,
1)[0] #sample a position, cue it
countsList[indexOfThisNStreams][cuedStream] += 1 #Increment the count
print('cuedStream is ' + str(cuedStream))
print(theseCueCounts)
print('cueFrame = ' + str(cuedFrame))
streamPositions = list(
) #Might need to pass this to elementArrayStim as xys. Might not though
streamLetterIdxs = np.empty( #use an array so I can select columns (frames) for buffering. This is an empty array that will eventually have the
#letter indexes for each stream. Selecting a column gives us all streams at a particular frame. Selecting a row gives us
#all frames for a particular stream
shape=(nStreams, numLettersToPresent),
dtype=int)
streamLetterIdentities = np.empty( #Letter identities for these streams
shape=(nStreams, numLettersToPresent),
dtype=str)
for thisStream in xrange(nStreams):
thisSequence = np.arange(24)
np.random.shuffle(thisSequence)
theseIdentities = [potentialLetters[idx] for idx in thisSequence]
streamLetterIdxs[thisStream, :] = thisSequence
streamLetterIdentities[thisStream, :] = theseIdentities
#print('For stream %(streamN)d the letters are: %(theseLetters)s' % {'streamN':thisStream, 'theseLetters':''.join(theseIdentities)})
print(streamLetterIdentities)
correctIdx = streamLetterIdxs[cuedStream, cuedFrame]
print('correctIdx')
print(correctIdx)
correctLetter = alphabetHelpers.numberToLetter(
correctIdx, potentialLetters) #potentialLetters is global
frameStimuli = list(
) #A list of elementArrayStim objects, each represents a frame. Drawing one of these objects will draw the letters and the cue for that frame
for thisFrame in xrange(numLettersToPresent):
theseStimuli = streamLetterIdxs[:,
thisFrame] #The alphabetical indexes of stimuli to be shown on this frame
### IN DO RSVP STIM ###
stimuliToDraw = list() #Can pass a list to bufferimageStim!
stimuliToDraw.append(fixatn)
stimuliToDrawCounterPhase = list()
stimuliToDrawCounterPhase.append(fixatnCounterphase)
for thisStream in xrange(nStreams):
thisPos = calcStreamPos(trial=trial,
cueOffsets=cueOffsets,
streami=thisStream,
streamOrNoise=False)
cueThisFrame = thisStream == cuedStream and thisFrame == cuedFrame #If true, draw the cue and capture that too
thisLetterIdx = theseStimuli[
thisStream] #The letter index for this particular stream on this particular frame
if nStreams == 2 and max(nStreamsPossibilities) > 2:
#print('Stream was' + str(thisStream) +', but is now' + str(trial['ring']*streamsPerRing+thisStream))
thisStreamStimulus = streamTextObjects[trial['ring'] *
streamsPerRing +
thisStream,
thisLetterIdx]
else:
thisStreamStimulus = streamTextObjects[thisStream,
thisLetterIdx]
thisStreamStimulus.pos = thisPos
#print('For stream %(thisStream)d the height is: %(letterHeight)s' % {'thisStream':thisStream, 'letterHeight':thisStreamStimulus.height})
stimuliToDraw.append(thisStreamStimulus)
stimuliToDrawCounterPhase.append(thisStreamStimulus)
if cueThisFrame and cueType == 'exogenousRing':
cue.setPos(thisPos)
cue = corticalMagnification.corticalMagnification(
cue, 0.9810000000000002, cue=True
) #this is the cuesize from the original experiment
stimuliToDraw.append(cue)
stimuliToDrawCounterPhase.append(cue)
buff = visual.BufferImageStim( #Buffer these stimuli
win=myWin, stim=stimuliToDraw)
buff = np.flipud(
np.array(buff.image)[..., 0]
) / 255.0 * 2.0 - 1.0 #Via djmannion. This converts the pixel values from [0,255] to [-1,1]. I think 0 is middle grey. I'll need to change this to match the background colour eventually
buff = np.pad(
array=buff,
pad_width=pad_amounts, #See 'Buffered image size dimensions' section
mode="constant",
constant_values=0.0)
thisFrameStimuli = visual.ElementArrayStim( #A stimulus representing this frame with the fixation at full luminance
win=myWin,
units='pix',
nElements=1,
xys=[[0, 0]],
sizes=buff.shape,
elementTex=buff,
elementMask='none')
buff = visual.BufferImageStim( #Buffer these stimuli
win=myWin, stim=stimuliToDrawCounterPhase)
buff = np.flipud(
np.array(buff.image)[..., 0]
) / 255.0 * 2.0 - 1.0 #Via djmannion. This converts the pixel values from [0,255] to [-1,1]. I think 0 is middle grey. I'll need to change this to match the background colour eventually
buff = np.pad(
array=buff,
pad_width=pad_amounts, #See 'Buffered image size dimensions' section
mode="constant",
constant_values=0.0)
thisFrameStimuliCounterPhase = visual.ElementArrayStim( #A stimulus representing this frame with the fixation phase reversed
win=myWin,
units='pix',
nElements=1,
xys=[[0, 0]],
sizes=buff.shape,
elementTex=buff,
elementMask='none')
frameStimuli.append([thisFrameStimuli, thisFrameStimuliCounterPhase])
ts = []
waiting = True
myMouse.setVisible(waiting)
while waiting:
startTrialStimuli.draw()
startTrialBox.draw()
myWin.flip()
if myMouse.isPressedIn(startTrialBox):
waiting = False
myMouse.setVisible(waiting)
if eyetracking:
tracker.startEyeTracking(nDone, True, widthPix,
heightPix) #start recording with eyetracker
ts = []
myWin.flip()
myWin.flip(
) #Make sure raster at top of screen (unless not in blocking mode), and give CPU a chance to finish other tasks
fixatn.draw()
myWin.flip()
core.wait(1)
t0 = trialClock.getTime()
for n in xrange(trialDurFrames):
oneFrameOfStim(n, frameStimuli)
myWin.flip()
ts.append(trialClock.getTime() - t0)
if eyetracking:
tracker.stopEyeTracking()
print('stopped tracking')
return streamLetterIdxs, streamLetterIdentities, correctLetter, ts, cuedStream, cuedFrame
def loadvisuals(win,
cwd,
masksize,
stimsize,
crosssize,
factor,
xcoo,
ycoo,
xyconfigs,
trial,
pos=4):
#Text
instructions = visual.TextStim(win=win,
units='norm',
height=0.1,
wrapWidth=1.7,
alignHoriz='center',
text="Press space to begin")
feedback = visual.TextStim(win=win,
units='norm',
alignHoriz='center',
height=0.1,
text="End of block ")
infoscr = visual.TextStim(
win=win,
units='norm',
height=0.1,
wrapWidth=1.7,
alignHoriz='center',
text="[C]alibration\n[B]uttons\n[T]rial number\n[S]tart " +
trial[1:].lower())
# fixation cross
fixation = visual.ShapeStim(win,
vertices=((0, -0.5 * crosssize),
(0, 0.5 * crosssize), (0, 0),
(-0.5 * crosssize,
0), (0.5 * crosssize, 0)),
lineWidth=round(crosssize / 8),
closeShape=False,
lineColor="red")
# fixation cross
fixation2 = visual.ShapeStim(win,
vertices=((0, -0.5 * crosssize),
(0, 0.5 * crosssize), (0, 0),
(-0.5 * crosssize,
0), (0.5 * crosssize, 0)),
lineWidth=round(crosssize / 8),
closeShape=False,
lineColor="white")
###############################################################################
# prepare cues
r = crosssize / 2.5
cuecolors = [[1, -1, -1], [-1, -0.06, 1],
[-1, -1, -1]] # test for equal luminance Blue [-1,-1,1] 6
colorsq = [[0, 1, 1, 1], [1, 0, 1, 1], [1, 1, 0, 1], [1, 1, 1, 0],
[0, 1, 1, 0], [1, 0, 0, 1], [0, 0, 0, 0]]
ss = 10
xycoo0 = [[xcoo[0] / ss, ycoo[0] / ss], [xcoo[1] / ss, ycoo[1] / ss],
[xcoo[2] / ss, ycoo[1] / ss], [xcoo[3] / ss, ycoo[0] / ss]]
xycoo1 = [[xcoo[0] / ss, ycoo[3] / ss], [xcoo[1] / ss, ycoo[2] / ss],
[xcoo[2] / ss, ycoo[2] / ss], [xcoo[3] / ss, ycoo[3] / ss]]
clb0, clb1 = [[visual.BufferImageStim(win)]
] * 7, [[visual.BufferImageStim(win)]] * 7
for c in range(len(clb0)):
cuelist0 = [visual.Circle(win=win)] * 4 + [fixation]
for d in range(4):
cuelist0[d] = visual.Circle(win=win,
units='pix',
radius=r,
fillColor=cuecolors[colorsq[c][d]],
lineColor=cuecolors[colorsq[c][d]],
pos=(xycoo0[d]))
clb0[c] = visual.BufferImageStim(win, stim=cuelist0)
for c in range(len(clb0)):
cuelist1 = [visual.Circle(win=win)] * 4 + [fixation]
for d in range(4):
cuelist1[d] = visual.Circle(win=win,
units='pix',
radius=r,
fillColor=cuecolors[colorsq[c][d]],
lineColor=cuecolors[colorsq[c][d]],
pos=(xycoo1[d]))
clb1[c] = visual.BufferImageStim(win, stim=cuelist1)
cue_list = [clb0, clb1]
###############################################################################
# load masks, stimuli, probe
mask_imgs = []
for i in os.listdir(cwd + "/masks"):
if i.startswith("Mask") and i.endswith(".bmp"):
mask_imgs.append(cwd + "/masks/" + i)
# create visuals
mask_display, stim_display = [], []
for i in range(pos):
m = visual.ImageStim(win=win, units='pix', size=masksize * factor[i])
s = visual.TextStim(win=win,
units='pix',
text='',
color='red',
height=stimsize * 1.316 * factor[i],
font='Arial',
bold=False)
mask_display.append(m)
stim_display.append(s)
stim_display.append(fixation)
mask_display.append(fixation)
maskcollection = [[], []]
for c in range(2):
for m in range(12):
shuffle(mask_imgs)
[mask_display[i].setImage(mask_imgs[i]) for i in range(len(xcoo))]
[
mask_display[i].setPos((xcoo[i], ycoo[xyconfigs[c][i]]))
for i in range(len(xcoo))
]
maskcollection[c].append(
visual.BufferImageStim(win, stim=mask_display))
probe_display = visual.TextStim(win=win,
units='pix',
color='red',
height=stimsize * 1.316 * factor[-1],
pos=(0, 0),
font='Arial',
bold=False)
# return instructions,feedback,infoscr,fixation,fixation2,cue_list,maskcollection,stim_display,probe_display
return instructions, feedback, infoscr, fixation, fixation2, cue_list, mask_imgs, mask_display, stim_display, probe_display
w = visual.Window(size=[800, 500], color=[-1, -1, -1], units='norm')
visual.TextStim(w, text='Waiting for a client').draw()
w.flip() # show init screen
imgs = [] # list of 6 images
for i in range(len(f)):
(x, y) = (-.75 + i * .3, -.2)
imgs.append(visual.ImageStim(w, f[i], size=.3, pos=(x, y)))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('localhost', 1234))
s.listen(1) # allow 1 client
(c, adr) = s.accept()
for t in range(nTrials):
visual.BufferImageStim(w, stim=imgs).draw()
visual.TextStim(w, text=instruct).draw()
w.flip() # show choices
key = event.waitKeys(keyList=map(str, range(1, 7))) # allow 1-6
w.flip() # clear screen
idx = int(key[0]) - 1 # choice as the array index
with open(f[idx], 'rb') as file:
data = file.read() # read in pic file
c.sendall(
(corAns[idx] + str(len(data))).encode(code)) # inform ans + pic size
c.sendall(data) # send pic file to the client
visual.TextStim(w, text='Waiting for the client').draw()
w.flip() # show waiting
print(c.recv(1).decode(code)) # waiting for a response from the client
s.close()
