def __init__(self, position, posLabel, color, identity, isChange,
              squareSize):
     self.squareSize = squareSize
     self.position = position
     self.positionLabel = posLabel
     self.color = color
     self.identity = identity
     self.isChangeTrial = isChange
     self.stim = visual.Rect(win,
                             width=self.squareSize,
                             height=self.squareSize,
                             fillColor=self.color,
                             lineColor=self.color,
                             units='pix',
                             pos=self.position)
Exemple #2
0
    def __init__(self,
                 win,
                 outer_diameter=0.5,
                 inner_diameter=0.1,
                 outer_color='white',
                 inner_color='black',
                 units='pix'):
        '''
        Class to generate a stimulus dot with 
        units are derived from the window
        '''

        # Set propertis of dot
        outer_dot = visual.Circle(win,
                                  fillColor=outer_color,
                                  radius=outer_diameter / 2.0,
                                  units=units)
        inner_dot = visual.Circle(win,
                                  fillColor=outer_color,
                                  radius=inner_diameter / 2.0,
                                  units=units)
        line_vertical = visual.Rect(win,
                                    width=inner_diameter,
                                    height=outer_diameter,
                                    fillColor=inner_color,
                                    units=units)
        line_horizontal = visual.Rect(win,
                                      width=outer_diameter,
                                      height=inner_diameter,
                                      fillColor=inner_color,
                                      units=units)

        self.outer_dot = outer_dot
        self.inner_dot = inner_dot
        self.line_vertical = line_vertical
        self.line_horizontal = line_horizontal
 def make_border(self,
                 width=0.5,
                 height=0.5,
                 lineWidth=2.8,
                 size=0.175,
                 color='blue',
                 name=None):
     return visual.Rect(self.win,
                        width=width,
                        height=height,
                        lineWidth=lineWidth,
                        units='height',
                        size=size,
                        lineColor=color,
                        name=name)
Exemple #4
0
def drawAllRespOptions(myWin,bgColor,xStart,namesPerColumn,possibleResps,color,drawBoundingBox,relativeSize):
    #relativeSize multiplied by standard size to get desired size
    authorStims = list()
    for i in range(len(possibleResps)):
        x, y, w, h = calcRespXYandBoundingBox( namesPerColumn,possibleResps, i )
        option = visual.TextStim(myWin,colorSpace='rgb',color=color,alignHoriz=alignHorizOption, alignVert='center',
                                                                height=h*relativeSize,units='norm',autoLog=False)
        option.setText(possibleResps[i])
        option.pos = (x-w/2, y)
        option.draw()
        authorStims.append(option)
        if drawBoundingBox:
            boundingBox = visual.Rect(myWin,width=w,height=h, pos=(x,y), units='norm')
            boundingBox.draw()            
    return authorStims
Exemple #5
0
 def test_contrast(self):
     # Create rectangle with chunky border
     obj = visual.Rect(self.win, units="pix", pos=(0, 0), size=(128, 128), lineWidth=10)
     # Set its colors to be rgb extremes
     obj.fillColor = 'red'
     obj.borderColor = 'blue'
     obj.opacity = 1  # Fix opacity at full as this is not what we're testing
     # Halve contrast
     obj.contrast = 0.5
     # Refresh
     self.win.flip()
     obj.draw()
     # Check rendered color
     utils.comparePixelColor(self.win, colors.Color(( 0.5, -0.5, -0.5), "rgb"), coord=(50, 50))
     utils.comparePixelColor(self.win, colors.Color((-0.5, -0.5,  0.5), "rgb"), coord=(1, 1))
 def __init__(self, psychopy_win, color):
     self.display_size = psychopy_win.size
     w, h = self.display_size
     win = psychopy_win
     self.color = color
     self.background = visual.Rect(win,
                                   w,
                                   h,
                                   lineColor=self.color,
                                   colorSpace=win.colorSpace,
                                   fillColor=self.color,
                                   units='pix',
                                   name='BACKGROUND',
                                   opacity=1.0,
                                   interpolate=False)
 def rect(self, width=None, height=None):
     if width is None:
         width = self.line_width
     if height is None:
         height = self.line_height
     self.current_depth = self.current_depth - 1.0
     return visual.Rect(pos=(0, 0),
                        size=[width, height],
                        interpolate=False,
                        lineColor=[1, 1, 1],
                        units='deg',
                        depth=self.current_depth,
                        lineWidth=1,
                        fillColor=[1, 1, 1],
                        win=self.win)
