Esempio n. 1
1
    def image(self, filename):
        """Filename, including relative or absolute path. The image
        can be any format that the Python Imaging Library can import
        (almost any). Can also be an image already loaded by PIL.
        """
        filename = pathToString(filename)
        self.__dict__['image'] = filename
        if isinstance(filename, basestring):
            # is a string - see if it points to a file
            if os.path.isfile(filename):
                self.filename = filename
                im = Image.open(self.filename)
                im = im.transpose(Image.FLIP_TOP_BOTTOM)
            else:
                logging.error("couldn't find image...%s" % filename)
                core.quit()
        else:
            # not a string - have we been passed an image?
            try:
                im = filename.copy().transpose(Image.FLIP_TOP_BOTTOM)
            except AttributeError:  # apparently not an image
                logging.error("couldn't find image...%s" % filename)
                core.quit()
            self.filename = repr(filename)  # '<Image.Image image ...>'

        self.size = im.size
        # set correct formats for bytes/floats
        if im.mode == 'RGBA':
            self.imArray = numpy.array(im).astype(numpy.ubyte)
            self.internalFormat = GL.GL_RGBA
        else:
            self.imArray = numpy.array(im.convert("RGB")).astype(numpy.ubyte)
            self.internalFormat = GL.GL_RGB
        self.dataType = GL.GL_UNSIGNED_BYTE
        self._needStrUpdate = True
Esempio n. 2
0
def startExperiment():
	startEEGBox = gui.Dlg(title='waiting for Actiview')
	startEEGBox.addText('click OK when you are sure ActiView is ready')
	startEEGBox.show()
	if startEEGBox.OK == False:
		core.quit()
	
	#now that we made sure that actiview works and receives our triggers, display another dialog box
	#that will allow us to review and/or set the experimental settings for the run
	configBox = gui.Dlg(title='Choose settings for this run')
	configBox.addField('# of repeats', EXPERIMENTAL_SETTINGS['nb_of_repeats'], tip="how many trials per type of trials. remember there are 4 types of trials")
	configBox.addField(label='Language', initial = EXPERIMENTAL_SETTINGS['language'], color='', choices= ['english', 'french'])
	configBox.addField(label='Get distances from file name?', initial=True, color='', choices=[True, False], tip='set to true if the names of the stimuli contain a hint to the vectorial distance of the pair. We will recover it with using curly brace parameters on the searchstring setting below')
	configBox.addField(label="Search String", initial=EXPERIMENTAL_SETTINGS['search_path'], color='', tip="read the READMD.txt or try me: [email protected] if you are not sure :)")
	configBox.addField(label="Code for 1st category", initial=EXPERIMENTAL_SETTINGS['1st_category_label'])
	handle = configBox.addField(label="Code for 2nd category", initial=EXPERIMENTAL_SETTINGS['2nd_category_label'])
	configBox.show()
	
	#DEBUG STATEMENT
	print configBox.data
	print handle
	
	#this represent the window in which the experiment will be displayed
	display = visual.Window(size=(1024, 760), fullscr=True, monitor = 'testMonitor', color='white')
	
	#this is a useful object to manage the order of trials and most of all save data! check the PsychoPy documentation to learn
	#how to use it!
	mainHandler = data.ExperimentHandler(version='1.0')
def enterSubjInfo(expName,optionList):
	""" Brings up a GUI in which to enter all the subject info."""

	def inputsOK(optionList,expInfo):
		for curOption in sorted(optionList.items()):
			if curOption[1]['options'] != 'any' and expInfo[curOption[1]['name']] not in curOption[1]['options']:
				return [False,"The option you entered for " + curOption[1]['name'] + " is not in the allowable list of options: " + str(curOption[1]['options'])]
		print "inputsOK passed"
		return [True,'']

	try:
		expInfo = misc.fromFile(expName+'_lastParams.pickle')
	except:
		expInfo={} #make the kind of dictionary that this gui can understand
		for curOption in sorted(optionList.items()):
			expInfo[curOption[1]['name']]=curOption[1]['default']
	#load the tips
	tips={}
	for curOption in sorted(optionList.items()):
		tips[curOption[1]['name']]=curOption[1]['prompt']
	expInfo['dateStr']= data.getDateStr()
	expInfo['expName']= expName
	dlg = gui.DlgFromDict(expInfo, title=expName, fixed=['dateStr','expName'],order=[optionName[1]['name'] for optionName in sorted(optionList.items())],tip=tips)
	if dlg.OK:
		misc.toFile(expName+'_lastParams.pickle', expInfo)
		[success,error] = inputsOK(optionList,expInfo)
		if success:
			return [True,expInfo]
		else:
			return [False,error]
	else:
		core.quit()
Esempio n. 4
0
    def setScale(self, units, font='dummyFont', prevScale=[1.0,1.0]):
	"""This method is called from within the draw routine and sets the
	scale of the OpenGL context to map between units. Could potentially be
	called by the user in order to draw OpenGl objects manually
	in each frame.

	The **units** can be 'norm'(normalised),'pix'(pixels),'cm' or
	'stroke_font'. The **font** argument is only used if units='stroke_font'
	"""
	if units is "norm":
	    thisScale = scipy.array([1.0,1.0])
	elif units in ["pix", "pixels"]:
	    thisScale = 2.0/scipy.array(self.size)
	elif units is "cm":
	    #windowPerCM = windowPerPIX / CMperPIX
	    #			= (window	/winPIX)	/ (scrCm				/scrPIX)
	    if (self.scrWidthCM in [0,None]) or (self.scrWidthPIX in [0, None]):
		print 'you didnt give me the width of the screen (pixels and cm)'
		core.wait(1.0); core.quit()
	    thisScale = (scipy.array([2.0,2.0])/self.size)/(float(self.scrWidthCM)/float(self.scrWidthPIX))
	elif units in ["deg", "degs"]:
	    #windowPerDeg = winPerCM*CMperDEG
	    #		= winPerCM		* tan(scipy.pi/180) * distance
	    if (self.scrWidthCM in [0,None]) or (self.scrWidthPIX in [0, None]):
		print 'you didnt give me the width of the screen (pixels and cm)'
		core.wait(1.0); core.quit()
	    cmScale = (scipy.array([2.0,2.0])/self.size)/(float(self.scrWidthCM)/float(self.scrWidthPIX))
	    thisScale = cmScale * 0.017455 * self.scrDistCM
	elif units is "stroke_font":
	    thisScale = scipy.array([2*font.letterWidth,2*font.letterWidth]/self.size/38.0)
	#actually set the scale as appropriate
	thisScale = thisScale/scipy.asarray(prevScale)#allows undoing of a previous scaling procedure
	print 'scale %f %f' %(thisScale[0], thisScale[1])
	GL.glScalef(float(thisScale[0]), float(thisScale[1]), 1.0)
	return thisScale #just in case the user wants to know?!
Esempio n. 5
0
    def __init__(self, settings=None):
        super(Pursuit, self).__init__()
        self.global_clock = mono_clock

        # set up input
        if settings['mouse']:
            self.device = Mouse(clock=self.global_clock.getTime)
        else:
            core.quit()
            #self.device = ForceHandle(clock=self.global_clock.getTime)
        try:
            #self.trial_table = pd.read_csv(settings['trial_table'])
            pass
        except FileNotFoundError:
            core.quit()
        
        # set up display
        self.win = visual.Window(size=(800, 800),
                                 pos=(0, 0),
                                 fullscr=settings['fullscreen'],
                                 screen=1,
                                 units='height',
                                 allowGUI=False,
                                 colorSpace='rgb',
                                 color=(-1, -1, -1),
                                 waitBlanking=False)
        self.win.recordFrameIntervals = True

        self.setup_visuals()

        # extras
        self.data = None
        self.total_frames = 0
        self.frames_on_target = 0
def waitForKeypress():
    allKeys = event.getKeys()
    while len(allKeys)==0:
        allKeys = event.getKeys()
    if 'escape' in allKeys[0]:
        mywin.close() # quit
        core.quit()
def start_datafile(sn):
    """creates datafile (after checking for old one)"""
    # determines file name
    if sn < 10:
        snstr = '0' + str(sn)
    else:
        snstr = str(sn)
    datafileName = "experiment_" + snstr + ".csv"
    currentDirectory = os.listdir("." + os.sep + "Data")
    for file in currentDirectory:
        if file == datafileName:
            warningDialog = gui.Dlg(title="Warning!")
            warningDialog.addText("A data file with this number already exists.")
            warningDialog.addField("Overwrite?", choices=["No", "Yes"])
            warningDialog.addField("If not, enter new subject number:",
                                   initial="0")
            warningDialog.show()
            if gui.OK:
                if warningDialog.data[0] == "No":
                    subjectNumber = int(warningDialog.data[1])
                    if subjectNumber < 10:
                        snstr = '0' + str(subjectNumber)
                    else:
                        sntstr = str(subjectNumber)
                    datafileName = "experiment_" + snstr + ".csv"
            else:
                core.quit()
    datafile = open("." + os.sep + "Data" + os.sep + datafileName,
                    "ab")
    datafile.write("subjectnum,runnum,trialnum,trialbegintime,trialduration,trialjitterduration,\
    response,responsetime,person,personnum, prefitem, prefnum\n")
    return(datafile, sn)
Esempio n. 8
0
 def present_fb(self, win, score, objects):
     """Display the feeback for the game. Requires the window, the score, 
         and a list of the objects already on the screen to be presented with the feedback."""
     #determine feedback picture and audio based on score
     if score: 
         fb = self.green_check
         sound = self.ding
     else: 
         fb = self.red_x
         sound = self.honk
     
     #check if objects is a list
     if type(objects)!=list:
         print 'objects passed to feedback must be a list; instead got {}'.format(type(objects))
         core.quit()
     #display objects and feedback
     for object in objects:
         object.draw()
     fb.draw()
     win.flip()
     sound.play()
     
     #wait 2 seconds
     start_time=self.trialClock.getTime()
     timer=0
     while timer<1:
         timer= self.trialClock.getTime() - start_time
         these_keys=event.getKeys(keyList=['escape'])
         if 'escape' in these_keys: core.quit()
Esempio n. 9
0
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 runTrial(self,*args):
     self.babyStatus=0 # -1 no signal, 0 saccade, 1 fixation,
     self.sacPerPursuit=0
     self.pursuedAgents=False
     self.rewardIter=0
     self.nrRewards=0
     self.blinkCount=0
     self.tFix=0
     self.isFixLast=False
     self.babySawReward=False
     ende=False
     if core.getTime()> BabyExperiment.expDur*60+self.tStart: ende=True
     if ende:
         print core.getTime()-self.tStart
         self.etController.sendMessage('Finished')
         self.etController.closeConnection()
         self.wind.close(); core.quit()
     self.timeNotLooking=0
     self.etController.preTrial(driftCorrection=self.showAttentionCatcher>0)
     self.etController.sendMessage('Trial\t%d'%self.t)        
     self.etController.sendMessage('Phase\t%d'%self.phases[self.pi])
     if self.eeg!=None: 
         self.eeg.setData(int(self.t+1))
     Experiment.runTrial(self,*args,fixCross=False)
     self.etController.postTrial()
Esempio n. 11
0
def get_subject_info(experiment_name, conditions, data_location):
    ss_info = []
    pc = socket.gethostname()
    my_Dlg = gui.Dlg(title=experiment_name)
    my_Dlg.addText('Subject Info')
    my_Dlg.addField('ID:', tip='or subject code')
    my_Dlg.addField('Condition:', rnd.choice(conditions), choices = conditions)
    my_Dlg.show()
    if not my_Dlg.OK:
        print 'User Terminated'
        core.quit()
        
    subject_info = [str(i) for i in my_Dlg.data]
    
    if subject_info[0]=='':
        core.quit()
    else: 
        id = subject_info[0]
        condition = subject_info[1]
        subject_file = (data_location + pc + '-' + experiment_name + '-' + 
            condition + '-' + id + '.csv')
        while os.path.exists(subject_file) == True:
            subject_file = (data_location + pc + '-' + experiment_name + '-' + 
                condition + '-' + id + '.csv' + '_dupe')
        return [int(id),int(condition),subject_file]
Esempio n. 12
0
    def _show_screen(self, text):
        visual.TextStim(text=text, **self.screen_text_kwargs).draw()
        self.win.flip()
        response = event.waitKeys(keyList=['space', 'q'])[0]

        if response == 'q':
            core.quit()
Esempio n. 13
0
def cleanup():
    '''
    cleanup function to be called if a KeyboardInterrupt is raised
    '''
    print "control C was pressed. aborting script and cleaning up monitors."
    core.quit()
    sys.exit(10)
Esempio n. 14
0
def on_key_release(k,m):
    if k == key.SPACE:
        print 'space up'
        global writeData
        global space_down
        global space_time
        global famStim
        global data
        global click_stim
        global look_onset
        global mode
        global counting
        global look_away_time
        if mode == "test" and counting == 0:
            counting = 1
            look_away_time = clock.getTime()
        elif mode == "get":
            pass
        else:
            space_time = (clock.getTime() - space_down) * 1000 #return time in milliseconds
            print click_stim, famStim
            data.append(  ( click_stim+"~~"+famStim, str(space_time), "lookingFam" )  ) #data to be written to the output file is added to the data array above on each key release, and some globals are updated, i.e. 'stimuli' are updated as the experiment executes

    if k == key.ESCAPE:
        if mode == 'test':
            escStim = stimuli
        elif mode == 'famil':
            escStim = famStim
        data.append( ( escStim, str( (clock.getTime() - famStart) * 1000), "totalPlaying-Escape" ) )
        writeData()
        win.close()
        core.quit()
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.
Esempio n. 16
0
 def _present_choices(self, oleft, oright, trial):
     """Present the left and the right outcomes, first at the left
     and second at the right of fixation. After choice_screen_dur
     fixation cross is colored red for choice_screen_dur2, user has 
     to respond while the cross is red. If user respond before or after
     then show the slow-down or too-slow message, otherwise color the
     outcome pressed yellow for remaining duration. Store all the
     events in dictionary trial, which is an argument to the method.
     Return value is the key pressed."""
     trial['success'] = False # set to True if user responded on time.
     start_time = time.time()
     dist = NUMBER_FIXATION_DIST
     left_outcome = visual.TextStim(self.win, 
                                    text=u"\u20AC" + str(oleft) ,
                                    pos=(-dist, 0))
     right_outcome = visual.TextStim(self.win, 
                                     text=u"\u20AC" + str(oright),
                                     pos=(dist, 0))
     self._render(left_outcome, right_outcome, self.fixation)
     # wait for choice_screen_dur and check if user presses left or right key
     try:
         key = event.waitKeys(maxWait=CHOICE_SCREEN_DUR,
                              keyList=[LEFT_KEY, RIGHT_KEY, ESC_KEY])[0]
     except:
         key = "none"
     #usr responded too early show her slow down message and return
     if key in [LEFT_KEY, RIGHT_KEY]:
         trial['slow_down_msg_event'] = time.time()
         trial['too_fast'] = True
         self._render(slow_down_msg, duration=SLOW_DOWN_MSG_DUR)
         return key
     if key == ESC_KEY:
         self.win.close()
         core.quit()
     # turn the fixation cross red and wait for 1 sec for a user to respond
     trial['fixation_color_red_event'] = time.time()
     self.fixation.color = "red"
     self._render(left_outcome, right_outcome, self.fixation)
     try:
         key = event.waitKeys(maxWait=CHOICE_SCREEN_DUR2,
                              keyList=[LEFT_KEY, RIGHT_KEY])[0]
         trial['key_pressed_event'] = time.time()
     except:
         key = "none"
     self.fixation.color = "black"
     # user did not responded, show too slow msg and return.
     if key == "none":
         trial['too_slow'] = True
         trial['too_slow_msg_event'] = time.time()
         self._render(too_slow_msg, duration=TOO_SLOW_MSG_DUR)
         return key
     #show the pressed key in yellow for the remaining time.
     if key == LEFT_KEY:
         left_outcome.color = "yellow"
     elif key == RIGHT_KEY:
         right_outcome.color = "yellow"
     self._render(left_outcome, right_outcome, self.fixation)
     time_elasped = time.time() - start_time
     core.wait(CHOICE_SCREEN_DUR + CHOICE_SCREEN_DUR2 - time_elasped)
     return key
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
Esempio n. 18
0
	def present(self, start=None, stop=None):
		if not isinstance(start, int):
			start = self.this_page
		if not isinstance(stop, int):
			stop = len(self.pages)

		# show pages:
		self.this_page = start
		while self.this_page < stop:
			# create page elements
			self.create_page()
			self.show_page()

			# wait for response
			if not self.auto:
				k = event.waitKeys(keyList=self.navigation.keys() + ['q'])[0]
				if 'q' in k:
					core.quit()
				action = self.navigation[k]
			else:
				core.wait(0.15)
				action = 'next'

			# go next/prev according to the response
			if action == 'next':
				self.this_page += 1
			else:
				self.this_page = max(0, self.this_page - 1)
