コード例 #1
0
ファイル: psychopyscreen.py プロジェクト: TCRichards/Insights
	def draw_polygon(self, pointlist, colour=None, pw=1, fill=True):

		"""Draws a polygon on the screen
		
		arguments
		pointlist	-- a list of (x,y) tuples resembling the cornerpoints
				   of the polygon
		
		keyword arguments
		colour	-- colour for the circle (a colour name (e.g. 'red') or
				   a RGB(A) tuple (e.g. (255,0,0) or (255,0,0,255))) or
				   None for the default foreground colour, self.fgc
				   (default = None)
		pw		-- penwidth: polygon line thickness (default = 1)
		fill		-- Boolean indicating whether polygon should be filled
				   or not (default = False)
		
		returns
		Nothing	-- draws a polygon on (PyGame) or adds a ShapeStim
				   stimulus to (PsychoPy) the self.screen property
		"""

		if colour == None:
			colour = self.fgc

		colour = rgb2psychorgb(colour)
		pl = []
		for pos in pointlist:
			pl.append(pos2psychopos(pos,dispsize=self.dispsize))

		if fill:
			self.screen.append(ShapeStim(pygaze.expdisplay, lineWidth=pw, lineColor=colour, lineColorSpace='rgb', fillColor=colour, fillColorSpace='rgb',vertices=pl, closeShape=True))
		else:
			self.screen.append(ShapeStim(pygaze.expdisplay, lineWidth=pw, lineColor=colour, lineColorSpace='rgb', fillColor=rgb2psychorgb(self.bgc), fillColorSpace='rgb',vertices=pl, closeShape=True))
コード例 #2
0
def genMask(size, dir):
    # Store coordinates of the edges of the screen. Top right, bottom right,
    # bottom left, top left
    coords = [[300, 300], [300, -300], [-300, -300], [-300, 300]]

    if dir == 0:  # Right (0°)
        # Reduce the x coordinates for the right of the mask to the center + the
        # distance needed to cover the characters at the center of the screen
        coords[0][0] = 0 + ((size * 0.75) * 2)
        coords[1][0] = 0 + ((size * 0.75) * 2)
    elif dir == 1:  # Down (270°)
        # Reduce the y coordinates for the bottom of the mask to the center - the
        # distance needed to cover the characters at the center of the screen
        coords[0][1] = 0 - ((size * 0.85) * 2)
        coords[3][1] = 0 - ((size * 0.85) * 2)
    elif dir == 2:  # Left (180°)
        # Reduce the x coordinates for the left of the mask to the center + the
        # distance needed to cover the characters at the center of the screen
        coords[2][0] = 0 - ((size * 0.75) * 2)
        coords[3][0] = 0 - ((size * 0.75) * 2)
    elif dir == 3:  # Up (90°)
        # Reduce the y coordinates for the top of the mask to the center + the
        # distance needed to cover the characters at the center of the screen
        coords[0][1] = 0 + ((size * 0.85) * 1.5)
        coords[3][1] = 0 + ((size * 0.85) * 1.5)

    # Convert the coords to a list of tuples
    verts = list(map(tuple, coords))

    # Generate a grey shape with the coordinates as vertices
    mask = ShapeStim(win, vertices=verts, fillColor='grey', size=.5,\
         lineColor='grey')

    # Display the mask shape
    mask.draw()
コード例 #3
0
    def test_isPressedIn(self):
        m = event.Mouse(self.win, newPos=(0,0))
        s = ShapeStim(self.win, vertices=[[10,10],[10,-10],[-10,-10],[-10,10]], autoLog=False)
        if not s.contains(m.getPos()):
            pytest.skip()  # or cant test

        event.mouseButtons = [1, 1, 1]
        assert m.isPressedIn(s)
コード例 #4
0
ファイル: online_experiment.py プロジェクト: wozu-dichter/BCI
def stimuli_blinking_nonstop(frame_on1, frame_off1, frame_on2, frame_off2,
                             frame_on3, frame_off3, shapes, arrow):

    looptime = math.gcd(frame_on1, math.gcd(frame_on2, frame_on3))

    global flipCount

    while True:
        # if flipCount == 59:
        #     flipCount = 0
        if (flipCount == 0 or (flipCount % frame_on1 == 0 and flipCount %
                               (frame_on1 * 2) != 0)):
            shapes[0].setAutoDraw(True)
            shapes[1].setAutoDraw(False)
        if (flipCount % (frame_off1 * 2) == 0):
            shapes[1].setAutoDraw(True)
            shapes[0].setAutoDraw(False)

        if (flipCount == 0 or (flipCount % frame_on2 == 0 and flipCount %
                               (frame_on2 * 2) != 0)):
            shapes[2].setAutoDraw(True)
            shapes[3].setAutoDraw(False)
        if (flipCount % (frame_off2 * 2) == 0):
            shapes[3].setAutoDraw(True)
            shapes[2].setAutoDraw(False)

        if (flipCount == 0 or (flipCount % frame_on3 == 0 and flipCount %
                               (frame_on3 * 2) != 0)):
            shapes[4].setAutoDraw(True)
            shapes[5].setAutoDraw(False)
        if (flipCount % (frame_off3 * 2) == 0):
            shapes[5].setAutoDraw(True)
            shapes[4].setAutoDraw(False)

        # time = trialclock.getTime()

        # for frameN in range(looptime):
        mywin.flip()
        flipCount += 1

        result = marker_result()
        if (result):
            print("Marker received: ", result[0][0])
            arrow.setAutoDraw(False)
            arrow = ShapeStim(mywin,
                              vertices=arrowVert,
                              fillColor='darkred',
                              size=.2,
                              lineColor='red',
                              pos=arrowSequence[result[0][0]])
            arrow.setAutoDraw(True)
            mywin.flip()
            core.wait(2.0)

        if 'escape' in event.getKeys():
            core.quit()
コード例 #5
0
def ChoiceConfidenceTrial(TopImage, BottomImage, Clock, Screen, tStim, bStim,
                          expData, presTime, waitTime):
    """ForcedChoiceTrial plays one trial of a forced choice paradigm given time and stimuli and returns the keypresses of the individual"""
    first = [(-1, -1), (-1, -1)]
    #set the argument images to the matching image object
    TopImage.setImage(tStim)
    BottomImage.setImage(bStim)
    #fixation cross
    fx = ShapeStim(Screen,
                   vertices='cross',
                   size=1,
                   pos=(0, 0),
                   lineColor='red',
                   fillColor='red')

    expData.addData("tStim", os.path.basename(tStim))
    expData.addData("bStim", os.path.basename(bStim))

    #draw the fixation cross to the screen
    fx.draw()

    Screen.flip()
    #reset clock for counting and reaction times
    Clock.reset()

    #fixation cross wait, make consistent at 1 second for now
    core.wait(1, 1)

    #draw the stimuli to the screen's buffer
    TopImage.draw(Screen)
    BottomImage.draw(Screen)

    #present the stimuli simultaneously by flipping the buffer
    Screen.flip()
    #reset the clock on next cpu tick to allow for stimulus duration
    Clock.reset()
    #Wait for the given amount of time in arg 4, still listen for keypresses though
    core.wait(presTime, presTime)

    q = visual.TextStim(Screen, text="Which image was clearer? Top/Bottom?")
    #draw to the buffer
    q.draw()
    #flip screen back to blank. This is the response screen
    Screen.flip()
    #reset clock for counting and reaction times
    Clock.reset()

    core.wait(waitTime, waitTime)
    #pull the input from the participant's trial and return it
    #if event.getKeys(None, False, Clock) != 0:

    first = event.getKeys(None, False, Clock)

    #return pressed Keys
    return (first)