def feedback(response,
             correct,
             rside,
             conf,
             imBuffer,
             totPoints,
             fbPositions=[leftPos, rightPos]):
    win.flip()
    core.wait(.5)
    #Figure out how many points the person can get/lose
    if rside != None:
        fbPos = fbPositions[rside]
    points = 0  #If resp/rside = None
    pcol = 'white'
    if response == None:
        points = 0
        imBuffer.draw()
    elif response == correct:
        points = 10 * adjustConf(
            conf / 2, .08)  #adjusted reward - logit with slope = to .08
        pcol = 'green'
        imBuffer.draw()
        fb = visual.Rect(win,
                         height=sy * .12,
                         width=sy * .12,
                         fillColor=(0, 1, 0),
                         lineWidth=0,
                         opacity=.5)
        fb.setPos(fbPos)
        fb.draw()
    elif response != correct:
        points = -10 * conf  #linear punishment
        pcol = 'red'
        fb = visual.TextStim(win, text='X', height=100, color='red')
        imBuffer.draw()
        fb.setPos(fbPos)
        fb.draw()
    points = round(points)
    pointsText = visual.TextStim(win,
                                 text='%d points' % points,
                                 height=30,
                                 color=pcol,
                                 pos=(0, sy * .25))
    pointsText.draw()

    win.flip()
    core.wait(1)
    return response == correct, points
Exemple #9
0
    def __init__(self,
                 win,
                 info: FabFruitInfo,
                 keys: KeypressDict = KEYS,
                 timing_method: TimeTypes = TimeTypes.onset):
        self.win = win

        # settings
        self.info = info
        self.fruits = info.fruits
        self.boxes = info.boxes
        self.keys = keys
        self.save_path = None
        self.cheat = False

        if timing_method != TimeTypes.block:
            self.set_times(timing_method)

        # display objects
        self.box = visual.ImageStim(self.win, image_path('box_open.png'))
        self.fruit = visual.ImageStim(self.win, image_path('apple.png'))
        self.X = visual.ImageStim(self.win, image_path('devalue.png'))
        self.confidence = visual.ImageStim(self.win,
                                           image_path("confidence.png"))
        self.hand = visual.ImageStim(self.win, image_path("hand_only.png"))
        # downsize hands
        # previously only for half screen. but why not all screens
        # if(self.win.size[1] <= 600):
        self.confidence.size *= .5
        self.hand.size *= .5
        # bottom align
        self.confidence.pos[1] = -1 + self.confidence.size[1] / 2
        self.hand.pos[1] = -1 + self.hand.size[1] / 2

        # score box for ID feeback
        (w, h) = self.box.size
        self.scoreBox = visual.Rect(self.win,
                                    lineWidth=2,
                                    fillColor='yellow',
                                    lineColor='black',
                                    pos=(0, h / 2),
                                    size=(w / 2, h / 5))
        self.textBox = visual.TextStim(self.win)

        self.arrowBox = visual.TextStim(self.win,
                                        color='darkgray',
                                        pos=(0, -.7 * h),
                                        height=.2)  # ← or →
def shapes(pos=(0, 0), color=(0, 0, 0)):
    rect = visual.Rect(win=win,
                       name='keyboardButtons',
                       width=(0.1, 0.1)[0],
                       height=(0.1, 0.1)[1],
                       ori=0,
                       pos=pos,
                       lineWidth=1,
                       lineColor='black',
                       lineColorSpace='rgb',
                       fillColor=color,
                       fillColorSpace='rgb',
                       opacity=1,
                       depth=0.0,
                       interpolate=True)
    return rect
Exemple #11
0
    def setRectangles(self, word):
        """Create rectangles (visual.Rect) of height and width size and set their positions. Returns a list of rectangles """    
        self.rectangles = [visual.Rect(self.win, size = (120,120),fillColor='grey', lineColor='grey',
                                       units="pix") for i in range(len(self.capList))]
        self.colors = []
        for cap in self.capList:
            if cap not in word:
                self.colors.append('grey')
            elif cap in word:
                if cap in clusters:
                    self.colors[-1] = 'black'
                self.colors.append('black')                   

        [rectangle.setPos(location) for rectangle,location in zip(self.rectangles,self.locations)]
        [rectangle.setFillColor(color) for rectangle,color in zip(self.rectangles,self.colors)]
        [rectangle.setLineColor(color) for rectangle,color in zip(self.rectangles,self.colors)]