def runVerbalFluency(win, ask, test, language):
    try:
           
        output = { "A" : { "English" : FormAEng, "French" : FormAFr },
            "B" : { "English" : FormBEng,  "French" : FormBFr },
            "C" : {  "English" : FormCEng, "French" :FormCFr }
            }
        instructions = output[test][language]
        stopSign = visual.SimpleImageStim(win, image = stopSignPath, units='norm', pos=(0.0, 0.0)) #Stop Sign
        ding = sound.Sound(audioPath)
        ding.setVolume(1.0)

        ask(instructions)
        timer = core.CountdownTimer(60)
        while timer.getTime() > 0:  # after 60s will become negative
            win.flip()
            ding.play()
            #instructionText.draw(win)
            responses = event.waitKeys(timeStamped=False)
            if 'q' in responses:
                print 'Program aborted...'
                core.quit()
            elif 's' in responses:
                print "Skipped experiment"
                return
        else:
            win.flip()
            ding.play()
            stopSign.draw(win)
            ask()
            
    except KeyboardInterrupt:
        raise
        core.quit()
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
Esempio n. 21
0
def showText(myWin, textToShow, fontFace):
    """Display text on screen (e.g., instructions for participants)."""
    try:
        textClock
    except NameError:
        textClock = core.Clock()
    else:
        textClock.reset()
    textStim = visual.TextStim(myWin,
                               text=textToShow,
                               color='black',
                               font=fontFace,
                               height=1)
    continueInstruct = True
    while continueInstruct:
        # Get current time
        t = textClock.getTime()

        # Update/draw components on each frame
        if (0 <= t):
            textStim.draw()
        if (0 <= t):
            keypresses = event.getKeys()
            if len(keypresses) > 0:
                # At least one key was pressed.
                # Abort routine on response
                continueInstruct = False
                # Check for quit (the [Esc] key).
                if keypresses[0] == "escape":
                    core.quit()
        # Refresh the screen
        myWin.flip()
Esempio n. 22
0
 def close(self):
     if not TESTING and self.mark_mode == "Plexon":
         self.plexon.CloseClient()
     if self.input_mode == "RTBox":
         self.RTBox.close()
     self.mark_task("end")
     core.quit()
def runRT(window,ask,test,language,preferred_hand,exp):
    try:
        while True:
            ask(lookup[test][language][preferred_hand])
            response = ask(practiceLookup[language])
            if event.getKeys(keyList=['escape', 'q']):
                core.quit()
            if 'r' in response:
                print 'r pressed'
                continue
            if 'space' in response:
                break
            if event.getKeys(keyList=['s']):
                print "Skipped experiment"
                return
            
        getReady = lookupGetReady[language]
        error = lookupError[language]
        wrongkey = lookupwrongKey[language]

        score=1
        while score != 0:
            score = run(window,clock, ask, error,getReady,wrongkey,language, exp,practice=True)
            print score
        #Run experiment
        run(window,clock, ask, error,getReady,wrongkey,language,exp)
    except KeyboardInterrupt:
        raise
        core.quit()
Esempio n. 24
0
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
Esempio n. 25
0
 def cleanup(self):
     """ Destructor """
     #STOP CLOCKS
     self.window.setRecordFrameIntervals(False) #stop recording frame intervals 
     self.stoptime = time.clock() #TIME SENSITIVE STUFF ENDS HERE
     
     #FLIP FOR SYNC SQUARE CLEAR
     for i in range(30):
         self.window.flip()   
         
     timestr = str(datetime.timedelta(seconds = (self.stoptime-self.starttime)))
     print "Actual experiment duration:", timestr
     self.stopdatetime = datetime.datetime.now()
     #DISPLAY SOME STUFF
     print "Actual sweeps completed:", str(self.sweepsdisplayed)
     self.printFrameInfo()
     #LOG INFORMATION (If not in replay mode)
     if not self.replay: self.logMeta()
     #CLOSE EVERYTHING
     if self.ni:
         self.dOut.WriteBit(self.sweepBit, 0) #ensure sweep bit is low
         self.dOut.WriteBit(self.frameBit, 0) #ensure frame bit is low
         self.dOut.ClearTask() #clear NIDAQ
     self.window.close()
     core.quit()
Esempio n. 26
0
def trial(city_left, city_right):
    """
    City-size paired comparison task
    """
    leftTS.text  = city_left
    rightTS.text = city_right

    questionTS.draw()
    fixpoint.draw()
    leftTS.draw()
    rightTS.draw()
    win.flip()

    timer.reset()
    response = None
    while response not in [city_left, city_right]:
        pressed_key = event.waitKeys(timeStamped=timer)
        if pressed_key[0][0] in ['q', 'escape']:
            core.quit()
        if pressed_key[0][0] == 'less':
            response = city_left
        if pressed_key[0][0] == 'minus':
            response = city_right

    questionTS.draw()
    fixpoint.draw()
    win.flip()
    core.wait(0.4)

    ## Save data
    datfile.write('%s;%s;%s;%1.4f\n' %
                  (city_left, city_right, response, pressed_key[0][1]))
Esempio n. 27
0
def wait_check_pause_quit(win, wait_time, quit_keys=["q", "escape"],
                          pause_keys=["space"], check_every=1):
    """Wait while checking for pause or quit input."""
    raise NotImplementedError("This isn't quite finished yet")
    checks = int(floor(wait_time / check_every))
    for _ in range(checks):

        core.wait(check_every)

        if event.getKeys(keyList=quit_keys):
            print "Subject quit execution"
            core.quit()

        if event.getKeys(keyList=pause_keys):

            pause_start = time.time()
            visual.TextStim(win, text="Experiment paused").draw()
            win.flip()
            paused = True
            while paused:
                if event.getKeys(keyList=pause_keys):
                    paused = False
                core.sleep(check_every)
            pause_end = time.time()

    pause_duration = pause_end - pause_start
    remaining = wait_time - checks * check_every
    if remaining:
        core.wait(remaining)

    return pause_duration
Esempio n. 28
0
    def text_and_stim_keypress(self, text, stim=None):
        if stim is not None:
            if type(stim) == list:
                map(lambda x: x.draw(), stim)
            else:
                stim.draw()
        display_text = visual.TextStim(self.win, text=text,
                                        font='Helvetica', alignHoriz='center',
                                        alignVert='center', units='norm',
                                        pos=(0, 0), height=0.1,
                                        color=[255, 255, 255], colorSpace='rgb255',
                                        wrapWidth=2)
        display_text.draw()
        self.win.flip()
        key = event.waitKeys()
        if key[0] == 'escape':
            self.trigger.flicker_block(0)
            
            # Save end data
            t = datetime.now()
            day_time = '%d:%d:%d:%d' % (t.hour, t.minute, t.second, t.microsecond)
            end_time = globalTimer.getTime()
            save_data(day_time, end_time, self.subjnum)

            core.quit()
            self.win.flip()
        self.win.flip()
Esempio n. 29
0
def setCup(pp):
    global button
    global cupBuffer
    sN = pp
    rtClock = core.Clock()
    while True:
        key = event.getKeys(keyList = ['q','escape'])
        if len(key) > 0:
            core.quit()
        mX, mY = mouse.getPos()
        if mX > buttonX[0] and mX < buttonX[1] and mY > buttonY[0] and mY < buttonY[1]: #Checks to see if "Next" button was pressed
            set_mouse_position(win,0,0)
            break
        if mY < (slotY-(slotHeight/2)) and mY > -(screenY*.2):
            sN1 = getSlot(mX,mY,slotSpread)
            if sN1 !=None:
                sN = sN1
            if sN == 0:
                sN = 1
            elif sN == 40:
                sN = 39
        plinkoTable.draw()
        button.draw()
        buttonText.draw()
        ball.draw()
        drawCup(slotPos[sN][0])
        drawPbar(totalPoints,maxScore)
        win.flip()
    rt = rtClock.getTime()
    plinkoTable.draw()
    drawCup(slotPos[sN][0])
    drawPbar(totalPoints,maxScore)
    cupBuffer = visual.BufferImageStim(win)
    return sN,rt
def CoolDown():
    
    # display cool-down message
    message1.setText("That's the end! ")
    message2.setText("Press 'q' or 'escape' to end the session.")
    win.logOnFlip(level=logging.EXP, msg='Display TheEnd')
    win.callOnFlip(SendMessage,'DisplayTheEnd')
    message1.draw()
    message2.draw()
    win.flip()
    thisKey = event.waitKeys(keyList=['q','escape'])
    
    """
    # stop recording SMI via serial port
    myTracker.stop_recording()
    
    # save result
    myTracker.save_data(path=(filename+'.idf'))
    
    # close serial port
    myTracker.cleanup()
    """
    #"""
    # End EyeLink recording: add 100 msec of data to catch final events
    pylink.endRealTimeMode()
    pumpDelay(100)
    getEYELINK().stopRecording()
    while getEYELINK().getkey(): # not sure what this is for
        pass
    
    # File transfer and cleanup!
    getEYELINK().setOfflineMode()                          
    msecDelay(500)                 
    
    message1.setText("Sending EyeLink File...")
    message2.setText("Please Wait.")
    win.logOnFlip(level=logging.EXP, msg='Display SendingFile')
    message1.draw()
    message2.draw()
    win.flip()
    #Close the file and transfer it to Display PC
    getEYELINK().closeDataFile()
    getEYELINK().receiveDataFile(edfHostFileName, edfFileName)
    getEYELINK().close();
    
    #Close the experiment graphicss
    pylink.closeGraphics()
    #"""
    
    # stop sound
#    fullSound.stop()
    whiteNoiseSound.stop()
    pageSound.stop()
    
    # save experimental info (if we reached here, we didn't have an error)
    expInfo['tSound'] = tSound
    toFile(expInfoFilename, expInfo) # save params to file for next time
    
    # exit
    core.quit()
def get_specs(subj_name='mmddyyn_wmLoadMem02'):
    """Opens a GUI to set up the experiment
    """

    dictDlg = gui.DlgFromDict(
        {
            'Participant number':
            '05dd181_sustAttnWM03',  #subject name: month, day, year, number, and project name
            'Environment': [
                'imac', 'booth', 'edslab'
            ],  #which environment (aka monitor name in Tools > Monitor Center)
            'Restarting experiment?':
            False,  #whether restarting an experiment that was aborted in the middle
            'Debug': False,  #whether instructions are in english
            'Picture game': True,
            'Block game': True
        },
        title='Welcome to the experiment',  #title for GUI
        fixed=[' '],
        order=[
            'Participant number', 'Environment', 'Restarting experiment?',
            'Debug'
        ])  #choose order of elements
    if dictDlg.OK == True:
        gui_specs = {}
        gui_specs['subj_name'] = str(dictDlg.data[0])
        gui_specs['env'] = dictDlg.data[1]
        gui_specs['restarting'] = dictDlg.data[2]
        gui_specs['expt_date'] = datetime.now().strftime("%m/%d/%Y %H:%M")
        gui_specs['debug'] = dictDlg.data[3]
        gui_specs['seed'] = int(time.time())
        gui_specs['sustattn'] = dictDlg.data[4]
        gui_specs['changedetect'] = dictDlg.data[5]
    else:
        core.quit()

    #check the specs
    assert isinstance(
        gui_specs['subj_name'],
        basestring), "subj_name is not an string: %r" % specs['subj_name']
    assert isinstance(gui_specs['env'],
                      basestring), "env is not a string: %r" % specs['env']
    assert isinstance(
        gui_specs['expt_date'],
        basestring), "expt_date is not a string: %r" % specs['expt_date']
    assert isinstance(gui_specs['seed'],
                      int), "seed is not a int: %r" % specs['seed']

    #which environment is being used to run the experiment
    if gui_specs['env'] == 'imac':
        gui_specs[
            'project_dir'] = '/Users/megan/Documents/projects/sustAttnWM03/'
    elif gui_specs['env'] == 'booth':
        gui_specs[
            'project_dir'] = 'C:/Users/AwhVogelLab/Desktop/Megan/sustAttnWM03/'
    elif gui_specs['env'] == 'edslab':
        gui_specs[
            'project_dir'] = '/Users/edslab/Documents/projects/sustAttnWM03/'
    else:
        print 'ERROR: unknown environment selected in the GUI'

    #which directory to use to save the data
    gui_specs['save_dir'] = gui_specs['project_dir'] + 'subjects/' + gui_specs[
        'subj_name'] + '/data/beh/'

    #if the directory where data will be saved does not exist yet
    if not os.path.isdir(gui_specs['save_dir']):
        print "saving files to: ", gui_specs['save_dir']
        os.makedirs(
            gui_specs['save_dir'])  #this command can make multiple subfolders

    return gui_specs
Esempio n. 32
0
import sys
reload(sys)
sys.setdefaultencoding('utf8')

import pandas as pd

import feedback_ansl as feedback
import screening_ansl as screening
# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__)).decode(sys.getfilesystemencoding())
os.chdir(_thisDir)
expInfo = {'participant':'', 'directory':'/home/michael/ANSL/questionnaires/data'}
dlg = gui.DlgFromDict(dictionary=expInfo, title='questionaire')
if dlg.OK == False:
    core.quit()  # user pressed cancel
expInfo['date'] = data.getDateStr()  # add a simple timestamp

save_path = expInfo['directory']
print(save_path)

# defines layout of hui gui and updates status of questionnaires after each run
def update(field1, field2):
    # creates starting gui
    myDlg = gui.Dlg(title=u'questionaires')
    myDlg.addText(u'status: o = noch ausstehend  x = erledigt\n')
    # prompts static text field showing the status of each questionaire
    myDlg.addText(field1 + ' demographisch')
    myDlg.addText(field2 + ' feedback')

    # create empty list to append to
Esempio n. 33
0
def sprTrial(sentence):
    """
    Experiment trial.
    """

    # Clear any key log.
    deadlineClock = core.Clock()

    # Decode sentence before presentation if using Unicode.
    #sentence = map(decode_unicode, sentence)

    # Display fixation point.
    fixation = visual.TextStim(stim_window,
                               text='+',
                               pos=(0.0, 0.0),
                               bold=True,
                               height=0.15)
    fixation.draw()
    stim_window.flip()

    core.wait(fix_time)
    stim_window.flip()

    # Display sentence word-by-word, but allow the final word to be distinct font or color.
    event.clearEvents()
    deadlineClock.reset()
    response = []
    current_word_position = 1

    for word in sentence:
        current_word_response = []

        while len(current_word_response
                  ) == 0 and deadlineClock.getTime() < deadline:
            stim = visual.TextStim(stim_window,
                                   text=word,
                                   pos=(0.0, 0.0),
                                   bold=True,
                                   height=0.15)
            stim.draw()
            stim_window.flip()
            current_word_response = event.getKeys(keyList=["space", "escape"])
            current_rt = deadlineClock.getTime()

        if deadlineClock.getTime() > deadline:
            timeout_feedback.draw()
            stim_window.flip()
            core.wait(1)
            stim_window.flip()
            response.append([word, current_word_position, 'NA', 'NA'])
            break
        elif "escape" in current_word_response:
            core.quit()
        else:
            response.append(
                [word, current_word_position,
                 round(1000 * current_rt), 'NA'])
            current_word_position += 1

        core.wait(between_words_time)
        deadlineClock.reset()
        event.clearEvents()

    return response