コード例 #6
0
ファイル: test_event.py プロジェクト: NSalem/psychopy
    def test_isPressedIn(self):
        if travis:
            pytest.skip()
        # travis error: ValueError: Monitor __blank__ has no known size in pixels (SEE MONITOR CENTER)

        m = event.Mouse(self.win, newPos=(0,0))
        s = ShapeStim(self.win, vertices=[[10,10],[10,-10],[-10,-10],[-10,10]], autoLog=False)
        if not s.contains(m.getPos()):
            pytest.skip()  # or cant test

        event.mouseButtons = [1, 1, 1]
        assert m.isPressedIn(s)
コード例 #7
0
    def __init__(self, logfile, imgDir, screenType, expVariant, trialDuration,
                 ISI, trialsPer, selfPaced, practiceTrials, inputButtons,
                 pauseButton):

        self.logfile = logfile
        self.expVariant = expVariant
        self.trialDuration = trialDuration
        self.selfPaced = selfPaced
        self.ISI = ISI
        self.trialsPer = trialsPer
        self.imgDir = imgDir
        self.leftOvers = []
        self.splitLures = self.SplitLures()
        self.splitSingles = self.SplitSingles()
        self.runPracticeTrials = practiceTrials
        self.leftButton = inputButtons[0]
        self.rightButton = inputButtons[1]
        self.pauseButton = pauseButton

        if (screenType == 'Windowed'):
            screenSelect = False
        elif (screenType == 'Fullscreen'):
            screenSelect = True

        self.window = Window(fullscr=screenSelect,
                             units='pix',
                             color='White',
                             allowGUI=False)
        self.imageWidth = self.window.size[1] / 3

        #Define the black box that appears in the lower left, to signal EEG
        rW = 110  #Width
        rH = 60  #Height
        rectVertices = [[rW, -rH], [-rW, -rH], [-rW, rH], [rW, rH]]
        rectCenter = [(-self.window.size[0] / 2 + rW),
                      (-self.window.size[1] / 2) + rH]
        self.blackBox = ShapeStim(self.window,
                                  fillColor='black',
                                  units='pix',
                                  fillColorSpace='rgb',
                                  vertices=rectVertices,
                                  closeShape=True,
                                  interpolate=True,
                                  pos=rectCenter)
        self.rangeITI = numpy.arange(1, 1.4, .001)

        self.clock = Clock()

        #Initialize scorelist for 4 categories|| [correct,incorrect,response]
        self.scoreList = []
        for i in range(0, 4):
            self.scoreList.append([0, 0, 0])
コード例 #8
0
 def FixationCue():
     RectC_Cue = ShapeStim(
         win=expwin,
         units="deg",
         lineWidth=10,
         lineColor=[-1, -1, -1],
         fillColor=None,
         vertices=[[-1.25, 1.25], [-1.25, -1.25], [1.25, -1.25],
                   [1.25, 1.25]],
     )
     RectC_Cue.draw()
     CrossLineH.draw()
     CrossLineV.draw()
     RectR.draw()
     RectL.draw()
コード例 #9
0
ファイル: psychopyscreen.py プロジェクト: johnbone25/PyGaze
    def draw_line(self, colour=None, color=None, spos=None, epos=None, pw=1):
        """Draws a line on the screen
        
        arguments
        None
        
        keyword arguments
        colour    -- colour for the circle (a colour name (e.g. 'red') or
                   a RGB(A) tuple (e.g. (255,0,0) or (255,0,0,255))) or
                   None for the default foreground colour, self.fgc
                   (default = None)
        spos        -- line start, an (x,y) position tuple or None for a
                   quarter x and a central y position (default = None)
        epos        -- line end, an (x,y) position tuple or None for a
                   three-quarter x and a central y position (default =
                   None)
        pw        -- penwidth: line thickness (default = 1)
        
        returns
        Nothing    -- draws a line on (PyGame) or adds a Line stimulus to
                   (PsychoPy) the self.screen property
        """

        if color is None and colour is None:
            pass
        elif color is None and colour is not None:
            pass
        elif color is not None and colour is None:
            colour = color
        elif colour != color:
            raise Exception(
                "The arguments 'color' and 'colour' are the same, but set to different values: color={}, colour={}"
                .format(color, colour))

        if colour is None:
            colour = self.fgc
        if spos is None:
            spos = (int(self.dispsize[0] * 0.25), self.dispsize[1] / 2)
        if epos is None:
            epos = (int(self.dispsize[0] * 0.75), self.dispsize[1] / 2)

        colour = rgb2psychorgb(colour)
        spos = pos2psychopos(spos, dispsize=self.dispsize)
        epos = pos2psychopos(epos, dispsize=self.dispsize)

        # The `Line` class appears to be broken in a recent update of
        # PsychoPy. Hence the fallback to `ShapeStim`. See also:
        # <https://groups.google.com/forum/#!topic/psychopy-dev/1sKn6RrqH-8>
        #self.screen.append(Line(pygaze.expdisplay, start=spos, end=epos, \
        #    lineColor=colour, lineColorSpace='rgb', lineWidth=pw))
        stim = ShapeStim(pygaze.expdisplay, lineWidth=pw, \
            vertices=[spos, epos], lineColor=colour)

        self.screen.append(stim)
コード例 #10
0
ファイル: mdts.py プロジェクト: yassalab/MDT-Suite
    def ImageDiagnostic(self):
        """Draws colored dots onto the window. The dots' positions represent
        the respective location of where images will be placed throughout the
        course of the task.

        This function is to only be used as a diagnostic tool, so that one can
        get a general sense of where images might appear, without having to 
        actually run through the task. To use this function properly:
            taskSpatial = mdts.MDTS(...)
            taskSpatial.ImageDiagnostic
            #taskSpatial.RunExp()
        """
        win = self.window
        cRad = 50
        tp = self.trialsPer
        ls = self.imageList
        shapes = []
        leng = len(ls)
        for i in range(0, leng):
            color = "black"
            #print "{:<24}{:<15}{:<15}".format(img[0],img[1],img[2])
            img = ls[i]
            if i < tp:
                color = "black"
            elif (i > tp) and (i < tp * 2):
                color = "blue"
            elif (i > tp * 2) and (i < tp * 3):
                color = "orange"
            elif i > tp * 3:
                color = "green"

            shapes.append(Circle(win, radius=cRad, pos=img[1],
                                 fillColor=color))
            shapes.append(Circle(win, radius=cRad, pos=img[2],
                                 fillColor=color))
            shapes.append(
                ShapeStim(win,
                          units='pix',
                          lineWidth=5,
                          lineColor=color,
                          vertices=(img[1], img[2])))

            for shape in shapes:
                shape.draw(self.window)

            self.window.flip()
        waitKeys(keyList=['escape'])
        self.window.close()
コード例 #11
0
def genMask(points):
    radius = angleCalc(foveaRadius)

    maskVerts = list(range(0))
    interval = points / 4

    for i in range(2):

        vertices = list(range(0))
        count = 0

        for i in range(points):

            quadrant, interval, xSign, ySign = findQuadrant(
                i, points, interval, 0)

            x = ((radius / interval) * count)
            y = (math.sqrt((radius**2) - (x**2)))
            if int(x) == 0:
                x = 0.01
            if int(y) == 0:
                y = 0.01
            x = round(x, 2) * xSign
            y = round(y, 2) * ySign

            vertex = tuple([x, y])
            vertices.append(vertex)

            if quadrant == 1 or quadrant == 3:
                count = count + 1
            else:
                count = count - 1

        maskVerts.append(vertices)
        radius = radius * 15

    mask = ShapeStim(win,
                     vertices=maskVerts,
                     fillColor='grey',
                     lineWidth=0,
                     size=1,
                     units='cm',
                     pos=(0, 0))

    return mask