def drawRespOption(myWin, x, color, drawBoundingBox, possibleResps, i):
    y, w, h = calcRespYandBoundingBox(possibleResps, i)
    option = visual.TextStim(myWin,
                             colorSpace='rgb',
                             color=color,
                             alignHoriz='center',
                             alignVert='center',
                             height=h,
                             units='norm',
                             autoLog=False)
    option.setText(possibleResps[i])
    option.pos = (x, y)
    option.draw()
    if drawBoundingBox:
        boundingBox = visual.Rect(myWin, width=w, height=h, pos=(x, y))
        boundingBox.draw()
Exemple #13
0
def create_apple(win, square_size, snake):
    """
    Creates an apple at a random place. \n
    Snake argument transmits snake's current position
    in order to avoid generating apple at the same position
    where the snake is.
    """
    apple_pos = (randint(0, 31), randint(0, 31))
    while apple_pos in [tuple(seg.pos) for seg in snake]:
        apple_pos = (randint(0, 31), randint(0, 31))

    pos = map_grid_to_win(apple_pos, square_size)

    apple = visual.Rect(win, size=square_size, pos=pos, fillColor="red")

    return apple
Exemple #14
0
    def _showGrid(self, highlight=None):
        """
        Show the grid. If a highlight is given,
        then that entity will be highlighted.
        """
        for k in range(1, self.numOptions + 1):
            rect = visual.Rect(self.win, 0.35, 0.35)
            rect.setFillColor(self.colors[k])
            rect.setPos(self.positions[k])
            rect.setLineWidth(0)
            if highlight == k:
                rect.setFillColor(self.highlightColors[k])

            rect.draw()

        self.win.flip()
Exemple #15
0
 def __init__(self, window, width, height, pos=(0, 0), bg_color='white', text_color='black', line_height=0.05,
              padding=0.01, max_length=float('inf'), valid_chars=None, other_stim=(), **kwargs):
     """
     Accept all input parameters that psychopy.visual.TextStim accepts
     :param max_length: (int) maximum length of the text input
     :param valid_chars: a list of characters that are allowed as input;
                        if None, all letters, numbers and standar characters are allowed
     :param padding: (float) distance between text and the border of the text box
     :param other_stim: a list of other psychopy stimuli to be displayed together
     """
     self._key_mapping = {
         'grave': ('`', '~'),
         'minus': ('-', '_'),
         'equal': ('=', '+'),
         'bracketleft': ('[', '{'),
         'bracketright': (']', '}'),
         'semicolon': (';', ':'),
         'apostrophe': ('\'', '"'),
         'comma': (',', '<'),
         'period': ('.', '>'),
         'slash': ('/', '?'),
         'backslash': ('\\', '|'),
         'return': '\n',
         'space': ' ',
         '1': '!',
         '2': '@',
         '3': '#',
         '4': '$',
         '5': '%',
         '6': '^',
         '7': '&',
         '8': '*',
         '9': '(',
         '0': ')',
     }
     self.window = window
     self.other_stim = other_stim
     self.max_length = max_length
     self.valid_chars = valid_chars
     self.text = ''
     text_pos = (pos[0] - float(width) / 2 + padding, pos[1] + float(height) / 2 - padding)
     wrap_width = width - padding * 2
     self.text_stim = visual.TextStim(self.window, self.text, color=text_color, pos=text_pos, height=line_height,
                                      alignHoriz='left', alignVert='top', wrapWidth=wrap_width, **kwargs)
     self.background = visual.Rect(window, width=width, height=height, pos=pos, fillColor=bg_color)
     self.draw()
     self.timer = core.Clock()