Esempio n. 34
0
        answer1.draw()
        answer2.draw()
        stim_window.flip()
        answer = event.getKeys(keyList=["f", "j", "escape"])
        answer_rt = deadlineClock.getTime()

    if deadlineClock.getTime() > qDeadline:
        timeout_feedback.draw()
        stim_window.flip()
        core.wait(1)
        stim_window.flip()
        response = ['QUESTION', 'NA', 'NA', 'NA']
    if "escape" in answer:
        core.quit()
    else:
        response = [
            'NA', 'NA',
            round(1000 * answer_rt),
            int(correct_response in answer)
        ]

    return response


##### RUNTIME #################################################################

practice()
main()
stim_window.close()
core.quit()
 def check_input(self):
     keys = event.getKeys()
     if 'space' in keys:
         self._manager.set_audio_scene()
     elif 'escape' in keys:
         core.quit()
Esempio n. 36
0
def check_exit():
    #abort if esc was pressed
    if event.getKeys('escape'):
        win.close()
        core.quit()
 def quit(self):
     self.myoHub.close()
     core.quit()
Esempio n. 38
0
def launchScan(win, settings, globalClock=None, simResponses=None,
               mode=None, esc_key='escape',
               instr='select Scan or Test, press enter',
               wait_msg="waiting for scanner...",
               wait_timeout=300, log=True):
    """
    Accepts up to four fMRI scan parameters (TR, volumes, sync-key, skip), and
    launches an experiment in one of two modes: Scan, or Test.

    :Usage:
        See Coder Demo -> experiment control -> fMRI_launchScan.py.

        In brief: 1) from psychopy.hardware.emulator import launchScan;
        2) Define your args; and 3) add 'vol = launchScan(args)'
        at the top of your experiment script.

    launchScan() waits for the first sync pulse and then returns, allowing your
    experiment script to proceed. The key feature is that, in test mode, it first
    starts an autonomous thread that emulates sync pulses (i.e., emulated by your CPU rather
    than generated by an MRI machine). The thread places a character in the key buffer, exactly like
    a keyboard event does. launchScan will wait for the first such sync pulse (i.e.,
    character in the key buffer). launchScan returns the number of sync pulses
    detected so far (i.e., 1), so that a script can account for them explicitly.

    If a globalClock is given (highly recommended), it is reset to 0.0 when the
    first sync pulse is detected. If a mode was not specified when calling
    launchScan, the operator is prompted to select Scan or Test.

    If **scan mode** is selected, the script will wait until the first scan pulse
    is detected. Typically this would be coming from the scanner, but note that
    it could also be a person manually pressing that key.

    If **test mode** is selected, launchScan() starts a separate thread to emit
    sync pulses / key presses. Note that this thread is effectively nothing more than
    a key-pressing metronome, emitting a key at the start of every TR, doing so with
    high temporal precision.

    If your MR hardware interface does not deliver a key character as a sync flag,
    you can still use launchScan() to test script timing. You have to code
    your experiment to trigger on either a sync character (to test timing) or
    your usual sync flag (for actual scanning).

    :Parameters:
        win: a :class:`~psychopy.visual.Window` object (required)

        settings : a dict containing up to 5 parameters (2 required: TR, volumes)

            TR :
                seconds per whole-brain volume (minimum value = 0.1s)
            volumes :
                number of whole-brain (3D) volumes to obtain in a given scanning run.
            sync :
                (optional) key for sync timing, default = '5'.
            skip :
                (optional) how many volumes to silently omit initially (during T1
                stabilization, no sync pulse). default = 0.
            sound :
                (optional) whether to play a sound when simulating scanner sync pulses

        globalClock :
            optional but highly recommended :class:`~psychopy.core.Clock` to
            be used during the scan; if one is given, it is reset to 0.000 when
            the first sync pulse is received.

        simResponses :
            optional list of tuples [(time, key), (time, key), ...]. time values
            are seconds after the first scan pulse is received.

        esc_key :
            key to be used for user-interrupt during launch. default = 'escape'

        mode :
            if mode is 'Test' or 'Scan', launchScan() will start in that mode.

        instr :
            instructions to be displayed to the scan operator during mode selection.

        wait_msg :
            message to be displayed to the subject while waiting for the scan to
            start (i.e., after operator indicates start but before the first
            scan pulse is received).

        wait_timeout :
            time in seconds that launchScan will wait before assuming something went
            wrong and exiting. Defaults to 300sec (5 minutes). Raises a TimeoutError
            if no sync pulse is received in the allowable time.
    """

    if not 'sync' in settings:
        settings.update({'sync': '5'})
    if not 'skip' in settings:
        settings.update({'skip': 0})
    try:
        wait_timeout = max(0.01, float(wait_timeout))
    except ValueError:
        raise ValueError("wait_timeout must be number-like, but instead it was %s." % str(wait_timeout))
    settings['sync'] = unicode(settings['sync'])
    settings['TR'] = float(settings['TR'])
    settings['volumes'] = int(settings['volumes'])
    settings['skip'] = int(settings['skip'])
    runInfo = "vol: %(volumes)d  TR: %(TR).3fs  skip: %(skip)d  sync: '%(sync)s'" % (settings)
    if log:  # pragma: no cover
        logging.exp('launchScan: ' + runInfo)
    instructions = visual.TextStim(win, text=instr, height=.05, pos=(0,0), color=.4, autoLog=False)
    parameters = visual.TextStim(win, text=runInfo, height=.05, pos=(0,-0.5), color=.4, autoLog=False)

    # if a valid mode was specified, use it; otherwise query via RatingScale:
    mode = str(mode).capitalize()
    if mode not in ['Scan', 'Test']:
        run_type = visual.RatingScale(win, choices=['Scan', 'Test'], marker='circle',
            markerColor='DarkBlue', size=.8, stretch=.3, pos=(0.8,-0.9),
            markerStart='Test', lineColor='DarkGray', autoLog=False)
        while run_type.noResponse:
            instructions.draw()
            parameters.draw()
            run_type.draw()
            win.flip()
            if event.getKeys([esc_key]):
                break
        mode = run_type.getRating()
    doSimulation = bool(mode == 'Test')

    win.mouseVisible = False
    if doSimulation:
        wait_msg += ' (simulation)'
    msg = visual.TextStim(win, color='DarkGray', text=wait_msg, autoLog=False)
    msg.draw()
    win.flip()

    event.clearEvents() # do before starting the threads
    if doSimulation:
        syncPulse = SyncGenerator(**settings)
        syncPulse.start() # start emitting sync pulses
        core.runningThreads.append(syncPulse)
        if simResponses:
            roboResponses = ResponseEmulator(simResponses)
            roboResponses.start() # start emitting simulated user responses
            core.runningThreads.append(roboResponses)

    # wait for first sync pulse:
    timeoutClock = core.Clock() # zeroed now
    allKeys = []
    while not settings['sync'] in allKeys:
        allKeys = event.getKeys()
        if esc_key and esc_key in allKeys:  # pragma: no cover
            core.quit()
        if timeoutClock.getTime() > wait_timeout:
            raise TimeoutError('Waiting for scanner has timed out in %.3f seconds.' % wait_timeout)
    if globalClock:
        globalClock.reset()
    if log:  # pragma: no cover
        logging.exp('launchScan: start of scan')
    win.flip() # blank the screen on first sync pulse received
    elapsed = 1 # one sync pulse has been caught so far

    return elapsed
Esempio n. 39
0
def main():
    # open up data file + gui
    expInfo = {'Participant': 0, 'Gender': ['Male', 'Female'], 'Age': 0}
    expInfo['dateStr'] = data.getDateStr()

    dlg = gui.DlgFromDict(expInfo,
                          title="Participant Info",
                          fixed=['dateStr'],
                          order=['Participant', 'Age', 'Gender'])
    if dlg.OK:
        LogFile = "SP_participantInfo"
        infoFile = open('data/' + LogFile + '.csv', 'a')
        infoFile.write('%s,%s,%s,%s\n' %
                       (expInfo['Participant'], expInfo['Gender'],
                        expInfo['Age'], expInfo['dateStr']))
        infoFile.close()
    else:
        core.quit()

    fileName = 'Participant' + str(
        expInfo['Participant']) + '_SP'  # + expInfo['dateStr']
    global dataFile, win, patchCols, maskTex, fix, instrText, instrImage
    dataFile = open('data/' + fileName + '.csv', 'w')
    dataFile.write(
        'Trial, SetSize, Cond, testChange, respChange, RT, study, test\n')

    win = visual.Window([1024, 768],
                        fullscr=True,
                        allowGUI=False,
                        units='deg',
                        monitor='testMonitor')
    patchCols = [
        colours[col]
        for col in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4, 6, 7, 2, 5, 1]
    ]  # random.sample([colours[col] for col in range(Nstim)*2], 16)
    maskTex = numpy.array(patchCols).reshape((4, 4, 3))

    fix = visual.TextStim(win, text='+', color="black", height=1, pos=[0, 0])
    instrText = visual.TextStim(win,
                                color="black",
                                height=1,
                                pos=[0, 0],
                                wrapWidth=30)  # before each trial
    instrImage = visual.ImageStim(win, contrast=1,
                                  pos=[0, 5])  # before each block
    # determine block order - following Donkin et al (2013)
    blockList = []
    for i in range(3):
        for j in random.sample([.3, .5, .7], 3):
            blockList.append(j)

    # main experimental trials
    for block in range(len(blockList)):
        pc = blockList[block]
        trials = genBlock(Ns, blockList[block], trialsPerBlock)
        # instruction screen + image (pie chart)
        instrImage.setImage('images/pie' + str(int(pc * 100)) + '.png')
        instrImage.draw()
        instr(
            "In this block there is a %s%% chance that one square has changed colour between study and test.\n\n\nPress %s for SAME or %s for CHANGE\n\n\nPress any key to start."
            % (int(pc * 100), SameKey, ChangeKey))
        win.flip()
        core.wait(.5)
        trialSeq(trials)
        if block < len(blockList) - 1:
            instr('End of block\n\n\nPress any key to begin next block')
        else:
            instr('End of Experiment\n\n\nThank you for taking part!')
Esempio n. 40
0
from psychopy.constants import *  # things like STARTED, FINISHED
import numpy as np  # whole numpy lib is available, prepend 'np.'
from numpy import sin, cos, tan, log, log10, pi, average, sqrt, std, deg2rad, rad2deg, linspace, asarray
from numpy.random import random, randint, normal, shuffle
import os  # handy system and path functions
from psychopy.hardware.emulator import launchScan
import time
# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__))
os.chdir(_thisDir)

# Store info about the experiment session
expName = u'test2'  # from the Builder filename that created this script
expInfo = {u'session': u'001', u'participant': u''}
dlg = gui.DlgFromDict(dictionary=expInfo, title=expName)
if dlg.OK == False: core.quit()  # user pressed cancel
expInfo['date'] = data.getDateStr()  # add a simple timestamp
expInfo['expName'] = expName

# MRI INFORMATION FOR SYNCHRONIZATION
MR_settings = {
    'TR': 2.000,  # duration (sec) per volume
    'volumes': 5,  # number of whole-brain 3D volumes / frames
    'sync':
    'equal',  # character to use as the sync timing event; assumed to come at start of a volume
    'skip':
    0,  # number of volumes lacking a sync pulse at start of scan (for T1 stabilization)
    'sound':
    False  # in test mode only, play a tone as a reminder of scanner noise
}
# DISPLAY PARAMETERS FOR THE USER TO CONFIRM
Esempio n. 41
0
#------------------------------

#get values from dialog
expName = 'Rest'
myDlg = gui.Dlg(title=expName, pos=(860, 340))
myDlg.addField(label='Participant', initial=0, tip='Participant name or code'),
myDlg.addField(label='Duration', choices=(3, 5, 10), tip='Minutes'),
myDlg.addField(label='Show',
               choices=('nothing', 'photo', 'beach', 'earth', 'forest')),
myDlg.addField(label='Hz', choices=(144, 60), tip='Refresh Rate')
myDlg.addField(label='Triggers',
               initial='Yes',
               choices=['Yes', 'No'],
               tip='Send Parallel Port Triggers')
dlg_data = myDlg.show()
if myDlg.OK == False: core.quit()  #user pressed cancel

#store values from dialog
expInfo = {
    'Participant': dlg_data[0],
    'Duration': dlg_data[1],
    'Show': dlg_data[2],
    'Hz': dlg_data[3],
    'Triggers': dlg_data[4]
}
expInfo['date'] = data.getDateStr()  #add a simple timestamp
expInfo['expName'] = expName

#-----------------------
#setup files for saving
#-----------------------
Esempio n. 42
0
def trialSeq(block):
    nDone = 0
    for thisTrial in block:
        # # # SET-UP TRIAL (done before time critical stuff)
        # extract relevant information for trial
        N = thisTrial['SetSize']
        ttype = thisTrial['SoC']
        pChange = thisTrial['pChange']

        # create trial stimuli and masks
        trialMasks = []
        trialStim = []
        for s in range(N):
            trialStim.append(visual.Rect(win, width=stimSize, height=stimSize))
            trialMasks.append(
                visual.GratingStim(win,
                                   tex=maskTex,
                                   mask=None,
                                   size=stimSize,
                                   sf=1.0 / stimSize,
                                   texRes=256))

        # select trial locations
        trialLocs = []
        for i in range(N):
            works = 0
            while works < 1:  # while we havent got a location that works (i.e. is not more than 2 deg from others...)
                candidate = [
                    random.uniform(widthLim[0], widthLim[1]),
                    random.uniform(heightLim[0], heightLim[1])
                ]  # generate random candidate
                close = 0  # test is this close
                if numpy.sqrt((candidate[0])**2 + (candidate[1])**2
                              ) > locSep:  # if candidate is far from centre
                    for loc in trialLocs:
                        dist = numpy.sqrt((loc[0] - candidate[0])**2 +
                                          (loc[1] - candidate[1])**2)
                        if dist < locSep:  # if the candidate location is near an already sampled one...
                            close += 1
                else:
                    close += 1
                if close == 0:  # if the candidate is not close to any
                    trialLocs.append(candidate)  # add to trial list
                    works += 1  # this one works...

        # place trial stimuli in location
        for s in range(N):
            trialStim[s].setPos(trialLocs[s])
            trialMasks[s].setPos(trialLocs[s])

        # select study stimuli (indices to store later)
        study = random.sample(range(Nstim), N)

        # randomly choose an item to change (for use if trial == 'change')
        testItem = random.choice(range(N))

        # select a colour to change to (for use if trial == 'change')
        newItem = random.choice([x for x in range(Nstim) if x not in study])

        test = study[testItem]
        if ttype == 'c':  # if trial == 'change'
            test = newItem  # new colour in place of the old

        # # # MAIN TRIAL SEQUENCE
        instrText.setText('Ready - %s%% chance of a change' %
                          (int(pChange * 100)))

        # 1000 ms warning (with reminder of change probability)
        for fr in range(frameRate):
            instrText.draw()
            win.flip()

        # 1000 ms fixation
        for fr in range(frameRate):
            fix.draw()
            win.flip()

        # set study colours
        for s in range(N):
            trialStim[s].setLineColor(colours[study[s]])
            trialStim[s].setFillColor(colours[study[s]])

        # present study array for 500 ms
        for fr in range(frameRate / 2):
            [trialStim[i].draw() for i in range(N)]
            win.flip()

        # 500 ms blank screen
        for fr in range(frameRate / 2):
            win.flip()

        # present masks for 500 ms
        for fr in range(frameRate / 2):
            [trialMasks[i].draw() for i in range(N)]
            win.flip()

#        # set test colours + draw
#        for s in range(N):
#            trialStim[s].setLineColor(colours[test[s]])
#            trialStim[s].setFillColor(colours[test[s]])
#        [trialStim[i].draw() for i in range(N)]