コード例 #12
0
 def Line2():
     TargetLine2_1 = ShapeStim(win=expwin,
                               units="deg",
                               lineWidth=2,
                               lineColor=[-1, -1, -1],
                               vertices=Line_Shape2[0][0],
                               closeShape=False,
                               pos=theLoc2)
     TargetLine2_2 = ShapeStim(win=expwin,
                               units="deg",
                               lineWidth=2,
                               lineColor=[-1, -1, -1],
                               vertices=Line_Shape2[0][1],
                               closeShape=False,
                               pos=theLoc2)
     TargetLine2_1.draw()
     TargetLine2_2.draw()
     CenterBox()
     RectR.draw()
     RectL.draw()
コード例 #13
0
    def CueDisplay():

        #此处暂时设定i值为0。正式实验流程再进行调整
        CueRect_L = ShapeStim(win=expwin,
                              units="deg",
                              lineWidth=CueLine1[0],
                              lineColor=[-1, -1, -1],
                              fillColor=None,
                              vertices=[[-1.25, 1.25], [-1.25, -1.25],
                                        [1.25, -1.25], [1.25, 1.25]],
                              pos=RectL_pos)
        CueRect_R = ShapeStim(win=expwin,
                              units="deg",
                              lineWidth=CueLine2[0],
                              lineColor=[-1, -1, -1],
                              fillColor=None,
                              vertices=[[-1.25, 1.25], [-1.25, -1.25],
                                        [1.25, -1.25], [1.25, 1.25]],
                              pos=RectR_pos)

        CueRect_L.draw()
        CenterBox()
        CueRect_R.draw()
コード例 #14
0
Demo of psychopy.visual.ShapeStim: lines and arbitrary fillable shapes