Exemple #16
0
    def __init__(self, window, pos, text, button=False):
        self.window = window
        self.drawList = []
        self.button = button

        length = len(text)

        if length <= 60:
            wid = 0.45
            hei = 0.25
            Ppos = [pos[0] - 0.21, pos[1] + 0.1]
            wP = 0.4
            Bpos = [pos[0] + 0.175, pos[1] - 0.075]
        elif length <= 160 and len(text) > 60:
            wid = 0.6
            hei = 0.4
            Ppos = [pos[0] - 0.28, pos[1] + 0.175]
            wP = 0.55
            Bpos = [pos[0] + 0.225, pos[1] - 0.125]
        elif length > 150 <= 520:
            wid = 0.8
            hei = 0.6
            Ppos = [pos[0] - 0.38, pos[1] + 0.275]
            wP = 0.75
            Bpos = [pos[0] + 0.35, pos[1] - 0.25]
        self.Box = visual.Rect(window,
                               pos=pos,
                               width=wid,
                               height=hei,
                               fillColor='white',
                               opacity=0.8,
                               lineColor='black',
                               lineWidth=3)
        self.drawList.append(self.Box)
        self.text = visual.TextStim(window,
                                    text=text,
                                    height=0.04,
                                    pos=Ppos,
                                    color='black',
                                    wrapWidth=wP,
                                    alignHoriz='left',
                                    alignVert='top')
        self.drawList.append(self.text)

        # if you want a button to cancel box display
        if self.button:
            self.nexter = Button(window, pos=Bpos, scale=0.075)
Exemple #17
0
def trialAbsId(endpoint, map):
    box = visual.Rect(window, width=wBox, height=hBox)
    vertPos = random.sample(list(vCPos), 1)
    im = visual.Line(window,
                     start=[-endpoint, np.array(vertPos)],
                     end=[endpoint, np.array(vertPos)])
    feedback = visual.TextStim(window,
                               text=map,
                               pos=(0, np.array(vertPos) + 50),
                               height=20,
                               bold=True,
                               anchorVert="bottom")
    blank = visual.TextStim(window, "")
    timer.reset()
    im.draw()
    box.draw()
    window.flip()
    box.draw()
    keys = event.waitKeys(keyList=('1', '2', '3', '4', '5', '6', '7', '8', '9',
                                   abortKey),
                          timeStamped=timer)
    resp = keys[0][0]
    rt = keys[0][1]
    if resp == abortKey:
        window.close()
        core.quit()
    if (resp == map):
        feedback.text = "Correct answer!"
        im.draw()
        feedback.draw()
        window.flip()
        box.draw()
        feedback.draw()
        core.wait(0.5)
    else:
        feedback.text = "ERROR! Correct Answer: " + map
        im.draw()
        feedback.draw()
        window.flip()
        box.draw()
        im.draw()
        feedback.draw()
        core.wait(0.5)
    blank.draw()
    window.flip()
    core.wait(1)
    return (resp, rt)
Exemple #18
0
    def create_stimuli(self):
        self.stimuli = OrderedDict()

        self.stimuli['dotsBackground'] = visual.DotStim(win=self.win,
                                                        nDots=500,
                                                        coherence=1,
                                                        fieldSize=1060,
                                                        fieldShape='circle',
                                                        dotSize=2.0,
                                                        dotLife=100.0,
                                                        speed=0,
                                                        color=(-0.8, -0.8,
                                                               -0.8),
                                                        signalDots='same',
                                                        noiseDots='direction',
                                                        units='pix')
        self.stimuli['dotsBackground'].ori = 0

        self.stimuli['circlePatch'] = visual.Circle(win=self.win,
                                                    radius=240.0,
                                                    pos=(0, 0),
                                                    lineWidth=1,
                                                    lineColor=(-1, -1, -1),
                                                    fillColor=(-1, -1, -1),
                                                    units='pix')

        self.stimuli['rodStim'] = visual.Line(win=self.win,
                                              start=(0, -100),
                                              end=(0, 100),
                                              lineWidth=5,
                                              lineColor=(-0.84, -0.84, -0.84))

        self.stimuli['squareFrame'] = visual.Rect(win=self.win,
                                                  width=300.0,
                                                  height=300.0,
                                                  pos=(0, 0),
                                                  lineWidth=5,
                                                  lineColor=(-0.84, -0.84,
                                                             -0.84),
                                                  fillColor=None,
                                                  ori=0.0,
                                                  units='pix')

        # stimulus triggers
        self.triggers = {}
        for stim in self.stimuli:
            self.triggers[stim] = False