# present single central probe
        testStim = visual.Rect(win,
                               width=stimSize,
                               height=stimSize,
                               pos=testLoc,
                               lineColor=colours[test],
                               fillColor=colours[test])
        testStim.draw()

        RT.reset()  # start RT counter and present test
        win.flip()

        # # # COLLECT RESPONSE
        event.clearEvents(eventType='keyboard')
        keyP = 0
        while keyP == 0:
            for key in event.getKeys():
                if key in [SameKey]:
                    ans = 0
                    keyP += 1
                elif key in [ChangeKey]:
                    ans = 1
                    keyP += 1
                elif key in [quitKey]:
                    core.quit()
        # to test - comment above lines and uncomment below
#        core.wait(.5); ans = random.choice([1, 0])

        reactionTime = RT.getTime()

        nDone += 1

        # # # WRITE TO CSV
        dataFile.write('%i,%i,%.4f,%i,%i,%.4f,%s,%s\n' %
                       (nDone, N, pChange, int(ttype == 'c'), ans,
                        reactionTime, ''.join(str(x)
                                              for x in study), str(test)))
Esempio n. 43
0
    def __init__(self, params=None, reportobj=None, subroutines=[]):
        logging.LogFile(params['cwd'] + os.sep + params['logfile'],
                        level=logging.INFO,
                        filemode='w')
        logging.LogFile(level=logging.ERROR)

        logging.info('Using Python ' + sys.version)

        self.args = sys.argv
        self.params = self.update_params(self.args, params)
        self.win = None
        self.model = None
        self.routines = subroutines
        self.thisExp = None
        self.name = params['name']
        self.cwd = params['cwd']
        self.reportobj = reportobj

        if params['monitor'] not in monitors.getAllMonitors():
            logging.error('monitor not found: ' + params.monitor)
            logging.info('available monitors: ' +
                         ' '.join(monitors.getAllMonitors()))
            logging.info('Define monitor in monitor center.')
            logging.info('To launch monitor center, type:\n'
                         'python -m psychopy.monitors.MonitorCenter')
            core.quit()
        else:
            self.monitor = monitors.Monitor(
                '',
                width=None,
                distance=self.params['viewing_distance'],
                gamma=None,
                notes=None,
                useBits=None,
                verbose=True,
                currentCalib=None,
                autoLog=True)
            self.monitor.setSizePix((1920, 1280))
            self.monitor.setWidth(54.15)

            logging.exp('using monitor: ' + self.params['monitor'] +
                        ' with viewing_distance=' +
                        str(self.params['viewing_distance']) + ' cm\n' +
                        ' resolution (pixel/deg): ' +
                        str(deg2pix(1, self.monitor)))
            # TODO: change screen_pixel_size back to calculation from monitor
            # TODO: change the monitor definition width so that screen_pixel_size=0.282
            if 'screen_pixel_size' not in self.params['model']:
                self.params['model']['screen_pixel_size'] = pix2cm(
                    1, self.monitor) * 10.0

            #self.params['model']['screen_pixel_size'] = 0.282
            self.params['model'][
                'viewing_distance'] = self.params['viewing_distance'] / 2.54

        self.expInfo = params['exp_info']
        self.expInfo['date'] = data.getDateStr()

        # Ensure that relative paths start from the same directory as this script
        _thisDir = os.path.dirname(os.path.abspath(__file__))
        os.chdir(_thisDir)
        # Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
        runsubject = self.params['runsubject']
        if runsubject:
            self.filename = self.cwd + os.sep + u'data' + os.sep + '%s_%s_%s' % (
                self.expInfo['participant'], params['name'],
                self.expInfo['date'])
        else:
            self.filename = self.cwd + os.sep + u'data' + os.sep + 'model-' + params[
                'expName']
Esempio n. 44
0
    'ID number': '1',
    'frameRate': 120,
    'w1': 0.2,
    'ISI1': 0.3,
    'w2': 0.2,
    'blank': 0.3,
    'fp': 0.3,
    'task': 'wordPrimingTask',
    'computer': 'raylan'
}

dlg = gui.DlgFromDict(params, title='SameDiffTask', fixed=['dateStr'])
if dlg.OK:
    toFile('lastParams.pickle', params)  #save params to file for next time
else:
    core.quit()  #the user hit cancel so exit

fileName = params['ID number'] + '_SDTArb2'
dataFile = open('/home/zahrahussain/Documents/psychopy/data/wordSDT/' +
                fileName + '.txt',
                'a')  #a simple text file with 'comma-separated-values'
#dataFile = open(fileName+'.txt', 'a')
dataFile.write(
    'word, cue, condition, distractorType, corresp, subjectResp, accuracy, RT\n'
)

