def calibrateEyeTrackerPyGaze():
    """
        Runs the callibration process using PyGaze and tobii eye trackers.
    """

    disp = Display()
    tracker = EyeTracker(disp,resolution=(1600,900),  trackertype='tobii')
    
    tracker.calibrate()
    
    #tracker.close() 
    disp.close()
    return tracker
Пример #2
0
    def run(self):
        """The run phase of the plug-in goes here."""

        if hasattr(self.experiment, u'pygaze_eyetracker'):
            raise osexception( \
             u'You should have only one instance of `pygaze_init` in your experiment')
        self.set_item_onset()
        # Determine the tracker type and perform certain tracker-specific
        # operations.
        if self.tracker_type == u'Simple dummy':
            tracker_type = u'dumbdummy'
        elif self.tracker_type == u'Advanced dummy (mouse simulation)':
            tracker_type = u'dummy'
        elif self.tracker_type == u'EyeLink':
            tracker_type = u'eyelink'
            if self.get(u'eyelink_calbeep'):
                from openexp.synth import synth
                self.beep = synth(self.experiment)
        elif self.tracker_type == u'Tobii':
            tracker_type = u'tobii'
        elif self.tracker_type == u'SMI':
            tracker_type = u'smi'
        else:
            raise osexception(u'Unknown tracker type: %s' % self.tracker_type)
        # Determine logfile
        if self.get(u'_logfile') == u'automatic':
            logfile = os.path.splitext(self.get(u'logfile'))[0]
            if tracker_type == u'eyelink':
                logfile = logfile + u'.edf'
        else:
            logfile = self.get(u'_logfile')
        # Determine event detection
        if tracker_type == u'eyelink':
            event_detection = u'native'
        else:
            event_detection = u'pygaze'
        # Initialize pygaze and the eye-tracker object
        self.experiment.pygaze_display = Display(u'opensesame')
        self.experiment.pygaze_eyetracker = EyeTracker( \
         self.experiment.pygaze_display, trackertype=tracker_type, \
         data_file=logfile, eventdetection=event_detection, \
         saccade_velocity_threshold=self.get(u'sacc_vel_thr'), \
         saccade_acceleration_threshold=self.get(u'sacc_acc_thr'), \
         ip=self.get(u'smi_ip'), sendport=self.get(u'smi_send_port'), \
         receiveport=self.get(u'smi_recv_port'), logfile=logfile,
         eyelink_force_drift_correct= \
         self.get(u'eyelink_force_drift_correct'))
        self.experiment.pygaze_eyetracker.set_draw_calibration_target_func( \
         self.draw_calibration_canvas)
        self.experiment.cleanup_functions.append(self.close)
        if self.calibrate == u'yes':
            self.experiment.pygaze_eyetracker.calibrate()
Пример #3
0
	def run(self):

		"""
		desc:
			The run phase of the plug-in goes here.
		"""

		if hasattr(self.experiment, u'pygaze_eyetracker'):
			raise osexception( \
				u'You should have only one instance of `pygaze_init` in your experiment')
		self.set_item_onset()
		# Determine the tracker type and perform certain tracker-specific
		# operations.
		if self.tracker_type == u'Simple dummy':
			tracker_type = u'dumbdummy'
		elif self.tracker_type == u'Advanced dummy (mouse simulation)':
			tracker_type = u'dummy'
		elif self.tracker_type == u'EyeLink':
			tracker_type = u'eyelink'
		elif self.tracker_type == u'Tobii':
			tracker_type = u'tobii'
		elif self.tracker_type == u'SMI':
			tracker_type = u'smi'
		elif self.tracker_type == u'EyeTribe':
			tracker_type = u'eyetribe'
		else:
			raise osexception(u'Unknown tracker type: %s' % self.tracker_type)
		# Determine logfile
		if self.get(u'_logfile') == u'automatic':
			logfile = os.path.splitext(self.get(u'logfile'))[0]
			if tracker_type == u'eyelink':
				# Automatically shorten filenames like 'subject-0', because
				# these are too long. This avoids having to rename logfiles
				# all the time.
				basename = os.path.basename(logfile)
				dirname = os.path.dirname(logfile)
				if len(basename) > 8 and basename.startswith(u'subject-'):
					basename = u'sub_' + basename[8:]
					logfile = os.path.join(dirname, basename)
					print(u'Attention: EyeLink logfile renamed to %s.edf' \
						% logfile)
				elif basename == u'defaultlog':
					logfile = u'default'
					print(u'Attention: EyeLink logfile renamed to %s.edf' \
						% logfile)
				logfile = logfile + u'.edf'
		else:
			logfile = self.get(u'_logfile')
		# Determine event detection
		if tracker_type == u'eyelink':
			event_detection = u'native'
		else:
			event_detection = u'pygaze'
		# Initialize pygaze and the eye-tracker object
		self.experiment.pygaze_display = Display(u'opensesame')
		self.experiment.pygaze_eyetracker = EyeTracker(
			self.experiment.pygaze_display, trackertype=tracker_type,
			data_file=logfile, eventdetection=event_detection,
			saccade_velocity_threshold=self.get(u'sacc_vel_thr'),
			saccade_acceleration_threshold=self.get(u'sacc_acc_thr'),
			ip=self.get(u'smi_ip'), sendport=self.get(u'smi_send_port'),
			receiveport=self.get(u'smi_recv_port'), logfile=logfile,
			eyelink_force_drift_correct=self.get(
			u'eyelink_force_drift_correct'),pupil_size_mode=self.get(
			u'eyelink_pupil_size_mode'))
		if self.get(u'calbeep') == 'yes':
			from openexp.synth import synth
			self.beep = synth(self.experiment)
		self.experiment.pygaze_eyetracker.set_draw_calibration_target_func(
			self.draw_calibration_canvas)
		self.experiment.pygaze_eyetracker.set_draw_drift_correction_target_func(
			self.draw_calibration_canvas)
		self.experiment.cleanup_functions.append(self.close)
		if self.calibrate == u'yes':
			self.experiment.pygaze_eyetracker.calibrate()
