psychopy 2025.2.4__py3-none-any.whl

psychopy/demos/coder/input/joystick_universal.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+There are two ways to retrieve info from the first 3 joystick axes. You can use:
+    joy.getAxis(0)
+    joy.getX()
+Beyond those 3 axes you need to use the getAxis(id) form.
+Although it may be that these don't always align fully. This demo should help
+you to find out which physical axis maps to which number for your device.
+
+Known issue: Pygame 1.91 unfortunately spits out a debug message every time the
+joystick is accessed and there doesn't seem to be a way to get rid of those
+messages.
+"""
+
+from psychopy import visual, core, event
+from psychopy.hardware import joystick
+
+joystick.backend = 'pyglet'
+# As of v1.72.00, you need the winType and joystick.backend to match:
+win = visual.Window((800.0, 800.0), allowGUI=False, winType=joystick.backend)
+
+nJoysticks = joystick.getNumJoysticks()
+
+if nJoysticks > 0:
+    joy = joystick.Joystick(0)
+    print('found ', joy.getName(), ' with:')
+    print('...', joy.getNumButtons(), ' buttons')
+    print('...', joy.getNumHats(), ' hats')
+    print('...', joy.getNumAxes(), ' analogue axes')
+else:
+    print("You don't have a joystick connected!?")
+    win.close()
+    core.quit()
+
+nAxes = joy.getNumAxes()
+
+fixSpot = visual.GratingStim(win, pos=(0, 0),
+    tex="none", mask="gauss",
+    size=(0.05, 0.05), color='black')
+grating = visual.GratingStim(win, pos=(0.5, 0),
+    tex="sin", mask="gauss",
+    color=[1.0, 0.5, -1.0],
+    size=(0.2, .2), sf=(2, 0))
+message = visual.TextStim(win, pos=(0, -0.95), text='Hit "q" to quit')
+
+trialClock = core.Clock()
+t = 0
+while not event.getKeys():
+    # update stim from joystick
+    xx = joy.getX()
+    yy = joy.getY()
+    grating.setPos((xx, -yy))
+    # change SF
+    if nAxes > 3:
+        sf = (joy.getZ() + 1) * 2.0  # so should be in the range 0: 4?
+        grating.setSF(sf)
+    # change ori
+    if nAxes > 6:
+        ori = joy.getAxis(5) * 90
+        grating.setOri(ori)
+    # if any button is pressed then make the stimulus colored
+    if sum(joy.getAllButtons()):
+        grating.setColor('red')
+    else:
+        grating.setColor('white')
+
+    # drift the grating
+    t = trialClock.getTime()
+    grating.setPhase(t * 2)
+    grating.draw()
+
+    fixSpot.draw()
+    message.draw()
+    print(joy.getAllAxes())  # to see what your axes are doing!
+
+    event.clearEvents()  # do this each frame to avoid a backlog of mouse events
+    win.flip()  # redraw the buffer
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/input/keyNameFinder.py

@@ -0,0 +1,39 @@
+from psychopy import visual
+from psychopy.hardware import keyboard
+
+# Make window
+win = visual.Window(units="height")
+
+# Make instructions textbox
+instr = visual.TextBox2(win,
+    text="Press any key...",
+    font="Open Sans", letterHeight=0.1,
+    pos=(0, 0.2))
+# Make key name textbox
+output = visual.TextBox2(win,
+    text="No key pressed yet",
+    font="Open Sans", letterHeight=0.1,
+    pos=(0, -0.2))
+
+# Make keyboard object. Optionally add backend kwarg, using 'iohub', 'ptb', 'event', or ''.
+# If using '', best available backend will be selected.
+#kb = keyboard.Keyboard(backend='iohub')
+kb = keyboard.Keyboard()
+print("KB backend: ", kb.getBackend())
+
+# Listen for keypresses until escape is pressed
+keys = kb.getKeys()
+while 'escape' not in keys:
+    # Draw stimuli
+    instr.draw()
+    output.draw()
+    win.flip()
+    # Check keypresses
+    keys = kb.getKeys()
+    if keys:
+        # If a key was pressed, display it
+        output.text = f"That key was `{keys[-1].name}`. Press another key."
+        for k in keys:
+            print(k.name, k.code, k.tDown, k.rt, k.duration)
+# End the demo
+win.close()

psychopy/demos/coder/input/mouse.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of mouse handling.
+
+As of version 1.51 the mouse coordinates for
+    myMouse.getPos()
+    myMouse.setPos()
+    myMouse.getRel()
+are in the same units as the window.
+
+You can also check the motion of the wheel with myMouse.getWheelRel()
+(in two directions for the mac mighty mouse or equivalent!)
+"""
+
+from psychopy import visual, core, event
+
+# Create a window to draw in
+win = visual.Window((600.0, 600.0), allowGUI=True)
+
+# Initialize some stimuli
+fixSpot = visual.GratingStim(win, tex="none", mask="gauss",
+    pos=(0, 0), size=(0.05, 0.05), color='black', autoLog=False)
+grating = visual.GratingStim(win, pos=(0.5, 0),
+    tex="sin", mask="gauss",
+    color=[1.0, 0.5, -1.0],
+    size=(1.0, 1.0), sf=(3, 0),
+    autoLog=False)  # autologging not useful for dynamic stimuli
+myMouse = event.Mouse()  #  will use win by default
+message = visual.TextStim(win, pos=(-0.95, -0.9), height=0.08,
+    alignText='left', anchorHoriz='left',
+    text='left-drag=SF, right-drag=pos, scroll=ori',
+    autoLog=False)
+
+# Continue until keypress
+while not event.getKeys():
+    # get mouse events
+    mouse_dX, mouse_dY = myMouse.getRel()
+    mouse1, mouse2, mouse3 = myMouse.getPressed()
+    if (mouse1):
+        grating.setSF(mouse_dX, '+')
+    elif (mouse3):
+        grating.setPos([mouse_dX, mouse_dY], '+')
+    else:
+        fixSpot.setPos(myMouse.getPos())
+
+    # Handle the wheel(s):
+    # dY is the normal mouse wheel, but some have a dX as well
+    wheel_dX, wheel_dY = myMouse.getWheelRel()
+    grating.setOri(wheel_dY * 5, '+')
+
+    # get rid of other, unprocessed events
+    event.clearEvents()
+
+    # Do the drawing
+    fixSpot.draw()
+    grating.setPhase(0.05, '+')  # advance 0.05 cycles per frame
+    grating.draw()
+    message.draw()
+    win.flip()
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/iohub/delaytest.py