# Create a visual window:
#win = visual.Window(fullscr=True, allowGUI = True, monitor = 'testmonitor', units = 'deg')
win = visual.Window(fullscr=True,
                    allowGUI=True,
                    monitor='2wordTasks',
Esempio n. 45
0
        # stimulus
        #    for frameN in range(int(round(params['duration']*params['frameRate']))):
        clockRT.reset()
        target.draw()
        arrow2.draw()
        arrow3.draw()
        arrow4.draw()
        arrow5.draw()
        win.update()

        # start collecting response

        allKeys = event.waitKeys(timeStamped=clockRT)
        for keyTuple in allKeys:
            [thisKey, thisRT] = keyTuple
        for thisKey in allKeys:
            if thisKey in ['escape']: core.quit()
            elif int(thisKey[0]) == int(trials.thisTrial['dir']):
                thisResponse = 1
                accuracy = 1
                corSnd.play()
            else:
                thisResponse = 1
                accuracy = 0
                incorSnd.play()
            trials.data.add('accuracy', accuracy)

    event.clearEvents()

win.close()
core.quit()
Esempio n. 46
0
    def run(self,
            runsubject=False,
            monitor=None,
            distance=None,
            store_runtime_info=False,
            display_report=True):
        try:
            # TODO: do this only if this a model run
            print('Removing old model data files.')
            logging.info('Removing old model data files from data directory.')
            filelist = glob.glob(
                os.path.join(self.cwd, 'data',
                             'model-' + self.params['expName'] + '.csv'))
            for f in filelist:
                print('Removing: ' + str(f))
                os.remove(f)

            runtime_info = None
            runsubject = self.params['runsubject']
            if runsubject or self.params['genstim']:
                self.win = visual.Window(
                    size=self.monitor.getSizePix(),
                    fullscr=False,
                    screen=0,
                    winType='pyglet',
                    allowGUI=True,
                    allowStencil=False,
                    #monitor=self.monitor, color='black', colorSpace='rgb',
                    # TODO: add color parameter for newlibrary: mainwindow
                    monitor=self.monitor,
                    color=self.params['window_color'],
                    colorSpace='rgb',
                    blendMode='avg',
                    useFBO=True,
                    autoLog=False)

                if store_runtime_info:
                    from psychopy import info  # this library is slow to load, so we load here only since it is now needed
                    runtime_info = info.RunTimeInfo(author=None,
                                                    version=None,
                                                    win=self.win,
                                                    refreshTest='grating',
                                                    userProcsDetailed=False,
                                                    verbose=True)

            else:
                self.model = Model(name=self.params['expName'],
                                   cwd=self.params['cwd'],
                                   saveimages=self.params['saveimages'],
                                   params=self.params,
                                   **self.params['model'])
                self.params['model'][
                    'decision_sigma'] = self.model.decision_sigma
                self.params['model']['decision_K'] = self.model.decision_K
                #logging.exp('Params:\n'+str(params))

            if not self.params['genstim']:
                # An ExperimentHandler isn't essential but helps with data saving
                self.thisExp = data.ExperimentHandler(
                    name=self.params['name'],
                    version='',
                    extraInfo=self.expInfo,
                    runtimeInfo=runtime_info,
                    savePickle=False,
                    saveWideText=True,
                    dataFileName=self.filename,
                    autoLog=True)

            for routine in self.routines:
                routine.create(self.win, exp_handler=self.thisExp)

            for routine in self.routines:
                routine.run(runmodel=self.model,
                            genstim=self.params['genstim'],
                            params=self.params,
                            loopstate=Params())

            if self.thisExp:
                self.thisExp.close()
                logging.exp('Experiment Finished.')
                logging.exp('Params used in experiment:\n' + str(self.params))
                logging.exp('Done.--------------------------------')

            if display_report:
                self.displayreport()
                #core.quit()

        except Exception as e:
            logging.error(traceback.format_exc())
            self.end()
            core.quit()
Esempio n. 47
0
def itemrecog_pattsep(subject_stim, context_bind_items, count):
    # Item recognition and pattern separation instructions
    for n in range(17, 20):
        temp_instr = visual.TextStim(win, instr[n], color='black', pos=[0, 0])
        temp_instr.draw()
        win.update()
        event.waitKeys(keyList=['space'])
        win.flip()

    encoding_pres_items = subject_stim[subject_stim['Part'] == 'encoding']

    feedback_correct = 'That’s right.'
    feedback_incorrect = 'Actually, you saw that friend with this object circled in black.'

    random.shuffle(character_list)
    for character in character_list:
        if event.getKeys(['escape']):
            win.close()
            core.quit()
        subject_stim['Scene'].iloc[n].split('_')[0]
        items_already_pres = subject_stim['Item'].tolist(
        ) + subject_stim['Lure_1'].tolist() + subject_stim['Lure_2'].tolist()

        # Get two random category lures
        lures_ir = random.sample([
            x for x in stimulus_key[stimulus_key['Character'] == character]
            ['Item'].unique() if x not in items_already_pres
        ], 2)
        # Get lure items that were not presented during encoding and set random color
        lure1_ir = lures_ir[0]
        lure2_ir = lures_ir[1]
        target_ir = [
            x for x in encoding_pres_items[encoding_pres_items['Character'] ==
                                           character]['Item'].tolist()
            if x not in context_bind_items
        ][0]
        subject_stim.loc[count, 'Part'] = 'item_recognition'
        subject_stim.loc[count, 'Character'] = character
        subject_stim.loc[count, 'Item'] = target_ir
        subject_stim.loc[count, 'Lure_1'] = lure1_ir
        subject_stim.loc[count, 'Lure_2'] = lure2_ir

        # Present stimuli
        char_stim = Image.open(char_dir + [
            i for i in os.listdir(char_dir) if i.endswith(character + '.png')
        ][0])
        lure1_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(lure1_ir + '_white.png')
        ][0])
        lure2_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(lure2_ir + '_white.png')
        ][0])
        target_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(target_ir + '_white.png')
        ][0])
        char_stim.thumbnail(item_size, Image.ANTIALIAS)
        lure1_stim.thumbnail(item_size, Image.ANTIALIAS)
        lure2_stim.thumbnail(item_size, Image.ANTIALIAS)
        target_stim.thumbnail(item_size, Image.ANTIALIAS)
        stim_pos = [[-0.5, -0.6], [0, -0.6], [0.5, -0.6]]
        random.shuffle(stim_pos)
        char_pres = visual.ImageStim(win, char_stim, pos=[0, 0.5])
        lure1_pres = visual.ImageStim(win, lure1_stim, pos=stim_pos[0])
        lure2_pres = visual.ImageStim(win, lure2_stim, pos=stim_pos[1])
        target_pres = visual.ImageStim(win, target_stim, pos=stim_pos[2])
        char_pres.draw()
        lure1_pres.draw()
        lure2_pres.draw()
        target_pres.draw()
        win.update()
        timer.reset()

        # Record response and give feedback
        while True:
            if mouse.isPressedIn(target_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = target_ir
                temp_instr = visual.TextStim(win,
                                             feedback_correct,
                                             color='black',
                                             pos=[0, 0])
                feedback_circle = visual.Polygon(win,
                                                 edges=100,
                                                 radius=0.3,
                                                 pos=target_pres.pos)
                feedback_circle.lineColor = 'black'
                feedback_circle.lineWidth = 7
                char_pres.draw()
                lure1_pres.draw()
                lure2_pres.draw()
                target_pres.draw()
                temp_instr.draw()
                feedback_circle.draw()
                win.flip()
                core.wait(time_bind)
                break
            elif mouse.isPressedIn(lure1_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = lure1_ir
                temp_instr = visual.TextStim(win,
                                             feedback_incorrect,
                                             color='black',
                                             pos=[0, 0])
                feedback_circle = visual.Polygon(win,
                                                 edges=100,
                                                 radius=0.3,
                                                 pos=target_pres.pos)
                feedback_circle.lineColor = 'black'
                feedback_circle.lineWidth = 7
                char_pres.draw()
                lure1_pres.draw()
                lure2_pres.draw()
                target_pres.draw()
                temp_instr.draw()
                feedback_circle.draw()
                win.flip()
                core.wait(time_bind)
                break
            elif mouse.isPressedIn(lure2_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = lure2_ir
                temp_instr = visual.TextStim(win,
                                             feedback_incorrect,
                                             color='black',
                                             pos=[0, 0])
                feedback_circle = visual.Polygon(win,
                                                 edges=100,
                                                 radius=0.3,
                                                 pos=target_pres.pos)
                feedback_circle.lineColor = 'black'
                feedback_circle.lineWidth = 7
                char_pres.draw()
                lure1_pres.draw()
                lure2_pres.draw()
                target_pres.draw()
                temp_instr.draw()
                feedback_circle.draw()
                win.flip()
                core.wait(time_bind)
                break
        win.update()
        win.flip()
        fix_pres = scene_pres = visual.ImageStim(win, fixation, pos=[0, 0])
        fix_pres.draw()
        win.update()
        core.wait(time_fixcr)
        win.flip()
        subject_stim.to_csv(save_subj_file_name)
        count = count + 1

        # Pattern Separation
        target_ps = encoding_pres_items[encoding_pres_items['Item'] ==
                                        target_ir][['Item', 'Color'
                                                    ]].iloc[0].str.cat(sep='_')
        lures_ps = random.sample([
            x for x in stimulus_key[stimulus_key['Item'] == target_ir]['Stim']
            if x not in target_ps
        ], 2)
        lure1_ps = lures_ps[0]
        lure2_ps = lures_ps[1]
        subject_stim.loc[count, 'Part'] = 'pattern_separation'
        subject_stim.loc[count, 'Character'] = character
        subject_stim.loc[count, 'Item'] = target_ps.rsplit('_', 1)[0]
        subject_stim.loc[count, 'Color'] = target_ps.rsplit('_', 1)[1]
        subject_stim.loc[count, 'Lure_1'] = lure1_ps
        subject_stim.loc[count, 'Lure_2'] = lure2_ps

        lure1_ps_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(lure1_ps + '.png')
        ][0])
        lure2_ps_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(lure2_ps + '.png')
        ][0])
        target_ps_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(target_ps + '.png')
        ][0])
        lure1_ps_stim.thumbnail(item_size, Image.ANTIALIAS)
        lure2_ps_stim.thumbnail(item_size, Image.ANTIALIAS)
        target_ps_stim.thumbnail(item_size, Image.ANTIALIAS)
        stim_pos = [[-0.5, -0.6], [0, -0.6], [0.5, -0.6]]
        random.shuffle(stim_pos)
        char_pres = visual.ImageStim(win, char_stim, pos=[0, 0.5])
        lure1_ps_pres = visual.ImageStim(win, lure1_ps_stim, pos=stim_pos[0])
        lure2_ps_pres = visual.ImageStim(win, lure2_ps_stim, pos=stim_pos[1])
        target_ps_pres = visual.ImageStim(win, target_ps_stim, pos=stim_pos[2])
        char_pres.draw()
        lure1_ps_pres.draw()
        lure2_ps_pres.draw()
        target_ps_pres.draw()
        win.update()
        timer.reset()

        while True:
            if mouse.isPressedIn(target_ps_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = target_ps
                break
            elif mouse.isPressedIn(lure1_ps_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = lure1_ps
                break
            elif mouse.isPressedIn(lure2_ps_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = lure2_ps
                break
        win.update()
        win.flip()
        count = count + 1
        fix_pres = scene_pres = visual.ImageStim(win, fixation, pos=[0, 0])
        fix_pres.draw()
        win.update()
        core.wait(time_fixcr)
        win.flip()
        subject_stim.to_csv(save_subj_file_name)
    return subject_stim, count
Esempio n. 48
0
    def run(self,
            runmodel=None,
            genstim=False,
            trialparams={},
            params={},
            loopstate={}):
        self.update_params(trialparams, loopstate)
        resp = Response()
        filename = ''
        # If we have a window then either we are generating stimuli or
        #   running a human subject experiment
        if self.win is not None:
            for component in self.components:
                if genstim:
                    filename = self.get_filename(trialparams, loopstate)
                    component.start(trialparams, loopstate)
                else:
                    component.run(trialparams, loopstate)

            left, top = params['model']['view_pos']
            width, height = params['model']['view_size']

            ###################
            #diff_x,diff_y = params['diff_size']
            diff_x, diff_y = 1.0, 1.0  # TODO: remove all this diff_size code
            width_window, height_window = self.win.size
            center_left = int(deg2pix(left, self.win.monitor))
            center_top = int(deg2pix(top, self.win.monitor))
            upper_left = center_left - int(0.5 * width)
            upper_top = center_top + int(0.5 * height)
            if width % 2 == 0:  # width is even number of pixels
                lower_right = upper_left + width
                lower_bottom = upper_top - height
            else:
                lower_right = upper_left + (width + 1)
                lower_bottom = upper_top - (height + 1)
            # convert to normalized coords
            upper_left_norm = upper_left / (0.5 * width_window)
            upper_top_norm = upper_top / (0.5 * height_window)
            lower_right_norm = lower_right / (0.5 * width_window)
            lower_bottom_norm = lower_bottom / (0.5 * height_window)
            rect = [
                upper_left_norm, upper_top_norm, lower_right_norm * diff_x,
                lower_bottom_norm * diff_y
            ]
            extra = 2  # extra space to draw lines around rect
            if not self.viewport:
                self.viewport = visual.Rect(win=self.win,
                                            width=width + extra,
                                            height=height + extra,
                                            autoLog=None,
                                            units='pixels',
                                            lineWidth=1,
                                            lineColor='yellow',
                                            lineColorSpace='rgb',
                                            fillColor=None,
                                            fillColorSpace='rgb',
                                            pos=(center_left, center_top),
                                            ori=0.0,
                                            opacity=0.5,
                                            contrast=0.8,
                                            depth=1000,
                                            interpolate=False,
                                            name=None,
                                            autoDraw=True)
            else:
                self.viewport.setPos((center_left, center_top))

            self.win.flip()

            if genstim:
                model_stimulus = self.win._getFrame(rect=None, buffer='front')
                model_stimulus = np.array(model_stimulus)
                center_height = int(height_window / 2) + center_top
                center_width = int(width_window / 2) + center_left
                top_height = int(center_height - height / 2)
                bottom_height = int(center_height + height / 2)
                top_width = int(center_width - width / 2)
                bottom_width = int(center_width + width / 2)
                model_stimulus = model_stimulus[top_height:bottom_height,
                                                top_width:bottom_width, :]
                model_stimulus = Image.fromarray(model_stimulus)
                if np.shape(model_stimulus)[1] != width or np.shape(
                        model_stimulus)[0] != height:
                    print(np.shape(model_stimulus))
                    import pdb
                    pdb.set_trace()
                    # TODO: Make it so this exception gets caught
                    logging.error('problem with model window')
                    raise Exception(
                        'Error in calculating shape of model window.')

                if 'model' in os.path.join(params['cwd'],
                                           'stimuli' + os.sep + filename):
                    import pdb
                    pdb.set_trace()

                logging.info('saving: ' + filename)
                model_stimulus.save(
                    os.path.join(params['cwd'], 'stimuli' + os.sep + filename),
                    "PNG")
                keys = []
            else:
                keys = event.waitKeys(maxWait=self.timeout, keyList=None)
                resp = Response(key=keys[0])
                for component in self.components:
                    component.end()
        else:
            filename = self.get_filename(trialparams, loopstate)
            # if we don't have a target_contrast in the parameters
            #  then we need to load an image and get its target_contrast
            if 'target_contrast' not in params['model']:
                target_key, target_val = params['target_identifier']
                target_condition = Params(trialparams)
                target_condition.update({target_key: target_val})
                target_filename = self.get_filename(target_condition,
                                                    loopstate)

                # load stim from filename
                im = Image.open(
                    os.path.join(params['cwd'], 'stimuli' + os.sep +
                                 target_filename)).convert('L')
                im_array = np.frombuffer(im.tobytes(), dtype=np.uint8)
                width, height = im.size
                im_array = im_array.reshape((height, width))
                contrast = runmodel.process(data=im_array)
                runmodel.target_contrast = contrast
                logging.exp('Generating target_contrast from ' +
                            target_filename)
                logging.exp('Using target_contrast = ' + str(contrast))
                params['model']['target_contrast'] = contrast
                runmodel.update_decision_params()
                params['model']['decision_K'] = runmodel.decision_K
                params['model']['decision_sigma'] = runmodel.decision_sigma
                logging.exp('***Using decision_K = ' +
                            str(runmodel.decision_K))
                logging.exp('***Using decision_sigma = ' +
                            str(runmodel.decision_sigma))

            # load stim from filename define StimulusNotFound and raise it
            im = Image.open(
                os.path.join(params['cwd'],
                             'stimuli' + os.sep + filename)).convert('L')
            im_array = np.frombuffer(im.tobytes(), dtype=np.uint8)
            width, height = im.size
            im_array = im_array.reshape((height, width))

            print('processing:', filename)
            save_conv_filename = None
            if params['saveimages']:
                #save_conv_filename = 'images/'+filename[:-4]+'-convolved.png'
                save_conv_filename = filename[:-4]
            correct_answer, incorrect_answer = self.get_answer(
                trialparams, loopstate)

            # if we are saving additional plots we also want to pass the
            #  corresponding target data to the runmodel.runsponse
            im_array_target = None
            if save_conv_filename:
                target_key, target_val = params['target_identifier']
                target_condition = Params(trialparams)
                target_condition.update({target_key: target_val})
                target_filename = self.get_filename(target_condition,
                                                    loopstate)

                # load stim from filename
                im_target = Image.open(
                    os.path.join(params['cwd'], 'stimuli' + os.sep +
                                 target_filename)).convert('L')
                im_array_target = np.frombuffer(im_target.tobytes(),
                                                dtype=np.uint8)
                width_target, height_target = im_target.size
                im_array_target = im_array_target.reshape(
                    (height_target, width_target))

            # TODO: if we are generating all the plots then read the target data
            #       from the file using the 'target_identifier' from params
            #       then pass into runmodel.response
            key, prob, contrast = runmodel.response(
                data=im_array,
                correct_answer=correct_answer,
                incorrect_answer=incorrect_answer,
                save_conv_filename=save_conv_filename,
                target_data=im_array_target)

            correct = False
            if key == correct_answer:
                correct = True
            resp = Response(key=key,
                            rt=0,
                            correct=correct,
                            prob=prob,
                            contrast=contrast)
            #keys = ['left']

        if resp.key == 'escape':
            core.quit()

        return resp
Esempio n. 49
0
def isolumCheckerScan(scanDict, screenSize=[1024, 768]):
    #do full field flickering checkerboard
    #length of scan in s
    scanLength = float(scanDict['numCycles'] * scanDict['period'] +
                       scanDict['preScanRest'])
    #parse out vars from scanDict
    IR = scanDict['innerRadius']
    OR = scanDict['outerRadius']
    #    colorA=scanDict['colorA']
    #    colorB=scanDict['colorB']
    #    colorBG=scanDict['colorBackground']
    colorA = numpy.zeros((3, 1))
    colorB = numpy.zeros((3, 1))
    colorBG = numpy.zeros((3, 1))
    foo = scanDict['colorA']
    bar = foo.split(",")
    colorA[0] = float(bar[0])
    colorA[1] = float(bar[1])
    colorA[2] = float(bar[2])
    foo = scanDict['colorB']
    bar = foo.split(",")
    colorB[0] = float(bar[0])
    colorB[1] = float(bar[1])
    colorB[2] = float(bar[2])
    foo = scanDict['colorBackground']
    bar = foo.split(",")
    colorBG[0] = float(bar[0])
    colorBG[1] = float(bar[1])
    colorBG[2] = float(bar[2])
    flickFreq = scanDict['animFreq']
    timeBase = scanDict['timeBase']
    #open subject window
    mySubScreen = numpy.int(scanDict['subjectScreen'])
    myOpScreen = numpy.int(scanDict['operatorScreen'])
    #    print mySubScreen
    #    print myOpScreen
    winSub = visual.Window(screenSize,
                           monitor=scanDict['monCalFile'],
                           units="deg",
                           screen=mySubScreen,
                           color=[-1.0, -1.0, -1.0],
                           colorSpace='rgb',
                           fullscr=False,
                           allowGUI=False)
    #needs to be flexible--how do I extract the dims from screen?
    #    screenSize=numpy.array([1600,1200])
    #screenSize=numpy.array([1024,768])
    fixPercentage = scanDict['fixFraction']
    fixDuration = 0.25
    respDuration = 1.0
    subjectResponse = numpy.zeros((numpy.ceil(scanLength * 60 / 100), 1))
    subRespArray = numpy.zeros((numpy.ceil(scanLength * 60 / 100), 3))
    subjectResponse[:] = numpy.nan
    #plotResp=numpy.zeros((2,2))
    #    plotRespWrong=numpy.zeros((2,2))
    plotMax = numpy.ceil(scanLength * (60.0 / 100.0))
    plotResp = numpy.zeros((plotMax, 2))
    plotColors = numpy.zeros((plotMax, 3))
    #axesX=numpy.arange(0,scanLength*60/100)
    white = [1.0, 1.0, 1.0]
    gray = [0.0, 0.0, 0.0]
    black = [-1.0, -1.0, -1.0]
    #    plt.ion()
    #    plt.plot(plotResp[0:2],'ro')
    #    plt.ylabel('subject responses')
    #    plt.show()
    #    plt.axis([0,scanLength*0.6,-0.1,1.1])

    operatorWindow = visual.Window([1024, 768],
                                   monitor='testMonitor',
                                   units='deg',
                                   screen=myOpScreen,
                                   color=[0, 0, 0],
                                   colorSpace='rgb')

    #create a shapeStim to show the operator how the subject is doing on the task
    #    opPlotRight=visual.ShapeStim(operatorWindow,units='pix',vertices=plotResp,closeShape=False,pos=(-448,-448),lineWidth=1,lineColor=[-1,1,-1],lineColorSpace='rgb' )
    #    opPlotWrong=visual.ShapeStim(operatorWindow,units='pix',vertices=plotResp,closeShape=False,pos=(-448,-448),lineWidth=1,lineColor=[1,-1,-1],lineColorSpace='rgb' )
    #try another kind of plot
    opPlot = visual.ElementArrayStim(operatorWindow,
                                     units='pix',
                                     xys=plotResp,
                                     sizes=7,
                                     nElements=plotMax,
                                     fieldPos=(-500, -384),
                                     colors=plotColors,
                                     colorSpace='rgb',
                                     sfs=0,
                                     fieldShape='square',
                                     elementMask='circle')
    opPlot = visual.ElementArrayStim(operatorWindow,
                                     units='pix',
                                     xys=plotResp,
                                     sizes=7,
                                     nElements=plotMax,
                                     fieldPos=(-500, -384),
                                     colors=plotColors,
                                     colorSpace='rgb',
                                     sfs=0,
                                     fieldShape='square',
                                     elementMask='circle')
    gridLinesVertices = numpy.zeros((46, 2))
    gridLinesVertices[:, 0] = [
        0, 998, 0, 0, 998, 0, 0, 998, 0, 0, 998, 0, 0, 998, 0, 0, 998, 100,
        100, 100, 200, 200, 200, 300, 300, 300, 400, 400, 400, 500, 500, 500,
        600, 600, 600, 700, 700, 700, 800, 800, 800, 900, 900, 900, 998, 998
    ]
    gridLinesVertices[:, 1] = [
        0, 0, 0, 100, 100, 100, 200, 200, 200, 300, 300, 300, 400, 400, 400,
        500, 500, 500, 0, 500, 500, 0, 500, 500, 0, 500, 500, 0, 500, 500, 0,
        500, 500, 0, 500, 500, 0, 500, 500, 0, 500, 500, 0, 500, 500, 0
    ]
    opPlotGrid = visual.ShapeStim(operatorWindow,
                                  units='pix',
                                  vertices=gridLinesVertices,
                                  closeShape=False,
                                  pos=(-512, -334))
    #    gridLinesStart=numpy.zeros((17,2))
    #    gridLinesEnd=numpy.zeros((17,2))
    #    for i in range(11):
    #        gridLinesStart[i,0]=i*100
    #        gridLinesEnd[i,0]=i*100
    #        gridLinesStart[i,1]=0
    #        gridLinesEnd[i,1]=500
    #    for i in range(11,17):
    #        gridLinesStart[i,0]=0
    #        gridLinesEnd[i,0]=1000
    #        gridLinesStart[i,1]=(i-12)*100
    #        gridLinesEnd[i,1]=(i-12)*100
    #    opPlotGrid00=visual.Line(operatorWindow,units='pix',start=gridLinesStart[:,0],end=gridLinesEnd[:,0],pos=(-448,-448))
    #    opPlotGrid01=visual.Line(operatorWindow,units='pix',start=gridLinesStart[:,1],end=gridLinesEnd[:,1],pos=(-448,-448))
    #    opPlotGrid02=visual.Line(operatorWindow,units='pix',start=gridLinesStart[:,2],end=gridLinesEnd[:,2],pos=(-448,-448))

    #labels for the plot regions
    plotLabel1 = visual.TextStim(
        operatorWindow,
        units='pix',
        pos=(-450, 150),
        alignHoriz='left',
        text='Correct (active--displayed \'X\' and got a button press)',
        color=(-1, 1, -1),
        colorSpace='rgb',
        height=15)
    plotLabel2 = visual.TextStim(
        operatorWindow,
        units='pix',
        pos=(-450, -250),
        alignHoriz='left',
        text='Wrong (\'X\' displayed, NO button press)',
        color=(1, -1, -1),
        colorSpace='rgb',
        height=15)
    plotLabel3 = visual.TextStim(
        operatorWindow,
        units='pix',
        pos=(-450, -150),
        alignHoriz='left',
        text='Wrong-ish (No \'X\', but got a button press!?)',
        color=(1, -1, -1),
        colorSpace='rgb',
        height=15)
    plotLabel4 = visual.TextStim(
        operatorWindow,
        units='pix',
        pos=(-450, 25),
        alignHoriz='left',
        text='Correct (passive--no \'X\', no button press)',
        color=(-1, -1, 1),
        colorSpace='rgb',
        height=15)
    #create a designmatrix for trigger-based counting
    #first create an array--length = total number of Trs
    numTr = scanLength / scanDict['Tr']
    designMatrix = numpy.zeros((numTr, 1))

    #first N Trs are already zero--rest
    #figure out when the stim should be on
    for iStim in range(scanDict['numCycles']):
        restAmt = scanDict['preScanRest'] / scanDict['Tr']
        stimDur = scanDict['period'] / scanDict['Tr']  #CHECK THIS
        firstVal = restAmt + iStim * stimDur
        lastVal = firstVal + scanDict['period'] / (2 * scanDict['Tr'])
        designMatrix[firstVal:lastVal] = 1
    numpy.savetxt('debug.txt', designMatrix, fmt='%.3i')

    #convert colors to psychopy's scheme
    colorAf = numpy.asarray(colorA, dtype=float)
    colorBf = numpy.asarray(colorB, dtype=float)
    colorBGf = numpy.asarray(colorBG, dtype=float)
    colorAp = 2 * colorAf - 1
    colorBp = 2 * colorBf - 1
    colorBGp = 2 * colorBGf - 1
    #    image1=visual.SimpleImageStim(winSub,image='redblack1.jpg')
    #    image2=visual.SimpleImageStim(winSub,image='redblack2.jpg')

    #    image1=visual.PatchStim(winSub,tex='redblack1a.jpg',mask=None,size=[OR,OR])
    #    image2=visual.PatchStim(winSub,tex='redblack2a.jpg',mask=None,size=[OR,OR])

    #let's try making some numpy arrays of the checkerboards! translated from matlab arrays
    #size of image--hardcode for now, but needs to be 2^n that fits inside smaller screen dimension
    #    twoN=numpy.ones((13))
    #    for n in range(13):
    #        twoN[n]=pow(2.0,n)
    #    twoNsize=numpy.nonzero(twoN>screenSize[1])
    #    #hmm, this somehow made a nested tuple, whatever that is
    #    keep_n=twoNsize[0][0]-1
    #    imageSize=pow(2,keep_n)
    #    halfSize=numpy.int(imageSize/2)
    debugVar = numpy.zeros((scanLength * 60, 2))
    #imageSize=1024
    if screenSize[0] < 257:
        imageSize = 256
    elif screenSize[0] < 513:
        imageSize = 512
    elif screenSize[0] < 1025:
        imageSize = 1024
    elif screenSize[0] < 2057:
        imageSize = 2048
    halfSize = numpy.int(imageSize / 2)
    #    print screenSize
    #    print imageSize
    #    print halfSize
    #create arrays of x,y, and r,theta
    xIn = numpy.arange(-halfSize, halfSize, 1)
    yIn = numpy.arange(-halfSize, halfSize, 1)
    xIn.astype(float)
    yIn.astype(float)
    x, y = numpy.meshgrid(xIn, yIn)
    r = numpy.sqrt(x**2 + y**2)
    #avoid divide by zero issues
    y[y == 0] = numpy.finfo(numpy.float).eps
    xOverY = x / y
    theta = numpy.arctan(xOverY)
    theta[halfSize + 1, halfSize + 1] = 0

    #number of wedges (pairs!!)--eventually to be a var passed in
    nWedges = 8.0
    #number of ring pairs
    nRings = 15.0
    #width of wedges in radians
    wedgeWidth = 2.0 * math.pi / nWedges
    ringWidth = 2.0 / nRings
    #ring function--describes how the ring width increases with eccentricity
    ringFunction = numpy.power(
        r / halfSize, 0.3) + 0.2  #um, is there an int float problem here?

    wedgeMask = 0.5 - (numpy.mod(theta, wedgeWidth) >
                       (wedgeWidth / 2.0))  #does this work
    rmA = numpy.mod(ringFunction, ringWidth) > (ringWidth / 2.0)
    ringMask = 1 - 2.0 * (rmA)

    checkerBoardLogic = wedgeMask * ringMask + 0.5
    #checkerBoardBG=r>
    #initialize an array of 1024x1024x3 for RGB channels
    checkerBoardA = numpy.ones((imageSize, imageSize, 3))
    checkerBoardAR = numpy.ones((imageSize, imageSize))
    checkerBoardAB = numpy.ones((imageSize, imageSize))
    checkerBoardAG = numpy.ones((imageSize, imageSize))
    #set the RGB values based on the colors passed in during launch
    #CBA, logic=1-->colorB, logic=0-->colorA
    #CBB, logic=1-->colorA, logic=0-->colorB
    #color A, column 1
    checkerBoardAR[checkerBoardLogic == 1] = colorAp[0]
    checkerBoardAG[checkerBoardLogic == 1] = colorAp[1]
    checkerBoardAB[checkerBoardLogic == 1] = colorAp[2]
    checkerBoardAR[checkerBoardLogic == 0] = colorBp[0]
    checkerBoardAG[checkerBoardLogic == 0] = colorBp[1]
    checkerBoardAB[checkerBoardLogic == 0] = colorBp[2]
    #now add in the background color around the widest ring
    #    imageMask=numpy.ones((imageSize,imageSize))
    #   imageMask[r>halfSize]=-1
    print(colorBG)
    print(colorBGf)
    print(colorBGp)
    checkerBoardAR[r > halfSize] = colorBGp[0]
    checkerBoardAG[r > halfSize] = colorBGp[1]
    checkerBoardAB[r > halfSize] = colorBGp[2]
    #smoosh the arrays together
    checkerBoardA[:, :, 0] = checkerBoardAR
    checkerBoardA[:, :, 1] = checkerBoardAG
    checkerBoardA[:, :, 2] = checkerBoardAB

    checkerBoardB = numpy.ones((imageSize, imageSize, 3))
    checkerBoardBR = numpy.ones((imageSize, imageSize))
    checkerBoardBB = numpy.ones((imageSize, imageSize))
    checkerBoardBG = numpy.ones((imageSize, imageSize))
    checkerBoardBR[checkerBoardLogic == 1] = colorBp[0]
    checkerBoardBG[checkerBoardLogic == 1] = colorBp[1]
    checkerBoardBB[checkerBoardLogic == 1] = colorBp[2]
    checkerBoardBR[checkerBoardLogic == 0] = colorAp[0]
    checkerBoardBG[checkerBoardLogic == 0] = colorAp[1]
    checkerBoardBB[checkerBoardLogic == 0] = colorAp[2]
    checkerBoardBR[r > halfSize] = colorBGp[0]
    checkerBoardBG[r > halfSize] = colorBGp[1]
    checkerBoardBB[r > halfSize] = colorBGp[2]
    checkerBoardB[:, :, 0] = checkerBoardBR
    checkerBoardB[:, :, 1] = checkerBoardBG
    checkerBoardB[:, :, 2] = checkerBoardBB

    #    numpy.savetxt('chAr.txt',checkerBoardA[:,:,0],fmt='%f')
    #    numpy.savetxt('chAg.txt',checkerBoardA[:,:,1],fmt='%f')
    #    numpy.savetxt('chAb.txt',checkerBoardA[:,:,2],fmt='%f')
    #    numpy.savetxt('chBr.txt',checkerBoardB[:,:,0],fmt='%f')
    #    numpy.savetxt('chBg.txt',checkerBoardB[:,:,1],fmt='%f')
    #    numpy.savetxt('chBb.txt',checkerBoardB[:,:,2],fmt='%f')
    #finally, create the image textures!!
    #oooh, these are fun--tiles the checkerboards!
    #stimA=visual.GratingStim(winSub,tex=checkerBoardA,size=imageSize)
    #stimB=visual.GratingStim(winSub,tex=checkerBoardB,size=imageSize)
    stimA = visual.GratingStim(winSub,
                               tex=checkerBoardA,
                               size=imageSize,
                               sf=1 / imageSize,
                               units='pix',
                               texRes=imageSize)
    stimB = visual.GratingStim(winSub,
                               tex=checkerBoardB,
                               size=imageSize,
                               sf=1 / imageSize,
                               units='pix')

    ReverseFreq = flickFreq  #drift in Hz.

    #make a fixation cross which will rotate 45 deg on occasion
    fix0 = visual.Circle(winSub,
                         radius=IR / 2.0,
                         edges=32,
                         lineColor=gray,
                         lineColorSpace='rgb',
                         fillColor=gray,
                         fillColorSpace='rgb',
                         autoLog=False)
    fix1 = visual.ShapeStim(winSub,
                            pos=[0.0, 0.0],
                            vertices=((0.0, -0.2), (0.0, 0.2)),
                            lineWidth=3.0,
                            lineColor=black,
                            lineColorSpace='rgb',
                            fillColor=black,
                            fillColorSpace='rgb',
                            autoLog=False)

    fix2 = visual.ShapeStim(winSub,
                            pos=[0.0, 0.0],
                            vertices=((-0.2, 0.0), (0.2, 0.0)),
                            lineWidth=3.0,
                            lineColor=black,
                            lineColorSpace='rgb',
                            fillColor=black,
                            fillColorSpace='rgb',
                            autoLog=False)

    #stim.setOri(t*rotationRate*360.0)
    #stim.setRadialPhase(driftRate,'+')
    #stim.setPos()#something here
    msg1x = visual.TextStim(winSub,
                            pos=[0, +8],
                            text='flickering checkerboard')
    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 + becomes an X.',
                            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
    while thisKey == None:
        thisKey = event.waitKeys(
            keyList=['r', 'g', 'b', 'y', '1', '2', '3', '4', 'q', 'escape'])
    if thisKey in ['q', 'escape']:
        core.quit()  #abort
    else:
        event.clearEvents()
#    while len(event.getKeys())==0:
#        core.wait(0.05)
#    event.clearEvents()
#    msg1=visual.TextStim(winSub,pos=[0,+0.1],text='Waiting for magnet....',color=[-1,1,-1],colorSpace='rgb',height=0.1,units='norm')
#    msg1=visual.TextStim(winSub,text='Waiting for magnet....',height=10)
#    msg1=visual.TextStim(operatorWindow,pos=[0,-3],text='Subject: wait.',color=[1,-1,-1],colorSpace='rgb')
#    fix0.draw()
#    fix1.draw()
#    fix2.draw()
#    msg1.draw()
#    winSub.flip()
    msg1a = visual.TextStim(winSub, pos=[0, +5], text='   ', height=1)
    msg1b = visual.TextStim(winSub,
                            pos=[0, +2],
                            text='Waiting for magnet',
                            height=1)
    #msg1c=visual.TextStim(winSub,pos=[0,-3],text='Subject: Hit a key when ready.',color=[1,-1,-1],colorSpace='rgb')
    msg1c.draw()
    msg1a.draw()
    msg1b.draw()
    fix0.draw()
    fix1.draw()
    fix2.draw()
    winSub.flip()

    #wait for trigger
    trig = None
    while trig == None:
        #wait for trigger "keypress"
        trig = event.waitKeys(keyList=['t', '5', 'q', 'escape'])
    if trig in ['q', 'escape']:
        core.quit()
    else:  #stray key
        event.clearEvents()

    #start the timer
    scanTimer = core.Clock()
    startTime = scanTimer.getTime()

    #draw the fixation point
    #    wedge1.draw()
    fix0.draw()
    fix1.draw()
    fix2.draw()
    winSub.flip()
    # and drift it
    timeNow = scanTimer.getTime()
    #row=1
    msg = visual.TextStim(operatorWindow,
                          units='pix',
                          text='t = %.3f' % timeNow,
                          pos=(0.0, 325.0),
                          height=30)
    msg.draw()
    loopCounter = 0
    restLoopCounter = 0
    TrCounter = 0
    if timeBase == 0:
        ttp = TrCounter + 1
        msgTr = visual.TextStim(operatorWindow,
                                units='pix',
                                pos=(0.0, 275.0),
                                text='Tr = %i' % ttp,
                                height=30)
        msgTr.draw()
#    msgPC = visual.TextStim(operatorWindow,units='pix',text = 'percent correct',pos=(0.0,0.0),height=30)
#    msgPC.draw()
#    msgTC = visual.TextStim(operatorWindow,units='pix',text = 'time since correct',pos=(0.0,-75.0),height=30)
#    msgTC.draw()
    plotLabel1.draw()
    plotLabel2.draw()
    plotLabel3.draw()
    plotLabel4.draw()

    fixTimer = core.Clock()
    respTimer = core.Clock()
    flickerTimer = core.Clock()

    fixOri = 0
    numCoins = 0
    event.clearEvents()
    for key in event.getKeys():
        if key in ['q', 'escape']:
            core.quit()
        elif key in ['r', 'g', 'b', 'y', '1', '2', '3', '4'
                     ] and respTimeCheck < respDuration:
            subjectResponse[numCoins] = 1
    if timeBase == 1:
        #time based loop advancement
        respCounter = 0
        #display rest for pre-scan duration
        while timeNow < scanDict['preScanRest']:
            timeNow = scanTimer.getTime()
            #draw fixation
            #every 100 frames, decide if the fixation point should change or not
            if restLoopCounter % 100 == 0 and restLoopCounter > 10:
                #flip a coin to decide
                flipCoin = numpy.random.ranf()
                if flipCoin < fixPercentage:
                    #reset timers/change ori
                    fixOri = 45
                    fixTimer.reset()
                    respTimer.reset()
                    numCoins += 1
                    subjectResponse[numCoins] = 0
                #store info--expected response or not?
                respCounter += 1
                subRespArray[respCounter, 0] = timeNow
                subRespArray[respCounter, 1] = flipCoin < fixPercentage
            fixTimeCheck = fixTimer.getTime()
            respTimeCheck = respTimer.getTime()
            if fixTimeCheck > fixDuration:  #timer expired--reset ori
                fixOri = 0

            fix1.setOri(fixOri)
            fix2.setOri(fixOri)
            fix0.draw()
            fix1.draw()
            fix2.draw()
            msg.setText('t = %.3f' % timeNow)
            msg.draw()
            winSub.flip()
            operatorWindow.flip()
            for key in event.getKeys():
                if key in ['q', 'escape']:
                    core.quit()
                elif key in ['r', 'g', 'b', 'y', '1', '2', '3', '4'
                             ] and respTimeCheck < respDuration:
                    subjectResponse[numCoins] = 1
                    plotResp[numCoins] = 1
                    subRespArray[respCounter, 2] = 1
#                elif key in ['t']:
#increment loop count for each trigger
#update the operator graph
#determine response correctness and append to plot vertices variable
            plotResp[respCounter, 0] = respCounter
            if subRespArray[respCounter, 1] == 1 and subRespArray[respCounter,
                                                                  2] == 1:
                #exp resp and got resp--correct and awake
                plotResp[respCounter, 1] = 500
                plotColors[respCounter, 0] = -1
                plotColors[respCounter, 1] = 1
                plotColors[respCounter, 2] = -1
#                 plotResp=numpy.append(plotResp,[[respCounter,500]],0)
#opPlotRight.setLineColor([-1,1,-1])
            elif subRespArray[respCounter,
                              1] == 1 and subRespArray[respCounter, 2] == 0:
                #exp response, got NONE--wrong!
                plotResp[respCounter, 1] = 100
                plotColors[respCounter, 0] = 1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = -1
#                 plotRespWrong=numpy.append(plotRespWrong,[[respCounter,200]],0)
#opPlotRight.setLineColor([1,-1,-1])
            elif subRespArray[respCounter,
                              1] == 0 and subRespArray[respCounter, 2] == 1:
                #exp NONE, got response--wrong, but awake at least
                plotResp[respCounter, 1] = 150
                plotColors[respCounter, 0] = 1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = -1
#                plotRespWrong=numpy.append(plotRespWrong,[[respCounter,250]],0)
#opPlotRight.setLineColor([1,-1,-1])
            elif subRespArray[respCounter,
                              1] == 0 and subRespArray[respCounter, 2] == 0:
                #exp none, got NONE--correct, but uninformative
                plotResp[respCounter, 1] = 400
                plotColors[respCounter, 0] = -1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = 1
#                plotResp=numpy.append(plotResp,[[respCounter,450]],0)
#opPlotRight.setLineColor([-1,1,-1])
#update the vertices
            plotLabel1.draw()
            plotLabel2.draw()
            plotLabel3.draw()
            plotLabel4.draw()
            opPlotGrid.draw()
            #plot only the last 10==do hijinks for n<10
            plotStart = respCounter - 10
            if plotStart < 0:
                plotStart == 0
            opPlot.setXYs(plotResp[plotStart:respCounter])
            opPlot.setColors(plotColors)
            opPlot.draw()
            restLoopCounter += 1
#            if restLoopCounter%300 and restLoopCounter>5:
#                plt.plot(plotResp[0:numCoins+1],'ro')
#                plt.draw

#pre-scan rest is done.
#prepare for looping through the cycles
        epochTimer = core.Clock()

        #time based looping through stimulus
        while timeNow < startTime + scanLength:  #loop for scan duration
            timeBefore = timeNow
            timeNow = scanTimer.getTime()
            deltaT = timeNow - startTime
            deltaTinc = timeNow - timeBefore

            #every 100 frames, decide if the fixation point should change or not
            if loopCounter % 100 == 0 and loopCounter > 10:
                #flip a coin to decide
                flipCoin = numpy.random.ranf()
                if flipCoin < fixPercentage:
                    #reset timers/change ori
                    fixOri = 45
                    fixTimer.reset()
                    respTimer.reset()
                    numCoins += 1
                    subjectResponse[numCoins] = 0
                    plotResp[numCoins] = 1
                #store info--expected response or not?
                respCounter += 1
                subRespArray[respCounter, 0] = timeNow
                subRespArray[respCounter, 1] = flipCoin < fixPercentage
            fixTimeCheck = fixTimer.getTime()
            respTimeCheck = respTimer.getTime()
            if fixTimeCheck > fixDuration:  #timer expired--reset ori
                fixOri = 0

            fix1.setOri(fixOri)
            fix2.setOri(fixOri)

            # alternate between stimulus and rest, starting with pre-scan duration of rest
            epochTime = epochTimer.getTime()
            #half-period  epoch of stimulus
            radialPhase = nowTime
            oriAngle = nowTime / 360.0
            if epochTime < scanDict['period'] / 2.0:
                #alternate wedge 1&2 at flicker rate
                flickerTimeCheck = flickerTimer.getTime()
                if flickerTimeCheck < 1 / (2.0 * ReverseFreq):
                    #first half of a period, show wedge 1
                    #image1.draw()
                    stimA.setPhase(radialPhase)
                    stimA.draw()
                elif flickerTimeCheck < 1 / ReverseFreq:
                    #second half of period, show wedge 2
                    #                image2.draw()
                    stimB.setPhase(radialPhase)
                    stimB.draw()
                else:
                    #clocked over, reset timer
                    #could also do some modulus of timing
                    flickerTimer.reset()
                fix0.draw()
                fix1.draw()
                fix2.draw()
            elif epochTime < scanDict['period']:
                #half-period epoch of rest
                fix0.draw()
                fix1.draw()
                fix2.draw()
            else:
                epochTimer.reset()

            msg.setText('t = %.3f' % timeNow)
            msg.draw()
            operatorWindow.flip()
            winSub.flip()
            #row+=1
            #core.wait(3.0/60.0)

            #count number of keypresses since previous frame, break if non-zero
            for key in event.getKeys():
                if key in ['q', 'escape']:
                    core.quit()
                elif key in ['r', 'g', 'b', 'y', '1', '2', '3', '4'
                             ] and respTimeCheck < respDuration:
                    subjectResponse[numCoins] = 1
                    subRespArray[respCounter, 2] = 1
#            if loopCounter%300 and loopCounter>5:
#                plt.plot(plotResp[0:numCoins+1],'ro')
#                plt.draw

#update the operator graph
#determine response correctness and append to plot vertices variable
            plotResp[respCounter, 0] = respCounter
            #print subRespArray[respCounter,1:2]
            if subRespArray[respCounter, 1] == 1 and subRespArray[respCounter,
                                                                  2] == 1:
                #exp resp and got resp--correct and awake
                plotResp[respCounter, 1] = 500
                #print('exp resp, got resp')
                #print plotResp[respCounter,1]
                plotColors[respCounter, 0] = -1
                plotColors[respCounter, 1] = 1
                plotColors[respCounter, 2] = -1
#                 plotResp=numpy.append(plotResp,[[respCounter,500]],0)
#opPlotRight.setLineColor([-1,1,-1])
            elif subRespArray[respCounter,
                              1] == 1 and subRespArray[respCounter, 2] == 0:
                #exp response, got NONE--wrong!
                plotResp[respCounter, 1] = 100
                #print('exp resp, got none')
                #print plotResp[respCounter,1]
                plotColors[respCounter, 0] = 1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = -1
#                 plotRespWrong=numpy.append(plotRespWrong,[[respCounter,200]],0)
#opPlotRight.setLineColor([1,-1,-1])
            elif subRespArray[respCounter,
                              1] == 0 and subRespArray[respCounter, 2] == 1:
                #exp NONE, got response--wrong, but awake at least
                plotResp[respCounter, 1] = 150
                #print('exp none, got one')
                #print plotResp[respCounter,1]
                plotColors[respCounter, 0] = 1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = -1
#                plotRespWrong=numpy.append(plotRespWrong,[[respCounter,250]],0)
#opPlotRight.setLineColor([1,-1,-1])
            elif subRespArray[respCounter,
                              1] == 0 and subRespArray[respCounter, 2] == 0:
                #exp none, got NONE--correct, but uninformative
                plotResp[respCounter, 1] = 400
                #print('exp none, got none')
                #print plotResp[respCounter,1]
                plotColors[respCounter, 0] = -1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = 1
#                plotResp=numpy.append(plotResp,[[respCounter,450]],0)
#opPlotRight.setLineColor([-1,1,-1])
#update the vertices
            plotLabel1.draw()
            plotLabel2.draw()
            plotLabel3.draw()
            plotLabel4.draw()
            opPlotGrid.draw()
            opPlot.setXYs(plotResp)
            opPlot.setColors(plotColors)
            opPlot.draw()
            loopCounter += 1

    else:  #trigger based
        #loop through, presenting stim or rest according to designMatrix
        TrCounter = 0
        loopCounter = 0
        respCounter = 0
        numFlips = 0
        #WORKING HERE
        #trigger based loop advancement
        #wait for trigger until N triggers found
        while TrCounter < numTr:
            #update times
            timeNow = scanTimer.getTime()
            timeBefore = timeNow
            timeNow = scanTimer.getTime()
            deltaT = timeNow - startTime
            deltaTinc = timeNow - timeBefore

            #organize fixation point orientation
            #every 100 frames, decide if the fixation point should change or not
            debugVar[loopCounter, 0] = loopCounter
            if loopCounter % 50 == 0 and loopCounter > 10:
                #flip a coin to decide
                flipCoin = numpy.random.ranf()
                numFlips += 1
                if flipCoin < fixPercentage:
                    #reset timers/change ori
                    fixOri = 45
                    fixTimer.reset()
                    respTimer.reset()
                    numCoins += 1
                    subjectResponse[numCoins] = 0
                #store info--expected response or not?
                respCounter += 1
                subRespArray[respCounter, 0] = timeNow
                subRespArray[respCounter, 1] = flipCoin < fixPercentage
            fixTimeCheck = fixTimer.getTime()
            respTimeCheck = respTimer.getTime()
            if fixTimeCheck > fixDuration:  #timer expired--reset ori
                fixOri = 0

            debugVar[loopCounter, 1] = fixOri
            fix1.setOri(fixOri)
            fix2.setOri(fixOri)

            #draw stim or rest, based on designMatrix
            # alternate between stimulus and rest, starting with pre-scan duration of rest
            if designMatrix[TrCounter] == 1:
                #alternate wedge 1&2 at flicker rate
                flickerTimeCheck = flickerTimer.getTime()
                if flickerTimeCheck < 1 / (2.0 * ReverseFreq):
                    #first half of a period, show wedge 1
                    #image1.draw()
                    stimA.draw()
                elif flickerTimeCheck < 1 / ReverseFreq:
                    #second half of period, show wedge 2
                    #                image2.draw()
                    stimB.draw()
                else:
                    #clocked over, reset timer
                    #could also do some modulus of timing
                    flickerTimer.reset()
                fix0.draw()
                fix1.draw()
                fix2.draw()
            else:
                #rest
                fix0.draw()
                fix1.draw()
                fix2.draw()

            #count number of keypresses since previous frame,
            TrDone = 0
            for key in event.getKeys():
                if key in ['q', 'escape']:
                    core.quit()
                elif key in ['r', 'g', 'b', 'y', '1', '2', '3', '4'
                             ] and respTimeCheck < respDuration:
                    subjectResponse[numCoins] = 1
                    subRespArray[respCounter, 2] = 1
                elif key in ['t'] and TrDone == 0:
                    #increment loop count for each trigger
                    TrCounter += 1
                    TrDone = 1
            #update the operator graph
            #determine response correctness and append to plot vertices variable
            plotResp[respCounter, 0] = respCounter
            if subRespArray[respCounter, 1] == 1 and subRespArray[respCounter,
                                                                  2] == 1:
                #exp resp and got resp--correct and awake
                plotResp[respCounter, 1] = 500
                plotColors[respCounter, 0] = -1
                plotColors[respCounter, 1] = 1
                plotColors[respCounter, 2] = -1
#                 plotResp=numpy.append(plotResp,[[respCounter,500]],0)
#opPlotRight.setLineColor([-1,1,-1])
            elif subRespArray[respCounter,
                              1] == 1 and subRespArray[respCounter, 2] == 0:
                #exp response, got NONE--wrong!
                plotResp[respCounter, 1] = 100
                plotColors[respCounter, 0] = 1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = -1
#                 plotRespWrong=numpy.append(plotRespWrong,[[respCounter,200]],0)
#opPlotRight.setLineColor([1,-1,-1])
            elif subRespArray[respCounter,
                              1] == 0 and subRespArray[respCounter, 2] == 1:
                #exp NONE, got response--wrong, but awake at least
                plotResp[respCounter, 1] = 150
                plotColors[respCounter, 0] = 1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = -1
#                plotRespWrong=numpy.append(plotRespWrong,[[respCounter,250]],0)
#opPlotRight.setLineColor([1,-1,-1])
            elif subRespArray[respCounter,
                              1] == 0 and subRespArray[respCounter, 2] == 0:
                #exp none, got NONE--correct, but uninformative
                plotResp[respCounter, 1] = 400
                plotColors[respCounter, 0] = -1
                plotColors[respCounter, 1] = -1
                plotColors[respCounter, 2] = 1
#                plotResp=numpy.append(plotResp,[[respCounter,450]],0)
#opPlotRight.setLineColor([-1,1,-1])
#update the vertices
            plotLabel1.draw()
            plotLabel2.draw()
            plotLabel3.draw()
            plotLabel4.draw()
            opPlotGrid.draw()
            opPlot.setXYs(plotResp)
            opPlot.setColors(plotColors)
            opPlot.draw()
            #            opPlotWrong.setVertices(plotRespWrong)
            #            opPlotWrong.draw()
            #update the operator on the last 10 responses
            #            if numCoins>9:
            #                findResp = subjectResponse[~numpy.isnan(subjectResponse)]
            #                calcResp=findResp[findResp==1]
            #                numCorrect=float(calcResp.shape[0])
            #                percentCorrect=float(numCorrect)/(float(findResp.shape[0]))
            #                timeLastCor=subRespArray[-1,0]
            #                timeSinceCor=timeNow-timeLastCor
            #                msgTextPC='Last 10 fixation tasks, percent correct: %.1f' %(percentCorrect)
            ##                msgTextTC='time since last correct response: %f' %(timeSinceCor)
            #                msgPC.setText(msgTextPC)
            ##                msgTC.setText(msgTextTC)
            #                msgPC.draw()
            ##                msgTC.draw()
            msg.setText('t = %.3f' % timeNow)
            ttp = TrCounter + 1
            msgTr.setText('Tr = %i' % ttp)
            msg.draw()
            msgTr.draw()
            operatorWindow.flip()
            winSub.flip()
            #row+=1
            #core.wait(3.0/60.0)

            #update plot once per 3Tr
            #            if TrCounter%3==0 and TrCounter>1:
            #                plt.plot(plotResp[0:numFlips+1],'ro')
            #                plt.draw
            #plt.draw()
            #            if numCoins>2:
            #                #calculate correct percentage
            #                findResp=subjectResponse[~numpy.isnan(subjectResponse)]
            #                calcResp=findResp[findResp==1]
            #                numCorrect=float(calcResp.shape[0])
            #                percentCorrect=float(numCorrect)/(float(numCoins))
            #                timeLastCor=subRespArray[len(calcResp),0]
            #                timeSinceCor=timeNow-timeLastCor
            #                msgText='Subject responses: %f correct' %(percentCorrect,)
            #                msgText2='Time since last correct response: %f s' %(timeSinceCor,)
            #                msg4.setText(msgText)
            #                msg4.draw()
            #                msg5.setText(msgText2)
            #                msg5.draw()
            #                msg.draw()
            #                msgTr.draw()
            #                operatorWindow.flip()
            #                print msgText
            #                print msgText2

            loopCounter += 1

    #core.wait(5.0)
    #outFile = open("debug.txt","w")
    #outFile.write(str(debugVar))
    #outFile.close()
    #numpy.savetxt('debug.txt',debugVar,fmt='%.3f')
    #numpy.savetxt('debug.txt',designMatrix,fmt='%.3i')
    #numpy.savetxt('debugchop.txt',debugVar[:row,],fmt='%.3f')

    #calculate %age of responses that were correct
    #find non-nan
    #np.isnan(a) gives boolean array of true/a=false
    #np.isnan(a).any(1) gives a col vector of the rows with nans
    #~np.isnan(a).any(1) inverts the logic
    #myarray[~np.isnan(a).any(1)] gives the subset that I want
    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, )
    msg1 = visual.TextStim(winSub, pos=[0, +3], text=msgText)
    msg1.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 = 'isolumResponse%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)
    winSub.close()
    operatorWindow.close()
Esempio n. 50
0
# Experiment session GUI dialog
#------------------------------

#get values from dialog
my_dlg = gui.Dlg(title=exp_name, pos=(860, 340))
my_dlg.addField(label='id', initial=0, tip='Participant name or code'),
my_dlg.addField(label='age', initial=0, tip='Participant age'),
my_dlg.addField(label='gender',
                choices=('female', 'male', 'Other/Prefer no to say'))
my_dlg.addField(label='screen', choices=(60, 144), tip='Refresh Rate')
my_dlg.addField(label='triggers',
                initial='No',
                choices=['Yes', 'No'],
                tip='Send EEG Triggers')
dlg_data = my_dlg.show()
if my_dlg.OK == False: core.quit()  #user pressed cancel

#store values from dialog
exp_info = {
    'id': dlg_data[0],
    'age': dlg_data[1],
    'gender': dlg_data[2],
    'screen': dlg_data[3],
    'triggers': dlg_data[4]
}

exp_info['date'] = data.getDateStr()  #get a simple timestamp for filename
exp_info['exp_name'] = exp_name

#-----------------------
#setup files for saving
Esempio n. 51
0
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()
Esempio n. 52
0
def context_binding(subject_stim, context_bind_items, count):
    encoding_pres_items = subject_stim[subject_stim['Part'] == 'encoding']

    temp_instr = visual.TextStim(win, instr[16], color='black', pos=[0, 0])
    temp_instr.draw()
    win.update()
    event.waitKeys(keyList=['space'])
    win.flip()

    random.shuffle(character_list)
    for character in character_list:
        if event.getKeys(['escape']):
            win.close()
            core.quit()
        subject_stim['Scene'].iloc[n].split('_')[0]
        items_already_pres = subject_stim['Item'].tolist(
        ) + subject_stim['Lure_1'].tolist() + subject_stim['Lure_2'].tolist()

        # Get two random category lures
        cb_items = random.sample(
            encoding_pres_items[encoding_pres_items['Character'] == character]
            ['Item'].tolist(), 3)
        # Get lure items that were not presented during encoding and set random color
        scene_cb = encoding_pres_items[encoding_pres_items['Item'] ==
                                       cb_items[0]]['Scene'].iloc[0]
        target_cb = encoding_pres_items[encoding_pres_items['Item'] ==
                                        cb_items[0]][[
                                            'Item', 'Color'
                                        ]].iloc[0].str.cat(sep='_')
        lure1_cb = encoding_pres_items[encoding_pres_items['Item'] ==
                                       cb_items[1]][[
                                           'Item', 'Color'
                                       ]].iloc[0].str.cat(sep='_')
        lure2_cb = encoding_pres_items[encoding_pres_items['Item'] ==
                                       cb_items[2]][[
                                           'Item', 'Color'
                                       ]].iloc[0].str.cat(sep='_')
        context_bind_items = context_bind_items + [
            target_cb.rsplit('_', 1)[0],
            lure1_cb.rsplit('_', 1)[0],
            lure2_cb.rsplit('_', 1)[0]
        ]
        subject_stim.loc[count, 'Part'] = 'context_binding'
        subject_stim.loc[count, 'Character'] = character
        subject_stim.loc[count, 'Scene'] = scene_cb
        subject_stim.loc[count, 'Item'] = target_cb.rsplit('_', 1)[0]
        subject_stim.loc[count, 'Color'] = target_cb.rsplit('_', 1)[1]
        subject_stim.loc[count, 'Lure_1'] = lure1_cb
        subject_stim.loc[count, 'Lure_2'] = lure2_cb

        # Present stimuli
        scene_stim = Image.open(scene_dir + scene_cb + '.png')
        lure1_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(lure1_cb + '.png')
        ][0])
        lure2_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(lure2_cb + '.png')
        ][0])
        target_stim = Image.open(item_dir + character + '/' + [
            i for i in os.listdir(item_dir + character + '/')
            if i.startswith(target_cb + '.png')
        ][0])
        char_stim.thumbnail(item_size, Image.ANTIALIAS)
        lure1_stim.thumbnail(item_size, Image.ANTIALIAS)
        lure2_stim.thumbnail(item_size, Image.ANTIALIAS)
        target_stim.thumbnail(item_size, Image.ANTIALIAS)
        stim_pos = [[-0.5, -0.6], [0, -0.6], [0.5, -0.6]]
        random.shuffle(stim_pos)
        scene_pres = visual.ImageStim(win, scene_stim, pos=[0, 0.35])
        lure1_pres = visual.ImageStim(win, lure1_stim, pos=stim_pos[0])
        lure2_pres = visual.ImageStim(win, lure2_stim, pos=stim_pos[1])
        target_pres = visual.ImageStim(win, target_stim, pos=stim_pos[2])

        scene_pres.draw()
        lure1_pres.draw()
        lure2_pres.draw()
        target_pres.draw()
        win.update()
        timer.reset()

        # Record response and give feedback
        while True:
            if mouse.isPressedIn(target_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = target_cb
                break
            elif mouse.isPressedIn(lure1_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = lure1_cb
                break
            elif mouse.isPressedIn(lure2_pres):
                subject_stim.loc[count, 'Reaction_Time'] = timer.getTime()
                subject_stim.loc[count, 'Answer'] = lure2_cb
                break
        win.update()
        win.flip()
        fix_pres = scene_pres = visual.ImageStim(win, fixation, pos=[0, 0])
        fix_pres.draw()
        win.update()
        core.wait(time_fixcr)
        win.flip()
        subject_stim.to_csv(save_subj_file_name)
        count = count + 1

    return subject_stim, context_bind_items, count
Esempio n. 53
0
pauseClock = core.Clock()

######################################################################################################

#####################  Routine "iViewX_Connect"

# routine_helper
comps = []
iview_connect_clock = core.Clock()
routine_helper = RoutineHelper(win, comps)
routine_helper.reset_components()

while routine_helper.get_status():
    if not routine_helper.get_status(): break
    routine_helper.set_status(False)
    if event.getKeys(keyList=conf_escape_keys): core.quit()
    if routine_helper.get_status(): win.flip()

routine_helper.end_components()  # end components
routineTimer.reset()  # reset the non-slip timer

######################################################################################################

#####################  Trials loop setup

# set up handler to look after randomisation of conditions etc
trials = data.TrialHandler(nReps=conf_total_trials,
                           method='random',
                           extraInfo=expInfo,
                           originPath=-1,
                           trialList=[None],
Esempio n. 54
0
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']]
        imagepath = os.path.join(expdir, 'Images')
        image = os.path.join(imagepath, "%s.png") % condition_label
        pictureStim.setImage(image)

        #decision phase
        timer.reset()
        event.clearEvents()

        decision_onset = globalClock.getTime()
        trials.addData('decision_onset', decision_onset)

        #while timer.getTime() < decision_dur:
        while timer.getTime() < 1:
            partner_offer = trial['Offer']
            partnerOffer = 'Proposal: $%s.00 out of $20.00' % partner_offer
            offer_text.setText(partnerOffer)
            offer_text.draw()
            offer_text.draw()
            pictureStim.draw()
            win.flip()

        resp_val = None
        resp_onset = None

        while timer.getTime() < (decision_dur):
            resp_text_accept.draw()
            resp_text_reject.draw()
            pictureStim.draw()
            offer_text.setText(partnerOffer)
            offer_text.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])
                resp_onset = globalClock.getTime()
                rt = resp_onset - decision_onset
                if resp_val == 2:
                    resp_text_reject.setColor('darkorange')
                if resp_val == 3:
                    resp_text_accept.setColor('darkorange')
                resp_text_accept.draw()
                resp_text_reject.draw()
                pictureStim.draw()
                offer_text.setText(partnerOffer)
                offer_text.draw()
                win.flip()
                core.wait((decision_dur - rt) + .5)
                decision_offset = globalClock.getTime()
                break
            else:
                resp_val = 999
                rt = 999
                resp_onset = 999
                outcome_txt = outcome_map[resp_val]
                decision_offset = globalClock.getTime()

        trials.addData('resp', resp_val)
        trials.addData('rt', rt)
        trials.addData('resp_onset', resp_onset)
        trials.addData('decision_offset', decision_offset)
        #win.flip()

        timer.reset()
        if resp_val == 999:
            outcome_stim.setText(outcome_txt)
            outcome_stim.draw()
            win.flip()
            missFB_onset = globalClock.getTime()
            core.wait(.5)
            missFB_offset = globalClock.getTime()

        #reset rating number color
        resp_text_accept.setColor('#FFFFFF')
        resp_text_reject.setColor('#FFFFFF')

        trial_offset = globalClock.getTime()
        duration = trial_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'])
        fixation.draw()
        win.flip()
        core.wait(iti_for_trial)
        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)

    #trials.saveAsText(fileName=log_file.format(subj_id),delim=',',dataOut='all_raw')
    os.chdir(subjdir)
    trials.saveAsWideText(fileName)
    os.chdir(expdir)
    if globalClock.getTime() < 408:
        #10 seconds above what task is clocking in at
        endTime = (408 - globalClock.getTime())
    else:
        endTime = 10
    core.wait(endTime)
    print globalClock.getTime()