header = ['trialnr', \
    'nstim', 'rewtype', 'rewamount', 'reward', 'total', \
    'fixonset', 'stimonset', 'maintenanceonset', 'probeonset', 't1', 'rewardonset', \
    'RT', 'nfixself', 'nfixother', 'probedstim', 'response']
for stimnr in range(max(NSTIM)):
    header.extend(['self_fixated%d' % stimnr, 'other_fixated%s' % stimnr, \
        'rewarded%d' % stimnr, 'ori%d' % stimnr, 'XYloc%d' % stimnr, \
        'error%d' % stimnr])
header.extend(['E', 'X', 'T'])
for i in range(max(NSTIM)-1):
    header.append('NT%d' % i)
log.write(header)

# Initialise the eye tracker.
_print("Initialising EyeTracker.")
tracker = EyeTracker(disp, logfile=logpath+'_eye')
#tracker.calibrate()


# # # # #
# RUN TRIALS

_print("Starting experiment. Clientnr=%d.\n" % (clientnr))

# Run until the server stops the experiment.
ntrials = 0
running = True
while running:
    
    # PREPARE TRIAL
    # Show the fixation screen.
Пример #5
0
    def run(self):
        f = open("testeFile.txt", 'w')
        f.writelines(["ENTROU NO JOGO\n"])
        f.close()
        eyetracker = EyeTracker(disp)
        eyetracker.calibrate()
        disp.fill(screen)
        disp.show()

        self.reloadItems()
        running = True
        main_music = pygame.mixer.music.load("media/sounds/crimson.wav")
        pygame.mixer.music.set_volume(0.6)
        pygame.mixer.music.play()

        while running:
            self.canvas.clear()

            # Limit frame speed to 50 FPS
            self.clock.tick(50)
            for event in pygame.event.get():
                if (event.type
                        == pygame.QUIT) or ((event.type == pygame.KEYDOWN) and
                                            (event.key == pygame.K_ESCAPE)):
                    running = False

            # Redraw the background
            self.screen.fill(self.bg_color)
            # display.show()
            # Draw Menu Title

            title_x = self.scr_width / 2 - self.title.get_rect(
            ).width / 2  # screen.get_rect().width/2 - self.title.get_rect().width/2
            title_y = self.scr_height / 10  # .get_rect().height/10

            self.screen.blit(self.title, (title_x, title_y))

            # Menu Options

            for item in self.items:
                if item.is_mouse_over(pygame.mouse.get_pos()):
                    item.set_font_color((255, 0, 0))
                    if ((1, 0, 0) == pygame.mouse.get_pressed()):
                        if (item.index == 0):
                            print "loading "

                            if avalgame.isEnabled():
                                playercode = SetGamerId(self.canvas,
                                                        disp,
                                                        avalgame=avalgame)
                                self.canvas.clear()
                                playercode.run()
                                print("playercode START")
                                if avalgame._done:
                                    startGame = game.Game(self.canvas,
                                                          disp,
                                                          avalgame=avalgame)
                                    self.canvas.clear()
                                    startGame.run()
                                    print("GAME START")

                            else:
                                startGame = game.Game(self.canvas, disp)
                                self.canvas.clear()
                                startGame.run()
                                print("GAME START")
                        elif (item.index == 1):
                            print "settings"
                            settingsGame = GameSettings(self.canvas,
                                                        disp,
                                                        avalgame=avalgame)
                            self.canvas.clear()
                            settingsGame.run()
                            print("settings START")
                        elif (item.index == 2):
                            print("Saindo do jogo")
                            # log.close()
                            running = False
                        elif (item.index == 3):
                            if (self.lang == "pt"):
                                self.langButton.text = "Pt-BR"
                                self.labels = ["Start", "Settings", "Exit"]
                                self.lang = "en"
                                self.reloadItems()
                                pygame.mouse.set_pos(
                                    self.screen.get_rect().width / 2,
                                    self.screen.get_rect().height / 2 - 30)
                            else:
                                self.langButton.text = "En-US"
                                self.labels = [
                                    "Iniciar", "Configuracoes", "Sair"
                                ]
                                self.lang = "pt"
                                self.reloadItems()
                                pygame.mouse.set_pos(
                                    self.screen.get_rect().width / 2,
                                    self.screen.get_rect().height / 2 - 30)
                else:
                    item.set_font_color((255, 255, 255))

                self.screen.blit(item.label, item.position)

            # Draw version
            version_x = self.screen.get_rect().width - self.version.get_rect(
            ).width
            version_y = self.screen.get_rect().height - self.version.get_rect(
            ).height
            self.screen.blit(self.version, (version_x, version_y))

            # Draw languageButton

            self.screen.blit(self.langButton.label, self.langButton.position)

            ############ DISPLAY ##############
            # pygame.display.flip()
            x, y = eyetracker.sample()

            self.canvas.draw_circle(colour=(255, 0, 0),
                                    pos=(x, y),
                                    r=5,
                                    fill=True)
            disp.fill(self)
            disp.show()