@@ -0,0 +1,231 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Tests the round trip delay from when the experiment runtime requests
+new events from the ioHub server to when a response with >=1 new
+event is received and ready for use within the experiment script.
+
+Only getEvent requests that return with at least one new event are used in
+the calculated statistics to try and ensure the reported delay is measuring
+the higher processing load case of new events being returned, vs. the
+case of no new events being available.
+
+At the end of the test, a MatPlotLib figure is displayed showing a
+histogram of the round trip event request delays as well as two figures
+representing the retrace onset detection stability of PsychoPy.
+"""
+
+from numpy import zeros
+from scipy.stats import norm
+from psychopy import visual
+from psychopy.iohub import Computer, launchHubServer
+from psychopy.iohub.constants import EventConstants
+from collections import OrderedDict
+
+totalEventRequestsForTest = 1000
+numEventRequests = 0
+
+
+def run():
+    global numEventRequests
+    # create fullscreen pyglet window at current resolution, as well as required resources / drawings
+    psychoWindow, psychoStim = createPsychoGraphicsWindow()
+
+    io = launchHubServer(window=psychoWindow, experiment_code='delay_test')
+    io.devices.mouse.setPosition((0, 0))
+
+    lastFlipTime = 0.0
+
+    # create stats numpy arrays, set experiment process to high priority.
+    # Init Results numpy array
+    results = zeros((totalEventRequestsForTest, 3), dtype='f4')
+
+    numEventRequests = 0
+
+    # clear the ioHub event Buffer before starting the test.
+    # This is VERY IMPORTANT, given an existing bug in ioHub.
+    # You would want to do this before each trial started until the bug is fixed.
+    io.clearEvents('all')
+
+    # draw and flip to the updated graphics state.
+    flipTime = drawAndFlipPsychoWindow(psychoStim, psychoWindow, io, None)
+    ifi = flipTime - lastFlipTime
+    lastFlipTime = flipTime
+
+    # START TEST LOOP >>>>>>>>>>>>>>>>>>>>>>>>>>
+    while numEventRequests < totalEventRequestsForTest:
+        # send an Experiment Event to the ioHub server process
+        io.sendMessageEvent("This is a test message %.3f" % flipTime)
+
+        # check for any new events from any of the devices, and return the events list and the time it took to
+        # request the events and receive the reply
+        events, callDuration = checkForEvents(io)
+        if events:
+            # events were available
+            results[numEventRequests][0] = callDuration  # ctime it took to get events from ioHub
+            results[numEventRequests][1] = len(events)  # number of events returned
+            results[numEventRequests][2] = ifi * 1000.0  # calculating inter flip interval.
+            numEventRequests += 1  # incrementing tally counterfgh
+            # draw and flip to the updated graphics state.
+
+        flipTime = drawAndFlipPsychoWindow(psychoStim, psychoWindow, io, events)
+        ifi = flipTime - lastFlipTime
+        lastFlipTime = flipTime
+
+    # END TEST LOOP <<<<<<<<<<<<<<<<<<<<<<<<<<
+
+    psychoWindow.close()
+
+    # plot collected delay and retrace detection results.
+    plotResults(results)
+    printResults(results)
+
+
+def createPsychoGraphicsWindow():
+    # create a window
+    psychoStim = OrderedDict()
+    psychoWindow = visual.Window((1920, 1080),
+                                 monitor='default',
+                                 units='pix',
+                                 color=[128, 128, 128], colorSpace='rgb255',
+                                 fullscr=True, allowGUI=False,
+                                 screen=0
+                                 )
+
+    psychoWindow.setMouseVisible(False)
+
+    fixation = visual.PatchStim(psychoWindow, size=25, pos=[0, 0], sf=0,
+                                color=[-1, -1, -1], colorSpace='rgb')
+    title = visual.TextStim(win=psychoWindow,
+                            text="ioHub getEvents Delay Test", pos=[0, 125],
+                            height=36, color=[1, .5, 0], colorSpace='rgb',
+                            wrapWidth=800.0)
+
+    instr = visual.TextStim(win=psychoWindow,
+                            text='Move the mouse around, press keyboard keys and mouse buttons',
+                            pos=[0, -125], height=32, color=[-1, -1, -1],
+                            colorSpace='rgb', wrapWidth=800.0)
+
+    psychoStim['static'] = visual.BufferImageStim(win=psychoWindow,
+                                                  stim=(fixation, title, instr))
+    psychoStim['grating'] = visual.PatchStim(psychoWindow,
+                                             mask="circle", size=75, pos=[-100, 0],
+                                             sf=.075)
+    psychoStim['keytext'] = visual.TextStim(win=psychoWindow,
+                                            text='key', pos=[0, 300], height=48,
+                                            color=[-1, -1, -1], colorSpace='rgb',
+                                            wrapWidth=800.0)
+    psychoStim['mouseDot'] = visual.GratingStim(win=psychoWindow,
+                                                tex=None, mask="gauss",
+                                                pos=(0,0), size=(50, 50),
+                                                color='purple')
+    psychoStim['progress'] = visual.ShapeStim(win=psychoWindow,
+                                              vertices=[(0, 0), (0, 0), (0, 0), (0, 0)],
+                                              pos=(400, -300))
+
+    return psychoWindow, psychoStim
+
+
+def drawAndFlipPsychoWindow(psychoStim, psychoWindow, io, events):
+    psychoStim['grating'].setPhase(0.05, '+')  # advance phase by 0.05 of a cycle
+    currentPosition, currentDisplayIndex = io.devices.mouse.getPosition(return_display_index=True)
+
+    if currentDisplayIndex == 0:
+        currentPosition = (float(currentPosition[0]), float(currentPosition[1]))
+        psychoStim['mouseDot'].setPos(currentPosition)
+
+    if events:
+        diff = totalEventRequestsForTest - numEventRequests
+        v = psychoWindow.size[1] / 2.0 * diff / totalEventRequestsForTest
+        vert = [[0, 0], [0, v], [2, v], [2, 0]]
+        psychoStim['progress'].setVertices(vert)
+
+        for r in events:
+            if r.type is EventConstants.KEYBOARD_PRESS:  # keypress code
+                psychoStim['keytext'].setText(r.key)
+
+    [psychoStim[skey].draw() for skey in psychoStim]
+
+    flipTime = psychoWindow.flip()
+    return flipTime
+
+
+def checkForEvents(io):
+    # get the time we request events from the ioHub
+    stime = Computer.getTime()
+    r = io.getEvents()
+    if r and len(r) > 0:
+        # so there were events returned in the request, so include this getEvent request in the tally
+        etime = Computer.getTime()
+        dur = etime - stime
+        return r, dur * 1000.0
+    return None, None
+
+
+def plotResults(results):
+    #### calculate stats on collected data and draw some plots ####
+    from matplotlib.pyplot import axis, title, xlabel, hist, grid, show, ylabel, plot
+    import pylab
+
+    durations = results[:, 0]
+    flips = results[1:, 2]
+
+    dmean = durations.mean()
+    dstd = durations.std()
+
+    fmean = flips.mean()
+    fstd = flips.std()
+
+    pylab.figure(figsize=(7, 5))
+    pylab.subplot(1, 3, 1)
+
+    # the histogram of the delay data
+    n, bins, patches = hist(durations, 50, facecolor='blue', alpha=0.75)
+    # add a 'best fit' line
+    y = norm.pdf(bins, dmean, dstd)
+    plot(bins, y, 'r--', linewidth=1)
+    xlabel('ioHub getEvents Delay')
+    ylabel('Percentage')
+    title('ioHub Event Delays (msec):\n' + r'$\ \mu={0:.3f},\ \sigma={1:.3f}$'.format(dmean, dstd))
+    axis([0, durations.max() + 1.0, 0, 25.0])
+    grid(True)
+
+    # graphs of the retrace data ( taken from retrace example in psychopy demos folder)
+    intervalsMS = flips
+    m = fmean
+    sd = fstd
+    distString = "Mean={0:.1f}ms,    s.d.={1:.1f},    99%CI={2:.1f}-{3:.1f}".format(
+        m, sd, m - 3 * sd, m + 3 * sd)
+    nTotal = len(intervalsMS)
+    nDropped = sum(intervalsMS > (1.5 * m))
+    droppedString = "Dropped/Frames = {0:d}/{1:d} = {2:0.2f}%".format(
+        nDropped, nTotal, int(nDropped) / float(nTotal))
+
+    pylab.subplot(1, 3, 2)
+
+    # plot the frameintervals
+    pylab.plot(intervalsMS, '-')
+    pylab.ylabel('t (ms)')
+    pylab.xlabel('frame N')
+    pylab.title(droppedString)
+
+    pylab.subplot(1, 3, 3)
+    pylab.hist(intervalsMS, 50, histtype='stepfilled')
+    pylab.xlabel('t (ms)')
+    pylab.ylabel('n frames')
+    pylab.title(distString)
+    show()
+
+
+def printResults(results):
+    durations = results[:, 0]
+    dmean = durations.mean()
+    dstd = durations.std()
+    print("ioHub getEvent Delays:")
+    print("\tMEAN: ", dmean)
+    print("\tSDEV: ", dstd)
+
+
+if __name__ == "__main__":
+    run()

psychopy/demos/coder/iohub/eyetracking/gcCursor/readTrialEventsByConditionVariables.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Example of reading events from an iohub hdf5 file, saving to a tab delimited text file.
+The condition variables table is used to split samples into trial groupings,
+saving condition variable columns with each event.
+
+SAVE_EVENT_TYPE and SAVE_EVENT_FIELDS specify the event type, and which event fields, are saved.
+
+This example can process hdf5 files saved by running the gcCursor demo.
+"""
+import sys
+import os
+from psychopy.iohub.constants import EventConstants
+from psychopy.iohub.datastore.util import displayDataFileSelectionDialog
+from psychopy.iohub.datastore.util import ExperimentDataAccessUtility
+
+SAVE_EVENT_TYPE = EventConstants.MONOCULAR_EYE_SAMPLE
+SAVE_EVENT_FIELDS = ['time', 'gaze_x', 'gaze_y', 'pupil_measure1', 'status']
+
+#SAVE_EVENT_TYPE = EventConstants.BINOCULAR_EYE_SAMPLE
+#SAVE_EVENT_FIELDS = ['time', 'left_gaze_x', 'left_gaze_y', 'left_pupil_measure1',
+#                     'right_gaze_x', 'right_gaze_y', 'right_pupil_measure1', 'status']
+
+if __name__ == '__main__':
+    # Select the hdf5 file to process.
+    data_file_path = displayDataFileSelectionDialog(os.path.dirname(os.path.abspath(__file__)))
+    if data_file_path is None:
+        print("File Selection Cancelled, exiting...")
+        sys.exit(0)
+    data_file_path = data_file_path[0]
+    dpath, dfile = os.path.split(data_file_path)
+
+    datafile = ExperimentDataAccessUtility(dpath, dfile)
+
+    events_by_trial = datafile.getEventAttributeValues(SAVE_EVENT_TYPE, SAVE_EVENT_FIELDS,
+                                                       startConditions={'time': ('>=', '@TRIAL_START@')},
+                                                       endConditions={'time': ('<=', '@TRIAL_END@')})
+
+    ecount = 0
+
+    # Open a file to save the tab delimited output to.
+    #
+    output_file_name = "%s.txt" % (dfile[:-5])
+    with open(output_file_name, 'w') as output_file:
+        print('Writing Data to %s:\n' % (output_file_name))
+        column_names = events_by_trial[0].condition_set._fields[2:] + events_by_trial[0]._fields[:-2]
+        output_file.write('\t'.join(column_names))
+        output_file.write('\n')
+
+        for trial_data in events_by_trial:
+            cv_fields = [str(cv) for cv in trial_data.condition_set[2:]]
+            # Convert trial_data namedtuple to list of arrays.
+            # len(trial_data) == len(SAVE_EVENT_FIELDS)
+            trial_data = trial_data[:-2]
+            for eix in range(len(trial_data[0])):
+                # Step through each event, saving condition variable and event fields
+                ecount += 1
+                event_data = [str(c[eix]) for c in trial_data]
+                output_file.write('\t'.join(cv_fields + event_data))
+                output_file.write('\n')
+
+                if eix % 100 == 0:
+                    sys.stdout.write('.')
+
+    print("\n\nWrote %d events." % ecount)
+    datafile.close()