See shapeContains.py for dynamic interaction of ShapeStim and Mouse.
"""

from psychopy import visual, event, core
from psychopy.visual import ShapeStim

win = visual.Window(size=(500, 400), units='height')

# some shapes:
arrowVert = [(-0.4, 0.05), (-0.4, -0.05), (-.2, -0.05), (-.2, -0.1), (0, 0),
             (-.2, 0.1), (-.2, 0.05)]
arrow = ShapeStim(win,
                  vertices=arrowVert,
                  fillColor='darkred',
                  size=.5,
                  lineColor='red')

star7Vert = [(0.0, 0.5), (0.09, 0.18), (0.39, 0.31), (0.19, 0.04),
             (0.49, -0.11), (0.16, -0.12), (0.22, -0.45), (0.0, -0.2),
             (-0.22, -0.45), (-0.16, -0.12), (-0.49, -0.11), (-0.19, 0.04),
             (-0.39, 0.31), (-0.09, 0.18)]
star7 = ShapeStim(win,
                  vertices=star7Vert,
                  fillColor='green',
                  lineWidth=2,
                  lineColor='white')

# self-crossings are fine:
selfxVert = [(0, 0), (0, .2), (.2, 0), (.2, .2)]
コード例 #15
0
############################################################################################
win = psychopy.visual.Window(
    size=(scr_w, scr_h),
    units='pix',
    #fullscr=True,
    color=[1, 1, 1])

############################################################################################
# Definition of stimuli
############################################################################################
triangle = [(0, 3500), (-2500, -1500), (2500, -1500)]
rectangle = [(-2000, 2000), (-2000, -2000), (2000, -2000), (2000, 2000)]

rs_rect = ShapeStim(win,
                    vertices=rectangle,
                    fillColor=(1, 0, 0),
                    size=.05,
                    lineColor=(1, 0, 0))
rt_rect = psychopy.visual.TextStim(win=win,
                                   text="Red Square",
                                   color="red",
                                   pos=[0, 0],
                                   bold=True)

rs_tri = ShapeStim(win,
                   vertices=triangle,
                   fillColor=(1, 0, 0),
                   size=.05,
                   lineColor=(1, 0, 0))
rt_tri = psychopy.visual.TextStim(win=win,
                                  text="Red Triangle",
コード例 #16
0
ファイル: online_experiment.py プロジェクト: wozu-dichter/BCI
arrowVert = [(0, 0), (-0.1, 0.15), (-0.05, 0.15), (-0.05, 0.3), (0.05, 0.3),
             (0.05, 0.15), (0.1, 0.15)]

shapes = [
    patternup1, patternup2, patternright1, patternright2, patternleft1,
    patternleft2
]

# %%
#running the actual experiment
message = visual.TextStim(mywin,
                          text='Start recording and press space to continue')
message.draw()
mywin.flip()
while True:
    keys = event.getKeys()
    if 'space' in keys:  # If space has been pushed
        message.setText = ''
        message.draw()
        mywin.flip()
        arrow = ShapeStim(mywin,
                          vertices=arrowVert,
                          fillColor='darkred',
                          size=.5,
                          lineColor='red',
                          pos=arrowSequence[0])
        stimuli_blinking_nonstop(frame_on1, frame_off1, frame_on2, frame_off2,
                                 frame_on3, frame_off3, shapes, arrow)

# %%
コード例 #17
0
             units='pix',
             color=BACKGROUND,
             fullscr=False)

# draw instructions
instructionsStim = TextStim(win,
                            text=INSTRUCTIONS,
                            font="Arial",
                            pos=(0.0, 0.0),
                            color=FOREGROUND,
                            height=24)

# creating a fixation cross
fixStim = ShapeStim(win,
                    vertices=((0, -10), (0, 10), (0, 0), (-10, 0), (10, 0)),
                    lineWidth=3,
                    closeShape=False,
                    lineColor=FOREGROUND)

# create the left box
leftboxStim = Rect(win,
                   pos=BOX_LEFT,
                   width=BOXSIZE,
                   height=BOXSIZE,
                   lineColor=FOREGROUND,
                   lineWidth=3,
                   fillColor=None)
# create the right box
rightboxStim = Rect(win,
                    pos=BOX_RIGHT,
                    width=BOXSIZE,
コード例 #18
0
    expt_trial_type.append(14)
    expt_trial_type.append(15)
    expt_trial_type.append(16)

# Shuffle trial order:
np.random.shuffle(expt_trial_type)
########################################################################################
########################################################################################


########################################################################################
# Define the market screens:
########################################################################################
# Define your market screen:
your_fundi = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)],[(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]
your_fund = ShapeStim(win, vertices=your_fundi, fillColor='white', lineWidth=0, size=16, pos=(-14, 7))
# Define neighbour market screen:
n_fundi = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)],[(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]
n_fund = ShapeStim(win, vertices=n_fundi, fillColor='white', lineWidth=0, size=15, pos=(14, 7))
# Define your market screen PROFIT:
your_fundi_p = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)],[(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]
your_fund_p = ShapeStim(win, vertices=your_fundi_p, fillColor='green', lineWidth=0, size=16, pos=(-14, 7))
# Define neighbour market screen PROFIT:
n_fundi_p = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)],[(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]
n_fund_p = ShapeStim(win, vertices=n_fundi_p, fillColor='green', lineWidth=0, size=15, pos=(14, 7))
# Define your market screen LOSS:
your_fundi_l = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)],[(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]
your_fund_l = ShapeStim(win, vertices=your_fundi_l, fillColor='red', lineWidth=0, size=16, pos=(-14, 7))
# Define neighbour market screen LOSS:
n_fundi_l = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)],[(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]
n_fund_l = ShapeStim(win, vertices=n_fundi_l, fillColor='red', lineWidth=0, size=15, pos=(14, 7))
コード例 #19
0
def ChoiceConfidenceTrial(TopImage, BottomImage, flicker, Clock, Screen, tStim,
                          bStim, expData, presTime, waitTime):
    """ForcedChoiceTrial plays one trial of a forced choice paradigm given time and stimuli and returns the keypresses of the individual"""
    first = [(-1, -1), (-1, -1)]
    #set the argument images to the matching image object
    TopImage.setImage(tStim)
    BottomImage.setImage(bStim)
    #fixation cross
    fx = ShapeStim(Screen,
                   vertices='cross',
                   size=1,
                   pos=(0, 0),
                   lineColor='red',
                   fillColor='red')

    expData.addData("tStim", os.path.basename(tStim))
    expData.addData("bStim", os.path.basename(bStim))

    #draw the fixation cross to the screen
    fx.draw()

    Screen.flip()
    #reset clock for counting and reaction times
    Clock.reset()

    #fixation cross wait, make consistent at 1 second for now
    core.wait(1, 1)

    #draw the stimuli to the screen's buffer

    #4 hz flicker begin
    #if top image is flickered
    for i in range(2):
        xdiff = random.uniform(-.25, .25)
        ydiff = random.uniform(-.25, .25)

        if flicker == 0:
            BottomImage.pos = (0, -8)
            TopImage.pos = (0, 8)

        elif flicker == 1:  #flicker == 1, bottom image needs to be flickered
            #present the stimuli simultaneously by flipping the buffer
            #Screen.flip()
            BottomImage.pos = (0 + xdiff, -8 + ydiff)

        elif flicker == 2:
            #present the stimuli simultaneously by flipping the buffer
            #Screen.flip()
            TopImage.pos = (0 + xdiff, 8 + ydiff)
            #reset the clock on next cpu tick to allow for stimulus duration

        else:  #flicker == 3:
            #Screen.flip()
            TopImage.pos = (0 + xdiff, 8 + ydiff)
            BottomImage.pos = (0 + xdiff, -8 + ydiff)

        #Wait for the 1/3 given amount of time in arg 4, still listen for keypresses though
        TopImage.draw(Screen)
        BottomImage.draw(Screen)
        Screen.flip()
        Clock.reset()
        core.wait(presTime / 10, presTime / 10)

    BottomImage.pos = (0, -8)
    TopImage.pos = (0, 8)
    TopImage.draw(Screen)
    BottomImage.draw(Screen)
    Screen.flip()
    core.wait(2 * presTime / 3, 2 * presTime / 3)

    q = visual.TextStim(Screen, text="Which image was clearer? Top/Bottom?")
    #draw to the buffer
    q.draw()
    #flip screen back to blank. This is the response screen
    Screen.flip()
    #reset clock for counting and reaction times
    Clock.reset()

    core.wait(waitTime, waitTime)
    #pull the input from the participant's trial and return it
    #if event.getKeys(None, False, Clock) != 0:

    first = event.getKeys(None, False, Clock)

    #return pressed Keys
    return (first)
コード例 #20
0
    return condition


Cons = Conditions()

#设定屏幕
expwin = visual.Window((1280, 800),
                       monitor='testMonitor',
                       color=[255, 255, 255],
                       units="deg",
                       fullscr=True)
#设定中间的正方形
RectC = ShapeStim(
    win=expwin,
    units="deg",
    lineWidth=2,
    lineColor=[-1, -1, -1],
    fillColor=None,
    vertices=[[-1.25, 1.25], [-1.25, -1.25], [1.25, -1.25], [1.25, 1.25]],
)
#设定中间正方形的十字注视点
CrossLineH = ShapeStim(win=expwin,
                       units="deg",
                       lineWidth=2,
                       lineColor=[-1, -1, -1],
                       vertices=[[-0.75, 0], [0.75, 0]],
                       closeShape=False,
                       pos=[0, 0])
CrossLineV = ShapeStim(win=expwin,
                       units="deg",
                       lineWidth=2,
                       lineColor=[-1, -1, -1],
コード例 #21
0
ファイル: stroopII.py プロジェクト: zahrahussn/psychopy
colourList = ['red', 'green', 'blue', 'yellow']
stimList = []
for color in [1, 2, 3, 4]:
    stimList.append({'color': color})
trials = data.TrialHandler(stimList, 25)

trials.data.addDataType('accuracy')
trials.data.addDataType('RT')
clockRT = core.Clock()

for thisTrial in trials:
    c = int(trials.thisTrial['color']) - 1
    colour = colourList[c]
    square = ShapeStim(win,
                       vertices=SquareVert,
                       fillColor=colour,
                       lineWidth=0,
                       size=5,
                       pos=(0, 0))

    # show fixation point for one second
    for frameN in range(int(round(params['fp'] * params['frameRate']))):
        fixation.draw()
        win.update()

    # show square
    thisResponse = None
    while thisResponse == None:
        clockRT.reset()
        square.draw()
        win.update()
コード例 #22
0
# create window and stimuli
win = visual.Window(fullscr=True,
                    allowGUI=True,
                    monitor='attentionExperimentsMonitor',
                    units='deg')
win.mouseVisible = False
targetLeftVert = [(0.1, -0.1), (-0.1, 0), (0.1, 0.1)]
targetRightVert = [(-0.1, -0.1), (0.1, 0), (-0.1, 0.1)]
arrowCol = [-1, -1, -1]
linew = 4
arrowSize = 6
targetLeft = ShapeStim(win,
                       vertices=targetLeftVert,
                       size=arrowSize,
                       lineColor=arrowCol,
                       lineWidth=linew,
                       closeShape=False,
                       pos=[0, 0])
targetRight = ShapeStim(win,
                        vertices=targetRightVert,
                        size=arrowSize,
                        lineColor=arrowCol,
                        lineWidth=linew,
                        closeShape=False,
                        pos=[0, 0])
arrow2 = ShapeStim(win,
                   vertices=targetLeftVert,
                   size=arrowSize,
                   lineColor=arrowCol,
                   lineWidth=linew,
コード例 #23
0
                      text=n_fi,
                      pos=(-14, 3),
                      height=textsize,
                      wrapWidth=40,
                      alignHoriz='center')
########################################################################################

########################################################################################
# Define the market screens:
########################################################################################
# Define your market screen:
your_fundi = [[(-.2, -.2), (-.2, .2), (.2, .2), (.2, -.2)],
              [(-.15, -.15), (-.15, .15), (.15, .15), (.15, -.15)]]
your_fund = ShapeStim(win,
                      vertices=your_fundi,
                      fillColor='white',
                      lineWidth=0,
                      size=16,
                      pos=(-14, 7))
# Define neighbour market screen:
n_fundi = [[(-.2, -.2), (-.2, .2), (.2, .2), (.2, -.2)],
           [(-.15, -.15), (-.15, .15), (.15, .15), (.15, -.15)]]
n_fund = ShapeStim(win,
                   vertices=n_fundi,
                   fillColor='white',
                   lineWidth=0,
                   size=15,
                   pos=(14, 7))
# Define your market screen PROFIT:
your_fundi_p = [[(-.2, -.2), (-.2, .2), (.2, .2), (.2, -.2)],
                [(-.15, -.15), (-.15, .15), (.15, .15), (.15, -.15)]]
your_fund_p = ShapeStim(win,
コード例 #24
0
# create stimuli
fixation = visual.GratingStim(win, color='black', tex=None, mask='circle', size=0.2)
respond = visual.GratingStim(win, color='white', tex=None, mask='circle', size=0.3)

pr_grating = visual.GratingStim(
    win=win, name='grating_murray',units='deg', 
    tex='sin', mask='gauss',
    ori=params.grating_ori, pos=(0, 0), size=params.grating_deg, sf=params.spf, phase=0,
    color=[params.max_contr, params.max_contr, params.max_contr], colorSpace='rgb', opacity=1, blendmode='avg',
    texRes=128, interpolate=True, depth=0.0)
    
# `donut` has a true hole, using two loops of vertices:
donutVert = [[(-params.donut_outer_rad,-params.donut_outer_rad),(-params.donut_outer_rad,params.donut_outer_rad),(params.donut_outer_rad,params.donut_outer_rad),(params.donut_outer_rad,-params.donut_outer_rad)],
[(-params.donut_inner_rad,-params.donut_inner_rad),(-params.donut_inner_rad,params.donut_inner_rad),(params.donut_inner_rad,params.donut_inner_rad),(params.donut_inner_rad,-params.donut_inner_rad)]]
donut = ShapeStim(win, vertices=donutVert, fillColor=params.donut_color, lineWidth=0, size=.75, pos=(0, 0))

# text messages
welcome  = visual.TextStim(win, pos=[0, 0], 
    text = 'Welcome to the motion duration threshold study.\n\nPress SPACE bar to continue.')
instructions1 = visual.TextStim(win, pos=[0, 0], text = 'You will see a small patch of black and white stripes moving leftward or rightward.\n\nPress SPACE bar to continue.')
instructions2 = visual.TextStim(win, pos=[0, 0], text = 'Your need to detect whether the patch is moving to the left or the right.\n\nPress SPACE bar to continue.')
instructions3a = visual.TextStim(win, pos=[0, + 3],
    text='At first, you will see the small black dot appears, look at it. ')
instructions3b = visual.TextStim(win, pos=[0, -3],
    text="Then press SPACE bar to start the display. \n\nPress SPACE bar to continue.")
instructions4 = visual.TextStim(win, pos=[0, 0], text = 'After the small patch of black and white stripes disappear, you will see a white dot. It is the response cue. Once the white dot appears, press the LEFT arrow key if you see leftward motion and the RIGHT arrow key if you see rightward motion.\n\nIf you are not sure, just guess.\n\nYour goal is accuracy, not speed.\n\nPress SPACE bar to continue.')
instructions5 = visual.TextStim(win, pos=[0, 0], text = 'Let us try some easy practice trials. \n\nPress SPACE bar to continue.')
instructionsIncorrect = visual.TextStim(win, pos=[0, 0], text = 'Almost. Make sure to pay close attention.')
instructionsCorrect = visual.TextStim(win, pos=[0, 0], text = 'Awesome.')
instructions6 = visual.TextStim(win, pos=[0, 0], text = 'Do you have any questions? If not, press SPACE bar to get started!')
    texRes=128,
    interpolate=True,
    depth=0.0)

# `donut` has a true hole, using two loops of vertices:
donutVert = [[(-params.donut_outer_rad, -params.donut_outer_rad),
              (-params.donut_outer_rad, params.donut_outer_rad),
              (params.donut_outer_rad, params.donut_outer_rad),
              (params.donut_outer_rad, -params.donut_outer_rad)],
             [(-params.donut_inner_rad, -params.donut_inner_rad),
              (-params.donut_inner_rad, params.donut_inner_rad),
              (params.donut_inner_rad, params.donut_inner_rad),
              (params.donut_inner_rad, -params.donut_inner_rad)]]
donut = ShapeStim(win,
                  vertices=donutVert,
                  fillColor=params.donut_color,
                  lineWidth=0,
                  size=.75,
                  pos=(0, 0))

message1 = visual.TextStim(win, pos=[0, +3], text='Hit a key when ready.')
message2 = visual.TextStim(
    win,
    pos=[0, -3],
    text=
    "When the white box appears, press LEFT arrow to identify leftward motion or the RIGHT arrow to identify rightward motion."
)

# create the staircase handler
if params.staircase_style == 'quest':
    staircase = data.MultiStairHandler(stairType='quest',
                                       conditions=params.conditions_QUEST,
コード例 #26
0
def main(fCue, fStim, fInterval, fTest, fPause, tPerBlock, stimType,
         targChange, trialType, cue, numTrials, blocks):

    fCue = fCue
    fStim = fStim
    fTest = fTest
    fPause = fPause
    tPerBlock = tPerBlock
    stimType = stimType
    targChange = targChange
    trialType = trialType
    cue = cue
    numTrials = numTrials

    # 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 = 'Change Detection.py'
    expInfo = {'session': '001', 'participant': ''}
    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

    # Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
    filename = _thisDir + os.sep + u'data/%s_%s_%s' % (
        expInfo['participant'], expName, expInfo['date'])

    # An ExperimentHandler isn't essential but helps with data saving
    thisExp = data.ExperimentHandler(name=expName,
                                     version='',
                                     extraInfo=expInfo,
                                     runtimeInfo=None,
                                     originPath=None,
                                     savePickle=True,
                                     saveWideText=True,
                                     dataFileName=filename)
    # save a log file for detail verbose info
    logFile = logging.LogFile(filename + '.log', level=logging.EXP)
    logging.console.setLevel(
        logging.WARNING)  # this outputs to the screen, not a file

    endExpNow = False  # flag for 'escape' or other condition => quit the exp

    win = visual.Window(size=[1600, 900], units='height', fullscr=True)

    # KEYBOARD STUFF
    # Start iohub process. The iohub process can be accessed using `io`.
    io = launchHubServer()
    # A `keyboard` variable is used to access the iohub Keyboard device.
    keyboard = io.devices.keyboard
    events = keyboard.getKeys()

    # INITIALIZE
    # trialN       : number of trial
    # trialResp    : their response on each trial
    # correctResp  : if their response was correct
    # responseTime : the amount of time it took for them to respond on each trial
    m = 0
    trialN = [-1 for x in range(numTrials)]
    trialResp = [9 for x in range(numTrials)]
    correctResp = [9 for x in range(numTrials)]
    responseTime = [0 for x in range(numTrials)]
    pauseTime = [0 for x in range(blocks)]
    respChar = [['r', 'i'], ['f', 'j']]

    # Which stim to display
    # true if rectangles, false if cubes
    rectangles = not stimType

    # STIMULI
    pauseText = visual.TextStim(win,
                                text="Press the Spacebar to Continue",
                                font=u'Arial',
                                pos=(0, 0),
                                height=0.1,
                                wrapWidth=None,
                                ori=0,
                                color=u'white',
                                colorSpace='rgb',
                                opacity=1,
                                depth=0.0)
    fixation = visual.Line(win,
                           start=(-.025, 0),
                           end=(.025, 0),
                           lineColor='black',
                           lineWidth=4)
    fixation2 = visual.Line(win,
                            start=(0, -.025),
                            end=(0, 0.025),
                            lineColor='black',
                            lineWidth=4)
    arrowLeft = ShapeStim(win,
                          vertices=[(.03, .04), (-.03, .04), (-.03, .05),
                                    (-.05, .04), (-.03, .03), (-.03, .04)],
                          lineColor='black',
                          fillColor='black',
                          lineWidth=3)
    arrowRight = ShapeStim(win,
                           vertices=[(-.03, .04), (.03, .04), (.03, .05),
                                     (.05, .04), (.03, .03), (.03, .04)],
                           lineColor='black',
                           fillColor='black',
                           lineWidth=3)

    for t in range(numTrials):
        trialTime = time.time()
        if (t % tPerBlock == 0) & (t > 1):
            event.clearEvents(eventType='keyboard')
            waiting = []
            tStart = time.time()
            while not 'space' in waiting:
                waiting = event.getKeys(keyList=['space'])
                pauseText.draw()
                win.flip()
            pauseTime = time.time() - tStart
            thisExp.addData('pauseTime', pauseTime)

        trialN[t] = t + 1

        # STIM PRESENTATION
        randTrial = random.randint(1, 100)
        # THIS IS 1920 X 1080 VERSION
        stimName = 'stimType%d_trialType%d_cue%d_order%d (%d)_resized.png' % (
            stimType, trialType[t], cue[t], 0, randTrial)
        stimDir = '%d%d%d_resized/' % (stimType, trialType[t],
                                       cue[t]) + stimName
        # presents cue
        for frameN in range(fCue + 1):
            fixation.draw()
            fixation2.draw()
            if cue[t]:
                arrowRight.draw()
            else:
                arrowLeft.draw()
            win.flip()

        # presents stim
        for frameN in range(fStim + 1):
            stim = visual.ImageStim(win, image=stimDir)
            stim.draw()
            win.flip()

        # presents interval
        for frameN in range(fInterval + 1):
            fixation.draw()
            fixation2.draw()
            win.flip()

        # presents test array
        if targChange[t]:
            stimName = 'stimType%d_trialType%d_cue%d_order%d (%d).png' % (
                stimType, trialType[t], cue[t], 1, randTrial)
            stimDir = '%d%d%d/' % (stimType, trialType[t], cue[t]) + stimName
            stim = visual.ImageStim(win, image=stimDir)
        startT = time.time()
        for frameN in range(fTest + 1):
            theseKeys = event.getKeys(keyList=['r', 'f', 'i', 'j'])
            if len(theseKeys) > 0:  # at least one key was pressed
                trialResp[t] = theseKeys[-1]  # just the last key pressed
                responseTime[t] = time.time() - startT
            stim.draw()
            win.flip()

        # presents interval
        for frameN in range(fPause + 1):
            fixation.draw()
            fixation2.draw()
            win.flip()

        if cue[t]:
            if targChange[t]:
                if trialResp[t] == 'i':
                    correctResp[t] = 1
                else:
                    correctResp[t] = 0
            else:
                if trialResp[t] == 'j':
                    correctResp[t] = 1
                else:
                    correctResp[t] = 0
        else:
            if targChange[t]:
                if trialResp[t] == 'r':
                    correctResp[t] = 1
                else:
                    correctResp[t] = 0
            else:
                if trialResp[t] == 'f':
                    correctResp[t] = 1
                else:
                    correctResp[t] = 0

        # OUTPUT
        thisExp.addData('stimType', stimType)
        thisExp.addData('trialType', trialType[t])
        thisExp.addData('targChange', targChange[t])
        thisExp.addData('cue', cue[t])
        thisExp.addData('startTime', trialTime)
        thisExp.addData('responseTime', responseTime[t])
        thisExp.addData('trialKeyPress', trialResp[t])
        thisExp.addData('correctResponse', correctResp[t])
        thisExp.addData('trialNumber', trialN[t])
        thisExp.addData('stimulusHandle', stimName)
        thisExp.nextEntry()

    # these shouldn't be strictly necessary (should auto-save)
    thisExp.saveAsWideText(filename + '.csv')
    thisExp.saveAsPickle(filename)
    logging.flush()
    # make sure everything is closed down
    thisExp.abort()  # or data files will save again on exit
    origLUT = numpy.round(win.backend._origGammaRamp *
                          65535.0).astype("uint16")
    origLUT = origLUT.byteswap() / 255.0
    win.backend._origGammaRamp = origLUT
    win.close()
    core.quit()
コード例 #27
0
reference = pd.read_csv(('reference.csv'), header=0)
win = visual.Window([1000, 750],
                    monitor="testMonitor",
                    units="deg",
                    fullscr=True,
                    allowGUI=False,
                    screen=1)
responseKeys = ('2', '3', 'z')

#Setting image, face, fixation, and timing. Writing instructions
fixation = visual.TextStim(win, text="+", height=2)
arrowVert_down = [(0.05, .2), (-0.05, 0.2), (-0.05, 0), (-0.1, 0), (0, -.2),
                  (0.1, 0), (0.05, 0)]
down_arrow = ShapeStim(win,
                       vertices=arrowVert_down,
                       fillColor='darkred',
                       size=10,
                       lineColor='darkred')
arrowVert_up = [(0.05, -.2), (-0.05, -0.2), (-0.05, 0), (-0.1, 0), (0, .2),
                (0.1, 0), (0.05, 0)]
up_arrow = ShapeStim(win,
                     vertices=arrowVert_up,
                     fillColor='green',
                     size=10,
                     lineColor='green')

fixation_time = 0.54
decision_time = 3.0
fb_dur = 1.0

#instruction display settings, variables are from imported instructions file
コード例 #28
0
        # Get coordinates for stars! (different depending on value of visible card)
        if trial['visible_card'] == 1:
            starLocations = [(0, 0)]

        elif trial['visible_card'] == 2:
            starLocations = [(0, 0.2), (0, -0.2)]

        else:  # visible_card is 3
            starLocations = [(0, .35), (0, 0), (0, -.35)]

        starVertices = [makeStar(coords, .25) for coords in starLocations]
        for star in starVertices:
            starStim = ShapeStim(w,
                                 vertices=star,
                                 fillColor='green',
                                 lineWidth=2,
                                 lineColor='white')
            starStim.draw()

        w.flip()
        rt = core.Clock()

        keys = event.waitKeys(keyList=['z', 'm'], timeStamped=rt)
        trialData = trial.copy()
        trialData['key'] = keys[0][0]
        trialData['rt'] = keys[0][1]
        trialData['response'] = 'keep' if trialData['key'] == 'z' else 'switch'
        trialData['reward'] = trialData['hidden_card'] if trialData[
            'response'] == 'switch' else trialData['visible_card']
        lastReward = trialData['reward']
コード例 #29
0
        0, 1
    )  #to choose which of the word pairs will be a target and which will be the study word.

    #The 4 letter words that are disconnected between the 2nd and 3rd letters are very far apart when x=1.75; identifying these words using the bounding box so that I decrease their x position.
    width1 = word1_left.boundingBox
    width2 = word2_left.boundingBox
    width3 = word1_right.boundingBox
    width4 = word2_right.boundingBox
    #    print(width1)
    #    print(width2)
    #    print(width3)
    #    print(width4)
    square1Vert = [(-5, -0.9), (-5, 1.5), (0, 1.5), (0, -0.9)]
    square1 = ShapeStim(win,
                        vertices=square1Vert,
                        fillColor=[0, 0, 0],
                        lineWidth=0,
                        size=.7)
    square2Vert = [(0, -0.82), (5, -0.82), (5, -3.5), (0, -3.5)]
    square2 = ShapeStim(win,
                        vertices=square2Vert,
                        fillColor=[0, 0, 0],
                        lineWidth=0,
                        size=.7)

    # #These loops help set the 2 halves of the 4 letter disconnected words closer to the midline as they normally would appear if they were aligned.
    #    if width1[0]<171:
    #        word1_left.pos=[-1.2,-1]
    #        print(word1_left.pos)
    #    else :
    #        x1=x1
コード例 #30
0
    width = Box_Dimen[0], height = Box_Dimen[1], \
    lineColor = FGC, lineWidth = 3)

#define the cue and create the cue windows (thicker border)
cue_Stim = {}

cue_Stim['left'] = Rect(disp, pos = Box_Coord['left'], \
    width = Box_Dimen[0], height = Box_Dimen[1], \
    lineColor = cue_Flash, lineWidth = 8)

cue_Stim['right'] = Rect(disp, pos = Box_Coord['right'],\
    width = Box_Dimen[0], height = Box_Dimen[1],\
    lineColor = cue_Flash, lineWidth = 8)

#create a fixation point/cross
fix_Stim = ShapeStim(disp, lineWidth = 100, lineColor = [1, 1, 1], \
    fillColor = [1, 1, 1], vertices = 'cross')

#create a dictionary for target display, and nested dict for different targets
targ_Stim = {}
targ_Stim['left'] = {}
targ_Stim['right'] = {}

targ_Stim['left']['P'] = Circle(disp, radius = 15, edges = 32, lineColor = FGC,\
    lineWidth = 5, fillColor = FGC, pos = Box_Coord['left'])
targ_Stim['right']['P'] = Circle(disp, radius = 15, edges = 32, lineColor = FGC,\
    lineWidth = 5, fillColor = FGC, pos = Box_Coord['right'])
targ_Stim['left']['C'] = Circle(disp, radius = 50, edges = 32, lineColor = FGC,\
    lineWidth = 5, fillColor = FGC, pos = Box_Coord['left'])
targ_Stim['right']['C'] = Circle(disp, radius = 50, edges = 32, lineColor = FGC,\
    lineWidth = 5, fillColor = FGC, pos = Box_Coord['right'])
コード例 #31
0
ファイル: VSTSaveImg.py プロジェクト: ketolm/VisualSearch
def main(fCue, fStim, fInterval, fTest, fPause, recLength, recWidth,
         cubeLength, cubeWidth, tPerBlock, stimType, arraySize, targPresent,
         numTrials):

    fStim = fStim
    fTest = fTest
    fPause = fPause
    recLength = recLength
    recWidth = recWidth
    cubeLength = cubeLength
    cubeWidth = cubeWidth
    tPerBlock = tPerBlock
    stimType = stimType
    arraySize = arraySize
    targPresent = targPresent
    numTrials = numTrials

    # Ensure that relative paths start from the same directory as this script
    _thisDir = os.path.dirname(os.path.abspath(__file__))
    os.chdir(_thisDir + u'\%s%s%s' % (targPresent[0], stimType, arraySize[0]))

    # Store info about the experiment session
    expName = 'VST.py'
    expInfo = {'session': '001', 'participant': ''}
    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

    # Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
    filename = _thisDir + os.sep + u'data/%s_%s_%s' % (
        expInfo['participant'], expName, expInfo['date'])

    # An ExperimentHandler isn't essential but helps with data saving
    thisExp = data.ExperimentHandler(name=expName,
                                     version='',
                                     extraInfo=expInfo,
                                     runtimeInfo=None,
                                     originPath=None,
                                     savePickle=True,
                                     saveWideText=True,
                                     dataFileName=filename)
    # save a log file for detail verbose info
    logFile = logging.LogFile(filename + '.log', level=logging.EXP)
    logging.console.setLevel(
        logging.WARNING)  # this outputs to the screen, not a file

    endExpNow = False  # flag for 'escape' or other condition => quit the exp

    # 300 x 2 x 10 x 1 matrix
    # 300 entries, xy for each shape, 10 shape locations
    f = open('genCoorVST.pckl', 'rb')
    genCoor = pickle.load(f)
    f.close()
    win = visual.Window([1600, 900], units='height', fullscr=True)
    clock = core.Clock()

    # KEYBOARD STUFF
    # Start iohub process. The iohub process can be accessed using `io`.
    io = launchHubServer()
    # A `keyboard` variable is used to access the iohub Keyboard device.
    keyboard = io.devices.keyboard
    events = keyboard.getKeys()

    # INITIALIZE
    # trialN       : number of trial
    # trialResp    : their response on each trial
    # correctResp  : if their response was correct
    # responseTime : the amount of time it took for them to respond on each trial
    m = 0
    trialN = [-1 for x in range(numTrials)]
    trialResp = [9 for x in range(numTrials)]
    correctResp = [9 for x in range(numTrials)]
    responseTime = [0 for x in range(numTrials)]
    respChar = [['r', 'i'], ['f', 'j']]
    numSet = 100
    rectangles = not stimType
    shapeN = [[], []]

    # COLORS
    recColors = ['#0000ff', '#ff0000']
    cubeColors = [['#0000ff', '#9999ff', '#000066'],
                  ['#ff0000', '#ff9999', '#660000']]

    # STIMULI
    center = [0, 0]
    posTheta = [0, math.pi / 4, math.pi / 2, 3 * math.pi / 4]
    posCubes = [0, 1]
    pauseText = visual.TextStim(win,
                                text="Press the Spacebar to Continue",
                                font=u'Arial',
                                pos=(0, 0),
                                height=0.1,
                                wrapWidth=None,
                                ori=0,
                                color=u'white',
                                colorSpace='rgb',
                                opacity=1,
                                depth=0.0)

    # rotates [x,y] by theta
    def rotate(xy, center, theta):
        #pts = {} Rotates points(nx2) about center by angle theta in radians
        return numpy.dot(
            xy - center,
            numpy.array([[math.cos(theta), math.sin(theta)],
                         [-math.sin(theta), math.cos(theta)]])) + center

    def rotateRec(center, theta):
        center = center
        theta = theta
        p1 = [center[0] - recWidth, center[1] - recLength]
        p2 = [center[0] - recWidth, center[1] + recLength]
        p3 = [center[0] + recWidth, center[1] + recLength]
        p4 = [center[0] + recWidth, center[1] - recLength]
        rVert = rotate(numpy.array([p1, p2, p3, p4]), center, theta)
        return rVert

    # creates a three-sided cube
    def cubeCreator(centerV, cubeType):
        center = centerV
        cubeType = cubeType
        if cubeType == 0:
            p1 = [center[0], center[1]]
            p2 = [center[0], center[1] - cubeLength]
            p3 = [center[0] - cubeWidth, center[1] - cubeLength / 2]
            p4 = [center[0] - cubeWidth, center[1] + cubeLength / 2]
            sideOne = [p1, p2, p3, p4]

            q1 = [center[0], center[1]]
            q2 = [center[0], center[1] - cubeLength]
            q3 = [center[0] + cubeWidth, center[1] - cubeLength / 2]
            q4 = [center[0] + cubeWidth, center[1] + cubeLength / 2]
            sideTwo = [q1, q2, q3, q4]

            r1 = [center[0], center[1]]
            r2 = [center[0] - cubeWidth, center[1] + cubeLength / 2]
            r3 = [center[0], center[1] + cubeLength]
            r4 = [center[0] + cubeWidth, center[1] + cubeLength / 2]
            sideThree = [r1, r2, r3, r4]
        else:
            m1 = [center[0], center[1]]
            m2 = [center[0], center[1] + cubeLength]
            m3 = [center[0] + cubeWidth, center[1] + cubeLength / 2]
            m4 = [center[0] + cubeWidth, center[1] - cubeLength / 2]
            sideOne = [m1, m2, m3, m4]

            n1 = [center[0], center[1]]
            n2 = [center[0], center[1] + cubeLength]
            n3 = [center[0] - cubeWidth, center[1] + cubeLength / 2]
            n4 = [center[0] - cubeWidth, center[1] - cubeLength / 2]
            sideTwo = [n1, n2, n3, n4]

            s1 = [center[0], center[1]]
            s2 = [center[0] - cubeWidth, center[1] - cubeLength / 2]
            s3 = [center[0], center[1] - cubeLength]
            s4 = [center[0] + cubeWidth, center[1] - cubeLength / 2]
            sideThree = [s1, s2, s3, s4]
            # k cubes x 3 sides x 4 vertices x 2 coordinates
        cVert = [sideOne, sideTwo, sideThree]
        return cVert

    def randShuf(inputList):
        shufList = inputList[:]
        while True:
            random.shuffle(shufList)
            for a, b in zip(inputList, shufList):
                if a == b:
                    break
                else:
                    return shufList

    def recDraw(frames, nStim, stimulus, changeT, order):
        frames = frames
        for k in range(nStim):
            stimulus[k].draw()
        print('stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
              (stimType, arraySize[t], t, targPresent[t], order))
        time.sleep(0.03)
        win.getMovieFrame(buffer='back')
        win.flip()
        win.saveMovieFrames(
            'stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
            (stimType, arraySize[t], t, targPresent[t], order))

    def cubeDraw(frames, nStim, stimulus, changeT, order):
        frames = frames
        for j in range(nStim):
            for k in range(3):
                stimulus[j][k].draw()
                stimulus[j][k].draw()
        print('stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
              (stimType, arraySize[t], t, targPresent[t], order))
        time.sleep(0.03)
        win.getMovieFrame(buffer='back')
        win.flip()
        win.saveMovieFrames(
            'stimType%d_arraySize%d_trial%d_targPresent%d_order%d.png' %
            (stimType, arraySize[t], t, targPresent[t], order))

    for t in range(numTrials):
        if (t % tPerBlock == 0) & (t > 1):
            waiting = []
            while not ' ' in waiting:
                pauseText.draw()
                win.flip()
                waiting = keyboard.getKeys()
        random.shuffle(recColors[0][0])
        trialN[t] = t + 1
        nStim = arraySize[t]
        shapes = [[] for i in range(nStim)]
        recStim = [[] for i in range(nStim)]
        recVert = [[] for i in range(nStim)]
        cubeV = [[] for i in range(nStim)]
        # 3 because 3 sides
        targCube = [[] for i in range(3)]
        cubeStim = [[[], [], []] for i in range(nStim)]
        stimIndex = nStim - 1

        # START WORKING HERE
        # Choose random trial and get center coordinates of objects
        # ASSUMING ARRAYSIZE[T] IS A VECTOR OF ARRAY SIZES
        # genCoor (300 x 2 x 10 x 1)
        #          300 sets, (X pos, Y pos), 10 points
        # x any y pos of arraySize[t] locations
        randInt = random.randint(0, numSet - 1)
        for j in range(0, nStim):
            xCoor = genCoor[randInt, 0, j]
            yCoor = genCoor[randInt, 1, j]
            shapes[j] = [xCoor[0], yCoor[0]]

        if rectangles:
            # create a unique rectangle that will only been seen once or not at all
            random.shuffle(posTheta)
            coinFlip = (random.random() > .5)
            targTheta = posTheta[0]
            targColor = coinFlip
            targRectVert = rotateRec([0, 0], targTheta)

            # creates unique rectangle for cue
            targRect = ShapeStim(win,
                                 vertices=targRectVert,
                                 fillColor=recColors[targColor],
                                 size=.5)

            # creates numRect rectangles with random orientations and random colors
            for k in range(nStim):
                coinFlip = (random.random() > .5)
                random.shuffle(posTheta)
                while posTheta[0] == targTheta and coinFlip == targColor:
                    coinFlip = (random.random() > .5)
                    random.shuffle(posTheta)
                recVert[k] = rotateRec(shapes[k], posTheta[0])
                recStim[k] = ShapeStim(win,
                                       vertices=recVert[k],
                                       fillColor=recColors[coinFlip],
                                       size=.5)
                coinFlip = (random.random() > .5)
                random.shuffle(posTheta)

        else:
            # create a unique cube that will only been seen once or not at all
            random.shuffle(posCubes)
            coinFlip = (random.random() > .5)
            targOrientation = posCubes[coinFlip]
            random.shuffle(cubeColors[coinFlip])
            targCubeColors = cubeColors[coinFlip][:]
            targCubeVert = cubeCreator([0, 0], targOrientation)

            # creates unique cube for cue
            for b in range(3):
                targCube[b] = ShapeStim(win,
                                        vertices=targCubeVert[b],
                                        fillColor=targCubeColors[b],
                                        size=.5)

            for j in range(nStim):
                coinFlip = (random.random() > .5)
                random.shuffle(posCubes)
                random.shuffle(cubeColors[0])
                random.shuffle(cubeColors[1])
                while posCubes[0] == targOrientation and cubeColors[
                        coinFlip] == targCubeColors:
                    coinFlip = (random.random() > .5)
                    random.shuffle(posCubes)
                    random.shuffle(cubeColors[0])
                    random.shuffle(cubeColors[1])

                cubeVert = cubeCreator(shapes[j], posCubes[0])
                cubeV[j] = cubeCreator(shapes[j], posCubes[0])

                # creates each side
                for i in range(3):
                    cubeStim[j][i] = ShapeStim(
                        win,
                        vertices=cubeVert[i],
                        fillColor=cubeColors[coinFlip][i],
                        size=.5)

        # STIM PRESENTATION

        #
        # presents target
        if rectangles:
            recDraw(fStim, 1, [targRect], targPresent[t], 0)
        else:
            cubeDraw(fStim, 1, [targCube], targPresent[t], 0)

        ## presents interval
        #for frameN in range(fPause + 1):
        #    win.flip()

        # presents stim
        if targPresent[t]:
            if rectangles:
                # inserts target rectangle into line-up
                targRect = rotateRec(shapes[0], targTheta)
                recStim[0] = ShapeStim(win,
                                       vertices=targRect,
                                       fillColor=recColors[targColor],
                                       size=.5)

                recDraw(fStim, nStim, recStim, targPresent[t], 1)
            else:
                # inserts target cube into line-up
                for b in range(3):
                    cubeStim[0][b] = ShapeStim(win,
                                               vertices=cubeV[0][b],
                                               fillColor=targCubeColors[b],
                                               size=.5)

                cubeDraw(fStim, nStim, cubeStim, targPresent[t], 1)
        else:
            if rectangles:
                recDraw(fStim, nStim, recStim, targPresent[t], 1)
            else:
                cubeDraw(fStim, nStim, cubeStim, targPresent[t], 1)

        if trialResp[t] == targPresent[t]:
            correctResp[t] = 1
        else:
            correctResp[t] = 0

    # OUTPUT
    print()
    print('Correct response trials')
    print(correctResp)
    print('Percent correct')
    print(sum(correctResp) / numTrials)
    print('Response Time')
    print(responseTime)
    print('Average response time')
    print(sum(responseTime) / numTrials)

    thisExp.addData('correct responses', correctResp)
    thisExp.nextEntry()
    thisExp.addData('response times', responseTime)
    thisExp.nextEntry()
    # these shouldn't be strictly necessary (should auto-save)
    thisExp.saveAsWideText(filename + '.csv')
    thisExp.saveAsPickle(filename)
    logging.flush()
    # make sure everything is closed down
    thisExp.abort()  # or data files will save again on exit

    origLUT = numpy.round(win.backend._origGammaRamp *
                          65535.0).astype("uint16")
    origLUT = origLUT.byteswap() / 255.0
    win.backend._origGammaRamp = origLUT

    win.close()
    core.quit()
コード例 #32
0
ファイル: shapes.py プロジェクト: joeymoon/psychopy
#!/usr/bin/env python2

"""Demo of psychopy.visual.ShapeStim: lines and arbitrary fillable shapes

