psychopy 2025.2.4__py3-none-any.whl

psychopy/demos/coder/misc/rigidBodyTransform.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Demo for the class psychopy.visual.RigidBodyPose class.
+
+This demonstrates how to use rigid body transforms to control the poses of 3D
+objects in a scene.
+
+"""
+
+from psychopy import core, event
+import psychopy.visual as visual
+from psychopy.visual import SphereStim, LightSource, RigidBodyPose
+
+win = visual.Window((600, 600), allowGUI=False, monitor='testMonitor')
+
+# create a rigid body defining the pivot point of objects in the scene
+pivotPose = RigidBodyPose((0, 0, -5))
+
+# text to display
+instr = visual.TextStim(win, text="Any key to quit", pos=(0, -.7))
+
+# create scene light at the pivot point
+win.lights = [
+    LightSource(win, pos=pivotPose.pos, lightType='point',
+                diffuseColor=(0, 0, 0), specularColor=(1, 1, 1))
+]
+
+# Create poses for objects in the scene, these need to remain unchanged so we
+# define them here and then set the poses of the 3D stimuli. Pose positions
+# are relative to the pivot point.
+spherePose1 = RigidBodyPose((0.1, -0.1, 0.1))
+spherePose2 = RigidBodyPose((-0.1, 0.1, 0.1))
+spherePose3 = RigidBodyPose((0.1, -0.1 , -0.1))
+
+# create some sphere stim objects
+lightSphere = SphereStim(win, radius=0.05, color='white')
+sphere1 = SphereStim(win, radius=0.05, color='red')
+sphere2 = SphereStim(win, radius=0.1, color='green')
+sphere3 = SphereStim(win, radius=0.075, color='blue')
+
+angle = 0.0
+while not event.getKeys():
+
+    # rotate the pivot pose
+    pivotPose.setOriAxisAngle((0, 1, 0), angle)
+
+    # setup drawing
+    win.setPerspectiveView()
+
+    # sphere for the light source, note this does not actually emit light
+    lightSphere.thePose = pivotPose
+    lightSphere.draw()
+
+    # call after drawing `lightSphere` since we don't want it being shaded
+    win.useLights = True
+
+    # multiplying pose puts the first object in the reference frame of the
+    # second
+    sphere1.thePose = spherePose1 * pivotPose
+    sphere2.thePose = spherePose2 * pivotPose
+    sphere3.thePose = spherePose3 * pivotPose
+
+    sphere1.draw()
+    sphere2.draw()
+    sphere3.draw()
+
+    # reset transform to draw text correctly
+    win.resetEyeTransform()
+
+    instr.draw()
+
+    win.flip()
+    angle += 0.5
+
+win.close()
+core.quit()

psychopy/demos/coder/stimuli/MovieStim.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of MovieStim
+
+MovieStim opens a video file and displays it on a window.
+
+"""
+from psychopy import visual, core, constants
+from psychopy.hardware import keyboard
+
+# window to present the video
+win = visual.Window((800, 600), fullscr=False)
+
+# keyboard to listen for keys
+kb = keyboard.Keyboard()
+
+# create a new movie stimulus instance
+mov = visual.MovieStim(
+    win,
+    'default.mp4',    # path to video file
+    size=(256, 256),
+    flipVert=False,
+    flipHoriz=False,
+    loop=False,
+    noAudio=False,
+    volume=0.1,
+    autoStart=False)
+
+# print some information about the movie
+print('orig movie size={}'.format(mov.frameSize))
+print('orig movie duration={}'.format(mov.duration))
+
+# instructions
+instrText = "`r` Play/Resume\n`p` Pause\n`s` Stop\n`q` Stop and Close"
+instr = visual.TextStim(win, instrText, pos=(0.0, -0.75))
+
+# main loop, exit when the status is finished
+while not mov.isFinished:
+    # draw the movie
+    mov.draw()
+    # draw the instruction text
+    instr.draw()
+    # flip buffers so they appear on the window
+    win.flip()
+
+    # process keyboard input
+    if kb.getKeys('q'):   # quit
+        break
+    elif kb.getKeys('r'):  # play/start
+        mov.play()
+    elif kb.getKeys('p'):  # pause
+        mov.pause()
+    elif kb.getKeys('s'):  # stop the movie
+        mov.stop()
+
+# stop the movie, this frees resources too
+mov.unload()  # unloads when `mov.status == constants.FINISHED`
+
+# clean up and exit
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/stimuli/aperture.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo for the class psychopy.visual.Aperture().
+
+Draw two gabor circles, one with an irregular aperture and one with no aperture.
+"""
+
+from psychopy import visual, event
+
+# Need to allowStencil=True for a window with an Aperture:
+win = visual.Window([400, 400], allowStencil=True, units='norm')
+
+instr = visual.TextStim(win, text="Any key to quit", pos=(0, -.7))
+gabor1 = visual.GratingStim(win, mask='circle', sf=4, size=1.2, color=[0.5, -0.5, 1])
+gabor2 = visual.GratingStim(win, mask='circle', sf=4, size=1.2, color=[-0.5, -0.5, -1])
+vertices = [(-0.02, -0.0), (-.8, .2), (0, .6), (.1, 0.06), (.8, .3), (.6, -.4)]
+
+# `sizes in Aperture refers to the diameter when shape='circle';
+# vertices or other shapes are scaled accordingly
+aperture = visual.Aperture(win, size=0.9, shape=vertices)  # try shape='square'
+aperture.enabled = False  # enabled by default when created
+
+gabor1.draw()
+instr.draw()
+
+# drawing will now only be done within the aperture shape:
+aperture.enabled = True
+gabor2.draw()
+
+win.flip()
+event.waitKeys()
+
+win.close()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/stimuli/bufferImageStim.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of class psychopy.visual.BufferImageStim()
+
+- take a snapshot of a multi-item screen image
+- save and draw as a BufferImageStim
+- report speed of BufferImageStim to speed of drawing each item separately
+"""
+
+from psychopy import visual, event, core
+
+# need a window and clock:
+win = visual.Window(fullscr=False, monitor='testMonitor')
+clock = core.Clock()
+
+# first define a list of various slow, static stim
+imageList = ['face.jpg', 'beach.jpg']
+imageStim = visual.SimpleImageStim(win, imageList[0])
+imageStim2 = visual.SimpleImageStim(win, imageList[1], pos=(.300, .20))
+wordStim = visual.TextStim(win,
+            text='Press < escape > to quit.\n\nThere should be no change after 3 seconds.\n\n' +
+            'This is a text stim that is kinda verbose and long, so if it ' +
+            'were actually really long it would take a while to render completely.',
+            pos=(0, -.2))
+stimlist = [imageStim, imageStim2, wordStim]
+
+# Get and save a "screen shot" of everything in stimlist:
+rect = (-1, 1, 1, -1)
+t0 = clock.getTime()
+screenshot = visual.BufferImageStim(win, stim=stimlist, rect=rect)
+# rect is the screen rectangle to grab, (-1, 1, 1, -1) is whole-screen
+# as a list of the edges: Left Top Right Bottom, in norm units.
+
+captureTime = clock.getTime() - t0
+
+instr_buffer = visual.TextStim(win, text='BufferImageStim', pos=(0, .8))
+drawTimeBuffer = []  # accumulate draw times of the screenshot
+for frameCounter in range(200):
+    t0 = clock.getTime()
+    screenshot.draw()  # draw the BufferImageStim, fast
+    drawTimeBuffer.append(clock.getTime() - t0)
+    instr_buffer.draw()
+    win.flip()
+    if len(event.getKeys(['escape'])):
+        core.quit()
+
+# Just for the demo: Time things when drawn individually:
+instr_multi = visual.TextStim(win, text='TextStim and ImageStim', pos=(0, .8))
+drawTimeMulti  = []  # draw times of the pieces, as drawn separately
+for frameCounter in range(200):
+    t0 = clock.getTime()
+    for s in stimlist:
+        s.draw()  # draw all individual stim, slow
+    drawTimeMulti.append(clock.getTime() - t0)
+    instr_multi.draw()
+    win.flip()
+    if len(event.getKeys(['escape'])):
+        core.quit()
+
+# Report timing:
+firstFrameTime = drawTimeBuffer.pop(0)
+bufferAvg = 1000. * sum(drawTimeBuffer) / len(drawTimeBuffer)
+multiAvg = 1000. * sum(drawTimeMulti) / len(drawTimeMulti)
+msg = "\nBufferImageStim\nrect=%s norm units, becomes %s pix"
+print(msg % (str(rect), str(screenshot.size)))
+print("initial set-up / screen capture: %.0fms total" % (1000. * captureTime))
+print("first frame:    %.2fms (typically slow)" % (1000. * firstFrameTime))
+msg = "BufferImage:    %.2fms avg, %.2fms max draw-time (%d frames)"
+print(msg % (bufferAvg, max(drawTimeBuffer) * 1000., len(drawTimeBuffer)))
+msg = "Text & Image:   %.2fms avg, %.2fms max draw-time"
+print(msg % (multiAvg, max(drawTimeMulti) * 1000.))
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/stimuli/clockface.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Demo of using ShapeStim to make a functioning visual clock.
+"""
+from psychopy import visual, core, event
+import numpy, time
+win = visual.Window([800, 800], monitor='testMonitor')
+
+# vertices (using numpy means we can scale them easily)
+handVerts = numpy.array([ [0, 0.8], [-0.05, 0], [0, -0.05], [0.05, 0] ])
+
+second = visual.ShapeStim(win, vertices=[[0, -0.1], [0.1, 0.8]],
+    lineColor=[1, -1, -1], fillColor=None, lineWidth=2, autoLog=False)
+minute = visual.ShapeStim(win, vertices=handVerts,
+    lineColor='white', fillColor=[0.8, 0.8, 0.8], autoLog=False)
+hour = visual.ShapeStim(win, vertices=handVerts/2.0,
+    lineColor='black', fillColor=[-0.8, -0.8, -0.8], autoLog=False)
+clock = core.Clock()
+
+while not event.getKeys():
+    t = time.localtime()
+
+    minPos = numpy.floor(t[4]) * 360 / 60  # NB floor will round down
+    minute.ori = minPos
+    minute.draw()
+
+    hourPos = (t[3]) * 360 / 12  # this one can be smooth
+    hour.ori = hourPos
+    hour.draw()
+
+    secPos = numpy.floor(t[5]) * 360 / 60  # NB floor will round down
+    second.ori = secPos
+    second.draw()
+
+    win.flip()
+    event.clearEvents('mouse')  # only really needed for pygame windows
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.

psychopy/demos/coder/stimuli/colorPalette.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from psychopy import locale_setup, visual, core
+import numpy as np
+from psychopy.hardware import keyboard
+from psychopy import misc
+
+
+def createPalette(size):
+    """
+    Creates the color palette array in HSV and returns as RGB
+    """
+    # Create array 
+    hsv = np.ones([size,size,3], dtype=float)
+    
+    # Set hue
+    hsv[:,:,0] = np.linspace(0,360, size, endpoint=False)
+    
+    # Set saturation
+    for i in range(size):
+        hsv[:,i, 1] = np.linspace(0, 1, size, endpoint=False)
+    
+    # Convert to RGB
+    rgb = misc.hsv2rgb(hsv)
+
+    # Make in range 0:1 for image stim
+    rgb[:][:][:] = (rgb[:][:][:] + 1) / 2
+    return rgb
+ 
+def createValue(size):
+    """
+    Creates the value palette array in HSV and returns as RGB
+    """
+    # Create array 
+    hsv = np.zeros([20,size,3], dtype=float)
+    # Set value
+    hsv[:,:,2] = np.linspace(0,1, size, endpoint=False)
+    # Convert to RGB
+    rgb = misc.hsv2rgb(hsv)
+
+    # Make in range 0:1 for image stim
+    rgb[:][:][:] =  (rgb[:][:][:] + 1) / 2
+    return rgb
+    
+
+# Setup the Window
+win = visual.Window(size=[1920, 1080], fullscr=False, units='height')
+
+colorPalette = visual.ImageStim(win=win,name='colorPalette', units='pix', 
+                                image=None, mask=None,
+                                texRes=64, depth=0.0)
+    
+valuePalette = visual.ImageStim(win=win, name='valuePalette', units='pix', 
+                                pos=(0, -250), depth=-1.0)
+    
+hueSlider = visual.Slider(win=win, name='hueSlider',
+                          size=(.37, .02), pos=(0, 0.2),
+                          labels=None, ticks=(0, 360), style=['rating'])
+    
+satSlider = visual.Slider(win=win, name='satSlider',
+                          size=(.02, .37), pos=(0.2, 0),
+                          labels=None, ticks=(0, 1), style=['rating'])
+    
+valSlider = visual.Slider(win=win, name='valSlider',
+                          size=(.37, .02), pos=(0, -0.25),
+                          labels=None, ticks=(0,1), style=['rating'])
+    
+visualFeedback = visual.Rect(win=win, name='visualFeedback',
+                             width=(0.15, 0.15)[0], height=(0.15, 0.15)[1],
+                             pos=(0, 0.35),fillColor=[0,0,0], fillColorSpace='hsv',
+                             depth=-6.0)
+
+hsvText = visual.TextStim(win=win, name='hsvText',
+                          text=None, font='Arial',
+                          pos=(.4, 0), height=0.03)
+
+instText = visual.TextStim(win=win, name='instText',
+                           text=("Use the sliders to change:\n---hue (top)\n---"
+                                "saturation (right)\n---value (bottom)"),
+                           font='Arial',
+                           pos=(-.3, 0), height=0.03, wrapWidth=.4,
+                           alignText='left', anchorHoriz='right')
+
+quitText = visual.TextStim(win=win, name='quitText',
+                           text='Press escape to quit to continue',
+                           font='Arial',
+                           pos=(0, -.35), height=0.025, depth=-8.0,
+                           wrapWidth=.4)
+
+
+paletteSize = 400  # in pixels
+valRGB = createValue(paletteSize) 
+colPalRGB = createPalette(paletteSize)
+
+hueSlider.reset()
+satSlider.reset()
+valSlider.reset()
+
+colorPalette.setSize([paletteSize,paletteSize])
+colorPalette.setImage(colPalRGB)
+valuePalette.setSize((paletteSize, 20))
+valuePalette.setImage(valRGB)
+
+key_resp = keyboard.Keyboard()
+
+while True:
+    
+    h = hueSlider.getRating() or 0
+    s = satSlider.getRating() or 0
+    v = valSlider.getRating() or 0.5
+    visualFeedback.fillColor = [h,s,v]
+    hsvText.text = "Hue: {h:.0f}\nSat: {s:.2f}\nVal: {v:.2f}".format(h=h, s=s, v=v)
+
+    colorPalette.draw()
+    valuePalette.draw() 
+    hueSlider.draw()
+    satSlider.draw()
+    valSlider.draw()
+    visualFeedback.draw()
+    instText.draw()
+    hsvText.draw()
+    quitText.draw()
+    
+    theseKeys = key_resp.getKeys(keyList=['escape'], waitRelease=False)
+    if len(theseKeys):
+        theseKeys = theseKeys[0]  # at least one key was pressed
+        
+        # check for quit:
+        if "escape" == theseKeys:
+            win.close()
+            core.quit()
+            
+    win.flip()

psychopy/demos/coder/stimuli/compare_text_timing.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+"""
+Tests the timing of the TextBox, TextBox2, and TextStim:
+   * Time to create and perform the first build() of each stim type.
+   * Time to change the stim text to be displayed and call draw().
+   * Time to do a draw() call when the stim text content has not changed.
+
+At the end of the test, a txt report is printed to the console giving the
+various timing measures collected.
+"""
+import string
+import random
+from psychopy import visual, core, event
+from psychopy.visual import textbox
+from psychopy.iohub.util import NumPyRingBuffer
+import pyglet.gl as gl
+
+# Variables to control text string length etc.
+text_length=160
+chng_txt_each_flips=5
+max_flip_count=60*10
+text_stim_types = [visual.TextBox, visual.TextBox2, visual.TextStim]
+text_stim = []
+stim_init_durations={}
+txt_change_draw_times={}
+no_change_draw_times={}
+
+for stype in text_stim_types:
+    # Circular buffers to store timing measures
+    cname = stype.__name__
+    txt_change_draw_times[cname]=NumPyRingBuffer(max_flip_count)
+    no_change_draw_times[cname]=NumPyRingBuffer(max_flip_count)
+
+# Some utility functions >>>
+#
+char_choices=string.ascii_uppercase+"ùéèàç^ùèàç髼±£¢¤¬¦²³½¾°µ¯­±√∞≤≥±≠"
+
+def getRandomString(slength):
+    """
+    Create a random text string of length 'slength' from the unichar values 
+    in char_choices; then split the random text into 'words' of random length
+    from [1,3,5,7,9].
+    """
+    s=u''.join(random.choice(char_choices) for i in range(slength))
+    ns=u''
+    lns=len(ns)
+    while lns<slength:
+        ns+=s[lns:lns+random.choice([1,3,5,7,9])]+' '
+        lns=len(ns)
+    return ns[:slength]
+    
+text=getRandomString(text_length)
+
+### Main text Script logic ###
+
+# Create Window
+window=visual.Window((1920,1080),
+                        units='pix',
+                        fullscr=True, allowGUI=False,
+                        screen=0
+                        )
+
+# Find a font that is available on the system.
+fm = textbox.getFontManager()
+font_names=fm.getFontFamilyNames()
+font_name=font_names[0]
+prefered_fonts=[fn for fn in font_names if fn in ['Courier New',
+                                                  'Consolas',
+                                                  'Lucida Sans Typewriter',
+                                                  'Ubuntu Mono',
+                                                  'DejaVu Sans Mono',
+                                                  'Bitstream Vera Sans Mono']]
+if prefered_fonts:
+    font_name=prefered_fonts[0]
+print("Using font: ", font_name)
+
+text_class_params=dict()
+text_class_params['TextBox']=dict(window=window,
+                                text=text, 
+                                font_name=font_name,
+                                font_size=28,
+                                font_color=[255,255,255],
+                                size=(1.5,.5),
+                                pos=(0.0,.5), 
+                                units='norm',
+                                grid_horz_justification='left',
+                                grid_vert_justification='center',
+                                color_space='rgb255')
+text_class_params['TextBox2']=dict(win=window, 
+                                text=text,
+                                font=font_name,
+                                borderColor=None, 
+                                fillColor=[0,0,0],
+                                pos=(0.0,-0.1),
+                                units='height',
+                                anchor='center',
+                                letterHeight=0.03,
+                                editable=False,
+                                size=[1.5,.33])
+text_class_params['TextStim']=dict(win=window,
+                                pos=(0.0,-0.5),
+                                font=font_name,
+                                units='norm',
+                                height=0.06,
+                                text=text,
+                                autoLog=False,
+                                wrapWidth=1.5)
+
+# Create each stim type and perform draw on it. Time how long it takes 
+# to create the initial stim and do the initial draw. 
+for ttype in text_stim_types:
+    cname = ttype.__name__
+    stime=core.getTime()                                   
+    text_stim.append(ttype(**text_class_params[cname]))
+    text_stim[-1].draw()
+    etime=core.getTime()
+    stim_init_durations[cname]=etime-stime
+
+
+# Start the draw duration tests, for text change and no text change conditions.
+demo_start=window.flip()     
+event.clearEvents()
+fcount=0
+
+while True:
+    # For the textBox and TextStim resource, change the text every
+    # chng_txt_each_flips, and record the time it takes to update the text
+    # and redraw() each resource type.
+    #
+   
+    # Make sure timing of stim is for the time taken for that stim alone. ;)
+    gl.glFlush()
+    gl.glFinish()
+
+    if fcount==0 or fcount%chng_txt_each_flips==0:
+        t=getRandomString(text_length)
+        
+        for tstim in text_stim:
+            cname = tstim.__class__.__name__
+            stime=core.getTime()*1000.0
+            tstim.setText(tstim.__class__.__name__+t)
+            tstim.draw()
+            gl.glFinish()
+            etime=core.getTime()*1000.0 
+            txt_change_draw_times[cname].append(etime-stime)
+
+    else:
+        for tstim in text_stim:    
+            cname = tstim.__class__.__name__
+            stime=core.getTime()*1000.0
+            tstim.draw()
+            gl.glFinish()
+            etime=core.getTime()*1000.0 
+            no_change_draw_times[cname].append(etime-stime)
+        
+    # Update the display to show stim changes
+    flip_time=window.flip()
+    fcount+=1
+
+    # End the test when a keyboard event is detected or when max_flip_count
+    # win.flip() calls have been made.
+    #
+    kb_events=event.getKeys()
+    if kb_events:
+        break
+    if fcount>=max_flip_count:
+        break
+
+print()
+print('-------Text Draw Duration Test---------')
+print()
+print('+ Draw Order: {}\t'.format([c.__name__ for c in text_stim_types]))
+print('+ Text Stim Char Length:\t',text_length)
+print()
+for stim_type,init_dur in stim_init_durations.items():
+    print('+ {} INIT Dur (sec):\t{}'.format(stim_type, init_dur))
+print()
+print('+ Text Change Flip Perc:\t%.2f'%((1.0/chng_txt_each_flips)*100.0))
+print('+ Total Flip Count:\t\t',fcount)
+print('+ Test Duration (secs):\t\t%.3f'%(flip_time-demo_start))
+print('+ FPS:\t\t\t\t%.3f'%(fcount/(flip_time-demo_start)))
+print()
+print('+ Average Draw Call Durations (msec):')
+print()
+print('  Text Object\t\tNo Txt Change\tTxt Change')
+for stim_type in text_stim_types:
+    cname = stim_type.__name__
+    print('  %s\t\t%.3f\t\t%.3f'%(cname, 
+                                  no_change_draw_times[cname].mean(),
+                                  txt_change_draw_times[cname].mean()))
+print()
+    
+core.quit()

psychopy/demos/coder/stimuli/counterphase.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+There are many ways to generate counter-phase, e.g. vary the contrast of
+a grating sinusoidally between 1 and -1, take 2 gratings in opposite phase
+overlaid and vary the opacity of the upper one between 1: 0, or take two
+gratings overlaid with the upper one of 0.5 opacity and drift them
+in opposite directions.
+
+This script takes the first approach as a test of how fast
+contrast textures are being rewritten to the graphics card
+"""
+from psychopy import core, visual, event
+from numpy import sin, pi
+
+# Create a window to draw in
+win = visual.Window((600, 600), allowGUI=False, monitor='testMonitor', units='deg')
+
+# Initialize some stimuli
+grating1 = visual.GratingStim(
+    win, tex="sin", mask="circle", texRes=128,
+    color='white', size=5, sf=2, ori=45, depth=0.5, autoLog=False)
+message = visual.TextStim(
+    win, text='Any key to quit',
+    pos=(-0.95, -0.95), units='norm',
+    anchorVert='bottom', anchorHoriz='left')
+
+trialClock = core.Clock()
+t = 0
+while not event.getKeys() and t < 20:  # quits after 20 secs
+    t = trialClock.getTime()
+
+    grating1.contrast = sin(t * pi * 2)
+    grating1.draw()
+    message.draw()
+
+    win.flip()
+
+win.close()
+core.quit()
+
+# The contents of this file are in the public domain.