Esempio n. 55
0
def setupExperiment():
    from psychopy import gui
    """
    Setup the experimental variables with a dialog box
    """
    dlgMonitor, monitorInfo = setup_monitor()

    expInfo = {
        'Partecipant': 'Subj',
        'Subject code': '00',
        'SquareEdge': 6,
        'BallRadius': 0.5,
        'BlinkTime': 3,
        'TrainingTrials': 0,
        'SaveVideo': False
    }

    dlg = gui.DlgFromDict(dictionary=expInfo,
                          title='Flicker Experiment',
                          order=[
                              'Partecipant',
                              'Subject code',
                              'SquareEdge',
                              'BallRadius',
                              'BlinkTime',
                              'TrainingTrials',
                          ],
                          tip={
                              'Partecipant Name':
                              'Name of the participant',
                              'Subject code':
                              'Code of the subject',
                              'SquareEdge':
                              'Length of the virtual square edge',
                              'BallRadius':
                              'Radius of the balls in cm',
                              'BlinkTime':
                              'Time of white/black ball blinking in seconds',
                              'TrainingTrials':
                              'Number of preparation training trials',
                          })

    if not dlg.OK:
        core.quit()  # user pressed cancel

    # nUp is the number of incorrect (or 0) responses before the staircase level increases.
    # nDown is the number of correct (or 1) responses before the staircase
    # level decreases.
    staircaseInfo = {
        'StepType': ['lin', 'db', 'log'],
        'Selection': ['random', 'sequential'],
        'MinReversals': 6,
        'MinTrials': 10,
        'FlickerFreqLeft': 10.0,
        'FlickerFreqRight': 10.0,
        'StepSizes': '[0.5,0.25]',
        'nUpLeft': 1,
        'nUpRight': 1,
        'nDownLeft': 1,
        'nDownRight': 1,
        'AverageReversals': 3
    }

    dlgStaircase = gui.DlgFromDict(dictionary=staircaseInfo,
                                   title='Staircase procedure')

    if not dlgStaircase.OK:
        core.quit()

    outputfile = set_output_file(expInfo, 'flicker_')
    save_experimental_settings(outputfile + '_info.pickle', expInfo,
                               staircaseInfo, monitorInfo)

    return expInfo, staircaseInfo, outputfile, monitorInfo