def build_cross(cross_color):
    '''
    where "cross_color" has to be a color recognized by PsychoPy

    this function returns a fixationcross in given ("cross_color") color

    the cross has the size of 5 pixels in each direction
    '''
    
    fixationskreuz = visual.Rect(
        win=window,
        vertices=((0, -5), (0, 5), (0, 0), (-5, 0), (5, 0)),
        lineWidth=10,
        closeShape=False,
        lineColor=cross_color
    )
    return fixationskreuz
    def present(self, stimulus=None):
        """
        Present the stimulus grid.
        """
        if stimulus == None:
            # Present blank screen
            self.win.flip()
        else:
            # Present blank screen
            self.win.flip()
            core.wait(0.3)

            # Present stimulus
            rect = visual.Rect(self.win, 0.5, 0.5)
            rect.setFillColor(self.colors[stimulus])
            rect.draw()
            self.win.flip()
Exemple #21
0
 def drawGoal(self):
     """Draws the goal box and star on the screen."""
     assetString = "goal" + str(
         self.goal)  #so we can index into assets and get the picture
     #draws the star
     star = visual.ImageStim(win=self.window,
                             image=self.assets[assetString],
                             pos=[0, 300])
     star.draw()
     #draws the box around it
     highlightBox = visual.Rect(win=self.window,
                                width=110,
                                height=110,
                                pos=[0, 300],
                                lineColor=[-1, -1, -1],
                                lineWidth=5)
     highlightBox.draw()
Exemple #22
0
def drawRects(xRec, yRec, nRec, color, width, height, nWide):
    rect = visual.Rect(win=expWin, units = 'pix')
    j = 1
    for i in range(nRec):
        rect.width = width
        rect.height = height
        rect.fillColor = color
        rect.pos = (xRec,yRec)

        if j%nWide == 0 and i !=0:
            yRec += height
            xRec -= width*(nWide-1)
        else:
            xRec += width
            
        j += 1
        rect.draw()
Exemple #23
0
    def show_color_circle(self, num_col=16, gray_level=None):
        """
        Show color circle.
        :param num_col: Number of colors to be shown.
        :param gray_level: Gray level.
        """

        self.op_mode = True
        if gray_level is None:
            gray_level = self.gray_level

        phis = np.linspace(0, 2 * np.pi, num_col, endpoint=False)
        m_rgb = self.dklc2rgb(
            phi=phis,
            gray_level=gray_level,
        )

        win = visual.Window(size=[800, 600], monitor="eDc-1", fullscr=False)
        # set background gray level
        win.colorSpace = "rgb"
        win.color = self.color2pp(
            np.array([gray_level, gray_level, gray_level]))[0]
        win.flip()

        rect_size = 0.4 * win.size[0] * 2 / num_col
        radius = 0.2 * win.size[0]
        alphas = np.linspace(0, 360, num_col, endpoint=False)

        rect = visual.Rect(win=win,
                           units="pix",
                           width=int(rect_size),
                           height=int(rect_size))
        for i_rect in range(num_col):
            rect.fillColorSpace = "rgb"
            rect.lineColorSpace = "rgb"
            rect.fillColor = m_rgb[i_rect]
            rect.lineColor = m_rgb[i_rect]
            rect.pos = misc.pol2cart(alphas[i_rect], radius)
            rect.draw()

        win.flip()

        event.waitKeys()
        win.close()
        self.op_mode = False
Exemple #24
0
 def draw_pause_screen(self, current_trial):
     win_width, win_height = self.win.size
     pause_screen = visual.Rect(win=self.win,
                                width=win_width,
                                height=win_height,
                                lineColor=(0, 0, 0),
                                fillColor=(0, 0, 0))
     pause_str = "PAUSE  trial {}/{} Press space to continue".format(
         current_trial, self.num_trials)
     pause_text = visual.TextStim(win=self.win,
                                  text=pause_str,
                                  pos=(0.0, 0.0),
                                  color=(-1, -1, 0.6),
                                  units="pix",
                                  height=40)
     pause_screen.draw()
     pause_text.draw()
     self.win.flip()
