psychopy 2025.2.4__py3-none-any.whl

psychopy/demos/coder/experiment control/JND_staircase_analysis.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+This analysis script takes one or more staircase datafiles as input from a GUI
+It then plots the staircases on top of each other on the left
+and a combined psychometric function from the same data
+on the right.
+
+The combined plot uses every unique X value form the staircase, and alters the
+size of the points according to how many trials were run at that level
+"""
+
+from psychopy import data, gui, core
+from psychopy.tools.filetools import fromFile
+import pylab
+import os
+
+# set to 0.5 for Yes/No (or PSE). Set to 0.8 for a 2AFC threshold
+threshVal = 0.5
+
+# set to zero for Yes/No (or PSE). Set to 0.5 for 2AFC
+expectedMin = 0.0
+
+files = gui.fileOpenDlg('.')
+if not files:
+    core.quit()
+
+# get the data from all the files
+allIntensities, allResponses = [], []
+for thisFileName in files:
+    thisDat = fromFile(thisFileName)
+    assert isinstance(thisDat, data.StairHandler)
+    allIntensities.append(thisDat.intensities)
+    allResponses.append(thisDat.data)
+dataFolder = os.path.split(thisFileName)[0]  # just the path, not file name
+
+# plot each staircase in left hand panel
+pylab.subplot(121)
+colors = 'brgkcmbrgkcm'
+lines, names = [], []
+for fileN, thisStair in enumerate(allIntensities):
+    # lines.extend(pylab.plot(thisStair))  # uncomment for a legend for files
+    # names = files[fileN]
+    pylab.plot(thisStair, label=files[fileN])
+# pylab.legend()
+
+# get combined data
+i, r, n = data.functionFromStaircase(allIntensities, allResponses, bins='unique')
+combinedInten, combinedResp, combinedN = i, r, n
+combinedN = pylab.array(combinedN)  # convert to array so we can do maths
+
+# fit curve
+fit = data.FitWeibull(combinedInten, combinedResp, expectedMin=expectedMin,
+    sems=1.0 / combinedN)
+smoothInt = pylab.arange(min(combinedInten), max(combinedInten), 0.001)
+smoothResp = fit.eval(smoothInt)
+thresh = fit.inverse(threshVal)
+print(thresh)
+
+# plot curve
+pylab.subplot(122)
+pylab.plot(smoothInt, smoothResp, 'k-')
+pylab.plot([thresh, thresh], [0, threshVal], 'k--')  # vertical dashed line
+pylab.plot([0, thresh], [threshVal, threshVal], 'k--')  # horizontal dashed line
+pylab.title('threshold (%.2f) = %0.3f' %(threshVal, thresh))
+
+# plot points
+pointSizes = pylab.array(combinedN) * 5  # 5 pixels per trial at each point
+points = pylab.scatter(combinedInten, combinedResp, s=pointSizes,
+    edgecolors=(0, 0, 0), facecolor=(1, 1, 1), linewidths=1,
+    zorder=10,  # make sure the points plot on top of the line
+    )
+
+pylab.ylim([0, 1])
+pylab.xlim([0, None])
+# save a vector-graphics format for future
+outputFile = os.path.join(dataFolder, 'last.pdf')
+pylab.savefig(outputFile)
+print('saved figure to: ' + outputFile)
+pylab.show()
+
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/experiment control/JND_staircase_exp.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Measure your JND in orientation using a staircase method
+"""
+
+from psychopy import core, visual, gui, data, event
+from psychopy.tools.filetools import fromFile, toFile
+import time, numpy
+
+try:  # try to get a previous parameters file
+    expInfo = fromFile('lastParams.pickle')
+except:  # if not there then use a default set
+    expInfo = {'observer':'jwp', 'refOrientation':0}
+dateStr = time.strftime("%b_%d_%H%M", time.localtime())  # add the current time
+
+# present a dialogue to change params
+dlg = gui.DlgFromDict(expInfo, title='simple JND Exp', fixed=['date'])
+if dlg.OK:
+    toFile('lastParams.pickle', expInfo)  # save params to file for next time
+else:
+    core.quit()  # the user hit cancel so exit
+
+# make a text file to save data
+fileName = expInfo['observer'] + dateStr
+dataFile = open(fileName + '.txt', 'w')
+dataFile.write('targetSide	oriIncrement	correct\n')
+
+# create window and stimuli
+globalClock = core.Clock()  # to keep track of time
+trialClock = core.Clock()  # to keep track of time
+win = visual.Window([800, 600], allowGUI=False, monitor='testMonitor', units='deg')
+foil = visual.GratingStim(win, sf=1, size=4, mask='gauss', ori=expInfo['refOrientation'])
+target = visual.GratingStim(win, sf=1,  size=4, mask='gauss', ori=expInfo['refOrientation'])
+fixation = visual.GratingStim(win, color='black', tex=None, mask='circle', size=0.2)
+message1 = visual.TextStim(win, pos=[0, + 3],
+    text='Hit a key when ready.')
+message2 = visual.TextStim(win, pos=[0, -3],
+    text="Then press left or right to identify the %.1fdegree probe." % expInfo['refOrientation'])
+
+# create the staircase handler
+staircase = data.StairHandler(startVal=20.0,
+    stepType='lin',
+    stepSizes=[8, 4, 4, 2, 2, 1, 1],  # reduce step size every two reversals
+    minVal=0, maxVal=90,
+    nUp=1, nDown=3,  # will home in on the 80% threshold
+    nTrials=50)
+
+# display instructions and wait
+message1.draw()
+message2.draw()
+fixation.draw()
+win.flip()
+# check for a keypress
+event.waitKeys()
+
+for thisIncrement in staircase:  # will step through the staircase
+    # set location of stimuli
+    targetSide = round(numpy.random.random()) * 2 - 1  # +1 = right, -1 = left
+    foil.setPos([-5 * targetSide, 0])
+    target.setPos([5 * targetSide, 0])  # in other location
+
+    # set orientation of probe
+    foil.setOri(expInfo['refOrientation'] + thisIncrement)
+
+    # draw all stimuli
+    foil.draw()
+    target.draw()
+    fixation.draw()
+    win.flip()
+
+    core.wait(0.5)  # wait 500ms (use a loop of x frames for more accurate timing)
+
+    # blank screen
+    fixation.draw()
+    win.flip()
+
+    # get response
+    thisResp = None
+    while thisResp is None:
+        allKeys = event.waitKeys()
+        for thisKey in allKeys:
+            if ((thisKey == 'left' and targetSide == -1) or
+                (thisKey == 'right' and targetSide == 1)):
+                thisResp = 1  # correct
+            elif ((thisKey == 'right' and targetSide == -1) or
+                (thisKey == 'left' and targetSide == 1)):
+                thisResp = 0  # incorrect
+            elif thisKey in ['q', 'escape']:
+                core.quit()  # abort experiment
+        event.clearEvents('mouse')  # only really needed for pygame windows
+
+    # add the data to the staircase so it can calculate the next level
+    staircase.addResponse(thisResp)
+    dataFile.write('%i	%.3f	%i\n' % (targetSide, thisIncrement, thisResp))
+
+# staircase has ended
+dataFile.close()
+staircase.saveAsPickle(fileName)  # special python data file to save all the info
+
+# give some output to user
+print('reversals:')
+print(staircase.reversalIntensities)
+print('mean of final 6 reversals = %.3f' % numpy.average(staircase.reversalIntensities[-6:]))
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/experiment control/TrialHandler.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of TrialHandler
+
+The contents of this file are in the public domain.
+
+"""
+
+from random import random
+
+from psychopy import data
+
+# create your list of stimuli
+# NB as of version 1.62 you could simply import an excel spreadsheet with this
+# using data.importConditions('someFile.xlsx')
+stimList = []
+for ori in range(90, 180, 30):
+    for sf in [0.5, 1.0, 2.0]:
+        # append a python 'dictionary' to the list
+        stimList.append({'sf': sf, 'ori': ori})
+
+# organize them with the trial handler
+trials = data.TrialHandler(stimList, 10,
+                           extraInfo={'participant': "Nobody", 'session':'001'})
+
+# run the experiment
+nDone = 0
+for thisTrial in trials:  # handler can act like a for loop
+    # simulate some data
+    thisReactionTime = random() + float(thisTrial['sf']) / 2.0
+    thisChoice = round(random())
+    trials.data.add('RT', thisReactionTime)  # add the data to our set
+    trials.data.add('choice', thisChoice)
+    nDone += 1  # just for a quick reference
+
+    msg = 'trial %i had position %s in the list (sf=%.1f)'
+    print(msg % (nDone, trials.thisIndex, thisTrial['sf']))
+
+# After the experiment, print a new line
+print('\n')
+
+# Write summary data to screen
+trials.printAsText(stimOut=['sf', 'ori'],
+                   dataOut=['RT_mean', 'RT_std', 'choice_raw'])
+
+# Write summary data to a text file ...
+trials.saveAsText(fileName='testData',
+                  stimOut=['sf', 'ori'],
+                  dataOut=['RT_mean', 'RT_std', 'choice_raw'])
+
+# ... or an xlsx file (which supports sheets)
+trials.saveAsExcel(fileName='testData',
+                   sheetName='rawData',
+                   stimOut=['sf', 'ori'],
+                   dataOut=['RT_mean', 'RT_std', 'choice_raw'])
+
+# Save a copy of the whole TrialHandler object, which can be reloaded later to
+# re-create the experiment.
+trials.saveAsPickle(fileName='testData')
+
+# Wide format is useful for analysis with R or SPSS.
+df = trials.saveAsWideText('testDataWide.txt')

psychopy/demos/coder/experiment control/TrialHandler2.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of TrialHandler
+"""
+
+from random import random
+from psychopy import data
+
+# create your list of stimuli
+# NB as of version 1.62 you could simply import an excel spreadsheet with this
+# using data.importConditions('someFile.xlsx')
+stimList = []
+for ori in range(90, 180, 30):
+    for sf in [0.5, 1.0, 2.0]:
+        # append a python 'dictionary' to the list
+        stimList.append({'sf':sf, 'ori':ori})
+
+# organize them with the trial handler
+trials = data.TrialHandler2(stimList, 10,
+                            extraInfo= {'participant':"Nobody", 'session':'001'})
+
+# run the experiment
+nDone = 0
+for thisTrial in trials:  # handler can act like a for loop
+    # simulate some data
+    thisReactionTime = random() + float(thisTrial['sf']) / 2.0
+    thisChoice = round(random())
+    trials.addData('RT', thisReactionTime)  # add the data to our set
+    trials.addData('choice', thisChoice)
+    nDone += 1  # just for a quick reference
+
+    msg = 'trial %i had position %s in the list (sf=%.1f)'
+    print(msg % (nDone, trials.thisIndex, thisTrial['sf']))
+
+# after the experiment
+print('\n')
+trials.saveAsPickle(fileName = 'testData')  # this saves a copy of the whole object
+df = trials.saveAsWideText("testDataWide.csv")  # wide is useful for analysis with R or SPSS. Also returns dataframe df
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/experiment control/autoDraw_autoLog.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+One easy way to handle stimuli that are drawn repeatedly is to
+setAutoDraw(True) for that stimulus. It will continue to be drawn until
+stim.setAutoDraw(False) is called. By default a logging message of
+level EXP will be created when the setAutoDraw is called.
+
+This can be turned off for each call with stim.setAutoDraw(True, autoLog=False)
+"""
+
+from psychopy import visual, core
+
+win = visual.Window([800, 800])
+
+# a stim's name is used in log entries
+stim1 = visual.GratingStim(win, pos=[-0.5, -0.5], name='stim1')
+stim2 = visual.TextStim(win, pos=[0.5, 0.5], text='stim2', name='textStim')
+
+# no need to log the fixation point info, use autoLog=False
+fixation = visual.GratingStim(win, mask='gauss', tex=None, size=0.02,
+    name='fixation', autoLog=False)
+
+fixation.setAutoDraw(True)
+stim1.setAutoDraw(True)
+stim2.setAutoDraw(True)
+# both on
+for frameN in range(20):  # run 20 frames like this
+    win.flip()
+
+stim2.setAutoDraw(False)
+# will draw only stim1 (and fixation)
+for frameN in range(20):  # run 20 frames like this
+    win.flip()
+
+stim1.setAutoDraw(False)
+stim2.setAutoDraw(True)
+# will draw only stim2 (and fixation)
+for frameN in range(20):  # run 20 frames like this
+    win.flip()
+
+for stim in [stim1, stim2, fixation]:
+    stim.setAutoDraw(False)
+win.flip()  # will cause the 'off' log messages to be sent
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/experiment control/experimentHandler.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of class data.ExperimentHandler
+"""
+
+from psychopy import data, logging
+from numpy import random
+logging.console.setLevel(logging.DEBUG)
+
+exp = data.ExperimentHandler(name='testExp',
+                version='0.1',
+                extraInfo={'participant':'jwp', 'ori':45},
+                runtimeInfo=None,
+                originPath=None,
+                savePickle=True,
+                saveWideText=True,
+                dataFileName='testExp')
+
+# a first loop (like training?)
+conds = data.createFactorialTrialList(
+    {'faceExpression':['happy', 'sad'], 'presTime':[0.2, 0.3]})
+training = data.TrialHandler(trialList=conds, nReps=3, name='train',
+                 method='random',
+                 seed=100)  # this will set the global seed - for the whole exp
+exp.addLoop(training)
+# run those trials
+for trial in training:
+    training.addData('training.rt', random.random() * 0.5 + 0.5)
+    if random.random() > 0.5:
+        training.addData('training.key', 'left')
+    else:
+        training.addData('training.key', 'right')
+    exp.nextEntry()
+
+# then run 3 repeats of a staircase
+outerLoop = data.TrialHandler(trialList=[], nReps=3, name='stairBlock',
+                 method='random')
+exp.addLoop(outerLoop)
+for thisRep in outerLoop:  # the outer loop doesn't save any data
+    staircase = data.StairHandler(startVal=10, name='staircase', nTrials=5)
+    exp.addLoop(staircase)
+    for thisTrial in staircase:
+        id=random.random()
+        if random.random() > 0.5:
+            staircase.addData(1)
+        else:
+            staircase.addData(0)
+        exp.addData('id', id)
+        exp.nextEntry()
+for e in exp.entries:
+    print(e)
+print("Done. 'exp' experimentHandler will now (end of script) save data to testExp.csv")
+print(" and also to testExp.psydat, which is a pickled version of `exp`")
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/experiment control/fMRI_launchScan.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+This demo illustrates using hardware.emulator.launchScan() to either start a
+real scan, or emulate sync pulses. Emulation is to allow debugging script timing
+offline, without requiring a scanner (or a hardware sync pulse generator).
+"""
+
+# Author: Jeremy R. Gray
+
+from psychopy import visual, event, core, gui
+from psychopy.hardware.emulator import launchScan
+
+# settings for launchScan:
+MR_settings = {
+    'TR': 2.000,     # duration (sec) per whole-brain volume
+    'volumes': 5,    # number of whole-brain 3D volumes per scanning run
+    'sync': 'slash', # 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': True    # in test mode: play a tone as a reminder of scanner noise
+    }
+infoDlg = gui.DlgFromDict(MR_settings, title='fMRI parameters', order=['TR', 'volumes'])
+if not infoDlg.OK:
+    core.quit()
+
+win = visual.Window(fullscr=False)
+globalClock = core.Clock()
+
+# summary of run timing, for each key press:
+output = u'vol    onset key\n'
+for i in range(-1 * MR_settings['skip'], 0):
+    output += u'%d prescan skip (no sync)\n' % i
+
+counter = visual.TextStim(win, height=.05, pos=(0, 0), color=win.rgb + 0.5)
+output += u"  0    0.000 sync  [Start of scanning run, vol 0]\n"
+
+# launch: operator selects Scan or Test (emulate); see API documentation
+vol = launchScan(win, MR_settings, globalClock=globalClock)
+counter.setText(u"%d volumes\n%.3f seconds" % (0, 0.0))
+counter.draw()
+win.flip()
+
+duration = MR_settings['volumes'] * MR_settings['TR']
+# note: globalClock has been reset to 0.0 by launchScan()
+while globalClock.getTime() < duration:
+    allKeys = event.getKeys()
+    for key in allKeys:
+        if key == MR_settings['sync']:
+            onset = globalClock.getTime()
+            # do your experiment code at this point if you want it sync'd to the TR
+            # for demo just display a counter & time, updated at the start of each TR
+            counter.setText(u"%d volumes\n%.3f seconds" % (vol, onset))
+            output += u"%3d  %7.3f sync\n" % (vol, onset)
+            counter.draw()
+            win.flip()
+            vol += 1
+        else:
+            # handle keys (many fiber-optic buttons become key-board key-presses)
+            output += u"%3d  %7.3f %s\n" % (vol-1, globalClock.getTime(), str(key))
+            if key == 'escape':
+                output += u'user cancel, '
+                break
+
+t = globalClock.getTime()
+win.flip()
+
+output += u"End of scan (vol 0..%d = %d of %s). Total duration = %7.3f sec" % (vol - 1, vol, MR_settings['volumes'], t)
+print(output)
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/experiment control/gammaMotionAnalysis.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Use this script to analyze data from the gammaMotionNull.py
+script.
+
+Instructions: From the dialogue box select multiple staircases (Cmd-click
+or shift-click) to plot the results
+"""
+
+import matplotlib
+matplotlib.use('TKAgg')
+
+from psychopy import data, gui, core
+from psychopy.tools.filetools import fromFile
+import pylab
+import numpy as num
+
+files = gui.fileOpenDlg('.')
+if not files:
+    core.quit()
+
+# get the data from all the files
+allIntensities, allResponses = [], []
+for thisFileName in files:
+    thisDat = fromFile(thisFileName)
+    assert isinstance(thisDat, data.StairHandler)
+    allIntensities.append( thisDat.intensities )
+    allResponses.append( thisDat.data )
+
+# plot each staircase
+pylab.subplot(121)
+lines, names = [], []
+for fileN, thisStair in enumerate(allIntensities):
+    # lines.extend(pylab.plot(thisStair))
+    # names = files[fileN]
+    pylab.plot(thisStair, label=files[fileN])
+# pylab.legend()
+
+# get combined data
+i, r, n = data.functionFromStaircase(allIntensities, allResponses, 'unique')
+combinedInten, combinedResp, combinedN = i, r, n
+
+# fit curve
+guess =[num.average(combinedInten), num.average(combinedInten)/5]
+
+fit = data.FitWeibull(combinedInten, combinedResp, guess=guess, expectedMin=0.0)
+smoothInt = num.arange(min(combinedInten), max(combinedInten), 0.001)
+smoothResp = fit.eval(smoothInt)
+thresh = fit.inverse(0.5)
+print(thresh)
+
+# plot curve
+pylab.subplot(122)
+pylab.plot(smoothInt, smoothResp, '-')
+pylab.plot([thresh, thresh], [0, 0.5], '--')
+pylab.plot([0, thresh], [0.5, 0.5], '--')
+pylab.title('threshold = %0.3f' %(thresh))
+
+# plot points
+pylab.plot(combinedInten, combinedResp, 'o')
+pylab.ylim([0, 1])
+
+pylab.show()
+core.quit()
+
+# The contents of this file are in the public domain.