Esempio n. 56
0
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;
from numpy.random import random, randint, normal, shuffle
import random
import os  # Handy system and path functions
import sys  # to get file system encoding

# Ensure that relative paths start from the same directory as this script
_thisDir = (os.path.dirname(os.path.abspath(__file__)).decode(
    sys.getfilesystemencoding()))
os.chdir(_thisDir)

# Store info about the experiment session
expName = 'PDR_script'  # From the Builder filename that created this script
expInfo = {'participant': '', 'session': ''}
dlg = gui.DlgFromDict(dictionary=expInfo, title=expName)
if dlg.OK == False:
    core.quit()  # User pressed cancel during popout
expInfo['date'] = data.getDateStr()  # Add a simple timestamp
expInfo['expName'] = expName

# Setup the Window
win = visual.Window(size=(1280, 800),
                    fullscr=True,
                    allowGUI=False,
                    monitor='testMonitor',
                    color=[1, 1, 1],
                    useFBO=True)

# store frame rate of monitor if we can measure it
expInfo['frameRate'] = win.getActualFrameRate()

# cueversions = np.repeat([0,1,2,3,4,5],4)                                      # Randomizes assignment of cues for participants, counterbalanced, counterbalanced
Esempio n. 58
0
def flickerTrial(win, experimentalInfo, flickerFreq, side, useOddBall):
    from psychopy import visual, event
    """
    Start the tracking trial
    """
    # Generate the 4 balls as list
    balls = []
    edge = experimentalInfo['SquareEdge']
    # First two balls are left, second two balls are right
    positions = [
        np.array([-edge / 2, -edge / 2]),
        np.array([-edge / 2, edge / 2]),
        np.array([edge / 2, -edge / 2]),
        np.array([edge / 2, edge / 2])
    ]
    for i in range(0, 4):
        balls.append(
            Ball(win,
                 position=positions[i],
                 direction=np.array([0, 0]),
                 speed=0,
                 radius=experimentalInfo['BallRadius'],
                 color='Black'))

    fixationBall = Ball(win,
                        position=np.array([0.0, 0.0]),
                        direction=np.array([0.0, 0.0]),
                        speed=0.0,
                        radius=0.15,
                        color='White')
    oddBallIndex = randrange(0, 4)
    oddBalls = [balls[oddBallIndex]]

    noiseMaskStimuli = []
    for i in range(0, 4):
        noiseMaskStimuli.append(
            visual.GratingStim(win,
                               pos=positions[i],
                               units='cm',
                               tex=np.random.rand(256, 256) * 2.0 - 1.0,
                               mask='circle',
                               size=[
                                   experimentalInfo['BallRadius'] * 2,
                                   experimentalInfo['BallRadius'] * 2
                               ]))

    arrows = [
        visual.TextStim(win, "-->", pos=[0, 0]),
        visual.TextStim(win, "<--", pos=[0, 0])
    ]
    # Initialize a color for the balls
    for ball in balls:
        ball.setColor('Black')
        if useOddBall:
            for oddBall in oddBalls:
                oddBall.setColor('White')

    # Draw the arrow cue
    trialClock = core.Clock()
    trialClock.reset()

    sideIndex = (side == 'Left')
    while (trialClock.getTime() < 2.0):
        arrows[sideIndex].draw()
        if (experimentalInfo['SaveVideo']):
            win.getMovieFrame()
        win.flip()

    totalMaskTime = 0.350  # seconds
    totalMaskTimeInFrames = int(round(totalMaskTime * win.measuredFPS))
    for t in range(0, totalMaskTimeInFrames):
        for i in range(0, 4):
            noiseMaskStimuli[i].draw()
        if (experimentalInfo['SaveVideo']):
            win.getMovieFrame()
        win.flip()

    # Here instead of using timers we precompute the number of frames to display for the stimuli, so
    # that the calls to timers are avoided and the program is faster between
    # two flips
    totStimFrames = int(round(experimentalInfo['BlinkTime'] * win.measuredFPS))
    totBlinkFrames = int(round(1.0 / flickerFreq * win.measuredFPS))

    blinkFrame, totBlinks = 0, 0
    times = [None] * totStimFrames
    switchIndices = []
    for t in range(0, totStimFrames):
        fixationBall.draw()
        blinkFrame = blinkFrame + 1
        oldTotBlinks = totBlinks
        if (blinkFrame >= totBlinkFrames):
            blinkFrame = 0
            totBlinks = totBlinks + 1
            if (oldTotBlinks < totBlinks):
                switchIndices.append(t)
                if (totBlinks % 2):
                    for ball in balls:
                        ball.setColor('White')
                    if useOddBall:
                        for oddBall in oddBalls:
                            oddBall.setColor('Black')
                else:
                    for ball in balls:
                        ball.setColor('Black')
                    if useOddBall:
                        for oddBall in oddBalls:
                            oddBall.setColor('White')
        for ball in balls:
            ball.draw()
        if (experimentalInfo['SaveVideo']):
            win.getMovieFrame()
        times[t] = win.flip()

    totalMaskTimeInFrames = int(round(totalMaskTime * win.measuredFPS))
    for t in range(0, totalMaskTimeInFrames):
        for i in range(0, 4):
            noiseMaskStimuli[i].draw()
        if (experimentalInfo['SaveVideo']):
            win.getMovieFrame()
        win.flip()

    times = np.array(times)
    # switchIndices=np.array(switchIndices)
    # switchTimes=np.diff(times[switchIndices])
    # print "Average switch times",np.average(switchTimes),"corresponding to ",1.0/np.average(switchTimes)," [Hz]"
    # print "Average inversion times
    # error=",np.average(switchTimes-1.0/flickerFreq)*1000,"[ms]"

    # Get the subject response
    event.getKeys()
    trialClock = core.Clock()
    trialClock.reset()
    response = None

    while True:
        keys = event.getKeys()
        fixationBall.draw()
        if 's' in keys:
            response = (sideIndex == (oddBallIndex >= 2))
            trialClock.reset()
            break
        if 'd' in keys:
            response = (sideIndex == (oddBallIndex < 2))
            trialClock.reset()
            break
        if 'escape' in keys:
            win.close()
            core.quit()
        if (experimentalInfo['SaveVideo']):
            win.getMovieFrame()
        win.flip()

    print sideIndex, side, oddBallIndex, response

    if (experimentalInfo['SaveVideo']):
        import os
        currentpath = os.getcwd()
        savedatapath = currentpath + os.path.sep + 'data'
        outputVideo = savedatapath + os.path.sep + \
            "frames" + os.path.sep + 'Flicker.png'
        print "Saving video to " + outputVideo
        win.saveMovieFrames(outputVideo)
    return response