Exemple #25
0
def create_snake(win, square_size, position=None):
    """
    Creates a snake with the length of one segment
    at a random place by default. \n
    The position may optionally be specified with the help of
    position argument. \n
    The function returns a snake object embedded in a list
    since new segments of snake might be added later with the
    help of add_segment() function.
    """
    if position == None:
        pos = map_grid_to_win((randint(0, 31), randint(0, 31)), square_size)
    else:
        pos = position

    snake = visual.Rect(win, size=square_size, pos=pos, fillColor="green")

    return [snake]
Exemple #26
0
    def make_searchTarget(self):
        LR = [-1, 1]
        shuffle(LR)

        self.cue_colors = self.trial_settings[2]

        self.targetStim.append(
            visual.Circle(self.screen,
                          radius=self.parameters['ring_stim_size'],
                          pos=(LR[0] * self.parameters['cue_pos'], 0),
                          fillColor=None,
                          lineColor=self.parameters['ring_color'],
                          lineWidth=self.parameters['ring_line_width']))
        self.targetStim.append(
            visual.Circle(self.screen,
                          radius=self.parameters['cue_stim_size'],
                          pos=(LR[0] * self.parameters['cue_pos'], 0),
                          fillColor=self.cue_colors[0],
                          fillColorSpace='rgb',
                          lineColor=None))

        self.targetStim.append(
            visual.Circle(self.screen,
                          radius=self.parameters['ring_stim_size'],
                          pos=(LR[1] * self.parameters['cue_pos'], 0),
                          fillColor=None,
                          lineColor=self.parameters['ring_color'],
                          lineWidth=self.parameters['ring_line_width']))
        for ori in self.parameters['ring_dash_ori']:
            self.targetStim.append(
                visual.Rect(self.screen,
                            ori=ori,
                            pos=(LR[1] * self.parameters['cue_pos'], 0),
                            width=self.parameters['ring_dash_width'],
                            height=self.parameters['ring_dash_length'],
                            fillColor=self.parameters['screenBackground'],
                            lineColor=None))
        self.targetStim.append(
            visual.Circle(self.screen,
                          radius=self.parameters['cue_stim_size'],
                          pos=(LR[1] * self.parameters['cue_pos'], 0),
                          fillColor=self.cue_colors[1],
                          fillColorSpace='rgb',
                          lineColor=None))
def draw_test_square(win, edgeLength=10):
    from psychopy import visual, event, core
    from show_instructions import show_instructions
    from Ball import Ball
    import numpy as np
    r = visual.Rect(win, edgeLength, edgeLength, units='cm')
    timer = core.Clock()
    show_instructions(
        win,
        "Measure the edges of this rectangle, it's 10x10, press SPACE when done, ESC to quit"
    )

    b = Ball(win,
             position=np.array([-edgeLength / 2.0, -edgeLength / 2.0]),
             direction=np.array([1, 0]),
             speed=1,
             radius=0.1,
             color='Black')
    start = True
    finalTime = None
    timer.reset()
    while True:
        r.draw()
        b.draw()
        if start:
            b.move([1.0 / win.fps(), 0.0])
        if (b.pos()[0] >= edgeLength / 2.0) and start is True:
            finalTime = timer.getTime()
            break
        win.flip()

    while True:
        r.draw()
        keys = event.getKeys()
        if 'space' in keys:
            break
        if 'escape' in keys:
            win.close()
            core.quit()
        win.flip()

    show_instructions(
        win, "Time elapsed to run 10 cm at 1 cm/s is " + str(finalTime) +
        " [s] press spacebar to continue, ESC to quit")