psychopy/demos/coder/iohub/eyetracking/gcCursor/readTrialEventsByMessages.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Example of reading events from an iohub hdf5 file, saving to a tab delimited text file.
+
+Events are split into trials by reading the time of 'TRIAL_START' and
+'TRIAL_END' experiment Message events.
+
+SAVE_EVENT_TYPE and SAVE_EVENT_FIELDS specify the event type, and which event fields, are saved.
+
+This example can process hdf5 files saved by running the gcCursor demo.
+"""
+from psychopy.iohub.datastore.util import saveEventReport
+
+# Specify which event type and event fields to save
+SAVE_EVENT_TYPE = 'MonocularEyeSampleEvent'
+SAVE_EVENT_FIELDS = ['time', 'gaze_x', 'gaze_y', 'pupil_measure1', 'status']
+#SAVE_EVENT_TYPE = 'BinocularEyeSampleEvent'
+#SAVE_EVENT_FIELDS = ['time', 'left_gaze_x', 'left_gaze_y', 'left_pupil_measure1',
+#                     'right_gaze_x', 'right_gaze_y', 'right_pupil_measure1', 'status']
+
+# Specify the experiment message text used to split events into trial periods.
+# Set both to None to save all events.
+TRIAL_START_MESSAGE = "TRIAL_START"
+TRIAL_END_MESSAGE = "TRIAL_END"
+
+if __name__ == '__main__':
+    result = saveEventReport(hdf5FilePath=None, eventType=SAVE_EVENT_TYPE, eventFields=SAVE_EVENT_FIELDS,
+                             trialStart=TRIAL_START_MESSAGE, trialStop=TRIAL_END_MESSAGE)
+    if result:
+        file_saved, events_saved = result
+        print("Saved %d events to %s." % (events_saved, file_saved))
+    else:
+        raise RuntimeError("saveEventReport failed.")