Esempio n. 59
0
def end():
    ### end of this exp, disp thank you instr
    end = images['end'][0].draw()
    win.flip()
    event.waitKeys(keyList=['space'])
    core.quit()
Esempio n. 60
0
from numpy.random import random, randint, normal, shuffle
import os  # handy system and path functions
import sys  # to get file system encoding
import csv

# Ensure that relative paths start from the same directory as this script
_thisDir = os.path.dirname(os.path.abspath(__file__))
os.chdir(_thisDir)


# Store info about the experiment session
expName = 'SelfCont'  # from the Builder filename that created this script
expInfo = {'participant':'', 'session':'01'}
dlg = gui.DlgFromDict(dictionary=expInfo, title=expName)
if dlg.OK == False:
    core.quit()  # user pressed cancel
expInfo['date'] = data.getDateStr()  # add a simple timestamp
expInfo['expName'] = expName
endExpNow = False  # flag for 'escape' or other condition => quit the exp
# Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
filename= _thisDir + os.sep + u'SelfCont' + os.sep + '%s_%s' % (expInfo['participant'], expName + ".csv")




####################################################################################################
#                                         Program Constants                                        #
####################################################################################################
# Set psychopy required names for things
EXP_NAME     = "self_control_questionnaire"  # The name of the experiment for save files
MONITOR_NAME = "testMonitor"     # The name of the monitor set in PsychoPy.