Exemple #28
0
    def genStim(self):

        stim = {}
        textColor = 'black'
        stim['name'] = visual.TextStim(
            win=self.win,
            pos=(0.0, 0.5),
            text=self.expInfo['expName'],
            height=0.07,
            color=textColor)
        stim['date'] = visual.TextStim(
            win=self.win,
            pos=(0.0, 0.4),
            text=time.strftime("%Y-%m-%d"),
            height=0.06,
            color=textColor)
        stim['time'] = visual.TextStim(
            win=self.win,
            pos=(0.0, 0.3),
            text=time.strftime("%H:%M"),
            height=0.06,
            color=textColor)
        stim['label'] = visual.TextStim(
            win=self.win,
            text='',
            color=textColor)
        stim['input'] = visual.TextStim(
            win=self.win,
            pos=(0.0, -0.2),
            text='',
            color=textColor)
        stim['duplicate'] = visual.TextStim(
            win=self.win,
            pos=(0.0, 0.0),
            text='Subject file already excists, try a different combination',
            color=textColor)
        stim['square'] = visual.Rect(
            win=self.win,
            width=0.5,
            height=0.15,
            pos=(0.0, -0.21),
            fillColor='grey')

        return(stim)
    def confirm(self, rel_position, transform=False):
        # Highlight the chosen emoji
        index = rel_position-1
        green_rect = visual.Rect(win=self.window, units="pix", width=self.emoji_size,
                                 height=self.emoji_size, fillColor=[-1, 1, -1], lineColor=[0, 0, 0])
        green_rect.pos = (self.imXaxis[index], 0)
        green_rect.draw()

        # Transform every emoji into the chosen one if asked and draw
        if transform:
            for i in range(self.num_emojis):
                self.stimuli.items[index].pos = (self.imXaxis[i], 0)
                self.stimuli.items[index].draw()
        else:  # Or just draw all emojis again
            for i in range(self.num_emojis):
                self.stimuli.items[i].draw()

        # Explain the key use
        text = visual.TextStim(win=self.window, pos=[0, -5],
                               text="Left = Accept. Right = Deny.")
        text.draw()

        # Refresh the window
        self.window.flip()

        # Wait for the user to press a key
        response = None
        while response == None:
            all_keys = event.getKeys()
            for key in all_keys:
                if key == "left":
                    response = True
                    rel_position_final = rel_position
                elif key == "right":
                    response = False
                    rel_position_final = self.double_feedback()

        # Print and return the response
        print("The user said that the selection of emoji {0} is {1}".format(
            rel_position, response))
        if response == False:
            print("The user said that emoji {0} was the target".format(rel_position_final))
            
        return [response, rel_position_final]
Exemple #30
0
def showInstructions(mywin, condition, interval, prop):
    i1_8 = "Thank you for agreeing to participate today. You will be asked to complete a series of tasks. The instructions on the screen will guide you through the process. Please pay close attention and try as hard as you can. \n\nThe first task is a grip strength task. Each time the screen says go, please grip the force meter as hard as you can and hold it for a few seconds (until the screen says STOP).\n\n There will be a bar at the bottom of the screen to indicate your progress through the study."
    i2_8 = "Reminder: each time the screen says go, please grip the force meter as hard as you can and hold it for a few seconds (until the screen says STOP)."
    i3_8 = "Reminder: each time the screen says go, please grip the force meter as hard as you can and hold it for a few seconds (until the screen says STOP)."

    i1_1 = "Thank you for agreeing to participate today. You will be asked to complete a series of tasks. The instructions on the screen will guide you through the process. Please pay close attention and try as hard as you can. \n\nThe first task is a grip strength task. Each time the screen says go, please grip the force meter as hard as you can and hold it for a few seconds (until the screen says STOP).\n\n There will be a bar at the bottom of the screen to indicate your progress through the study."
    i2_1 = "The next task is also a grip strength task. \n\nReminder: each time the screen says go, please grip the force meter as hard as you can and hold it for a few seconds (until the screen says STOP)."
    i3_1 = "The next task is also a grip strength task. \n\nReminder: each time the screen says go, please grip the force meter as hard as you can and hold it for a few seconds (until the screen says STOP)."

    if condition == 1:
        if interval == 1: instructions = i1_8
        if interval == 2: instructions = i2_8
        if interval == 3: instructions = i3_8

    if condition == 2:
        if interval == 1: instructions = i1_1
        if interval == 2: instructions = i2_1
        if interval == 3: instructions = i3_1

    instruction_text = visual.TextStim(mywin,
                                       text=instructions,
                                       color=(255, 255, 255),
                                       colorSpace='rgb255',
                                       pos=(0, 100),
                                       height=20,
                                       units='pix',
                                       wrapWidth=500)

    emptyBar = visual.Rect(mywin,
                           width=500,
                           height=20,
                           units='pix',
                           lineColor=(255, 255, 255),
                           lineColorSpace='rgb255',
                           pos=(0, -220),
                           fillColor=(0, 0, 0),
                           fillColorSpace='rgb255')

    instruction_text.draw()

    fillBar(mywin, prop)

    mywin.flip()
    core.wait(15)