Пример #6
0
    def run(self):
        """
		desc:
			The run phase of the plug-in goes here.
		"""

        if hasattr(self.experiment, u'pygaze_eyetracker'):
            raise osexception(
                u'You should have only one instance of `pygaze_init` in your experiment'
            )
        self.set_item_onset()
        # Determine the tracker type and perform certain tracker-specific
        # operations.
        kwdict = {}
        if self.var.tracker_type == u'Simple dummy':
            tracker_type = u'dumbdummy'
        elif self.var.tracker_type == u'Advanced dummy (mouse simulation)':
            tracker_type = u'dummy'
        elif self.var.tracker_type == u'EyeLink':
            tracker_type = u'eyelink'
            kwdict[u'eyelink_force_drift_correct'] = \
             self.var.eyelink_force_drift_correct == u'yes'
            kwdict[u'pupil_size_mode'] = self.var.eyelink_pupil_size_mode
        elif self.var.tracker_type == u'SMI':
            tracker_type = u'smi'
            kwdict[u'ip'] = self.var.smi_ip
            kwdict[u'sendport'] = self.var.smi_send_port
            kwdict[u'receiveport'] = self.var.smi_recv_port
        elif self.var.tracker_type == u'EyeTribe':
            tracker_type = u'eyetribe'
        elif self.var.tracker_type == u'OpenGaze':
            tracker_type = u'opengaze'
        elif self.var.tracker_type == u'Alea':
            tracker_type = u'alea'
            kwdict[u'alea_key'] = self.var.alea_api_key
            kwdict[u'animated_calibration'] = \
             self.var.alea_animated_calibration == u'yes'
        elif self.var.tracker_type == u'Tobii':
            tracker_type = u'tobii'
        elif self.var.tracker_type == u'Tobii-legacy':
            tracker_type = u'tobii-legacy'
        elif self.var.tracker_type == u'Tobii Pro Glasses 2':
            tracker_type = u'tobiiglasses'
            kwdict[u'address'] = self.var.tobiiglasses_address
            kwdict[u'udpport'] = self.var.tobiiglasses_udpport
        else:
            raise osexception(u'Unknown tracker type: %s' %
                              self.var.tracker_type)
        # Determine logfile
        if self.var._logfile == u'automatic':
            logfile = os.path.splitext(self.var.logfile)[0]
            if tracker_type == u'eyelink':
                # Automatically shorten filenames like 'subject-0', because
                # these are too long. This avoids having to rename logfiles
                # all the time.
                basename = os.path.basename(logfile)
                dirname = os.path.dirname(logfile)
                if len(basename) > 8 and basename.startswith(u'subject-'):
                    basename = u'sub_' + basename[8:]
                    logfile = os.path.join(dirname, basename)
                    print(u'Attention: EyeLink logfile renamed to %s.edf' \
                     % logfile)
                elif basename == u'defaultlog':
                    logfile = u'default'
                    print(u'Attention: EyeLink logfile renamed to %s.edf' \
                     % logfile)
                logfile = logfile + u'.edf'
                kwdict[u'data_file'] = logfile
        else:
            logfile = self.var._logfile
        # Register the logfile with OpenSesame
        self.experiment.data_files.append(logfile)
        # Determine event detection. Currently, only the EyeLink has native
        # event detection.
        if tracker_type == u'eyelink':
            event_detection = u'native'
        else:
            event_detection = u'pygaze'
        # Initialize pygaze and the eye-tracker object
        self.experiment.pygaze_display = Display(u'opensesame')
        self.experiment.pygaze_eyetracker = EyeTracker(
            self.experiment.pygaze_display,
            trackertype=tracker_type,
            eventdetection=event_detection,
            saccade_velocity_threshold=self.var.sacc_vel_thr,
            saccade_acceleration_threshold=self.var.sacc_acc_thr,
            logfile=logfile,
            **kwdict)
        if self.var.calbeep == u'yes':
            from openexp.synth import synth
            self.beep = synth(self.experiment)
        self.experiment.pygaze_eyetracker.set_draw_calibration_target_func(
            self.draw_calibration_canvas)
        self.experiment.pygaze_eyetracker.set_draw_drift_correction_target_func(
            self.draw_calibration_canvas)
        self.experiment.cleanup_functions.append(self.close)
        if self.var.calibrate == u'yes':
            self.experiment.pygaze_eyetracker.calibrate()
        self.python_workspace[
            u'eyetracker'] = self.experiment.pygaze_eyetracker
Пример #7
0
DIR = os.path.split(os.path.abspath(__file__))[0]
soundfile = os.path.join(DIR, 'bark.ogg')
imagefile = os.path.join(DIR, 'kitten.png')

# # # # #
# create instances

# initialize the display
disp = Display()

# initialize a screen
scr = Screen()

# initialize an EyeTracker
tracker = EyeTracker(disp)

# initialize a keyboard
kb = Keyboard(keylist=['space'], timeout=None)

# initialize a sound
snd = Sound(soundfile=soundfile)

# initialize a Timer
timer = Time()

# create a new logfile
log = Logfile(filename="test")
log.write(["test", "time"])

# # # # #
Пример #8
0
from pygaze import libtime
from pygaze.libscreen import Display, Screen
from pygaze.eyetracker import EyeTracker
from pygaze.libinput import Keyboard
from pygaze.liblog import Logfile
from pygaze.libgazecon import FRL

# timing and initialization
libtime.expstart()

# visuals
disp = Display()
scr = Screen()

# eye tracking
tracker = EyeTracker(disp, trackertype='dummy')
frl = FRL(pos='center', dist=125, size=200)

# input collection and storage
kb = Keyboard(keylist=['escape', 'space'], timeout=None)
log = Logfile()
log.write(["trialnr", "trialstart", "trialend", "duration", "image"])

# run trials
tracker.calibrate()
for trialnr in range(0, len(IMAGES)):
    # blank display
    disp.fill()
    disp.show()
    libtime.pause(1000)
    # prepare stimulus
Пример #9
0
scr = Screen()
scr.draw_text("Loading, please wait...", fontsize=24)
disp.fill(scr)
disp.show()

# Open a new log file.
log = Logfile()
# TODO: Write header.
log.write(["trialnr", "block", "run","stim", "keypress", "go_nogo", "face_onset", "signal_onset","resp_onset", "RT", "accuracy", "respmap", "block_type"])

# Open a new log file to log events.
event_log = Logfile(filename=EVENT_LOG)
event_log.write(["time", "event"])

# Initialise the eye tracker.
tracker = EyeTracker(disp)

# Create a new Keyboard instance to process key presses.
kb = Keyboard(keylist=None, timeout=5000)
mouse = Mouse()

# intitliase the MEG interface NI box 
if MRI:
	trigbox = MRITriggerBox()