See shapeContains.py for dynamic interaction of ShapeStim and Mouse.
"""

from psychopy import visual, event
from psychopy.visual import ShapeStim

win = visual.Window(size=(500, 400), units='height')

# some shapes:
arrowVert = [(-0.4,0.05), (-0.4,-0.05), (-.2,-0.05), (-.2,-0.1), (0,0), (-.2,0.1), (-.2,0.05)]
arrow = ShapeStim(win, vertices=arrowVert, fillColor='darkred', size=.5, lineColor='red')

star7Vert = [(0.0, 0.5), (0.09, 0.18), (0.39, 0.31), (0.19, 0.04), (0.49, -0.11), (0.16, -0.12), (0.22, -0.45), 
        (0.0, -0.2), (-0.22, -0.45), (-0.16, -0.12), (-0.49, -0.11), (-0.19, 0.04), (-0.39, 0.31), (-0.09, 0.18)]
star7 = ShapeStim(win, vertices=star7Vert, fillColor='green', lineWidth=2, lineColor='white')

# self-crossings are fine:
selfxVert = [(0,0),(0,.2),(.2,0),(.2,.2)]
selfx = ShapeStim(win, vertices=selfxVert, fillColor='darkmagenta', lineColor='yellow', opacity=.6, pos=(.2,-.3), size=2)

# `thing` has a fake hole and discontinuity (as the border will reveal):
thingVert = [(0,0),(0,.4),(.4,.4),(.4,0),(.1,0),(.1,.1),(.3,.1),(.3,.3),(.1,.3),(.1,0),
    (0,0),(.1,-.1),(.3,-.1),(.3,-.3),(.1,-.3),(.1,-.1)]
thing = ShapeStim(win, vertices=thingVert, fillColor='blue', lineWidth=0, opacity=.3, size=.7)

# `donut` has a true hole, using two loops of vertices:
donutVert = [[(-.2,-.2),(-.2,.2),(.2,.2),(.2,-.2)], [(-.15,-.15),(-.15,.15),(.15,.15),(.15,-.15)]]