def GetResponse(): global currentRule, currentTgt, ruleCount, rightAnswers, gameScore event.clearEvents() retVal = 0 #if not modified, breaks the task answerPressed = -1 # which card was selected? keylist = { 'down': ['down', '2'], 'left': ['left', '4'], 'up': ['up', '8'], 'right': ['right', '6']} keys = event.waitKeys(keyList=['f10', 'escape', 'up', 'right', 'down', 'left', '2', '4', '6', '8']) if keys[0] == 'f10': triggerAndLog(portCodes['stop'], "STP", 0, 0, "STOP: aborted by F10") win.close() core.quit() if keys[0] == 'escape': retVal = 0 #elif keys[0] == 'up': elif keys[0] in keylist['up']: if CheckCard( 0, currentRule, currentTgt ): rightAnswers += 1 retVal = 1 else: retVal = -1 #elif keys[0] == 'right': elif keys[0] in keylist['right']: if CheckCard( 1, currentRule, currentTgt ): rightAnswers += 1 retVal = 2 else: retVal = -2 #elif keys[0] == 'down': elif keys[0] in keylist['down']: if CheckCard( 2, currentRule, currentTgt ): rightAnswers += 1 retVal = 3 else: retVal = -3 #elif keys[0] == 'left': elif keys[0] in keylist['left']: if CheckCard( 3, currentRule, currentTgt ): rightAnswers += 1 retVal = 4 else: retVal = -4 idx=str(rules.index(currentRule)+1) if retVal > 0: gameScore += 1 triggerAndLog( portCodes['respRight'] + portCodes['rule'+idx],\ "RSP", currentBlock, currentTrial, 'RESPONSE 1 ' + currentRule + ' ANSWER ' + str(retVal) ) elif retVal < 0: gameScore -= 1 triggerAndLog( portCodes['respWrong'] + portCodes['rule'+idx],\ "RSP", currentBlock, currentTrial, 'RESPONSE 0 ' + currentRule + ' ANSWER ' + str(retVal) ) return retVal
def run_preferential_gaze(self): cont=True for i in range(self.preferential_gaze_trials): self.distractor_set.show_video() # clear any keystrokes before starting event.clearEvents() self.preferential_gaze.run(self.ns, self.eye_tracker, self.mouse, self.gaze_debug, self.debug_sq) # Check user input all_keys = event.getKeys() if len(all_keys): # Quit experiment if all_keys[0].upper() in ['Q', 'ESCAPE']: cont = False break # Pause block elif all_keys[0].upper() == 'P': self.pause() # End block elif all_keys[0].upper() == 'E': break event.clearEvents() return cont
def textInput(): #until return pressed, listen for letter keys & add to text string text = '' while event.getKeys(keyList=['escape'])==[]: letterlist=event.getKeys() letterDict = {'space': ' '} # letterlist=event.getKeys(keyList=['0','1','2','3','4','5','6','7','8','9','backspace']) for l in letterlist: if l == 'space': text += ' ' elif l == 'return': text += '\n' #if key isn't backspace, add key pressed to the string elif l != 'backspace': text += l #otherwise, take the last letter off the string elif len(text)>0: text = text[:-1] #continually redraw text onscreen until return pressed textObject = visual.TextStim(win=win, ori=0, name='pause', text=text, font=u'Arial', pos=[0, 0], height=1.0, wrapWidth=None, color=u'white', colorSpace=u'rgb', opacity=1, depth=-1.0) # textReport.draw() textObject.draw() win.flip() text = str(text) event.clearEvents() print text return text
def practicerounds(r): already = True#why is this here again? bet = 999 #load words words = ["one","two","three"] #show words event.clearEvents() if r == 0: while event.getKeys(keyList=['return'])==[]:#wait till ready instructions2[3].draw() mywin.flip() questions.draw()#draw blank w = visual.TextStim(mywin, height=55,text= words[rq],color="white",pos=(0,0)) if already == True: w.draw() mywin.flip()#show word core.wait(2)#wait 2 seconds #THIS IS WHERE THE TIMING STUFF WILL GO while bet > 10: print type(bet) print bet betAsk.draw()#ask how much they want to bet mywin.flip() trialtime = core.Clock() trialtime.reset() bet = WaitForKeyInput() #recieve bet input try: bet = int(bet) except ValueError: bet = 999 continue RT = trialtime.getTime()
def RunTrial(goForward, nKeys): # get trial start time tTrial = globalClock.getTime() * 1000 # reset trial clock trialClock.reset() # clear event buffer event.clearEvents() # display response direction line.draw() if goForward: rightArrow.draw() win.logOnFlip(level=logging.EXP, msg="Right Arrow") else: leftArrow.draw() win.logOnFlip(level=logging.EXP, msg="Left Arrow") win.flip() # wait for responses # core.wait(respDur) # get responses allKeys = [] while len(allKeys) < nKeys and trialClock.getTime() < respDur: newKeys = event.getKeys(timeStamped=trialClock) for thisKey in newKeys: allKeys.append(thisKey) # ,keyList=['1','2','3','4','q','Escape'] # allKeys = event.getKeys(timeStamped=trialClock) return (tTrial, allKeys)
def display_practice(graphics): """ Display the practice phase :param graphics: graphics object which holds all visuals. """ # num of trials in left must be equal to num of trials in right. if len(Constants.PRACTICE_LEFT_STIMS) != len(Constants.RIGHT_STIM_KEYS): return num_of_practice_trials = 2 practice_stim_val = [Constants.VIS_PRACTICE_LEFT_STIM, Constants.VIS_PRACTICE_RIGHT_STIM] practice_stim = [Constants.PRACTICE_LEFT_STIMS, Constants.PRACTICE_RIGHT_STIMS] routine_timer = core.CountdownTimer() for trial in range(num_of_practice_trials): # 2 practice trials for i in range(2): # Left stim then right stim for stim in range(3): # Go through each triplet # Set timer for each stim routine_timer.reset() routine_timer.add(Constants.DISPLAY_VISUAL_TIME) # Set and display current stim. graphics.set_text(practice_stim_val[i], practice_stim[i][trial][stim]) graphics.draw(practice_stim_val[i]) graphics.refresh() # Display for the given length while routine_timer.getTime() > 0: if event.getKeys(keyList=Constants.ESCAPE_KEYS): core.quit() elif event.getKeys(keyList=Constants.SKIP_KEYS): return graphics.refresh() routine_timer.add(Constants.NO_VISUAL_TIME) # Remove visuals for the given length (transition from one stim to another) while routine_timer.getTime() > 0: if event.getKeys(keyList=Constants.ESCAPE_KEYS): core.quit() elif event.getKeys(keyList=Constants.SKIP_KEYS): return # After stims have been displayed, draw a question mark and wait for response. graphics.draw(Constants.VIS_QUESTION_MARK) graphics.refresh() event.clearEvents() # Wait until response given or escape key is pressed. while True: if event.getKeys(keyList=Constants.ESCAPE_KEYS): core.quit() elif event.getKeys(keyList=Constants.PRACTICE_RESP_KEYS): break # Clear screen and wait for the given length before starting next trial. graphics.refresh() time.sleep(Constants.NO_VISUAL_TIME)
def pause(self): """ Pause block """ event.clearEvents() self.win.flip() event.waitKeys()
def new_block(input): im = Image.new("RGB", (2048, 500), bg) font = ImageFont.truetype("arial.ttf", 50) draw = ImageDraw.Draw(im) draw.text((580, 100), input, fill=(0,0,0), font=font) # Attention: input can only be one line! draw.text((580, 200), 'Weiter mit linker Maustaste.', fill=(0,0,0), font=font) im.save("instructions/new_block.png") eizoGS320.convert_to_eizo_picture("instructions/new_block.png", "instructions/block_eizo.png") im_draw = visual.SimpleImageStim(mywin, "instructions/block_eizo.png", units="pix") event.clearEvents() run = True while run: for key in event.getKeys(): if key in ['escape','q']: core.quit() mouse1, mouse2, mouse3 = mymouse.getPressed() if (mouse1): run = False event.clearEvents() im_draw.draw() mywin.flip() mywin.flip() core.wait(0.1)
def showUntilKeyPressed(self, text, keyList=[]): """ Show text until a key is pressed. If keyList is empty, it will listen for all keys. """ self._display(text) instructionClock = core.Clock() instructionClock.reset() keyPressed = False eventCheckStarted = False while not keyPressed: t = instructionClock.getTime() if t >= 0.5: # Do not check for events immediatelly, such that people do not accidentally # skip the message. if eventCheckStarted == False: # Remove keyboard events that were sent before the "grace" period had elapsed event.clearEvents(eventType='keyboard') eventCheckStarted = True # Check for keys if keyList == []: theseKeys = event.getKeys() else: theseKeys = event.getKeys(keyList=keyList) if len(theseKeys) > 0: # A key was pressed, return it return theseKeys[0]
def ask(text='', keyList=[]): """ Ask subject something. Shows question and returns answer (keypress) and reaction time. Defaults to no text and all keys. """ # Draw the TextStims to visual buffer, then show it and reset timing immediately (at stimulus onset) stimText.setText(codecs.decode(text,"utf-8")) spaceText.setText(codecs.decode(spaceLookup[language],"utf-8")) # Set the text height stimText.setHeight(1) spaceText.setHeight(1) # set the text color stimText.setColor('white') spaceText.setColor('white') stimText.draw() spaceText.draw() win.flip() event.clearEvents('keyboard') # Halt everything and wait for (first) responses matching the keys given in the Q object. response = event.waitKeys(keyList=['space','q','r']) if response[0] in keysQuit: # Look at first reponse [0]. Quit everything if quit-key was pressed core.quit() if response[0] in keysBreak: event.clearEvents('keyboard') win.flip() if event.getKeys(keyList=['escape', 'q']): core.quit() if event.getKeys(keyList=['s']): print "Skipped experiment" quit() return response # When answer given, return it.
def flush(self): """See openexp._mouse.legacy""" event.mouseButtons = [0,0,0] event.clearEvents() return False
def showResponseOptions(self): self.responseObj.updateVariants() self.win.setColor(self.responseBgnd) self.win.flip() t=self.clock.getTime() self.responseDur=-1 resp=None while resp==None: pos=self.mouse.getPos() choice=self.responseObj.variantForPoint(pos) self.mouse.setVisible(1) self.responseObj.draw() self.win.flip() btn=self.mouse.getPressed() if btn[0]==True and choice != -1: resp=True self.responseDur=self.clock.getTime()-t self.responseObj.blinkSelected() self.win.flip() event.clearEvents() return choice
def wait_get_response(p, clock, oddball, wait_time): """Get response info specific to this experiment.""" check_clock = core.Clock() good_resp = False corr, response, resp_rt = 0, 0, -1 while not good_resp: keys = event.getKeys(timeStamped=clock) for key, stamp in keys: if key in p.quit_keys: print "Subject quit execution" core.quit() elif key in p.match_keys: corr = 0 if oddball else 1 response = 1 resp_rt = stamp good_resp = True break elif key in p.nonmatch_keys: corr = 1 if oddball else 0 response = 2 resp_rt = stamp good_resp = True break event.clearEvents() # Possibly exit with nothing if check_clock.getTime() >= wait_time: return corr, response, resp_rt # Wait the rest of the time core.wait(wait_time - resp_rt) return corr, response, resp_rt
def WaitForKeyInput(): text='...' #until return pressed, listen for letter keys & add to text string while event.getKeys(keyList=['return'])==[]: letterlist=event.getKeys(keyList=['0', '1', '2', '3', '4', '5' , '6', '7', '8', '9','backspace','q']) for l in letterlist: if l == 'q': core.quit() #if key isn't backspace, add key pressed to the string if l !='backspace': if text =="...": text=l pressedkeys=l else: text+=l pressedkeys+=(";" + l) #otherwise, take the last letter off the string elif len(text)>0: text=text[:-1] pressedkeys+=(";backspace") #continually redraw text onscreen until return pressed text = unicode(text) print "UNICODE" print text response = visual.TextStim(mywin, height=36,text=text,color="white",pos=(0,-100)) betAsk.draw() response.draw() mywin.flip() core.wait(0.1) RT = trialClock.getTime() event.clearEvents() return text,RT
def run_calibration(): # display instructions set_msg('SET SOUND LEVEL','TITLE') set_msg('press up and down to increase/decrease sound level and press enter when level is confortable','MAIN') set_msg('Press return to continue','KEY') win.flip() # prepare calibration sound s = sound_build.make_lp_noise(100000,3000,Exp.rate) vol = 0.5 playsound(s,vol,200) pressEnter = False while pressEnter==False: allKeys=event.waitKeys() for thisKey in allKeys: if thisKey=='up': pygame.mixer.music.set_volume(pygame.mixer.music.get_volume()+0.03) print(pygame.mixer.music.get_volume()) elif thisKey=='down': pygame.mixer.music.set_volume(pygame.mixer.music.get_volume()-0.03) print(pygame.mixer.music.get_volume()) elif thisKey in ['return']: pressEnter = True elif thisKey in ['q', 'escape']: core.quit() #abort experiment event.clearEvents() #must clear other (eg mouse) events - they clog the buffer vol = pygame.mixer.music.get_volume() pygame.mixer.music.stop() return vol
def RunAttentionTrial(cue,stim,cueDur,preStimDur,stimDur): # --- SET UP #Flush the key buffer and mouse movements event.clearEvents() #Reset our clock to zero - I think this call should take less time than window.flip, so resetting after the flip should be slightly more accurate. clock.reset() # --- DISPLAY # display cue textStim.setText(cue) textStim.draw() win.flip() #Put the image on the screen core.wait(cueDur,cueDur) # tie up the CPU for cueDur seconds. # display blank textStim.setText('') textStim.draw() win.flip() core.wait(preStimDur,preStimDur) # tie up the CPU for preStimDur seconds. # display stimulus textStim.setText(stim) textStim.draw() win.flip() #Put the image on the screen #Wait stimDur seconds. Tie up the CPU the entire time (this is more accurate than letting other processes go) core.wait(stimDur,stimDur) # --- CLEAN UP #Get a list of all keys that were pressed during our wait. Tell it to give also give us the amount of time since our clock was reset when the key was pressed (reaction time). keypresses = event.getKeys(None,clock) return keypresses
def fScore(): global score wordsToScore = wordsTheyRecalled wordList = './words/words%i.txt' %(round-1) throwAwayWords = list(cor for cor in open(wordList).read().split("\n") if cor) print "WORDS THEY RECALLED" print wordsTheyRecalled print "ORIGINAL" print throwAwayWords for w in wordsToScore: instructions2[2].draw() mywin.flip() core.wait(0.1) if w in throwAwayWords: risk = int(findBet(w)) throwAwayWords.remove(w) score += risk writeToDataFile(scorefileName,w,risk,score) print score correctedWord = correct(w) if correctedWord != w: while event.getKeys(keyList=['return'])==[]: global corrects misspelled = visual.TextStim(mywin, height=30,text=w,color="white",pos=(-300,0)) didYouMean = visual.TextStim(mywin, height=30,text=correctedWord,color="white",pos=(300, 0)) ask = visual.TextStim(mywin, height=45,text='Did you mean:',color="white",pos=(0, 0)) how = visual.TextStim(mywin, height=30,text='press y for Yes or n for No',color="white",pos=(0, -200)) instructions[2].draw() misspelled.draw() didYouMean.draw() ask.draw() how.draw() mywin.flip() event.clearEvents() corrects = WaitForMouseInput() print "DID THEY CHANGE?" print corrects + "in loop" if corrects == "yes": if correctedWord in throwAwayWords: risk = int(findBet(correctedWord)) throwAwayWords.remove(correctedWord) score += risk writeToDataFile(scorefileName,correctedWord,risk,score) print score else: continue for w in throwAwayWords: risk = int(findBet(w)) score -= risk writeToDataFile(scorefileName,w,risk,score) print score questions.draw() #THIS IS WHERE THE FEEDBACK GOES t = visual.TextStim(mywin, height=36,text="Your current score: ",color="white",pos=(-150,-100)) doing = visual.TextStim(mywin, height=36,text=score,color="white",pos=(150,-100)) t.draw() doing.draw() mywin.flip() core.wait(4) return score
def RunTrial(sequence): # check for going over session time if globalClock.getTime()-tStartSession > tSessionMax: CoolDown() #exit experiment gracefully # get deadline for response respDur = tRespPerItem*(len(sequence)) respDur = int(tRespRoundOff * np.ceil(float(respDur)/tRespRoundOff)) # round up to next tRespRoundOff multiple # print("length = %d, respDur = %1.1f"%(len(sequence), respDur)) logging.log(level=logging.EXP, msg='Start Sequence %d'%len(sequence)) # play sequence for iStim in sequence: DisplayButtons([iStim],stimDur) beeps[iStim].play() core.wait(stimDur,stimDur) # wait so sound plays properly DisplayButtons([],pauseDur) # core.wait(pauseDur,pauseDur) logging.log(level=logging.EXP, msg='End Sequence %d'%len(sequence)) #draw fixation dot and wait for response event.clearEvents() # ignore any keypresses before now # win.logOnFlip(level=logging.EXP, msg='Display Fixation') # fixation.draw() DisplayButtons([],0,True) # tResp = trialClock.getTime() # IMPORTANT REFERENCE POINT tResp = tNextFlip[0] # IMPORTANT REFERENCE POINT iSeq = 0 # Response loop while globalClock.getTime() < (tResp + respDur) and iSeq < len(sequence): iStim = sequence[iSeq] thisKey = event.getKeys(timeStamped=globalClock) if len(thisKey)>0 and thisKey[0][0] == respKeys[iStim]: #tResp = trialClock.getTime(); # reset the shot clock # fixation.draw() DisplayButtons([iStim],0,True) # DON'T INCREMENT CLOCK beepsShort[iStim].play() core.wait(shortDur,shortDur) # USE CORE.WAIT HERE SO CLOCK DOESN'T INCREMENT # fixation.draw() DisplayButtons([],0,True) iSeq += 1 elif len(thisKey)>0 and thisKey[0][0] in ['q','escape']: core.quit() elif len(thisKey)>0: print('this: %s'%str(thisKey[0][0])) print('correct: %s'%str(respKeys[iStim])) buzz.play() core.wait(buzzDur,buzzDur) # USE CORE.WAIT HERE SO CLOCK DOESN'T INCREMENT return (WRONG) #get response if iSeq == len(sequence): # finished sequence DisplayButtons([],respDur,False) # increment next-frame clock return(RIGHT) else: # ran out of time buzz.play() core.wait(buzzDur,buzzDur) # USE CORE.WAIT HERE SO CLOCK DOESN'T INCREMENT DisplayButtons([],respDur,False) # increment next-frame clock return (TOOSLOW)
def RunTrial(targetDir, flankerDir, tStartTrial): # display fixation cross fixation.draw() win.logOnFlip(level=logging.EXP, msg="Display Fixation") win.flip() # wait until it's time to start the new trial while globalClock.getTime() < tStartTrial: pass # do nothing # get trial time tTrial = globalClock.getTime() # reset clock trialClock.reset() # display flankers for flanker in flankers: flanker.text = arrowChars[flankerDir] flanker.draw() win.logOnFlip(level=logging.EXP, msg="Display %sFlankers" % arrowNames[flankerDir]) win.flip() core.wait(flankerDur, flankerDur) # display flankers AND target arrow for flanker in flankers: flanker.draw() target.text = arrowChars[targetDir] target.draw() win.logOnFlip(level=logging.EXP, msg="Display %sTarget" % arrowNames[targetDir]) win.flip() tStim = trialClock.getTime() # get time when stim was displayed event.clearEvents() # flush buffer core.wait(targetDur, targetDur) # draw blank screen win.logOnFlip(level=logging.EXP, msg="Display Blank") win.flip() core.wait( respDur - targetDur, respDur - targetDur ) # wait for specified ms (use a loop of x frames for more accurate timing) # get responses allKeys = event.getKeys(timeStamped=trialClock) # find RT RT = float("Inf") for thisKey in allKeys: if thisKey[0] in respKeys: RT = thisKey[1] - tStim break if RT >= rtDeadline: tooSlowStim.draw() win.logOnFlip(level=logging.EXP, msg="Display TooSlow") win.flip() core.wait(rtTooSlowDur, rtTooSlowDur) # return trial time, response(s) return (tTrial, allKeys)
def doUserInteraction(stim, expectedKeys, timeout, soundFile): global paused if timeout == None or timeout == 0: timeout = sys.maxint startTime = trialClock.getTime() endTime = startTime + timeout response = { "keys": [], "firstKey": None, "lastKey": None, "startTime": startTime, "endTime": endTime, "duration": 0, "timedOut": False, } if soundFile != None: soundFile.play() while(True): stim.setAutoDraw(True) #continuously draws the stimulus to the buffer win.flip() # exposes the stimulus to the screen keys = [] # initializes an empty array to hold the keys that were pressed. # this IF checks 2 things in order to determine which keys are allowed to be pressed: if expectedKeys != None: # Have I specified a list of allowed keys? if len(expectedKeys) != 0: # Have I specified any particular keys (rather than just [] which means All keys? keys = event.getKeys(expectedKeys) # Listen for key presses from a particular subset else: keys = event.getKeys() # Listen for Any key presses. if len(keys) > 0: # If a key was pressed store some values in the object "response" defined above. response["keys"] = keys # put all the responses in here. response["firstKey"] = keys[0] # put the first keypress here response["lastKey"] = keys[len(keys)-1] # put the last keypress here. break #break out of this function elif trialClock.getTime() > endTime: # If the response time window has run out response["timedOut"] = True # indicate that we timed out response["firstKey"] = 'NA' # put 'NA' as the first key pressed break if event.getKeys(['f5']): # This is a "pause" button for the experiment textStim.text = 'Press any key to continue' textStim.pos = (0,-10) paused = 1 stimUntilAnyKey(textStim) textStim.pos = (0,0) #check for quit (the [Esc] key) if event.getKeys(["escape"]): core.quit() #quits the entire experiment - will dump you to the desktop or whatever. stim.setAutoDraw(False) # stop drawing the stimulus to the buffer win.flip() # expose the now blank buffer to the screen response["duration"] = trialClock.getTime() - startTime # keeps track of how long since the stim was drawn to the screen event.clearEvents(eventType=None) # clear the key buffer. return response # ends the function and returns the object "response". Without this return - we would not be able to access any of this data.
def GetResponse(): global currentRule, currentTgt, ruleCount, rightAnswers, gameScore event.clearEvents() retVal = 0 #if not modified, breaks the task answerPressed = -1 # which card was selected? keys = event.waitKeys() if keys[0]=='escape': retVal = 0 elif keys[0] == 'up': if CheckCard( 0, currentRule, currentTgt ): rightAnswers += 1 retVal = 1 else: retVal = -1 elif keys[0] == 'right': if CheckCard( 1, currentRule, currentTgt ): rightAnswers += 1 retVal = 2 else: retVal = -2 elif keys[0] == 'down': if CheckCard( 2, currentRule, currentTgt ): rightAnswers += 1 retVal = 3 else: retVal = -3 elif keys[0] == 'left': if CheckCard( 3, currentRule, currentTgt ): rightAnswers += 1 retVal = 4 else: retVal = -4 if retVal > 0: gameScore += 1 if currentRule == 'G1': triggerAndLog( portCodes['respRight'] | portCodes['rule1'], 'RESP 1 ' + currentRule + ' ANSWER ' + str(retVal) ) if currentRule == 'G2': triggerAndLog( portCodes['respRight'] | portCodes['rule2'], 'RESP 1 ' + currentRule + ' ANSWER ' + str(retVal) ) if currentRule == 'L1': triggerAndLog( portCodes['respRight'] | portCodes['rule3'], 'RESP 1 ' + currentRule + ' ANSWER ' + str(retVal) ) if currentRule == 'L2': triggerAndLog( portCodes['respRight'] | portCodes['rule4'], 'RESP 1 ' + currentRule + ' ANSWER ' + str(retVal) ) elif retVal < 0: gameScore -= 1 if currentRule == 'G1': triggerAndLog( portCodes['respWrong'] | portCodes['rule1'], 'RESP 0 ' + currentRule + ' ANSWER ' + str(retVal) ) if currentRule == 'G2': triggerAndLog( portCodes['respWrong'] | portCodes['rule2'], 'RESP 0 ' + currentRule + ' ANSWER ' + str(retVal) ) if currentRule == 'L1': triggerAndLog( portCodes['respWrong'] | portCodes['rule3'], 'RESP 0 ' + currentRule + ' ANSWER ' + str(retVal) ) if currentRule == 'L2': triggerAndLog( portCodes['respWrong'] | portCodes['rule4'], 'RESP 0 ' + currentRule + ' ANSWER ' + str(retVal) ) return retVal
def WaitForIt( keys=['x'], duration=-1 ): if duration < 0: keys = event.waitKeys(keys) core.wait(keyWait) event.clearEvents() else: core.wait(duration) return keys
def clearEvents(self, eventType=None): if havePTB: for buffer in self._buffers.values(): buffer._evts.clear() buffer._keys.clear() buffer._keysStillDown.clear() else: event.clearEvents(eventType)
def click_to_continue(cursor): event.clearEvents() cursor.clickReset() while cursor.getPressed()==[False,False,False]: cursor.getPressed() if event.getKeys(keyList = 'q'): print 'User Terminated' core.quit()
def show_instruction(instrStim): # shows an instruction until a key is hit. while True: instrStim.draw() win.flip() if len(event.getKeys()) > 0: break event.clearEvents()
def runBlock(loop = object, saveData = True): """Runs a loop for an experimental block and saves reposnes if requested""" for thisTrial in loop: resp = None rt = None probe.setPos( [thisTrial['probeX'], 0] ) cue.setOri( thisTrial['cueOri'] ) fixation.setAutoDraw(True) for frameN in range(info['fixFrames']): win.flip() cue.setAutoDraw(True) for frameN in range(info['cueFrames']): win.flip() cue.setAutoDraw(False) probe.setAutoDraw(True) win.callOnFlip(respClock.reset) event.clearEvents() for frameN in range(info['probeFrames']): if frameN == 0: respClock.reset() keys = event.getKeys(keyList = ['left','right','escape']) if len(keys) > 0: resp = keys[0] rt = respClock.getTime() break win.flip() probe.setAutoDraw(False) fixation.setAutoDraw(False) #clear screen win.flip() if resp == None: keys = event.waitKeys(keyList = ['left','right','escape']) resp = keys[0] rt = respClock.getTime() if saveData == True: if thisTrial['probeX']>0 and resp=='right': corr = 1 elif thisTrial['probeX']<0 and resp=='left': corr = 1 elif resp=='escape': corr = None trials.finished = True else: corr = 0 trials.addData('resp', resp) trials.addData('rt', rt) trials.addData('corr', corr) thisExp.nextEntry()
def picture_task(pictures, text_elem, patch_elem, choice_keys_dict, sheet_name, extra_info, side_info_dict, data_file, append): pictures_len = len(pictures) pictures_permutation = RandomPermutation(pictures_len) trial_clock = core.Clock() trials_list = [ { 'Trial': '%d' %(i+1) } for i in xrange(0, 2*pictures_len) ] trials = data.TrialHandler(trialList = trials_list, nReps=1, method=u'sequential', extraInfo=extra_info) trial_count = 0 for thisTrial in trials: which_picture = pictures_permutation.select() picture_info = pictures[which_picture] patch_elem['face']['obj'].setTex(patch_elem['face']['dir'] + picture_info['Face']) #run the trial keys_to_press = choice_keys_dict['input'].keys() timestamps = [] register_time = False continue_trial=True event.clearEvents() t=0; trial_clock.reset() while continue_trial and (t<1000000.0000): t = trial_clock.getTime() rt_k, keys = key_pressed(trial_clock, keys_to_press) if t >= 0: if len(keys) == 0: patch_elem['face']['obj'].draw() text_elem['choice_face']['obj'].draw() register_time = True elif len(timestamps) > 0: rt_picture = rt_k - timestamps[0] key_picture = choice_keys_dict['input'][keys[0]] continue_trial = False if trial_count < 2*pictures_len - 1: text_elem['choice_face']['obj'].draw() win.flip() if register_time: timestamps.append(trial_clock.getTime()) register_time = False for k,v in picture_info.items(): trials.addData(k, v) trials.addData('Key', key_picture) trials.addData('Response', side_info_dict['CHOICE'][key_picture]) trials.addData('RT', rt_picture) trial_count += 1 core.wait(0.5) trials.saveAsExcel(data_file, sheetName = sheet_name, stimOut=[], dataOut=['all_raw'], appendFile = append)
def fScore(): global score wordsToScore = wordsTheyRecalled wordList = './words/%s/words%s.txt' %(version, round-1) throwAwayWords = list(cor for cor in open(wordList).read().split("\n") if cor) #print "WORDS THEY RECALLED" #print wordsTheyRecalled for w in wordsToScore: instructions2[2].draw() core.wait(0.1) if w in throwAwayWords: risk = int(findBet(w)) throwAwayWords.remove(w) if practice == False: score += risk writeToDataFile(scorefileName,w,risk,score) print score correctedWord = correct(w) if correctedWord == w:#still show them scoring screen if there's no questions mywin.flip() core.wait(0.5) elif correctedWord != w: #ask them if they made a spelling error global corrects misspelled = visual.TextStim(mywin, height=30,text=w,color="white",pos=(-300,0)) didYouMean = visual.TextStim(mywin, height=30,text=correctedWord,color="white",pos=(300, 0)) ask = visual.TextStim(mywin, height=45,text='Did you mean:',color="white",pos=(0, 0)) how = visual.TextStim(mywin, height=30,text='press Yes or No',color="white",pos=(0, -200)) yes = visual.TextStim(mywin, height=50,text='Yes',color="white",pos=(-100, -150)) no = visual.TextStim(mywin, height=50,text='No',color="white",pos=(100, -150)) instructions2[2].draw() misspelled.draw() didYouMean.draw() ask.draw() how.draw() yes.draw() no.draw() mywin.flip() event.clearEvents() corrects = WaitForMouseInput() print "DID THEY CHANGE?" print corrects if corrects == "yes": if correctedWord in throwAwayWords: risk = int(findBet(correctedWord)) throwAwayWords.remove(correctedWord) if practice == False: score += risk writeToDataFile(scorefileName,correctedWord,risk,score) print score else: break for w in throwAwayWords: risk = int(findBet(w)) if practice == False: score -= risk writeToDataFile(scorefileName,w,risk,score) print score return score
def wait_for_key(keys): '''Wait for a key that is in a set of keys to be pressed before proceeding. Args: keys - A list or tuple of keys. ''' event.clearEvents() event.waitKeys(keyList=keys)
def test_no_mode(self): #pytest.skip() event.clearEvents() ResponseEmulator(simResponses=[(0.5, 'escape')]).run() vol = launchScan(self.win, BASE_MR_SETTINGS.copy(), globalClock=self.globalClock, wait_timeout=1, log=False) # no mode, so a RatingScale will be displayed; return to select value # the key event is not being detected here core.wait(1, 0)
def test_clearEvents_keyboard(self): event._onPygletKey(symbol='x', modifiers=0, emulated=True) event.clearEvents('keyboard') assert not event._keyBuffer
# *instr1* updates if t >= 0.0 and instr1.status == NOT_STARTED: # keep track of start time/frame for later instr1.tStart = t instr1.frameNStart = frameN # exact frame index instr1.setAutoDraw(True) # *ready1* updates if t >= 0.0 and ready1.status == NOT_STARTED: # keep track of start time/frame for later ready1.tStart = t ready1.frameNStart = frameN # exact frame index ready1.status = STARTED # keyboard checking is just starting event.clearEvents(eventType='keyboard') if ready1.status == STARTED: theseKeys = event.getKeys() # check for quit: if "escape" in theseKeys: endExpNow = True if len(theseKeys) > 0: # at least one key was pressed # a response ends the routine continueRoutine = False if useButtonBox: if totalTrials > 0: continueRoutine = False # check if all components have finished if not continueRoutine: # a component has requested a forced-end of Routine
def test_clearEvents_joystick(self): """Keyboard buffer should not be affected. """ event._onPygletKey(symbol='x', modifiers=0, emulated=True) event.clearEvents('joystick') assert event._keyBuffer
def run(self): self.checkParameterValues() self.prepareRun() # create checkerboard background self._squareSizePix = round(self.squareSize * self.pixelsPerDeg) leftOffset = rightOffset = topOffset = bottomOffset = self._squareSizePix bckgnd = self.makeCheckerboard( (math.ceil(self.imageSize[1] / self._squareSizePix), math.ceil(self.imageSize[0] / self._squareSizePix))) if self.moveLikeOpticFlow: centerOffset = (self.imageSize[0] / 2) % self._squareSizePix if centerOffset > 0: self.shiftBckgnd(bckgnd[:, ::-1], centerOffset, centerOffset) rightOffset = centerOffset checkerboardImage = np.copy( bckgnd[:self.imageSize[1], :self.imageSize[0]]) checkerboardStim = ImageStimNumpyuByte(self._win, image=checkerboardImage, size=self.imageSize, pos=self.imagePosition) # get trialTypes laserPwr = self.laserPower if self.laserRandom else [ self.laserPower[0] ] trialTypes = list( itertools.product( self.bckgndSpeed, [dir for dir in self.bckgndDir if dir in (0, 180)], self.patchSize, self.patchSpeed, [dir for dir in self.patchDir if dir in (0, 180)], self.patchElevation, laserPwr)) trialTypes.extend( itertools.product( self.bckgndSpeed, [dir for dir in self.bckgndDir if dir in (90, 270)], self.patchSize, self.patchSpeed, [dir for dir in self.patchDir if dir in (90, 270)], self.patchAzimuth, laserPwr)) for params in copy.copy(trialTypes): # don't need all bckgnd directions for bckgndSpeed=0 # or all patch sizes, directions, and positions for patchSpeed=0 # or patch speed and direction = bckgnd speed and direction when both speeds > 0 if ((params[0] == 0 and params[1] != self.bckgndDir[0]) or (params[3] == 0 and (params[2] != self.patchSize[0] or params[3] != self.patchSpeed[0] or params[4] != self.patchDir[0] or (params[5] != self.patchElevation[0] if params[4] in (0, 180) else params[5] != self.patchAzimuth[0]))) or (params[0] > 0 and params[3] > 0 and params[0] == params[3] and params[1] == params[4])): if params in trialTypes: trialTypes.remove(params) trialsPerLoop = len(trialTypes) * len(self.laserPower) if len(self.laserPower) > 1 and not self.laserRandom: trialTypes = [trialTypes] for pwr in self.laserPower[1:]: trials = [list(params) for params in trialTypes[0]] for params in trials: params[-1] = pwr trialTypes.append(trials) # run frame = 0 loop = -1 trial = -1 trialFrame = 0 trialInterval = self.getInterTrialInterval() self.trialStartFrame = [] self.trialNumFrames = [] self.trialBckgndSpeed = [] self.trialBckgndDir = [] self.trialPatchSize = [] self.trialPatchSpeed = [] self.trialPatchDir = [] self.trialPatchPos = [] self.trialLaserPower = [] while True: if trialFrame == trialInterval - 1: if loop == -1 or trial == trialsPerLoop - 1: if loop == self.numLoops - 1: break loop += 1 print('starting loop ' + str(loop + 1)) shuffledTrials = np.array( self.setTrialLaserPower(trialTypes)) if len(self.laserPower) > 1 and not self.laserRandom: self.spaceLaserTrials(shuffledTrials) trial = 0 else: trial += 1 trialFrame = -1 self.trialBckgndSpeed.append(shuffledTrials[trial, 0]) self.trialBckgndDir.append(shuffledTrials[trial, 1]) self.trialPatchSize.append(shuffledTrials[trial, 2]) self.trialPatchSpeed.append(shuffledTrials[trial, 3]) self.trialPatchDir.append(shuffledTrials[trial, 4]) self.trialPatchPos.append(shuffledTrials[trial, 5]) self.trialLaserPower.append(shuffledTrials[trial, 6]) if self.trialBckgndDir[-1] == 0: bckgndOffset = leftOffset elif self.trialBckgndDir[-1] == 180: bckgndOffset = rightOffset elif self.trialBckgndDir[-1] == 90: bckgndOffset = bottomOffset else: bckgndOffset = topOffset bckgndMovPerFrame = round(self.trialBckgndSpeed[-1] * self.pixelsPerDeg / self.frameRate) patchMovPerFrame = round(self.trialPatchSpeed[-1] * self.pixelsPerDeg / self.frameRate) patchSizePix = round(self.trialPatchSize[-1] * self.pixelsPerDeg) if patchMovPerFrame > 0: patch = self.makeCheckerboard( (round(self.trialPatchSize[-1] / self.squareSize), ) * 2) if self.trialPatchDir[-1] in [0, 180]: y = self._squareSizePix * round( (self.imageSize[1] / 2 - self.imagePosition[1] + self.trialPatchPos[-1] * self.pixelsPerDeg) / self._squareSizePix) - int(patchSizePix / 2) if topOffset < self._squareSizePix: y -= topOffset if self.trialPatchDir[-1] == 0: patchPos = [ self.imageSize[0] / 2 - patchSizePix, y ] else: patchPos = [self.imageSize[0], y] self.trialNumFrames.append( int( round((self.imageSize[0] / 2 + patchSizePix) / patchMovPerFrame))) else: x = self._squareSizePix * round( (self.imageSize[0] / 2 - self.imagePosition[0] + self.trialPatchPos[-1] * self.pixelsPerDeg) / self._squareSizePix) - int(patchSizePix / 2) if leftOffset < self._squareSizePix: x -= leftOffset if self.trialPatchDir[-1] == 90: patchPos = [x, self.imageSize[1]] else: patchPos = [x, -patchSizePix] self.trialNumFrames.append( int( round((self.imageSize[1] + patchSizePix) / patchMovPerFrame))) else: if bckgndMovPerFrame > 0: if self.trialBckgndDir[-1] in [0, 180]: self.trialNumFrames.append( int( round(self.imageSize[0] / 2 / bckgndMovPerFrame))) else: self.trialNumFrames.append( int( round(self.imageSize[1] / bckgndMovPerFrame))) else: self.trialNumFrames.append( int(round(2 * self.frameRate))) trialInterval = self.laserPreFrames + self.trialNumFrames[ -1] + self.laserPostFrames + self.getInterTrialInterval() elif trial > -1: if trialFrame == 0: self.setLaserOn(self.trialLaserPower[-1]) if self.laserPreFrames <= trialFrame < self.laserPreFrames + self.trialNumFrames[ -1]: if trialFrame == self.laserPreFrames: self.trialStartFrame.append(frame) if bckgndMovPerFrame > 0: if bckgndOffset == 0: bckgndOffset = self._squareSizePix bckgndOffset += bckgndMovPerFrame if bckgndOffset > self._squareSizePix: newSqOffset = bckgndOffset - self._squareSizePix bckgndOffset %= self._squareSizePix else: newSqOffset = 0 if self.trialBckgndDir[-1] == 0: if self.moveLikeOpticFlow: self.shiftBckgnd( bckgnd[:, self.imageSize[0] / 2 + 1:], bckgndMovPerFrame, newSqOffset) self.shiftBckgnd( bckgnd[:, self.imageSize[0] / 2::-1], bckgndMovPerFrame, newSqOffset) else: self.shiftBckgnd(bckgnd, bckgndMovPerFrame, newSqOffset) elif self.trialBckgndDir[-1] == 180: if self.moveLikeOpticFlow: self.shiftBckgnd( bckgnd[:, -1:self.imageSize[0] / 2:-1], bckgndMovPerFrame, newSqOffset) self.shiftBckgnd( bckgnd[:, :self.imageSize[0] / 2 + 1], bckgndMovPerFrame, newSqOffset) else: self.shiftBckgnd(bckgnd[:, ::-1], bckgndMovPerFrame, newSqOffset) elif self.trialBckgndDir[-1] == 90: self.shiftBckgnd(bckgnd[:, ::-1].T, bckgndMovPerFrame, newSqOffset) else: self.shiftBckgnd(bckgnd.T, bckgndMovPerFrame, newSqOffset) checkerboardImage = np.copy( bckgnd[:self.imageSize[1], :self.imageSize[0]]) if patchMovPerFrame > 0: if self.trialPatchDir[-1] == 0: patchPos[0] += patchMovPerFrame elif self.trialPatchDir[-1] == 180: patchPos[0] -= patchMovPerFrame elif self.trialPatchDir[-1] == 90: patchPos[1] -= patchMovPerFrame else: patchPos[1] += patchMovPerFrame if patchPos[0] <= self.imageSize[0] and patchPos[ 1] <= self.imageSize[1]: patchImagePos = copy.copy(patchPos) patchImage = patch if patchPos[0] < self.imageSize[0] / 2: patchImage = patch[:, int(self.imageSize[0] / 2 - patchPos[0]):] patchImagePos[0] = self.imageSize[0] / 2 if patchPos[1] < 0: patchImage = patch[-patchPos[1]:, :] patchImagePos[1] = 0 if patchPos[0] + patch.shape[1] > self.imageSize[0]: patchImage = patch[:, :int(self.imageSize[0] - patchPos[0])] if patchPos[1] + patch.shape[0] > self.imageSize[1]: patchImage = patch[:self.imageSize[1] - patchPos[1], :] checkerboardImage[ int(patchImagePos[1]):int(patchImagePos[1] + patchImage.shape[0]), int(patchImagePos[0] ):int(patchImagePos[0] + patchImage.shape[1])] = patchImage if trialFrame == self.laserPreFrames + self.trialNumFrames[ -1] - 1: if self.trialBckgndDir[-1] == 0: leftOffset = bckgndOffset rightOffset = self._squareSizePix - bckgndOffset if self.moveLikeOpticFlow: rightOffset += centerOffset if rightOffset > self._squareSizePix: rightOffset -= self._squareSizePix elif self.trialBckgndDir[-1] == 180: rightOffset = bckgndOffset leftOffset = self._squareSizePix - bckgndOffset if self.moveLikeOpticFlow: leftOffset -= centerOffset if leftOffset < 0: leftOffset += self._squareSizePix elif self.trialBckgndDir[-1] == 90: bottomOffset = bckgndOffset topOffset = self._squareSizePix - bckgndOffset else: topOffset = bckgndOffset bottomOffset = self._squareSizePix - bckgndOffset if trialFrame == self.laserPreFrames + self.trialNumFrames[ -1] + self.laserPostFrames: self.setLaserOff() checkerboardStim.setReplaceImage(checkerboardImage) checkerboardStim.draw() self.visStimFlip() frame += 1 trialFrame += 1 if len(event.getKeys()) > 0: event.clearEvents() break self.completeRun()
def VWFAlocImages(scanDict,screenSize=[1024,768]): #objects from #http://stims.cnbc.cmu.edu/Image%20Databases/TarrLab/Objects/ #faces from #http://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html # #more faces #http://tarrlab.cnbc.cmu.edu/newsite/index.php?option=com_content&view=article&id=51&Itemid=61 #more objects #http://stims.cnbc.cmu.edu/Image%20Databases/BOSS/ #scenes #http://pirsquared.org/research/vhatdb/full/ #houses #http://groups.csail.mit.edu/vision/SUN/ # USING IN THE END: #houses #http://groups.csail.mit.edu/vision/SUN/ #objects & chairs from #http://stims.cnbc.cmu.edu/Image%20Databases/TarrLab/Objects/ #faces from #http://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html #more chairs from #???? white=[1.0,1.0,1.0] gray=[0.0,0.0,0.0] black=[-1.0,-1.0,-1.0] fixPercentage =scanDict['fixFraction'] fixDuration=0.25 respDuration=1.0 IR=scanDict['innerRadius'] screenSize=scanDict['screenSize'] #create a designmatrix #there are 4 categories of things to show #faces, places (houses), chairs (objects), and letters (words?) #also need rest in there #so need 4 columns in design matrix numTrials=210 numImages=40*4 designMatrix=numpy.zeros((numTrials,4)) designMatrixX=numpy.zeros((numTrials,1)) #first N Trs are already zero--rest #figure out when each stim should be on #for now, just get the frame working #hard code this as restABCDrestBADCrestCBDArestDCABrest #rests are 10s of gray, blocks are 10s of images #within each block, show 10 examples drawn randomly from a big list stimDur=0.75 ISIdur=0.25 trialLength=stimDur+ISIdur trialsPerBlock=10 blockLength=trialLength*trialsPerBlock IBIdur=10 #A: 10-20,70-80,140-150,180-190 designMatrix[10:20,0]=1 designMatrix[70:80,0]=1 designMatrix[140:150,0]=1 designMatrix[180:190,0]=1 #B: 20-30,60-70,120-130,190-200 designMatrix[20:30,1]=1 designMatrix[60:70,1]=1 designMatrix[120:130,1]=1 designMatrix[190:200,1]=1 #C: 30-40,90-100,110-120,170-180 designMatrix[30:40,2]=1 designMatrix[90:100,2]=1 designMatrix[110:120,2]=1 designMatrix[170:180,2]=1 #D: 40-50,80-90, 130-140, 160-170 designMatrix[40:50,3]=1 designMatrix[80:90,3]=1 designMatrix[130:140,3]=1 designMatrix[160:170,3]=1 #UGH i need to hack a new design matrix for the images without the rest spots in it designMatrixX[10:20,0]=1 designMatrixX[70:80,0]=1 designMatrixX[140:150,0]=1 designMatrixX[180:190,0]=1 #B: 20-30,60-70,120-130,190-200 designMatrixX[20:30,0]=1 designMatrixX[60:70,0]=1 designMatrixX[120:130,0]=1 designMatrixX[190:200,0]=1 #C: 30-40,90-100,110-120,170-180 designMatrixX[30:40,0]=1 designMatrixX[90:100,0]=1 designMatrixX[110:120,0]=1 designMatrixX[170:180,0]=1 #D: 40-50,80-90, 130-140, 160-170 designMatrixX[40:50,0]=1 designMatrixX[80:90,0]=1 designMatrixX[130:140,0]=1 designMatrixX[160:170,0]=1 #length of scan in s scanLength=numTrials*trialLength # msgScanLength=visual.TextStim(winOp,pos=[0,2],text='Scan length (s): %.1f' %scanLength) # msgScanTr=visual.TextStim(winOp,pos=[0,1],text='No. of Volumes (at Tr=%.2f): %.0f' %(scanDict['Tr'],scanLength/scanDict['Tr']) ) # msgScanLength.draw() # msgScanTr.draw() # winOp.flip() #pop up the Tr info and wait for "ok" winOp = visual.Window([500,500],monitor='testMonitor',units='norm',screen=scanDict['operatorScreen'], color=[0.0,0.0,0.0],colorSpace='rgb') msgScanLength=visual.TextStim(winOp,pos=[0,0.5],units='norm',height=0.1,text='Scan length (s): %.1f' %scanLength) msgScanTr=visual.TextStim(winOp,pos=[0,0],units='norm',height=0.1,text='No. of Volumes (at Tr=%.2f): %.1f' %(scanDict['Tr'],scanLength/scanDict['Tr']) ) msgOK=visual.TextStim(winOp,pos=[0,-0.5],units='norm',height=0.1,text='Operator, press any key to proceed') msgScanLength.draw() msgScanTr.draw() msgOK.draw() winOp.flip() #wait for keypress thisKey=None while thisKey==None: thisKey = event.waitKeys() if thisKey in ['q','escape']: core.quit() #abort else: event.clearEvents() #close the winOp winOp.close() #open subject window winSub = visual.Window(screenSize,monitor=scanDict['monCalFile'],units="deg",screen=scanDict['subjectScreen'], color=gray,colorSpace='rgb',fullscr=False,allowGUI=False) subjectResponse=numpy.zeros((numTrials+1,1)) subRespArray=numpy.zeros((numTrials+1,3)) subjectResponse[:]=numpy.nan #prep display objects #get the list of files for each myPath=os.path.dirname(os.path.realpath(__file__)) Aimages=glob.glob(os.path.join(myPath,'vwfaProcImages','faces256','*.png')) if len(Aimages)==0: Aimages=glob.glob(os.path.join(myPath,'vwfaProcImages','faces256','*.PNG')) if len(Aimages)==0: print('No face images found') core.quit() Bimages=glob.glob(os.path.join(myPath,'vwfaProcImages','houses256','*.jpg')) if len(Bimages)==0: Bimages=glob.glob(os.path.join(myPath,'vwfaProcImages','houses256','*.JPG')) if len(Bimages)==0: print('No house images found') core.quit() Cimages=glob.glob(os.path.join(myPath,'vwfaProcImages','chairs256','*.png')) if len(Cimages)==0: Cimages=glob.glob(os.path.join(myPath,'vwfaProcImages','chairs256','*.PNG')) if len(Cimages)==0: print('No chair images found') core.quit() Dimages=glob.glob(os.path.join(myPath,'vwfaProcImages','letters256','*.png')) if len(Dimages)==0: Dimages=glob.glob(os.path.join(myPath,'vwfaProcImages','letters256','*.PNG')) if len(Dimages)==0: print('No letter images found') core.quit() #print Aimages #print Bimages ##print Cimages #print Dimages numInList=numpy.zeros((4,1)) numInList[0]=len(Aimages) numInList[1]=len(Bimages) numInList[2]=len(Cimages) numInList[3]=len(Dimages) #print numInList #generate my random sequence --need 40 of each list Asequence=numpy.random.randint(0,high=numInList[0],size=40) Bsequence=numpy.random.randint(0,high=numInList[1],size=40) Csequence=numpy.random.randint(0,high=numInList[2],size=40) Dsequence=numpy.random.randint(0,high=numInList[3],size=40) #now make one big list with all the filenames--much easier for showing them in the loop!! imageNameSequence = ['']*numImages Acounter=0 Bcounter=0 Ccounter=0 Dcounter=0 imCounter=0 #for iIm in xrange(numTrials):? for iIm in range(numTrials): if designMatrix[iIm,0]==1: #next Aimage imageNameSequence[imCounter]=Aimages[Asequence[Acounter]] Acounter+=1 imCounter+=1 elif designMatrix[iIm,1]==1: #next Bimage imageNameSequence[imCounter]=Bimages[Bsequence[Bcounter]] Bcounter+=1 imCounter+=1 elif designMatrix[iIm,2]==1: #next Cimage imageNameSequence[imCounter]=Cimages[Csequence[Ccounter]] Ccounter+=1 imCounter+=1 elif designMatrix[iIm,3]==1: #next Dimage imageNameSequence[imCounter]=Dimages[Dsequence[Dcounter]] Dcounter+=1 imCounter+=1 numpy.savetxt('vwfaImagesdesignMatrix.txt',designMatrix,fmt='%.3i',header='faces,houses,chairs,letters') #make a fixation square which will enlarge on occasion fixSize=IR/2.0 fix0 = visual.Rect(winSub,width=fixSize,height=fixSize,autoLog=False) fix0.setFillColor(color=[0.5,0.5,0.5],colorSpace='rgb') fix0.setLineColor(color=[1,-1,-1],colorSpace='rgb') #create the dictionary of images, but load only one currentImageNumber = 0 imageStimDict=dict.fromkeys(numpy.arange(0,40*4)) # imageStimDict[currentImageNumber]=visual.ImageStim(winSub,image=imageNameSequence[currentImageNumber]) imageStimDict[currentImageNumber]=visual.SimpleImageStim(winSub,image=imageNameSequence[currentImageNumber]) msg1x=visual.TextStim(winSub, pos=[0,+8],text='visual wordform area localizer with images') msg1a = visual.TextStim(winSub, pos=[0,+5],text='During the scan, please keep your eyes on the + in the center.',height=1) msg1b = visual.TextStim(winSub, pos=[0,+2],text='Hit any button any time the fixation square becomes bigger.',height=1) msg1=visual.TextStim(winSub,pos=[0,-3],text='Subject: Hit a button when ready.',color=[1,-1,-1],colorSpace='rgb') msg1.draw() msg1a.draw() msg1b.draw() msg1x.draw() fix0.draw() # fix1.draw() # fix2.draw() winSub.flip() #wait for subject thisKey=None responseKeys=list(scanDict['subjectResponse']) responseKeys.extend('q') responseKeys.extend('escape') while thisKey==None: thisKey = event.waitKeys(keyList=responseKeys) if thisKey in ['q','escape']: core.quit() #abort else: event.clearEvents() responseKeys=list(scanDict['subjectResponse']) msg1a = visual.TextStim(winSub, pos=[0,+5],text=' ',height=1) msg1b = visual.TextStim(winSub, pos=[0,+2],text='Waiting for magnet',height=1) #msg1c.draw() msg1a.draw() msg1b.draw() fix0.draw() #fix1.draw() #fix2.draw() winSub.flip() #wait for trigger trig=None triggerKeys=list(scanDict['trigger']) triggerKeys.extend('q') triggerKeys.extend('escape') while trig==None: #wait for trigger "keypress" trig=event.waitKeys(keyList=triggerKeys) if trig in ['q','escape']: core.quit() else: #stray key event.clearEvents() #start the timer scanTimer=core.Clock() startTime=scanTimer.getTime() timeNow=scanTimer.getTime() # msg = visual.TextStim(winOp,pos=[0,-1],text = 't = %.3f' %timeNow) # msg.draw() # trialTimer=core.Clock() # trialTime=trialTimer.getTime() trialTimerNew=core.CountdownTimer() fixTimer=core.Clock() respTimer=core.Clock() #start counters for each list Acounter=0 Bcounter=0 Ccounter=0 respCounter=0 numCoins=0 currentImageNumber = -1 #loop through the number of trials, presenting appropriate stimulus or rest for iTrial in range(numTrials): #print iTrial # print designMatrix[iTrial,:] respTimer.reset() flipCoin=numpy.random.ranf() if flipCoin<fixPercentage: #change fixation size fixSize*=1.2 fixTimer.reset() respTimer.reset() numCoins+=1 subjectResponse[numCoins]=0 fix0.setWidth(fixSize) fix0.setHeight(fixSize) if designMatrixX[iTrial,0]==1: #stim #load next image currentImageNumber+=1 if currentImageNumber+1<len(imageNameSequence): #don't load an image past the last one! imageStimDict[currentImageNumber+1]=visual.ImageStim(winSub,image=imageNameSequence[currentImageNumber+1]) #delete the 2nd previous one if currentImageNumber>3: del imageStimDict[currentImageNumber-1] #print imageStimDict[currentImageNumber] #print imageStimDict[currentImageNumber+1] #thisThing.draw() imageStimDict[currentImageNumber].draw() drawFix=0 drawStim=1 winSub.flip() else: #rest drawFix=1 drawStim=0 fix0.draw() #fix1.draw() #fix2.draw() #dispay stim for stimDuration amount of time trialTimerNew.add(stimDur) while trialTimerNew.getTime()>0: timeNow = scanTimer.getTime() fixTimeCheck=fixTimer.getTime() respTimeCheck=respTimer.getTime() #print trialTimerNew.getTime() if fixTimeCheck>fixDuration: fixSize=IR/2.0 fix0.setWidth(fixSize) fix0.setHeight(fixSize) if drawStim==1: imageStimDict[currentImageNumber].draw() if drawFix==1: fix0.draw() # msg.setText('t = %.3f' %timeNow) # msg.draw() # msgScanLength.draw() # msgScanTr.draw() winSub.flip() # winOp.flip() for key in event.getKeys(): if key in ['q','escape']: core.quit() elif key in responseKeys and respTimeCheck<respDuration: subjectResponse[numCoins]=1 #then show fixation for ISI time trialTimerNew.add(trialLength-stimDur) while trialTimerNew.getTime()>0: #then show fixation for ISI time timeNow = scanTimer.getTime() fixTimeCheck=fixTimer.getTime() respTimeCheck=respTimer.getTime() #print trialTimerNew.getTime() if fixTimeCheck>fixDuration: fixSize=IR/2.0 fix0.setWidth(fixSize) fix0.setHeight(fixSize) fix0.draw() winSub.flip() # msg.setText('t = %.3f' %timeNow) # msg.draw() # msgScanLength.draw() # msgScanTr.draw() # winOp.flip() for key in event.getKeys(): if key in ['q','escape']: core.quit() elif key in responseKeys and respTimeCheck<respDuration: subjectResponse[numCoins]=1 findResp=subjectResponse[~numpy.isnan(subjectResponse)] calcResp=findResp[findResp==1] numCorrect=float(calcResp.shape[0]) if numCoins>0: percentCorrect=100.0*float(numCorrect)/(float(numCoins)) else: percentCorrect=100.0 msgText='You got %.0f %% correct!' %(percentCorrect,) msgPC=visual.TextStim(winSub,pos=[0,+3],text=msgText) msgPC.draw() winSub.flip() #create an output file in a subdirectory #check for the subdirectory if os.path.isdir('subjectResponseFiles')==False: #create directory os.makedirs('subjectResponseFiles') nowTime=datetime.datetime.now() outFile='vwfaImResponse%04d%02d%02d_%02d%02d.txt'%(nowTime.year,nowTime.month,nowTime.day,nowTime.hour,nowTime.minute) outFilePath=os.path.join('subjectResponseFiles',outFile) numpy.savetxt(outFilePath,findResp,fmt='%.0f') core.wait(2) # winOp.close() winSub.close()
def do_run(stimset): #instructions if version == 'A' or 'B': instruct_screen.draw() else: instruct_screen_practice.draw() win.flip() event.waitKeys(keyList=('space','2')) if stimset == 'face': instruct_screen1_face.draw() win.flip() else: instruct_screen1_image.draw() win.flip() event.waitKeys(keyList=('space','2')) instruct_screen2.draw() win.flip() event.waitKeys(keyList=('space','2')) if stimset == 'face': if version == 'A' or 'B': instruct_screen3_face.draw() else: instruct_screen3_face_practice.draw() else: if version == 'A' or 'B': instruct_screen3_image.draw() else: instruct_screen3_image_practice.draw() win.flip() event.waitKeys(keyList=('space','2')) #wait for scan trigger if version == 'A' or 'B': ready_screen.draw() else: ready_screen_practice.draw() win.flip() event.waitKeys(keyList=('equal')) run_start = time.time() #set Version ITI, Image orders, feedback order pic_path = os.path.join(os.getcwd(), 'pictureFolder', f'{version}_{stimset}') #lists to store logging clock = core.Clock() clock.reset() onset = [] duration = [] condition = [] resp_val = [] responsetime = [] b_1 = [] b_2 = [] b_3 = [] for trial in reference.iterrows(): trial_start = clock.getTime() row_counter = trial[0] pic_L = visual.ImageStim(win,os.path.join(pic_path, reference.loc[reference.index[row_counter], f'{version}_{stimset}_L']), pos =(-7,0),size=(11.2,17.14)) pic_R = visual.ImageStim(win,os.path.join(pic_path, reference.loc[reference.index[row_counter], f'{version}_{stimset}_R']), pos =(7,0),size=(11.2,17.14)) border = visual.ShapeStim(win, vertices=pic_L.verticesPix, units='pix', fillColor = 'grey', lineColor = 'grey') border2 = visual.ShapeStim(win, vertices=pic_R.verticesPix, units='pix', fillColor = 'grey', lineColor = 'grey') trial_timer = core.CountdownTimer(5.2) while trial_timer.getTime() > 0: #1st fixation if stimset == 'image': timer = core.CountdownTimer(fixation_time + 0.034) else: timer = core.CountdownTimer(fixation_time) while timer.getTime() > 0: fixation.draw() win.flip() fixationPre_dur = clock.getTime() - trial_start #decision_phase timer = core.CountdownTimer(decision_time) resp = event.getKeys(keyList = responseKeys) decision_onset = clock.getTime() while timer.getTime() > 0: pic_L.draw() pic_R.draw() win.flip() resp = event.getKeys(keyList = responseKeys) if len(resp)>0: if 'z' in resp: log.to_csv(os.path.join("data",subj_id, f"{subj_id}_{stimset}-{version}.tsv"), sep='\t', index = False) core.quit() if selected == 2 or 3: selected = int(resp[0]) resp_onset = clock.getTime() rt = resp_onset - decision_onset border.autoDraw=True border2.autoDraw=True pic_L.draw() pic_R.draw() win.flip() core.wait(decision_time - rt) break else: selected = '999' rt = '999' core.wait(.25) decision_dur = clock.getTime() - decision_onset border.autoDraw=False border2.autoDraw=False #2nd fixation timer = core.CountdownTimer(fixation_time) fixationPost_onset = clock.getTime() while timer.getTime() > 0: fixation.draw() win.flip() fixationPost_dur = clock.getTime() - fixationPost_onset #feedback timer = core.CountdownTimer(fb_dur) feedback_onset = clock.getTime() fb_type = reference.loc[reference.index[row_counter], f'{version}_feedback'] if fb_type == 'loss': while timer.getTime() > 0: down_arrow.draw() win.flip() elif fb_type == 'win': while timer.getTime() > 0: up_arrow.draw() win.flip() else: print('Feedback Error') feedback_dur = clock.getTime() - feedback_onset #ITI ITI_onset = clock.getTime() ITI = reference.loc[reference.index[row_counter], f'{version}_ITI'] timer = core.CountdownTimer(ITI) while timer.getTime() > 0: fixation.draw() win.flip() core.wait(ITI) ITI_dur = clock.getTime() - ITI_onset #logging condition.append('fixation_1') onset.append(trial_start) duration.append(fixationPre_dur) resp_val.append('999') responsetime.append('999') condition.append('face') onset.append(decision_onset) duration.append(decision_dur) resp_val.append(selected) responsetime.append(rt) condition.append('fixation_2') onset.append(fixationPost_onset) duration.append(fixationPre_dur) resp_val.append('999') responsetime.append('999') condition.append('feedback ' + fb_type) onset.append(feedback_onset) duration.append(feedback_dur) resp_val.append('999') responsetime.append('999') condition.append('ITI') onset.append(ITI_onset) duration.append(ITI_dur) resp_val.append('999') responsetime.append('999') #BIDS Log b_1.append(decision_onset) b_2.append(decision_dur) b_3.append(fb_type) #data to frame log = pd.DataFrame( {'onset':onset, 'duration':duration, 'trial_type':condition, 'rt':responsetime, 'resp':resp_val}) bidsEvents = pd.DataFrame( {'onset':b_1, 'duration':b_2, 'trial_type':b_3}) log.to_csv(os.path.join("data",subj_id, f"sub-{subj_id}_{stimset}-{version}.tsv"), sep='\t', index = False) bidsEvents.to_csv(os.path.join("data",subj_id, f"sub-{subj_id}_task-socialReward-{stimset}-{version}.tsv"), sep='\t', index = False) run_end = time.time() run_length = run_end -run_start print(run_length) event.clearEvents() return;
def experiment_step(self): """ Run one step in the experiment """ trial_condition = self.state_machine.get_trial_condition() presentation_time = self.state_machine.get_presentation_time() timeout_ms = self.state_machine.get_timeout_ms() isi = self.state_machine.get_isi() trial_data = { 'trial_num': self.trial_num, 'x': trial_condition.x, 'y': trial_condition.y, 'color': trial_condition.color, 'fixation_color': trial_condition.fixation_color, 'isi': isi, 'presentation_time': presentation_time, 'catch_trial': False } self.state_machine.set_fixaction_color(trial_condition.fixation_color) self.state_machine.draw_fixation() self.state_machine.flip_window() self.state_machine.wait(isi / 1000.) self.beeper.play_locking_start_tone() present_stimulus = True if self.state_machine.is_catch_trial(): trial_data['catch_trial'] = True trial_data['x'] = -999 trial_data['y'] = -999 present_stimulus = False else: self.state_machine.increment_trial_number() stim_start = time.time() response = None while (time.time() - stim_start) < (presentation_time / 1000.) and response is None: self.state_machine.draw_fixation() if present_stimulus: self.state_machine.set_stimulus_position( trial_condition.x, trial_condition.y) self.state_machine.set_stimulus_color(trial_condition.color) self.state_machine.draw_stimulus() self.state_machine.flip_window() all_keys = event.getKeys() if len(all_keys) > 0: if 'space' in all_keys: response = 'seen' elif 'return' in all_keys or 'enter' in all_keys: response = 'not_seen' elif 'q' in all_keys: response = 'quit' self.quit_task = True else: response = 'invalid' event.clearEvents() while (time.time() - stim_start) < ( timeout_ms / 1000.) and response is None and not self.quit_task: self.state_machine.draw_fixation() self.state_machine.flip_window() all_keys = event.getKeys() if len(all_keys) > 0: if 'space' in all_keys: response = 'seen' elif 'return' in all_keys or 'enter' in all_keys: response = 'not_seen' elif 'q' in all_keys: response = 'quit' self.quit_task = True else: response = 'invalid' event.clearEvents() end_time = time.time() reaction_time = int((end_time - stim_start) * 1000) self.beeper.play_locking_end_tone() self.state_machine.draw_fixation() self.state_machine.flip_window() trial_data[ 'response'] = response if response is not None else 'TIMEOUT' trial_data['reaction_time'] = reaction_time if ( response is not None and response is not 'quit') else -999 event.clearEvents() return trial_data
def CheckForEscape(): '''Check for 'escape' key.''' KeyPress = event.getKeys(keyList=['escape']) if KeyPress: QuitTask() event.clearEvents()
def showtext (thetext): event.clearEvents() thetext.draw() win.flip()
while trialcounter < trials[-1] + 4: if trialcounter < trials[-1] + 3: theseKeys = event.getKeys(keyList=['y', 'n']) else: theseKeys = event.getKeys(keyList=['l', 's', 'n']) if theseKeys: thisExp.addData('Trial', trialcounter) if trialcounter < trials[-1] + 2: Post_Q1.setAutoDraw(False) Post_Q2.setAutoDraw(True) elif trialcounter < trials[-1] + 3: Post_Q2.setAutoDraw(False) Post_Q3.setAutoDraw(True) trialcounter += 1 thisExp.addData('Response', theseKeys[-1]) event.clearEvents(eventType='keyboard') thisExp.nextEntry() else: win.flip() Post_Q3.setAutoDraw(False) win.flip() trials = range(posttrials) # Probes about cues' meanings in exps 2 + 4, doesn't advance unless all three questions are answered correctly acclist = [] random.shuffle(CueTest_list) cloop = 0 Instr1.setText( 'In the instructions, you were informed that certain ' # Starting Instr1 that gets inherited into the start of cloop 'number cues either predicted task-switches (hard ' 'trials) or task-repeats (easy trials), or were non-'
def trackingTrial(win, experimentalInfo, ballSpeed, thisCondition, simulation=False, isCatchTrial=0): from psychopy import visual, event """ Start the tracking trial 1) Generate random balls 2) Generate the central white fixation dot 3) Start blinking 2 balls in the left or right zone, for unilateral, in both zones for bilateral 4) Move the balls in random directions, bouncing on walls and on theirselves """ # Generate a list of 4 balls on left side for unilateral condition trialClock = core.Clock() rectWidth, rectHeight = experimentalInfo['RectWidth'], experimentalInfo[ 'RectHeight'] displacementX = 4 # 1 cm central displacement nBallsPerRectangle = experimentalInfo['NumBalls'] ballRadius = experimentalInfo['BallRadius'] leftRightRectangles = [[ -rectWidth - displacementX / 2.0, -rectHeight / 2.0, -displacementX / 2.0, rectHeight / 2.0 ], [ displacementX / 2.0, -rectHeight / 2.0, rectWidth + displacementX / 2.0, rectHeight / 2.0 ]] ballsLeft, rectanglesLeft = createBalls(win, nBallsPerRectangle, radius=ballRadius, boundRect=leftRightRectangles[0], speed=ballSpeed) ballsRight, rectanglesRight = createBalls(win, nBallsPerRectangle, radius=ballRadius, boundRect=leftRightRectangles[1], speed=ballSpeed) #allBallsList = { 0:ballsLowerLeft, 1:ballsLowerRight, 2:ballsUpperLeft,3:ballsUpperRight } allBallsList = {0: ballsLeft, 1: ballsRight} fixationBall = Ball(win, position=np.array([0.0, 0.0]), direction=np.array([0.0, 0.0]), speed=0.0, radius=0.10, color='White') trialClock.reset() blinkingBalls = list() whichSide = None if thisCondition['Side'] == 'Left': whichSide = 0 if thisCondition['Side'] == 'Right': whichSide = 1 runMode = None if thisCondition['label'].split('-')[0] == 'Unilateral': runMode = 0 if thisCondition['label'].split('-')[0] == 'Bilateral': runMode = 1 runModes = {0: 'Unilateral', 1: 'Bilateral'} if runModes[runMode] == 'Unilateral': blinkingBalls = [ allBallsList[whichSide][0], allBallsList[whichSide][1] ] if runModes[runMode] == 'Bilateral': blinkingBalls = [ allBallsList[0][0], allBallsList[0][1], allBallsList[1][0], allBallsList[1][1] ] if runModes[runMode] != 'Unilateral' and runModes[runMode] != 'Bilateral': raise Exception("Run mode must be \"Unilateral\" or \"Bilateral\"") blinkTimer = core.Clock() blinkInteger = 0 rectanglesVisual = [] for r in rectanglesLeft + rectanglesRight: rectanglesVisual.append( visual.Rect(win, width=(r[2] - r[0]), height=(r[3] - r[1]), fillColor=None, lineColor='Red', units='cm', pos=[(r[0] + r[2]) / 2.0, (r[1] + r[3]) / 2.0])) # Start first part of the experiment, 2 balls blink for a certain amount # of time controlled by experimentalInfo['BlinkTime'] while trialClock.getTime() < experimentalInfo['BlinkTime']: fixationBall.draw() # speedText.draw() if experimentalInfo['DrawRectangles']: for r in rectanglesVisual: r.draw() for ballListID, ballList in allBallsList.iteritems(): for ball1 in ballList: ball1.draw() if (blinkTimer.getTime() > 0.125): blinkInteger = blinkInteger + 1 blinkTimer.reset() if (blinkInteger % 2): for blinkBall in blinkingBalls: blinkBall.setColor('White') else: for blinkBall in blinkingBalls: blinkBall.setColor('Black') if (experimentalInfo['SaveVideo']): win.getMovieFrame() win.flip() # Reset all colors of the balls to black and move each ball in its right # part of space for ballListID, ballList in allBallsList.iteritems(): for ball1 in ballList: ball1.setColor('Black') if (isCatchTrial == 1): ball1.setColor('Yellow') if (isCatchTrial == 2): ball1.setColor('Magenta') ball1.draw() fixationBall.draw() if (experimentalInfo['SaveVideo']): win.getMovieFrame() win.flip() trialClock.reset() # This function pregenerates all the trajectories so that in displaying # them we have no slowing allFrames = preGenerateTrajectories(ballSpeed / win.fps(), experimentalInfo, allBallsList, leftRightRectangles, repulsionStrength=2000.0 * ballSpeed, edgerepulsionStrength=10.0 * ballSpeed, centerAttraction=0.0001) trialClock.reset() for balls in allFrames: for ball, pos in balls.iteritems(): ball.setPos(pos) ball.draw() # speedText.draw() if experimentalInfo['DrawRectangles']: for r in rectanglesVisual: r.draw() fixationBall.draw() if (experimentalInfo['SaveVideo']): win.getMovieFrame() win.flip() event.clearEvents(eventType='keyboard') trialClock.reset() randomBall = allBallsList[whichSide][randrange(0, nBallsPerRectangle)] randomBall.setColor('Red') event.clearEvents(eventType='keyboard') trialClock.reset() responseKey = None response = None while True: keys = event.getKeys() fixationBall.draw() for ballListID, ballList in allBallsList.iteritems(): for ball1 in ballList: ball1.draw() randomBall.draw() if 's' in keys: responseKey = True response = responseKey == (randomBall in blinkingBalls) trialClock.reset() if 'd' in keys: responseKey = False response = responseKey == (randomBall in blinkingBalls) trialClock.reset() # Plot the green/red dot for 0.5 seconds if response is not None: break if 'escape' in keys: win.close() core.quit() if (experimentalInfo['SaveVideo']): win.getMovieFrame() win.flip() if response is True: fixationBall.setColor('Green') if response is False: fixationBall.setColor('Red') trialClock.reset() while trialClock.getTime() < 0.4: keys = event.getKeys() fixationBall.draw() for ballListID, ballList in allBallsList.iteritems(): for ball1 in ballList: ball1.draw() randomBall.draw() if (experimentalInfo['SaveVideo']): win.getMovieFrame() win.flip() if (experimentalInfo['SaveVideo']): import os currentpath = os.getcwd() savedatapath = currentpath + os.path.sep + 'data' outputVideo = savedatapath + os.path.sep + \ "frames" + os.path.sep + 'Tracking.png' print "Saving video to " + outputVideo win.saveMovieFrames(outputVideo) return response
def do_run(run, trials): resp = [] fileName = log_file.format(subj_id, run) #wait for trigger ready_screen.draw() win.flip() event.waitKeys(keyList=('equal')) globalClock.reset() studyStart = globalClock.getTime() #Initial Fixation screen fixation.draw() win.flip() core.wait(initial_fixation_dur) for trial in trials: condition_label = stim_map[trial['Partner']] image_label = image_map[trial['Partner']] imagepath = os.path.join(expdir, 'Images') image = os.path.join(imagepath, "%s.png") % image_label nameStim.setText(condition_label) pictureStim.setImage(image) #decision phase timer.reset() event.clearEvents() resp = [] resp_val = None resp_onset = None decision_onset = globalClock.getTime() trials.addData('decision_onset', decision_onset) while timer.getTime() < decision_dur: cardStim.draw() question.draw() pictureStim.draw() nameStim.draw() win.flip() resp = event.getKeys(keyList=responseKeys) if len(resp) > 0: if resp[0] == 'z': #trials.saveAsText(fileName=log_file.format(subj_id),delim=',',dataOut='all_raw') os.chdir(subjdir) trials.saveAsWideText(fileName) os.chdir(expdir) win.close() core.quit() resp_val = int(resp[0]) if resp_val == 2: resp_onset = globalClock.getTime() question.setColor('darkorange') rt = resp_onset - decision_onset #core.wait(decision_dur - rt) if resp_val == 3: resp_onset = globalClock.getTime() question.setColor('darkorange') rt = resp_onset - decision_onset #core.wait(decision_dur -rt) cardStim.draw() question.draw() pictureStim.draw() nameStim.draw() win.flip() core.wait(decision_dur - rt) break else: resp_val = 0 resp_onset = 999 rt = 999 trials.addData('resp', int(resp_val)) trials.addData('resp_onset', resp_onset) trials.addData('rt', rt) ###reset question mark color question.setColor('white') #outcome phase timer.reset() #win.flip() outcome_onset = globalClock.getTime() while timer.getTime() < outcome_dur: outcome_cardStim.draw() pictureStim.draw() nameStim.draw() #win.flip() if trial['Feedback'] == '3' and resp_val == 2: outcome_txt = int(random.randint(1, 4)) outcome_moneyTxt = 'h' outcome_color = 'lime' trials.addData('outcome_val', int(outcome_txt)) elif trial['Feedback'] == '3' and resp_val == 3: outcome_txt = int(random.randint(6, 9)) outcome_moneyTxt = 'h' outcome_color = 'lime' trials.addData('outcome_val', int(outcome_txt)) elif trial['Feedback'] == '2' and resp_val == 2: outcome_txt = int(5) outcome_moneyTxt = 'n' outcome_color = 'white' trials.addData('outcome_val', int(outcome_txt)) elif trial['Feedback'] == '2' and resp_val == 3: outcome_txt = int(5) outcome_moneyTxt = 'n' outcome_color = 'white' trials.addData('outcome_val', int(outcome_txt)) elif trial['Feedback'] == '1' and resp_val == 2: outcome_txt = int(random.randint(6, 9)) outcome_moneyTxt = 'i' outcome_color = 'darkred' trials.addData('outcome_val', int(outcome_txt)) elif trial['Feedback'] == '1' and resp_val == 3: outcome_txt = int(random.randint(1, 4)) outcome_moneyTxt = 'i' outcome_color = 'darkred' trials.addData('outcome_val', int(outcome_txt)) elif resp_val == 0: outcome_txt = '#' outcome_moneyTxt = '' outcome_color = 'white' outcome_value = '999' trials.addData('outcome_val', int(outcome_value)) #print outcome_txt outcome_text.setText(outcome_txt) outcome_money.setText(outcome_moneyTxt) outcome_money.setColor(outcome_color) outcome_text.draw() outcome_money.draw() win.flip() core.wait(outcome_dur) #trials.addData('outcome_val', outcome_txt) trials.addData('outcome_onset', outcome_onset) outcome_offset = globalClock.getTime() trials.addData('outcome_offset', outcome_offset) duration = outcome_offset - decision_onset trials.addData('trialDuration', duration) event.clearEvents() print "got to check 3" #ITI logging.log(level=logging.DATA, msg='ITI') #send fixation log event timer.reset() ITI_onset = globalClock.getTime() iti_for_trial = float(trial['ITI']) while timer.getTime() < iti_for_trial: fixation.draw() win.flip() ITI_offset = globalClock.getTime() trials.addData('ITIonset', ITI_onset) trials.addData('ITIoffset', ITI_offset) # Final Fixation screen after trials completed fixation.draw() win.flip() #core.wait(final_fixation_dur) os.chdir(subjdir) trials.saveAsWideText(fileName) os.chdir(expdir) endTime = 0.01 # not sure if this will take a 0, so giving it 0.01 and making sure it is defined expected_dur = 398 buffer_dur = 10 total_dur = expected_dur + buffer_dur if globalClock.getTime() < total_dur: endTime = (total_dur - globalClock.getTime()) else: endTime = buffer_dur core.wait(endTime) print globalClock.getTime()
def run(self): #setup monitor self.prepareRun() self._win.units = 'pix' event.clearEvents() mouse = event.Mouse(win=self._win) mouse.setVisible(0) stim = visual.Rect(self._win) stim.height = self.boxSize stim.width = self.boxSize stim.pos = (self.trialBoxPosition[0], self.trialBoxPosition[1]) stim.fillColor = self.boxColors[0] stim.lineColor = self.boxColors[0] lastMouseWheelButton = 0 numFrames = 0 mousePos = np.array([0, 0]) while True: # mousePos = mouse.getPos() mousePos += mouse.getRel() stim.pos = (mousePos[0], mousePos[1]) if self.toggleColor and (numFrames % self.togglePeriod == 0): stim.fillColor = -stim.fillColor stim.lineColor = -stim.lineColor stim.draw() self.visStimFlip() keys = event.getKeys( ['space', 'escape', 'period', 'comma', 'up', 'down', 'p']) mouseWheel = mouse.getWheelRel() mouseButtons = mouse.getPressed() stepSize = 10 if max(mouseButtons[0], mouseButtons[2]) == 0: stim.height += stepSize * mouseWheel[1] stim.width += stepSize * mouseWheel[1] else: if [mouseButtons[0], mouseButtons[2]] == [1, 0]: stim.height += stepSize * mouseWheel[1] if [mouseButtons[0], mouseButtons[2]] == [0, 1]: stim.width += stepSize * mouseWheel[1] if [mouseButtons[0], mouseButtons[2]] == [1, 1]: stim.height = (stim.height + stim.width) / 2 stim.width = (stim.height + stim.width) / 2 if mouseButtons[1] - lastMouseWheelButton == 1: stim.fillColor = -stim.fillColor stim.lineColor = -stim.lineColor if len(keys) > 0: if 'space' in keys: self.toggleColor = False if self.toggleColor else True if 'comma' in keys: self.togglePeriod -= 5 self.togglePeriod = 1 if self.togglePeriod <= 0 else self.togglePeriod if 'period' in keys: self.togglePeriod += 5 if 'up' in keys: stim.ori += 5 if 'down' in keys: stim.ori -= 5 if 'escape' in keys: break if 'p' in keys: print[pos / self.pixelsPerDeg for pos in stim.pos] lastMouseWheelButton = mouseButtons[1] numFrames += 1 event.clearEvents() self.completeRun()
grating = visual.GratingStim(win, mask='gauss', ori=45, sf=2) # Using bits++ with one stimulus globalClock = core.Clock() while True: # get new contrast t = globalClock.getTime() newContr = numpy.sin(t * numpy.pi * 2) # sinusoidally modulate contrast # set whole screen to this contrast bitsBox.setContrast(newContr) # draw gratings and update screen grating.draw() win.flip() # check for a keypress if event.getKeys(): break event.clearEvents('mouse') # only really needed for pygame windows # reset the bits++(and update the window so that this is done properly) bitsBox.setContrast(1) win.flip() win.close() core.quit() # The contents of this file are in the public domain.
def displayCircularStimuli(directions, colors, colors_wheel, thicknesses, speeds, duration): global mywin, plate, white mywin = visual.Window([1280, 1024], monitor="Dell Inc. 17", units="pix", fullscr=False, screen=1, color='white') plate = visual.Rect(win=mywin, size=(width_plate, height_plate), lineColor=[0, 0, 0], lineColorSpace="rgb255", lineWidth=4) white = visual.ImageStim(win=mywin, image="Solid_white.png", size=(1280, 1024), pos=[0, 0]) ops = [] for d in directions: if d == 'Clockwise': ops.append('+') else: ops.append('-') shape1 = visual.ShapeStim(mywin, units='', lineWidth=thicknesses[0], lineColor=colors_wheel[0], lineColorSpace='rgb', fillColor='red', fillColorSpace='rgb', vertices=np.multiply(wheel, scalingFactor), windingRule=None, closeShape=True, pos=(-width_plate / 6.4, height_plate / 8.2), size=1, ori=0.0, opacity=1.0, contrast=1.0, depth=0, interpolate=True, name=None, autoLog=None, autoDraw=False) shape1b = visual.Circle(mywin, radius=scalingFactor, fillColor=colors[0], pos=(-width_plate / 6.4, height_plate / 8.2)) shape2 = visual.ShapeStim(mywin, units='', lineWidth=thicknesses[1], lineColor=colors_wheel[1], lineColorSpace='rgb', fillColor='red', fillColorSpace='rgb', vertices=np.multiply(wheel, scalingFactor), windingRule=None, closeShape=True, pos=(0, height_plate / 8.2), size=1, ori=0.0, opacity=1.0, contrast=1.0, depth=0, interpolate=True, name=None, autoLog=None, autoDraw=False) shape2b = visual.Circle(mywin, radius=scalingFactor, fillColor=colors[1], pos=(0, height_plate / 8.2)) shape3 = visual.ShapeStim(mywin, units='', lineWidth=thicknesses[2], lineColor=colors_wheel[2], lineColorSpace='rgb', fillColor='red', fillColorSpace='rgb', vertices=np.multiply(wheel, scalingFactor), windingRule=None, closeShape=True, pos=(width_plate / 6.4, height_plate / 8.2), size=1, ori=0.0, opacity=1.0, contrast=1.0, depth=0, interpolate=True, name=None, autoLog=None, autoDraw=False) shape3b = visual.Circle(mywin, radius=scalingFactor, fillColor=colors[2], pos=(width_plate / 6.4, height_plate / 8.2)) shape4 = visual.ShapeStim(mywin, units='', lineWidth=thicknesses[3], lineColor=colors_wheel[3], lineColorSpace='rgb', fillColor='red', fillColorSpace='rgb', vertices=np.multiply(wheel, scalingFactor), windingRule=None, closeShape=True, pos=(-width_plate / 6.4, -height_plate / 8.2), size=1, ori=0.0, opacity=1.0, contrast=1.0, depth=0, interpolate=True, name=None, autoLog=None, autoDraw=False) shape4b = visual.Circle(mywin, radius=scalingFactor, fillColor=colors[3], pos=(-width_plate / 6.4, -height_plate / 8.2)) shape5 = visual.ShapeStim(mywin, units='', lineWidth=thicknesses[4], lineColor=colors_wheel[4], lineColorSpace='rgb', fillColor='red', fillColorSpace='rgb', vertices=np.multiply(wheel, scalingFactor), windingRule=None, closeShape=True, pos=(0, -height_plate / 8.2), size=1, ori=0.0, opacity=1.0, contrast=1.0, depth=0, interpolate=True, name=None, autoLog=None, autoDraw=False) shape5b = visual.Circle(mywin, radius=scalingFactor, fillColor=colors[4], pos=(0, -height_plate / 8.2)) shape6 = visual.ShapeStim(mywin, units='', lineWidth=thicknesses[5], lineColor=colors_wheel[5], lineColorSpace='rgb', fillColor='red', fillColorSpace='rgb', vertices=np.multiply(wheel, scalingFactor), windingRule=None, closeShape=True, pos=(width_plate / 6.4, -height_plate / 8.2), size=1, ori=0.0, opacity=1.0, contrast=1.0, depth=0, interpolate=True, name=None, autoLog=None, autoDraw=False) shape6b = visual.Circle(mywin, radius=scalingFactor, fillColor=colors[5], pos=(width_plate / 6.4, -height_plate / 8.2)) mywin.winHandle.maximize() mywin.winHandle.set_fullscreen(True) mywin.winHandle.activate() # display white while True: white.draw() plate.draw() mywin.flip() if event.waitKeys(0.5) == ["escape"]: break event.clearEvents() startCamera(duration) clock = core.Clock() for frameN in range(duration): white.draw() plate.draw() shape1.setOri(speeds[0], operation=ops[0]) shape1b.draw() shape1.draw() shape2.setOri(speeds[1], operation=ops[1]) shape2b.draw() shape2.draw() shape3.setOri(speeds[2], operation=ops[2]) shape3b.draw() shape3.draw() shape4.setOri(speeds[3], operation=ops[3]) shape4b.draw() shape4.draw() shape5.setOri(speeds[4], operation=ops[4]) shape5b.draw() shape5.draw() shape6.setOri(speeds[5], operation=ops[5]) shape6b.draw() shape6.draw() mywin.logOnFlip(level=logging.CRITICAL, msg='sent on actual flip') mywin.flip() for frameN in range(300): white.draw() plate.draw() mywin.flip() mywin.close() core.quit()
def test_clearEvents(self): for t in ['mouse', 'joystick', 'keyboard', None]: event.clearEvents(t)
def do_run(run_number, trials): timer = core.Clock() ############################## # 1. display ready screen and wait for 't' to be sent to indicate scanner trigger ready_screen.draw() # Change to the next slide win.flip() #showing "Ready" # wait until the key 't' appears event.waitKeys(keyList='t') # reset globalClock globalClock.reset() # send START log event logging.log(level=logging.DATA, msg='******* START (trigger from scanner) - run %i *******' % run_number) ################ # SHOW INSTRUCTIONS ################ timer.reset() #Change to the next slide: # - "Please review..." for "INSTRUCT_DUR" (8s) while timer.getTime() < INSTRUCT_DUR: instruction_text.draw() win.flip() timer.reset() #Change to the next slide: # - "pre-task fixation" for "FIXATION_DUR" (1.5 s) while timer.getTime() < FIXATION_DUR: fixation.draw() win.flip() ################ # MAIN LOOP # present trials for tidx, trial in enumerate(trials): # Set up local parameters-------------------------------- # Image 1--------------------- trial_type = trial['type'] cond = trial['cond'] theme = trial['theme'] image = "images/%s/First Image/%s_%s.png" % (cond, theme, trial_type) # print(image) pictureStim_image1.setImage(image) # send MESSAGE log event logging.log(level=logging.DATA, msg="MESSAGE: %s - %s - %s" % (cond, theme, trial_type)) trials.addData('stim_onset', globalClock.getTime()) timer.reset() #Change to the next slide:--------------------------------- # - "trial picture" for "MESSAGE_DUR" (3s) while timer.getTime() < MESSAGE_DUR: pictureStim_image1.draw() win.flip() # send SHOW RATING log event logging.log(level=logging.DATA, msg="SHOW RATING") trials.addData('resp_onset', globalClock.getTime()) # clear event buffer event.clearEvents() resp_onset = globalClock.getTime() #Change to the next slide:--------------------------------- # - trial picture along with"rating" for "RATING_DUR" (2s) # show rating and collect response timer.reset() while timer.getTime() < RATING_DUR: # draw the trial picture pictureStim_image1.draw() # draw the rating scale and anchors for rate_stim in ratingStim: rate_stim.draw() anchor1.draw() anchor4.draw() # Show the rating stimulus win.flip() # get key response resp = event.getKeys(keyList=BUTTONS) # the case when the subject did press a button if len(resp) > 0: # get the first button response resp_value = resp[0] # Mark the pressed value as red # (will be shown at the next win.flip()) ratingStim[BUTTON_LABELS[resp_value]].setColor('red') # Logging: add response value to the trial handler logging #pdb.set_trace() # Why is the reponse being ovewritten by the next trial?? (2019/04/01) # Note that the previous response is no unsaved. It IS overwritten. trials.addData('resp', resp_value) trials.addData('rt', globalClock.getTime() - resp_onset) #trials.nextEntry() #not working... #pdb.set_trace() # End of the rating slide #Change to the next slide:--------------------------------- # - image2 (3s) # show rating and collect response image2 = "images/%s/Second Image/%s_%s.png" % (cond, theme, trial_type) pictureStim_image2.setImage(image2) timer.reset() while timer.getTime() < MESSAGE_DUR: pictureStim_image2.draw() win.flip() # Reset rating number color for rate in ratingStim: rate.setColor('#FFFFFF') # ------------ FIXATION ------------ # logging: send FIXATION log event logging.log(level=logging.DATA, msg='FIXATION') # Get the fixation duration (a random int from 1 to 5) fixation_for_trial = fixations[run_number - 1][tidx] timer.reset() #Change to the next slide: # - "rating" for "RATING_DUR" (1-5s) while timer.getTime() < fixation_for_trial: #for frame in range(FIXATION_DUR): fixation.draw() win.flip() # End of all trials # Logging: Send END log event logging.log(level=logging.DATA, msg='******* END run %i *******' % run_number) #pdb.set_trace() # Save the trial infomation from trial handler log_filename2 = "%s_%i.csv" % (log_filename[:-4], run_number) # the data to write to csv is stored in "trials.data" # (1) trials.addDataData(): 'stim_onset', 'resp_onset', 'resp', 'rt' # - Comes from trials.addDataData() # (2) from trials.extraInfo: 'Participant ID', 'Date', 'Description' # - Comes from 'run_data' trials.saveAsWideText(log_filename2) # Show the run-ending slide run_end_screen.draw() win.flip() #trials.saveAsText(log_filename2, delim=',', dataOut=('n', 'all_raw')) #####FAIL with "-1" # Press 'space' to and the run (will move on to the next run if there is one) event.waitKeys(keyList=('space'))
def do_run(trials): resp = [] #wait for button press from RA ('spacebar' key press) ready_screen.draw() win.flip() event.waitKeys(keyList=('space')) globalClock.reset() for trial in trials: # add trial logic # i.e. show stimuli # get resp # add data to 'trial' condition_label = stim_map[trial['Partner']] shareStim.setText(condition_label) resp_left = trial['cLeft'] respcLeft = 'Share $%s.00' % resp_left resp_text_left.setText(respcLeft) resp_right = trial['cRight'] respcRight = 'Share $%s.00' % resp_right resp_text_right.setText(respcRight) if resp == ['z']: core.quit() #decision phase timer.reset() event.clearEvents() resp = [] resp_val = None resp_onset = None answer = 0 trial_onset = globalClock.getTime() ISI_pad = [] while timer.getTime() < .5: shareStim.draw() win.flip() while timer.getTime() < decision_dur: shareStim.draw() resp_text_left.draw() resp_text_right.draw() win.flip() if answer == 0: resp = event.getKeys(keyList=responseKeys) if len(resp) == 0: resp_val = 'NA' response = 'NA' resp_onset = globalClock.getTime() highlow = 'NA' ISI_pad = decision_dur - resp_onset if answer == 0 and len(resp) > 0: resp_val = int(resp[0]) resp_onset = globalClock.getTime() ISI_pad = decision_dur - resp_onset answer = 1 if resp_val == 2: resp_text_left.setColor('red') response = resp_left if resp_left < resp_right: highlow = 'low' else: highlow = 'high' if resp_val == 3: resp_text_right.setColor('red') response = resp_right if resp_left < resp_right: highlow = 'high' else: highlow = 'low' shareStim.draw() resp_text_left.draw() resp_text_right.draw() win.flip() core.wait(.5) break trials.addData('onset', trial_onset) trials.addData('bpress', resp_val) trials.addData('resp', response) trials.addData('resp_onset', resp_onset) trials.addData('highlow', highlow) trials.addData('rt', resp_onset - trial_onset) #reset rating number and amount resp_text_left.setColor('#FFFFFF') resp_text_right.setColor('#FFFFFF') resp_text_left.setText() resp_text_right.setText() #ISI #logging.log(level=logging.DATA, msg='ISI') #send fixation log event ISI_onset = globalClock.getTime() trials.addData('ISI_onset', ISI_onset) timer.reset() isi_for_trial = float(trial['ISI']) while timer.getTime() < isi_for_trial + ISI_pad: waiting.draw() win.flip() #outcome phase partner_resp = float(trial['Reciprocate']) if len(resp) > 0: if (int(trial['cLeft']) == 0 and resp_val == 2) or (int(trial['cRight']) == 0 and resp_val == 3): core.wait(.5) outcome_onset = 'NA' else: outcome_txt = outcome_map[2][partner_resp].format( condition_label) outcome_stim.setText(outcome_txt) outcome_stim.draw() win.flip() core.wait(2) outcome_onset = globalClock.getTime() else: outcome_txt = outcome_map[resp_val] outcome_stim.setText(outcome_txt) outcome_stim.draw() win.flip() core.wait(2) outcome_onset = 'NA' trials.addData('outcome_onset', outcome_onset) trial_duration = globalClock.getTime() trials.addData('duration', trial_duration - trial_onset) #ITI #logging.log(level=logging.DATA, msg='ITI') #send fixation log event timer.reset() iti_for_trial = float(trial['ITI']) ITI_onset = globalClock.getTime() while timer.getTime() < iti_for_trial: fixation.draw() win.flip() trials.addData('ITI_onset', ITI_onset) trials.saveAsWideText(fileName=log_file.format(subj_id, subj_id), delim=',', appendFile=True)
if setsize == 2: updates = run_details[2] A1.pos = (0, 140) B1.pos = (0, -140) A1.text = run_details[0]['A1'] B1.text = run_details[0]['B1'] reset_box_color() box_draw(2) A1.draw() B1.draw() win.flip() event.clearEvents() event.waitKeys(keyList=['space']) box_draw(2) win.flip() core.wait(0.5) stim_track = [] for stim in updates: if stim['dig'] > 0: stim_dig = '+' + str(stim['dig']) else: stim_dig = str(stim['dig']) exec("%s.text = stim_dig" % stim['pos'])
def stimuli_presentation(subject, hz_list, acquisition_scheme, order_volume, order_presentation, single_run): """function to present stimuli if single_run == True present a single trial with specified order of volume and frequency progression, if single_run == False presents all possible combinations of volume and frequency progression (2x2) for one specifies acquisition_scheme subject = subject code hz_list = list containing paths to stimuli acquisition_scheme = name of specified acq-scheme order_volume = volume progression either "increasing" or "decreasing" order_presentation = frequency progression either "ascending" or "descending" """ # setup your screen specifications #hz_list = pd.read_csv('/home/michael/atom/stimuli.csv') run_list = hz_list.columns if single_run == True: # setup window for stimuli presentation # set fullscr=True for fullscree presentation win = visual.Window([800, 600], monitor="testMonitor", units="deg", fullscr=False) print(acquisition_scheme) content['acq'] = str(acquisition_scheme) # reverse stimuli list if different order of frequency presentation is specified if order_presentation == 'descending': run_list = reversed(list(run_list)) # get order of volume and in what range they should be presented if order_volume == 'increasing': order = list(range(0, 9)) elif order_volume == 'decreasing': order = list(reversed(range(0, 9))) # get instruction for increasing or decreasing volume condition if order_volume == 'increasing': instruction = 'Press the button, once you - DO - hear a tone.' elif order_volume == 'decreasing': instruction = 'Press the button, if you - DO NOT - hear the tone anymore' # append order of volume and frequency presentation to json-file content.setdefault('volume_progression', []).append(order_volume) content.setdefault('frequency_progression', []).append(order_presentation) # create lists to keep track what and when stimuli is presented result_list = [] stim_start_type = [] stim_onset_list = [] rt_list = [] trial_onset_list = [] trial_end_list = [] all_stim_list = [] # specify and present instrtuction win.clearBuffer() win.flip() # update screen, display message message = visual.TextStim(win, text=instruction) win.flip() # update screen, display message message.setAutoDraw(True) # automatically draw every frame win.flip() # update screen, display message core.wait(1.5) # wait for given amount in seconds # wait for mri-trigger for i in range(3): while True: # get timestamp for first trigger if i == 0: trial_onset = time.time() # get trigger as keyboard input, 't' is the standard input for # our scanner, eventually needs to be changed for different # scanner theseKeys = event.getKeys('t') # if 't' in theseKeys: event.clearEvents(eventType='keyboard') print('trigger') break # end experiment by pressing "q" key_escape = event.getKeys('q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() trial_onset_list.append(trial_onset) # present msg indicating that trial begins message.setText('Run starts!') message.setAutoDraw(True) # automatically draw every frame win.flip() # update screen, display message # end experiment by pressing "q" key_escape = event.getKeys('q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() # present fixation cross win.clearBuffer() win.flip() # update screen, display message message.setText('+') win.flip() ####################################################################### # stimuli presentation starts here ####################################################################### #counter = 0 # counter # iterate over list of stimuli for i in run_list: for j in order: core.wait(1) # wait for one second before stimuli presentation #print(j) # which stimuli to play hz = hz_list[i][j] # condition to break loop once participants responds to stimuli stop_loop = False # set stimuli as sound object stim = sound.Sound(_thisDir + '/stimuli/' + hz) win.clearBuffer() win.flip() # update screen, display message # end experiment by pressing "q" key_escape = event.getKeys('q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() #core.wait(0.2) # wait for 0.2s for system to settle # clock object to keep track of presentation time trial_clock = core.Clock() stim.play() # play stimuli # get timestamp of stimuli presentation and append to list stim_start_absolute = time.time() stim_start = stim_start_absolute - trial_onset stim_start_type.append(hz) all_stim_list.append(stim_start) # present stimuli for 2s and wait for participants response while trial_clock.getTime( ) < 2.0: # clock times are in seconds if 0.0 <= trial_clock.getTime() < 2.0: # if participant presses the "7" key stop volume volume # progression and jump to next stimuli this_key = event.getKeys('7') if '7' in this_key: stim.stop() stim_onset_list.append( stim_start) #timestamp for stim onset #counter += 1 # get specific volume that was responded to result_list.append(hz) # get timestamp for participant response rt_absolute = time.time() rt = rt_absolute - trial_onset rt_list.append(rt) stop_loop = True # indicates that next stimuli should be picked break elif order_volume == 'decreasing' and j is 0 and '7' not in this_key and trial_clock.getTime( ) > 1.9: print('not_discovered') result_list.append(str(hz) + '/not_discovered') stim_onset_list.append(stim_start) #counter += 1 stim.stop() rt_absolute = time.time() rt = rt_absolute - trial_onset rt_list.append(rt) stop_loop = True break elif order_volume == 'increasing' and j is 8 and '7' not in this_key and trial_clock.getTime( ) > 1.9: print('not_discovered') result_list.append(str(hz) + '/not_discovered') stim.stop() stim_onset_list.append(stim_start) #counter += 1 rt_absolute = time.time() rt = rt_absolute - trial_onset rt_list.append(rt) stop_loop = True break key_escape = event.getKeys( 'q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() if stop_loop is True: break # close window for presentation win.close() # create DataFrame to save results df_results = pd.DataFrame({'stimuli': result_list}) order_presentation_list = [] volumes = [] frequencies = [] acquisition_scheme_list = [] order_volume_list = [] subject_name = [] for i in df_results.columns: for item in df_results[i]: subject_name.append(subject) # get info on acquisition_scheme if 'baseline' in acquisition_scheme: acquisition_scheme_list.append('baseline') elif 'epi_fast(TR1s)' in acquisition_scheme: acquisition_scheme_list.append('epi_fast(TR1s)') elif 'epi_standard(TR2s)' in acquisition_scheme: acquisition_scheme_list.append('epi_standard(TR2s)') elif 'mprage(T1w)' in acquisition_scheme: acquisition_scheme_list.append('mprage(T1w)') else: acquisition_scheme_list.append('mprage(T1w)') # get info on volume order if 'decreasing' in order_volume: order_volume_list.append('decreasing') elif 'increasing' in order_volume: order_volume_list.append('increasing') # get info on stimuli order if 'ascending' in order_presentation: order_presentation_list.append('ascending') elif 'descending' in order_presentation: order_presentation_list.append('descending') # extract discovered volume if 'not_discovered' in item: volumes.append('0') #elif '10dBFS' in item: # volumes.append(-10) elif '20dBFS' in item: volumes.append(-20) elif '30dBFS' in item: volumes.append(-30) elif '40dBFS' in item: volumes.append(-40) elif '50dBFS' in item: volumes.append(-50) elif '60dBFS' in item: volumes.append(-60) elif '70dBFS' in item: volumes.append(-70) elif '80dBFS' in item: volumes.append(-80) elif '90dBFS' in item: volumes.append(-90) elif '100dBFS' in item: volumes.append(-100) if '150hz' in item: frequencies.append(150) elif '1000hz' in item: frequencies.append(1000) elif '1500hz' in item: frequencies.append(1500) elif '2000hz' in item: frequencies.append(2000) elif '2250hz' in item: frequencies.append(2250) elif '2500hz' in item: frequencies.append(2500) elif '2750hz' in item: frequencies.append(2750) elif '3000hz' in item: frequencies.append(3000) elif '4000hz' in item: frequencies.append(4000) elif '6000hz' in item: frequencies.append(6000) elif '8000hz' in item: frequencies.append(8000) elif '250hz' in item: frequencies.append(250) elif '500hz' in item: frequencies.append(500) # set datframe containing exp results date = data.getDateStr() # get date df = pd.DataFrame({ 'stimuli': result_list, 'subject': subject_name, 'onset': stim_onset_list, 'reaction_time': rt_list, 'acquisition_scheme': acquisition_scheme_list, 'Level (dBFS)': volumes, 'Frequency (Hz)': frequencies, 'order_volume': order_volume_list, 'order_presentation': order_presentation_list }) # save data as csv df.to_csv('{first}_{second}_{third}_{fourth}_{last}.tsv'.format( first=subject, second=acquisition_scheme, third=order_volume, fourth=order_presentation, last=str(date)), encoding='utf-8', index=False, sep='\t') # save trial_start times df_trial_start = pd.DataFrame({'trial_start': trial_onset_list}) df_trial_start.to_csv( '{first}_{second}_{third}_{fourth}_trial_start_{last}.tsv'.format( first=subject, second=acquisition_scheme, third=order_volume, fourth=order_presentation, last=str(date)), encoding='utf-8', index=False, sep='\t') # save all stimuli onsets df_stimuli_onsets = pd.DataFrame({ 'stimuli_onset': all_stim_list, 'Frequency (Hz)': stim_start_type }) df_stimuli_onsets.to_csv( '{first}_{second}_{third}_{fourth}__stimuli_onsets_{last}.tsv'. format(first=subject, second=acquisition_scheme, third=order_volume, fourth=order_presentation, last=str(date)), encoding='utf-8', index=False, sep='\t') # write json-summary-file for trial with open( '{first}_{second}_{third}_{fourth}_{last}.json'.format( first=subject, second=acquisition_scheme, third=order_volume, fourth=order_presentation, last=str(date)), 'w') as f: json.dump(content, f, indent=4) ## if user specified to run all volume and presentation orders elif single_run == False: # repeat loop for each possible combination of conditions for x in range(4): content['acq'] = acquisition_scheme list_volume = ['increasing', 'decreasing'] list_order = ['ascending', 'descending'] if x == 0: # setup window for stimuli presentation # set fullscr=True for fullscree presentation win = visual.Window([800, 600], monitor="testMonitor", units="deg") # create lists to keep track what and when stimuli is presented result_list = [] stim_start_type = [] stim_onset_list = [] rt_list = [] trial_onset_list = [] trial_end_list = [] order_presentation_list = [] order_volume_list = [] all_stim_list = [] # x = how often loop was performed; which trial we're in if x == 0: # get presentation conditions for first trial order_volume = list_volume[0] order_presentation = list_order[0] instruction = 'Press the button, once you - DO - hear a tone.' elif x == 1: # get presentation conditions for second trial order_volume = list_volume[1] order_presentation = list_order[0] instruction = 'Press the button, if you - DO NOT - hear the tone anymore' elif x == 2: # get presentation conditions for third trial order_volume = list_volume[0] order_presentation = list_order[1] instruction = 'Press the button, once you - DO - hear a tone.' elif x == 3: # get presentation conditions for second trial order_volume = list_volume[1] order_presentation = list_order[1] instruction = 'Press the button, if you - DO NOT - hear the tone anymore' # list containing stimuli categories (e.g. 150hz, 250hz, etc.) run_list = hz_list.columns # reverse stimuli list if different order of frequency presentation is specified if order_presentation == 'descending': run_list = reversed(list(hz_list)) # get order of volume and in what range they should be presented if order_volume == 'increasing': order = list(range(0, 9)) elif order_volume == 'decreasing': order = list(reversed(range(0, 9))) # append order of volume and frequency presentation to json-file content.setdefault('volume_progression', []).append(order_volume) content.setdefault('frequency_progression', []).append(order_presentation) # to avoid overlap of different instructions on screen if x is not 0: message.setAutoDraw(False) # automatically draw every frame win.flip() # specify and present instrtuction message = visual.TextStim(win, text=instruction) message.setAutoDraw(True) # automatically draw every frame win.flip() # update screen, display message core.wait(1.5) # wait for given amount in seconds # wait for mri-trigger for i in range(3): while True: # get timestamp for first trigger if i == 0: trial_onset = time.time() # get trigger as keyboard input, 't' is the standard input for # our scanner, eventually needs to be changed for different # scanner theseKeys = event.getKeys('t') if 't' in theseKeys: event.clearEvents(eventType='keyboard') print('trigger') break key_escape = event.getKeys('q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() trial_onset_list.append(trial_onset) key_escape = event.getKeys('q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() # present fixation cross message.setText('+') message.setAutoDraw(True) # automatically draw every frame win.flip() #counter = 0 # iterate over list of stimuli for i in run_list: for j in order: # wait for 1 sec, otherwise next trial is started to quick core.wait(1) # which stimuli to play hz = hz_list[i][j] # condition to break loop once participants responds to stimuli stop_loop = False # set stimuli as sound object stim = sound.Sound(_thisDir + '/stimuli/' + hz) key_escape = event.getKeys('q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() #core.wait(0.2) trial_clock = core.Clock() stim.play() # play stimuli # get timestamp of stimuli presentation and append to list stim_start_absolute = time.time() stim_start = stim_start_absolute - trial_onset stim_start_type.append(hz) all_stim_list.append(stim_start) # present stimuli for 2s and wait for participants response while trial_clock.getTime( ) < 2.0: # clock times are in seconds if 0.0 <= trial_clock.getTime() < 2.0: # if participant presses the "7" key stop volume volume # progression and jump to next stimuli this_key = event.getKeys('7') if '7' in this_key: stim.stop() stim_onset_list.append(stim_start) #counter += 1 # get specific volume that was responded to result_list.append(hz) # get timestamp for participant response rt_absolute = time.time() rt = rt_absolute - trial_onset rt_list.append(rt) order_presentation_list.append( order_presentation) order_volume_list.append(order_volume) stop_loop = True # indicates that next stimuli should be picked break elif order_volume == 'decreasing' and j is 0 and '7' not in this_key and trial_clock.getTime( ) > 1.9: result_list.append(str(hz) + '/not_discovered') stim_onset_list.append(stim_start) #counter += 1 stim.stop() rt_absolute = time.time() rt = rt_absolute - trial_onset rt_list.append(rt) order_presentation_list.append( order_presentation) order_volume_list.append(order_volume) stop_loop = True break elif order_volume == 'increasing' and j is 8 and '7' not in this_key and trial_clock.getTime( ) > 1.9: result_list.append(str(hz) + '/not_discovered') stim.stop() stim_onset_list.append(stim_start) #counter += 1 rt_absolute = time.time() rt = rt_absolute - trial_onset rt_list.append(rt) order_presentation_list.append( order_presentation) order_volume_list.append(order_volume) stop_loop = True break key_escape = event.getKeys( 'q') # to end exp, if need be if 'q' in key_escape: win.close() core.quit() if stop_loop is True: break # if fourth trial is done if x == 3: # create DataFrame to save results df_results = pd.DataFrame({'stimuli': result_list}) volumes = [] frequencies = [] acquisition_scheme_list = [] subject_name = [] for i in df_results.columns: for item in df_results[i]: subject_name.append(subject) # get info on acquisition_scheme if 'baseline' in acquisition_scheme: acquisition_scheme_list.append('baseline') elif 'epi_fast(TR1s)' in acquisition_scheme: acquisition_scheme_list.append('epi_fast(TR1s)') elif 'epi_standard(TR2s)' in acquisition_scheme: acquisition_scheme_list.append('epi_standard(TR2s)') elif 'mprage(T1w)' in acquisition_scheme: acquisition_scheme_list.append('mprage(T1w)') else: acquisition_scheme_list.append('mprage(T1w)') # extract discovered volume if 'not_discovered' in item: volumes.append('0') #elif '10dBFS' in item: #volumes.append(-10) elif '20dBFS' in item: volumes.append(-20) elif '30dBFS' in item: volumes.append(-30) elif '40dBFS' in item: volumes.append(-40) elif '50dBFS' in item: volumes.append(-50) elif '60dBFS' in item: volumes.append(-60) elif '70dBFS' in item: volumes.append(-70) elif '80dBFS' in item: volumes.append(-80) elif '90dBFS' in item: volumes.append(-90) elif '100dBFS' in item: volumes.append(-100) # print(volumes) if '150hz' in item: frequencies.append(150) elif '1000hz' in item: frequencies.append(1000) elif '1500hz' in item: frequencies.append(1500) elif '2000hz' in item: frequencies.append(2000) elif '2250hz' in item: frequencies.append(2250) elif '2500hz' in item: frequencies.append(2500) elif '2750hz' in item: frequencies.append(2750) elif '3000hz' in item: frequencies.append(3000) elif '4000hz' in item: frequencies.append(4000) elif '6000hz' in item: frequencies.append(6000) elif '8000hz' in item: frequencies.append(8000) elif '250hz' in item: frequencies.append(250) elif '500hz' in item: frequencies.append(500) # set datframe containing exp results date = data.getDateStr() # get date df = pd.DataFrame({ 'stimuli': result_list, 'subject': subject_name, 'onset': stim_onset_list, 'reaction_time': rt_list, 'acquisition_scheme': acquisition_scheme_list, 'Level (dBFS)': volumes, 'Frequency (Hz)': frequencies, 'order_volume': order_volume_list, 'order_presentation': order_presentation_list }) # save data as tsv df.to_csv('{first}_{second}_{last}.tsv'.format( first=subject, second=acquisition_scheme, last=str(date)), encoding='utf-8', index=False, sep='\t') # save trial_start times df_trial_start = pd.DataFrame( {'trial_start': trial_onset_list}) df_trial_start.to_csv( '{first}_{second}_trial_start_{last}.tsv'.format( first=subject, second=acquisition_scheme, last=str(date)), encoding='utf-8', index=False, sep='\t') # save all stimuli onsets df_stimuli_onsets = pd.DataFrame({ 'stimuli_onset': all_stim_list, 'Frequency (Hz)': stim_start_type }) df_stimuli_onsets.to_csv( '{first}_{second}__stimuli_onsets_{last}.tsv'.format( first=subject, second=acquisition_scheme, last=str(date)), encoding='utf-8', index=False, sep='\t') # write json-summary-file for trial with open( '{first}_{second}_{last}.json'.format( first=subject, second=acquisition_scheme, last=str(date)), 'w') as f: json.dump(content, f, indent=4) # close window for presentation win.close()
def runBlock(nReps, saveTrials=True): #set up the trials/experiment conditions = data.importConditions( 'conditions.csv') #import conditions from file trials = data.TrialHandler(trialList=conditions, nReps=nReps) #create trial handler (loop) #(optional) set up logging if events should be saved if saveTrials: #create the base filename for our data files filename = "data/{participant}_{dateStr}".format(**info) logfile = logging.LogFile( filename + ".log", filemode= 'w', #if you set this to 'a' it will append instead of overwriting level=logging.EXP) #add trials to the experiment handler to store data thisExp = data.ExperimentHandler( name='Posner', version='1.0', #not needed, just handy extraInfo=info, #the info we created earlier dataFileName=filename, # using our string with data/name_date ) thisExp.addLoop( trials) #there could be other loops (like practice loop) # Actually present stimuli: loop through trials for thisTrial in trials: # set up this trial resp = None rt = None probe.setPos([thisTrial['probeX'], 0]) cue.setOri(thisTrial['cueOri']) #fixation period fixation.setAutoDraw(True) for frameN in range(info['fixFrames']): win.flip() #present cue cue.setAutoDraw(True) for frameN in range(info['cueFrames']): win.flip() cue.setAutoDraw(False) #present probe and collect responses during presentation probe.setAutoDraw(True) win.callOnFlip(respClock.reset) #NB: reset not reset() event.clearEvents() for frameN in range(info['probeFrames']): keys = event.getKeys(keyList=['left', 'right', 'escape']) if len(keys) > 0: resp = keys[0] #take the first keypress as the response rt = respClock.getTime() break #out of the probe-drawing loop win.flip() probe.setAutoDraw(False) fixation.setAutoDraw(False) #clear screen win.flip() #wait for response if we didn't already have one if resp is None: keys = event.waitKeys(keyList=['left', 'right', 'escape']) resp = keys[0] #take first response rt = respClock.getTime() #check if the response was correct if thisTrial['probeX'] > 0 and resp == 'right': corr = 1 elif thisTrial['probeX'] < 0 and resp == 'left': corr = 1 elif resp == 'escape': corr = None trials.finished = True else: corr = 0 #store the response and RT trials.addData('resp', resp) trials.addData('rt', rt) trials.addData('corr', corr) # Register end of trial in the log file if saveTrials: thisExp.nextEntry()
win.update() #get response thisResp = None while thisResp == None: allKeys = event.waitKeys() for thisKey in allKeys: if thisKey == 'left': if targetSide == -1: thisResp = 1 #correct else: thisResp = -1 #incorrect elif thisKey == 'right': if targetSide == 1: thisResp = 1 #correct else: thisResp = -1 #incorrect elif thisKey in ['q', 'escape']: core.quit() #abort experiment event.clearEvents( ) #must clear other (eg mouse) events - they clog the buffer #add the data to the staircase so it can calculate the next level staircase.addData(thisResp) dataFile.write('%i,%.3f,%i\n' % (targetSide, thisIncrement, thisResp)) #staircase has ended dataFile.close() staircase.saveAsPickle( fileName) #special python binary file to save all the info #give some output to user print 'reversals:' print staircase.reversalIntensities print 'mean of final 6 reversals = %.3f' % (numpy.average( staircase.reversalIntensities[-6:]))
def interbreak (thewait): event.clearEvents() win.flip() core.wait(thewait) if event.getKeys(['escape']): savequit()
def present(duration=120, stim_types=None, itis=None, secs=0.07, volume=0.8): #def present(duration=120, n_trials=10, iti=0.3, soa=0.2, jitter=0.2, # secs=0.2, volume=0.8, random_state=None): # Create markers stream outlet info = StreamInfo('Markers', 'Markers', 1, 0, 'int32', 'myuidw43536') outlet = StreamOutlet(info) #np.random.seed(random_state) markernames = [1, 2] start = time.time() # Set up trial parameters record_duration = np.float32(duration) # Initialize stimuli #aud1 = sound.Sound('C', octave=5, sampleRate=44100, secs=secs) aud1 = sound.Sound(440, secs=secs) #, octave=5, sampleRate=44100, secs=secs) aud1.setVolume(volume) aud1.setVolume(volume) #aud2 = sound.Sound('D', octave=6, sampleRate=44100, secs=secs) aud2 = sound.Sound(528, secs=secs) aud2.setVolume(volume) auds = [aud1, aud2] # Setup trial list #sound_ind = np.random.binomial(1, 0.25, n_trials) #itis = iti + np.random.rand(n_trials) * jitter #trials = DataFrame(dict(sound_ind=sound_ind, iti=itis)) #trials['soa'] = soa #trials['secs'] = secs trials = DataFrame(dict(sound_ind=stim_types, iti=itis)) # Setup graphics mywin = visual.Window([1920, 1080], monitor='testMonitor', units='deg', fullscr=True) fixation = visual.GratingStim(win=mywin, size=0.2, pos=[0, 0], sf=0, rgb=[1, 0, 0]) fixation.setAutoDraw(True) mywin.flip() for ii, trial in trials.iterrows(): # Intertrial interval time.sleep(trial['iti']) # Select and play sound ind = int(trial['sound_ind']) auds[ind].stop() auds[ind].play() # Send marker timestamp = time.time() outlet.push_sample([markernames[ind]], timestamp) # Offset #time.sleep(soa) #if (time.time() - start) > record_duration: # break # offset #core.wait(soa) if len(event.getKeys()) > 0 or (time.time() - start) > record_duration: break event.clearEvents() #if len(event.getKeys()) > 0 or (time() - start) > record_duration: # break #event.clearEvents() # Cleanup mywin.close() return trials
def show(win, screen_res, experiment, config, part_id, port_eeg, trigger_no, triggers_list, frame_time=1 / 60.): beh = [] rt_sum = 0 rt_mean = 0 fixation = visual.TextStim(win, color='black', text='+', height=2 * config['Fix_size'], pos=(0, 10)) clock = core.Clock() for block in experiment: if block['type'] == 'break': show_info(win=win, file_name=block['file_name'], text_size=config['Text_size'], screen_width=screen_res['width'], part_id=part_id, beh=beh, triggers_list=triggers_list) continue if block['type'] == 'calibration': rt_mean = 0 rt_sum = 0 for trial in block['trials']: trigger_name = prepare_trigger_name(trial=trial, block_type=block['type']) reaction_time = None response = None acc = 'negative' # draw fixation fixation_show_time = random.uniform(config['Fixation_show_time'][0], config['Fixation_show_time'][1]) show_text(win, fixation, fixation_show_time, part_id, beh, triggers_list) # draw cue trigger_no, triggers_list = prepare_trigger(trigger_type=TriggerTypes.CUE, trigger_no=trigger_no, triggers_list=triggers_list, trigger_name=trigger_name) cue_show_time = random.uniform(config['Cue_show_time'][0], config['Cue_show_time'][1]) trial['cue']['stimulus'].setAutoDraw(True) win.callOnFlip(clock.reset) event.clearEvents() win.flip() send_trigger(port_eeg=port_eeg, trigger_no=trigger_no, send_eeg_triggers=config['Send_EEG_trigg']) while clock.getTime() < cue_show_time: check_exit(part_id=part_id, beh=beh, triggers_list=triggers_list) win.flip() # print (cue_show_time - clock.getTime())*1000 trial['cue']['stimulus'].setAutoDraw(False) win.flip() # draw target trigger_no, triggers_list = prepare_trigger(trigger_type=TriggerTypes.TARGET, trigger_no=trigger_no, triggers_list=triggers_list, trigger_name=trigger_name) target_show_time = random.uniform(config['Target_show_time'][0], config['Target_show_time'][1]) trial['target']['stimulus'].setAutoDraw(True) win.callOnFlip(clock.reset) event.clearEvents() win.flip() send_trigger(port_eeg=port_eeg, trigger_no=trigger_no, send_eeg_triggers=config['Send_EEG_trigg']) while clock.getTime() < target_show_time: key = event.getKeys(keyList=config['Keys']) if key: reaction_time = clock.getTime() trigger_no, triggers_list = prepare_trigger(trigger_type=TriggerTypes.RE, trigger_no=trigger_no, triggers_list=triggers_list, trigger_name=trigger_name[:-1]+key[0]) send_trigger(port_eeg=port_eeg, trigger_no=trigger_no, send_eeg_triggers=config['Send_EEG_trigg']) response = key[0] break check_exit(part_id=part_id, beh=beh, triggers_list=triggers_list) win.flip() # print (target_show_time-clock.getTime())*1000 trial['target']['stimulus'].setAutoDraw(False) win.flip() # empty screen empty_screen_show_time = random.uniform(config['Empty_screen_show_time'][0], config['Empty_screen_show_time'][1]) while clock.getTime() < empty_screen_show_time: check_exit(part_id=part_id, beh=beh, triggers_list=triggers_list) win.flip() # print (empty_screen_show_time-clock.getTime())*1000 # verify reaction if response and trial['type'] == 'go': if not (block['type'] == 'experiment' and reaction_time > rt_mean - rt_mean * block['cutoff']): acc = 'positive' elif not response and trial['type'] != 'go': acc = 'positive' # calibration if block['type'] == 'calibration' and trial['type'] == 'go' and reaction_time is not None: rt_sum += reaction_time # feedback if block['type'] == 'experiment': # choose feedback type feedback_type = 'Feedback_{}_{}_'.format(trial['type'], acc) # draw feedback if config[feedback_type + 'show']: feedback_text = config[feedback_type + 'text'] feedback_text = visual.TextStim(win, color='black', text=feedback_text, height=config['Feedback_size']) feedback_show_time = random.uniform(config['Feedback_show_time'][0], config['Feedback_show_time'][1]) if acc == 'positive': trigger_type = TriggerTypes.FEEDB_GOOD else: trigger_type = TriggerTypes.FEEDB_BAD trigger_no, triggers_list = prepare_trigger(trigger_type=trigger_type, trigger_no=trigger_no, triggers_list=triggers_list, trigger_name=trigger_name) feedback_text.setAutoDraw(True) win.flip() send_trigger(port_eeg=port_eeg, trigger_no=trigger_no, send_eeg_triggers=config['Send_EEG_trigg']) time.sleep(feedback_show_time - frame_time) feedback_text.setAutoDraw(False) check_exit(part_id=part_id, beh=beh, triggers_list=triggers_list) win.flip() # save beh beh.append({'block type': block['type'], 'trial type': trial['type'], 'cue name': trial['cue']['name'], 'target name': trial['target']['name'], 'response': response, 'rt': reaction_time, 'reaction': True if acc == 'positive' else False, 'cal mean rt': rt_mean, 'cutoff': block['cutoff'] if block['type'] == 'experiment' else None}) if block['type'] == 'calibration': rt_mean = rt_sum / len([trial for trial in block['trials'] if trial['type'] == 'go']) return beh, triggers_list