###################
# GENERATE TRIALS #
###################
""" 
A run is a split of experiment, so each run should be matched by randomised 
We have 8 blocks: 4 distractors types x 2 go or no-go conditions 
Пример #10
0
from pygaze.libscreen import Display, Screen
from pygaze.libinput import Keyboard
from pygaze.eyetracker import EyeTracker
from pygaze.liblog import Logfile
import pygaze.libtime as timer
from pygaze.plugins.aoi import AOI
# # # # #
# SETUP

# visuals
disp = Display()
scr = Screen()

# input
kb = Keyboard()
tracker = EyeTracker(disp)

# output
log = Logfile(filename="fs_test")
log_sub = Logfile(filename="fs_test_sub")
log.write(["ntrials", "image", "gaze_pos_x", "gaze_pos_y", "gaze_time"])
log_sub.write(["ntrials", "image", "is_found", "search_time"])
# # # # #
# PREPARE

# load instructions from file
instfile = open(INSTFILE)
instructions = instfile.read()
instfile.close()

instfile = open(INSTFILE_DC)
Пример #11
0
    blockLen = 2
    nT = 14
    train = 2

# if which_monitor == "eyetracker":
# win = visual.Window([1280,1024], monitor="tobii", units="deg",color='white',fullscr=False)
# elif which_monitor == "haley_small":
# win = visual.Window([1080, 675], monitor="haleys", units="deg",color='white',fullscr=False)

# Initialise a new Display instance
disp = Display(disptype='psychopy',
               dispsize=(1280, 1024),
               bgc=(255, 255, 255, 255))

# Initialise a new EyeTracker instance
tracker = EyeTracker(disp, trackertype='tobii')
tracker.fixtresh = 1.5
tracker.calibrate()

win = pygaze.expdisplay
win.mouseVisible = False

fixation = visual.ShapeStim(win,
                            vertices=((0, -15), (0, 15), (0, 0), (-15, 0),
                                      (15, 0)),
                            lineWidth=5,
                            closeShape=False,
                            lineColor="black")

tracker.start_recording()
Пример #12
0
scr.draw_text("Loading, please wait...", fontsize=MAIN_FONTSIZE)
disp.fill(scr)
disp.show()



# Open a new log file.
log = Logfile(filename = LOGFILE)
log_det = Logfile(filename = DETAILED_LOGFILE)
log_events = Logfile(filename = EVENT_LOGFILE)
# TODO: Write header.
log.write(["trialnr","left_ang","right_ang", "cue_dir", "targ", "targ_ang", "resp_ang", "perc_diff", "resp_onset", "resp_duration", "iti", "iti_onset", "stim_onset","delay_onset", "cue_onset", "postcue_onset","probe_onset", "prac"])
log_det.write(["trialnr", "timestamp", "angle", "event", "targ_ang", "cue_dir"])
log_events.write(["Trigger", "Timestamp"])
# Initialise the eye tracker.
tracker = EyeTracker(disp)

# Create a new Keyboard instance to process key presses.
kb = Keyboard(keylist=None, timeout=5000)
mouse = Mouse()
mouse.set_visible(visible=False)

# intitliase the MEG interface NI box 
if MEG:
    trigbox = MEGTriggerBox()

# initialise a function 


# trigbox.set_trigger_state(1) <= Example usage 
        for k in range(2):
            c = 1 + k
            d = 2 - k
            A = (xcor + (d * tloc), ycor + (c * tloc))
            exscreen.draw_text(text=str(exvec[count]),
                               pos=A,
                               center=True,
                               fontsize=30)
            count += 1
        xcor += t_side
    ycor += t_side

##Set number of games played
rounds = 4

tracker = EyeTracker(disp)
##Experiment
choice = []

wait = True
while wait == True:
    disp.fill(introscreen)
    disp.show()
    pressed = mse.get_pressed()
    if sum(pressed) > 0:
        event.clearEvents(eventType='mouse')
        wait = False

pressed = [0, 0, 0]
wait = True
while wait == True:
Пример #14
0
DIR = os.path.split(os.path.abspath(__file__))[0]
soundfile = os.path.join(DIR, 'bark.ogg')
imagefile = os.path.join(DIR, 'kitten.png')


# # # # #
# create instances

# initialize the display
disp = Display()

# initialize a screen
scr = Screen()

# initialize an EyeTracker
tracker = EyeTracker(disp)

# initialize a keyboard
kb = Keyboard(keylist=['space'],timeout=None)

# initialize a sound
snd = Sound(soundfile=soundfile)

# initialize a Timer
timer = Time()

# create a new logfile
log = Logfile(filename="test")
log.write(["test", "time"])

Пример #15
0
from psychopy import event
# # # # #
# SETUP

# visuals
disp = Display()
scr = Screen()
blnk = Screen()
#audio
pygame.mixer.init(frequency=44100, size=-16, buffer=2048, channels=1)
# input
mouse = Mouse(visible=True)
kb = Keyboard()

#Start tracker and calibrate
eyetracker = EyeTracker(disp)
eyetracker.calibrate()
#set up logging
log = liblog.Logfile()
#########################################################################
#Load image files
#image stimuli.
image1 = {
    'number': 0,
    'name': "images/M_Y_MC_L_1.png",
    'age': "Y",
    'gender': "M",
    'soc': "M",
    'loc': "L"
}
image2 = {
Пример #16
0
# create keyboard object
keyboard = Keyboard()

# display object
disp = Display()

# screen objects
screen = Screen()
blankscreen = Screen()
hitscreen = Screen()
hitscreen.clear(colour=(0,255,0))
misscreen = Screen()
misscreen.clear(colour=(255,0,0))

# create eyelink objecy
eyetracker = EyeTracker(disp)

# eyelink calibration
eyetracker.calibrate()

# display surface
disp.fill(screen=blankscreen)
disp.show()

# # # # #
# game

# run several rounds
for trialnr in range(0,TRIALS):
	
	# start eye tracking
Пример #17
0
    t.daemon = True

    eye_lock = threading.Lock()
    eye_event = threading.Event()
    eye_thread = threading.Thread(name='eye_tracking',
                                  target=eye_tracker,
                                  args=(
                                      eye_lock,
                                      eye_event,
                                  ))
    eye_thread.daemon = True

    disp = Display(disptype='psychopy')
    scr = Screen(disptype='psychopy')
    disp.close()
    tracker = EyeTracker(disp, trackertype='eyetribe')

    EYE_DATA = Queue.Queue(500)

    try:
        t.start()

        eye_thread.start()

        with Listener(on_click=on_click) as listener:
            listener.join()

        # listener.start()

        try:
            exit_cmd = 'exit'
Пример #18
0
    import pygame

# # # # #
# INITIALISE

# Start a new Display instance to be able to show things on the monitor.
# The important parameters will automatically be loaded from the constants.
disp = Display()

# Initialise a Keyboard instance to detect key presses. Again, important
# parameters will be loaded from the constants.
kb = Keyboard()

# Initialise the EyeTracker and let it know which Display instance to use by
# passing it to the EyeTracker.
tracker = EyeTracker(disp)

# Create a Logfile instance that keeps track of when videos start.
log = Logfile()
# Write a header to the log file.
log.write(['date', 'time', 'trialnr', 'video', 'timestamp'])

# # # # #
# SCREENS

# Create a screen to show instructions on.
textscr = Screen()
textscr.draw_text("Press any key to start the next video.", fontsize=24)

# Create a screen to show images on. This will be the screen that we will use
# to display each video frame.
Пример #19
0
    def run(self):
        dt = datetime.now()
        #Eye tracker configure
        eyetracker = EyeTracker(self.disp)
        eyetracker.calibrate()
        self.disp.fill(self.canvas)
        self.disp.show()
        #self.disp.mousevis = True

        eyetracker.start_recording()

        etObject = objects.EyeTracker(0, 0, 20, 20)

        ##END

        main_music = pygame.mixer.music.load("media/sounds/megalovania.wav")
        pygame.mixer.music.play()

        pygame.mixer.music.set_volume(0.6)

        bob = self.player

        # List to hold all the sprites
        all_sprite_list = pygame.sprite.Group()

        # Make the walls. (x_pos, y_pos, width, height)
        wall_list = pygame.sprite.Group()

        # List of Foods
        food_list = pygame.sprite.Group()

        wall = objects.Wall("", 0, 40, 10, 560, 1)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 10, 40, 980, 10, 1)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 990, 40, 10, 560, 1)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 10, 590, 980, 10, 1)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        ## Gondulas
        wall = objects.Wall("", 100, 200, 226, 40, 8)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 100, 400, 226, 40, 8)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 620, 200, 226, 40, 8)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 620, 400, 226, 40, 8)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        wall = objects.Wall("", 450, 220, 40, 226, 9)
        wall_list.add(wall)
        all_sprite_list.add(wall)
        obstacles.append(wall)

        ## ATM
        atm_list = pygame.sprite.Group()
        atm = objects.ATM("", 940, 45, 13, 35, 1)
        atm_list.add(atm)
        all_sprite_list.add(atm)

        ## Monsters
        monster_list = pygame.sprite.Group()

        fFood = objects.FastFood("", 850, 400, 30, 30, 3)
        monster_list.add(fFood)
        all_sprite_list.add(fFood)

        fFood2 = objects.FastFood("", 500, 130, 30, 30, 3)
        monster_list.add(fFood2)
        all_sprite_list.add(fFood2)

        fFood = objects.FastFood("", 270, 100, 30, 30, 3)
        monster_list.add(fFood)
        all_sprite_list.add(fFood)

        fFood = objects.FastFood("", 220, 450, 30, 30, 3)
        monster_list.add(fFood)
        all_sprite_list.add(fFood)

        fFood = objects.FastFood("", 450, 470, 30, 30, 4)
        monster_list.add(fFood)
        all_sprite_list.add(fFood)

        ##
        bob.walls = wall_list
        all_sprite_list.add(bob)

        bob.updateValues()
        #pygame.draw.rect(self.screen, (255,0,0) ,((bob.position),(bob.collisionWidth, bob.collisionHeight)),0)

        for wall in obstacles:
            pygame.draw.rect(self.screen, (0, 0, 0), wall.rect, 0)

        time_decrement = pygame.USEREVENT + 1
        T1 = 1000  # second
        pygame.time.set_timer(time_decrement, T1)

        card_generator = pygame.USEREVENT + 2
        T2 = 4000  # 4 second
        pygame.time.set_timer(card_generator, T2)

        monster_move = pygame.USEREVENT + 3
        T3 = 100  # 0,1 second
        pygame.time.set_timer(monster_move, T3)

        food_time = pygame.USEREVENT + 4
        T4 = 8000  # 8 seconds
        pygame.time.set_timer(food_time, T4)

        eyeTracker_time = pygame.USEREVENT + 5
        T5 = 1000  # 1 seconds
        pygame.time.set_timer(eyeTracker_time, T5)

        logRecord_time = pygame.USEREVENT + 6
        T6 = 1000  # 1 seconds
        pygame.time.set_timer(logRecord_time, T6)

        #gravar tempo que comeca uma fixacao
        logRecord_fixation = pygame.USEREVENT + 7
        T7 = 1000  #2seconds
        pygame.time.set_timer(logRecord_fixation, T7)

        cards_hit_list = pygame.sprite.spritecollide(bob, cards_list, False)

        bground = BackGround(self.screen)

        cont_blinks = 0
        gameRunning = True
        staring = False
        position = 0

        blinkCount = 0
        lastBlinkPos = (0, 0)

        x = random.randint(50, 800)
        y = random.randint(50, 400)
        cash = objects.Cash("", x, y, 20, 20, 2)
        cards_list.append(cash)
        pygame.draw.rect(self.screen, (0, 255, 0), cash.rect, 0)
        all_sprite_list.add(cash)

        #comeco do game
        while (gameRunning):

            self.canvas.clear()
            self.screen.fill((255, 255, 255))
            self.screen.blit(self.image, (0, 40))
            clock.tick(60)

            cards_hit_list = pygame.sprite.spritecollide(
                bob, cards_list, False)
            monster_hit_list = pygame.sprite.spritecollide(
                bob, monster_list, False)
            atm_hit_list = pygame.sprite.spritecollide(bob, atm_list, False)
            food_hit_list = pygame.sprite.spritecollide(bob, food_list, False)

            etSawList = pygame.sprite.spritecollide(etObject, food_list, False)

            if (len(etSawList) == 0):
                staring = False

            for atm in atm_hit_list:
                if (bob.direction == "up"):
                    bob.rect.top = atm.rect.bottom
                elif (bob.direction == "right"):
                    bob.rect.right = atm.rect.left
                elif (bob.direction == "left"):
                    bob.rect.left = atm.rect.right

            for monster in monster_hit_list:
                pygame.mixer.music.fadeout(1000)
                pygame.mixer.Sound.play(go_sound)
                pygame.time.delay(3500)

                gameRunning = False

            for card in cards_hit_list:
                bob.c_card += 1
                pygame.mixer.Sound.play(card_sound)
                cards_list.remove(card)
                all_sprite_list.remove(card)
                #self.avalgame.storeCreditCollection(self.startTime)

            for food in food_hit_list:
                if (event.type == pygame.KEYDOWN
                        and event.key == pygame.K_RETURN
                        and bob.cash >= food.value):
                    bob.buyFood(food)
                    food_list.empty()
                    self.player.total_produtos += 1
                    if (bob.score >= 10):
                        gameRunning = False

            #####  FRAME EVENTS
            ## Time Decrementer
            for event in pygame.event.get():
                if (event.type == time_decrement):
                    bob.time -= 1

                if (event.type == eyeTracker_time):
                    #verificar se houve fixacao
                    time = libtime.get_time()
                    getX, getY = eyetracker.sample()
                    self.dataStore.get_quadrant((getX, getY))
                    self.dataStore.start_fixation((getX, getY))

                if (event.type == logRecord_time):
                    etObject.setPosition(eyetracker.sample())
                    for food in etSawList:
                        self.dataStore.start_staring(food.food_type)

                if (event.type == MOUSEBUTTONDOWN):
                    start_time = eyetracker.wait_for_event(3)
                    time_end = eyetracker.wait_for_event(4)
                    #     cont_blinks += 1
                    self.dataStore.start_blinking(str(cont_blinks), start_time,
                                                  time_end)

                    tracker_pos = eyetracker.sample()
                    if (tracker_pos != lastBlinkPos):
                        self.dataStore.start_blinkingTest(
                            lastBlinkPos, blinkCount)
                        lastBlinkPos = tracker_pos
                        blinkCount = 1
                    else:
                        blinkCount += 1

                if (event.type == food_time):
                    food_list.empty()
                    newFood1 = objects.Food(5, "vegetal")
                    food_list.add(newFood1)

                    newFood2 = objects.Food(5, "carbohidrato")
                    food_list.add(newFood2)

                    newFood3 = objects.Food(5, "doce")
                    food_list.add(newFood3)

                    newFood4 = objects.Food(5, "proteina")
                    food_list.add(newFood4)

                ## Credit Card Generator
                if (event.type == card_generator and len(cards_list) < 2):
                    cashGenerator = random.randint(0, 100)
                    if (cashGenerator <= 25):
                        x = random.randint(50, 800)
                        y = random.randint(50, 400)
                        cash = objects.Cash("", x, y, 20, 20, 2)
                        cards_list.append(cash)
                        pygame.draw.rect(self.screen, (0, 255, 0), cash.rect,
                                         0)
                        all_sprite_list.add(cash)

                ## Monster Movement
                if (event.type == monster_move):
                    for monster in monster_list:
                        monsterCollision = pygame.sprite.spritecollide(
                            monster, wall_list, False)
                        if (monster.movingPositive):
                            if (len(monsterCollision) == 0):
                                if monster.obj_type == 4:
                                    monster.rect.left -= 15
                                else:
                                    monster.rect.top -= 15
                            else:
                                if monster.obj_type == 4:
                                    monster.rect.right += 15
                                    monster.movingPositive = False
                                else:
                                    monster.rect.bottom += 15
                                    monster.movingPositive = False
                        else:
                            if (len(monsterCollision) == 0):
                                if monster.obj_type == 4:
                                    monster.rect.right += 15
                                else:
                                    monster.rect.bottom += 15
                            else:
                                if monster.obj_type == 4:
                                    monster.rect.left -= 15
                                    monster.movingPositive = True
                                else:
                                    monster.rect.top -= 15
                                    monster.movingPositive = True

                ## Player Input
                if (event.type == pygame.KEYDOWN):
                    pygame.event.set_blocked(pygame.KEYDOWN)
                    if (event.key == pygame.K_ESCAPE):
                        gameRunning = False
                    elif (event.key == pygame.K_UP):
                        bob.acceleration = 5
                        bob.direction = "up"

                    elif (event.key == pygame.K_DOWN):
                        bob.acceleration = 5
                        bob.direction = "down"

                    elif (event.key == pygame.K_LEFT):
                        bob.acceleration = 5
                        bob.direction = "left"

                    elif (event.key == pygame.K_RIGHT):
                        bob.acceleration = 5
                        bob.direction = "right"

                    elif (event.key == pygame.K_RETURN):
                        if (dist(bob.rect.x, bob.rect.y, atm.rect.x,
                                 atm.rect.y) <= 65 and bob.c_card >= 1):
                            pygame.mixer.Sound.play(cash_sound)
                            bob.c_card -= 1
                            bob.cash += 15
                            self.player.cashTotal += 15

                if (event.type == pygame.KEYUP):
                    bob.acceleration = 0
                    pygame.event.set_allowed(pygame.KEYDOWN)

            bob.updateValues()

            if (bob.direction == "up"):
                bob.moveUp()
            elif (bob.direction == "down"):
                bob.moveDown()
            elif (bob.direction == "left"):
                bob.moveLeft()
            elif (bob.direction == "right"):
                bob.moveRight()

            if bob.time <= 0:
                gameRunning = False

            all_sprite_list.update()
            all_sprite_list.draw(self.screen)
            food_list.draw(self.screen)

            self.screen.blit(bob.timeLabel, (450, 0))

            # Player Interface Draw
            cash_x = 0
            cash_y = 20

            self.screen.blit(bob.cashLabel, (cash_x, cash_y))

            cCard_x = 0
            cCard_y = 0

            self.screen.blit(bob.c_cardLabel, (cCard_x, cCard_y))

            self.screen.blit(bob.scoreLabel,
                             (1000 - bob.scoreLabel.get_rect().width - 50, 0))

            ##BARS

            self.screen.blit(bob.carboLabel, (55, 610))
            self.screen.blit(bob.vegLabel, (30, 640))
            self.screen.blit(bob.protLabel, (565, 610))
            self.screen.blit(bob.doceLabel, (500, 640))

            self.progressBars(bob)

            ##Display
            #pygame.display.flip()
            self.disp.fill(self.canvas)
            self.disp.show()

        pygame.event.set_allowed(pygame.KEYDOWN)
        pygame.mixer.music.fadeout(1000)
        pygame.mixer.music.load("media/sounds/crimson.wav")
        pygame.mixer.music.play()

        pyramidCompletion = 0.0
        if (self.player.doce == 10):
            pyramidCompletion += 2.5
        if (self.player.proteina == 20):
            pyramidCompletion += 2.5
        if (self.player.vegetal == 30):
            pyramidCompletion += 2.5
        if (self.player.carbohidrato == 40):
            pyramidCompletion += 2.5

        self.avalgame.storePyramidCompletion(self.startTime,
                                             valor_AEEJ=pyramidCompletion)

        foodTotal = 0
        if (0 < self.player.total_produtos <= 5):
            foodTotal = 1
        elif (5 < self.player.total_produtos <= 10):
            foodTotal = 2
        elif (self.player.total_produtos > 10):
            foodTotal = 3
        self.avalgame.storeFoodQuantity(self.startTime, valor_AEEJ=foodTotal)

        if self.player.cashTotal == 0:
            averageScore = 0
        else:
            averageScore = float(
                float(self.player.total_produtos) /
                float(self.player.cashTotal)) * 100

        self.avalgame.storeAverageScore(self.startTime,
                                        valor_AEEJ=averageScore)

        self.dataStore.start_blinkingTest(lastBlinkPos, blinkCount)
        self.dataStore.log_gen.recordBlinkLog(self.dataStore.blink_log,
                                              'blink-', 4,
                                              self.avalgame._playerCode)
        self.dataStore.log_gen.recordLog(self.dataStore.blink_log2, 'blink2-',
                                         4, self.avalgame._playerCode)
        self.dataStore.log_gen.recordLog(self.dataStore.staring_log,
                                         'products-', 3,
                                         self.avalgame._playerCode)
        self.dataStore.log_gen.recordLog(self.dataStore.quadrant_log,
                                         'quadrants', 2,
                                         self.avalgame._playerCode)
        self.dataStore.log_gen.recordLog(self.dataStore.position_log,
                                         'fixation-', 1,
                                         self.avalgame._playerCode)
        self.avalgame.recordBestScore(self.player.time, self.player.score)

        ge = GameEnd(self.canvas, self.disp)

        ge.defScore(bob.score)
        ge.defResult(bob.score)
        #ge.storeData(etObject.log)
        #ge.storeData2(etObject.log2)
        #ge.storeDataBlink(etObject.log_blink)
        #ge.storeDataFixation(etObject.log_fixation)

        ge.run()
Пример #20
0
# create keyboard object
keyboard = Keyboard()

# display object
disp = Display()

# screen objects
screen = Screen()
blankscreen = Screen()
hitscreen = Screen()
hitscreen.clear(colour=(0,255,0))
misscreen = Screen()
misscreen.clear(colour=(255,0,0))

# create eyelink objecy
eyetracker = EyeTracker(disp)

# eyelink calibration
eyetracker.calibrate()

# display surface
disp.fill(screen=blankscreen)
disp.show()

# # # # #
# game

# run several rounds
for trialnr in range(0,TRIALS):
	
	# start eye tracking
Пример #21
0
DIR = os.path.split(os.path.abspath(__file__))[0]
image_file = os.path.join(DIR, 'www.google.co.uk_(Pixel 2).png')

# # # # #
# create instances

# initialize the display
disp = Display()

# initialize a screen
scr = Screen()


# initialize an EyeTracker
tracker = EyeTracker(disp)

# initialize a keyboard
kb = Keyboard(keylist=['space'],timeout=None)

# initialize a Timer
timer = Time()

# create a new logfile
log = Logfile(filename="test")
log.write(["x_pos","y_pos", "time"])

# # # # #
# test gaze contingency

# UI test
Пример #22
0
from pygaze.display import Display
from pygaze.screen import Screen
from pygaze.eyetracker import EyeTracker
from pygaze.keyboard import Keyboard
from pygaze.libtime import clock


# # # # #
# SETUP

# visuals
disp = Display()
scr = Screen()

# input
tracker = EyeTracker(disp)
kb = Keyboard(keylist=None, timeout=None)

# calibrate
tracker.calibrate()

# starting screen
scr.clear()
scr.draw_text(text="Press Space to start")
disp.fill(scr)
disp.show()
kb.get_key(keylist=['space'], timeout=None, flush=True)


# # # # #
# VALIDATION
Пример #23
0
#4' viewing angle; since PsychoPy calculates distance on centerpoint, adding
#128 (half of stimulus width)
base_dist = (2 * dist * math.tan(math.radians(4)/2))
base_dist_half = base_dist / 2
pixpcm = res[0] / res[2]
base_dist_pix = int(base_dist_half * pixpcm) + 128

# In[Initiate PyGaze Objects]:
disp = Display(disptype='psychopy')
scr = Screen(disptype='psychopy')

if inScanner or withTracker:
    kb = Keyboard()

if withTracker:
    tracker = EyeTracker(disp)
    
    DISPSIZE = cst.DISPSIZE
    
    fps_str = str(flicker).replace('.','_')
    basename = "{}_{}".format(subid, fps_str)
    
    LOGFILENAME = basename + '_eyetracker'
    director = os.getcwd()
    LOGFILE = os.path.join(director,LOGFILENAME)
    
    FGC = cst.FGC
    BGC = cst.BGC
    SACCVELTHRESH = cst.SACCVELTHRESH
    SACCACCTHRESH = cst.SACCACCTHRESH
    TRACKERTYPE = cst.TRACKERTYPE
Пример #24
0
from constants import *
from pygaze.display import Display
from pygaze.screen import Screen
from pygaze.eyetracker import EyeTracker

disp = Display()
tracker = EyeTracker(disp)

scr.draw_text(text="Resetting connection to %s tracker" % (TRACKERTYPE), \
    fontsize=24)
disp.fill(scr)
disp.show()

try:
    tracker.stop_recording()
except:
    print("Could not stop recording")

tracker.close()
disp.close()
Пример #25
0
# # # # #
# SETUP

# visuals
disp = Display()
scr = Screen()
blnk = Screen()
# audio
pygame.mixer.init(frequency=44100, size=-16, buffer=2048, channels=1)
# input
mouse = Mouse(visible=True)
kb = Keyboard()

# Start tracker and calibrate
eyetracker = EyeTracker(disp)
eyetracker.calibrate()
# set up logging
log = liblog.Logfile()
#########################################################################
# Load image files
# image stimuli.
image1 = {"number": 0, "name": "images/M_Y_MC_L_1.png", "age": "Y", "gender": "M", "soc": "M", "loc": "L"}
image2 = {"number": 1, "name": "images/M_O_MC_L_1.png", "age": "O", "gender": "M", "soc": "M", "loc": "L"}
image3 = {"number": 2, "name": "images/M_Y_WC_L_1.png", "age": "Y", "gender": "M", "soc": "W", "loc": "L"}
image4 = {"number": 3, "name": "images/M_O_WC_L_1.png", "age": "O", "gender": "M", "soc": "W", "loc": "L"}
image5 = {"number": 4, "name": "images/M_Y_MC_NL_1.png", "age": "Y", "gender": "M", "soc": "M", "loc": "N"}
image6 = {"number": 5, "name": "images/M_O_MC_NL_1.png", "age": "O", "gender": "M", "soc": "M", "loc": "N"}
image7 = {"number": 6, "name": "images/M_Y_WC_NL_1.png", "age": "Y", "gender": "M", "soc": "W", "loc": "N"}
image8 = {"number": 7, "name": "images/M_O_WC_NL_1.png", "age": "O", "gender": "M", "soc": "W", "loc": "N"}
# image files
Пример #26
0
    def run(self):
        eyetracker = EyeTracker(disp)
        eyetracker.calibrate()

        running = True

        self.textinput = text_input.TextInput(text_color=(255, 255, 255),
                                              cursor_color=(255, 255, 255),
                                              literal_number=True)
        if self.avalgame._code is not None:
            self.textinput.input_string = str(self.avalgame._code)
            self.textinput.cursor_position = len(str(self.avalgame._code))

        self.text1 = self.textFont.render("Configuracoes", 1, (255, 255, 255))
        self.text2 = self.textFont.render("Codigo do jogo", 1, (255, 255, 255))
        #pygame.display.update()
        self.screen.fill(self.bg_color)
        self.screen.blit(self.text1, (380, 250))
        self.screen.blit(self.text2, (380, 300))
        exitLabel = self.exitFont.render("ESC para sair", 1, (255, 255, 255))
        self.screen.blit(exitLabel, (0, 650))
        self.logTheData()
        self.buttonOk.set_position(380, 400)
        self.buttonCancel.set_position(450, 400)

        while (running):
            clock.tick(60)
            self.screen.fill(self.bg_color)
            self.screen.blit(self.text1, (380, 250))
            self.screen.blit(self.text2, (380, 300))
            exitLabel = self.exitFont.render("ESC para sair", 1,
                                             (255, 255, 255))
            self.screen.blit(exitLabel, (0, 650))

            events = pygame.event.get()

            self.textinput.update(events)
            self.screen.blit(self.textinput.get_surface(), (380, 350))
            pygame.display.update()

            if self.buttonOk.is_mouse_over(pygame.mouse.get_pos()):
                self.buttonOk.set_font_color((255, 0, 0))
                if ((1, 0, 0) == pygame.mouse.get_pressed()):
                    if self.textinput.get_text() != '':
                        self.avalgame.install(True,
                                              int(self.textinput.get_text()))
                    else:
                        self.avalgame.install(False, 0)

                    running = False
            else:
                self.buttonOk.set_font_color((255, 255, 255))

            if self.buttonCancel.is_mouse_over(pygame.mouse.get_pos()):
                self.buttonCancel.set_font_color((255, 0, 0))
                if ((1, 0, 0) == pygame.mouse.get_pressed()):
                    running = False
            else:
                self.buttonCancel.set_font_color((255, 255, 255))

            for event in events:
                if (event.type == pygame.QUIT or event.type == pygame.KEYDOWN):
                    if (event.key == pygame.K_ESCAPE):
                        #print(self.textinput.get_text())
                        running = False

            self.screen.blit(self.buttonOk.label, self.buttonOk.position)
            self.screen.blit(self.buttonCancel.label,
                             self.buttonCancel.position)

            x, y = eyetracker.sample()
            self.canvas.draw_circle(colour=(255, 0, 0),
                                    pos=(x, y),
                                    r=5,
                                    fill=True)

            self.disp.fill(self)
            self.disp.show()
Пример #27
0
from pygaze.libinput import Keyboard
from pygaze.eyetracker import EyeTracker
from pygaze.liblog import Logfile
import pygaze.libtime as timer


# # # # #
# SETUP

# visuals
disp = Display()
scr = Screen()

# input
kb = Keyboard()
tracker = EyeTracker(disp)

# output
log = Logfile()
log.write(["trialnr","image","imgtime"])


# # # # #
# PREPARE

# load instructions from file
instfile = open(INSTFILE)
instructions = instfile.read()
instfile.close()

# read all image names