示例#1
0
 def ready(self):
     if self.app.config[self.name]["enabled"]:
         self.client = iViewXClient(
             self.app.config[self.name]["server_address"], int(self.app.config["PyViewX"]["server_outport"])
         )
         self.client.addDispatcher(self.d)
         if self.client:
             if self.app.config[self.name]["calmode"] == "Once":
                 self.post_calibrate_mode = self.app.state
                 self.app.state = self.app.STATE_CALIBRATE
             self.app.reactor.listenUDP(int(self.app.config[self.name]["server_inport"]), self.client)
             self.startDataStreaming()
示例#2
0
 def ready(self):
     if self.app.config[self.name]['enabled']:
         self.client = iViewXClient(
             self.app.config[self.name]['server_address'],
             int(self.app.config['PyViewX']['server_outport']))
         self.client.addDispatcher(self.d)
         if self.client:
             if self.app.config[self.name]['calmode'] == 'Once':
                 self.post_calibrate_mode = self.app.state
                 self.app.state = self.app.STATE_CALIBRATE
             self.app.reactor.listenUDP(
                 int(self.app.config[self.name]['server_inport']),
                 self.client)
             self.startDataStreaming()
示例#3
0
    def __init__(self):
        
        if not os.path.exists("data"): os.mkdir("data")
            
        pyglet.resource.path.append('resources')
        pyglet.resource.reindex()
        pyglet.resource.add_font('cutouts.ttf')
        pyglet.resource.add_font('scoreboard.ttf')
        
        director.init(width=int(1024*1.0), height=int(768*1.1),
                  caption=self.title, visible=False, resizable=True)
        director.window.set_size(int(1024*1.0), int(768*1.1))
        
        director.window.pop_handlers()
        director.window.push_handlers(DefaultHandler())
                    
        director.settings = {'overlay': False,
                             'eyetracker': True,
                             'eyetracker_ip': '127.0.0.1',
                             'eyetracker_out_port': '4444',
                             'eyetracker_in_port': '5555',
                             'calibration_speed': 1,
                             'calibration_wait': 1,
                             'calibration_random': 1,
                             'calibration_level': 3,
                             'calibration_auto': 1,
                             'calibration_points': 2,
                             'calibration_eye': 0
                            }
        
        self.client = None
        
        self.client = iViewXClient(director.settings['eyetracker_ip'], int(director.settings['eyetracker_out_port']))
        self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client)

        director.set_show_FPS(False)
        director.window.set_fullscreen(False)
        if director.settings['eyetracker']:
            director.window.set_mouse_visible(False)
        else:
            director.window.set_mouse_visible(True)
                
        # Intro scene and its layers        
        self.introScene = Scene()
                    
        self.mainMenu = MainMenu()
        self.optionsMenu = OptionsMenu()
        self.eyetrackerScrim = EyetrackerScrim()
        
        self.mplxLayer = MultiplexLayer(self.mainMenu, self.optionsMenu)
        self.introScene.add(self.mplxLayer, 1)
        
        self.introScene.register_event_type('start_task')
        self.introScene.register_event_type('eyetracker_info_changed')
        self.introScene.push_handlers(self)
                
        # Task scene and its layers
        self.taskScene = Scene()
        self.taskLayer = Task(self.client)

        self.calibrationLayer = CalibrationLayer(self.client)
        self.calibrationLayer.register_event_type('show_headposition')
        self.calibrationLayer.register_event_type('hide_headposition')
        self.calibrationLayer.push_handlers(self)
        
        self.taskLayer.register_event_type('new_trial')
        self.taskLayer.register_event_type('start_calibration')
        self.taskLayer.register_event_type('stop_calibration')
        self.taskLayer.push_handlers(self)
                
        self.taskScene.add(self.taskLayer, 1)
        
        self.taskScene.register_event_type('show_intro_scene')
        self.taskScene.push_handlers(self)
            
        director.window.set_visible(True)
示例#4
0
        draw_text("%d" % fp.nFixations, f, (255, 255, 255),
                  (screen_rect.left + 50, screen_rect.top + 15), screen)
        pygame.display.flip()

        angle1 += .05
        if angle1 >= 360:
            angle1 = 0

        angle2 -= .025
        if angle2 <= 0:
            angle2 = 360

    def cleanup(*args, **kwargs):
        reactor.stop()

    def start(lc, results):
        global state, update, client, cleanup
        state = 0
        client.addDispatcher(d)
        lc = LoopingCall(update)
        dd = lc.start(1.0 / 30)
        dd.addCallbacks(cleanup)

    client = iViewXClient(os.environ['EYE_TRACKER'], 4444)
    reactor.listenUDP(5555, client)
    calibrator = Calibrator(client, screen, reactor=reactor, eye=0)
    fp = VelocityFP(1680, 1050, 473.76, 296.1, 500, 23, 45)
    #calibrator.start(start)
    reactor.callLater(0, lambda: start(None, None))
    reactor.run()
示例#5
0
    def __init__(self):
        
        if not os.path.exists("data"): os.mkdir("data")
        
        pyglet.resource.path.append('resources')
        pyglet.resource.reindex()
        pyglet.resource.add_font('Pipe_Dream.ttf')
        pyglet.resource.add_font('cutouts.ttf')
        
        director.set_show_FPS(False)
        director.init(fullscreen=True, caption=self.title, visible=True, resizable=True)

        width = director.window.width
        height = director.window.height

        director.window.set_fullscreen(False)
        director.window.set_size(int(width * .75), int(height * .75))

        director.window.pop_handlers()
        director.window.push_handlers(Handler())

        director.settings = {'seed':'1',
                             'eyetracker': True,
                             'eyetracker_ip': '127.0.0.1',
                             'eyetracker_out_port': '4444',
                             'eyetracker_in_port': '5555',
                             'player': 'Human',
                             'players': ['Human'],
                             'mode': 'Insane',
                             'modes': ['Easy', 'Moderate', 'Hard', 'Insane', 'Experiment']}
        
        self.client = None
        self.client_actr = None
        
        if ACTR6:
            director.settings['players'].append("ACT-R")
            #director.settings['player'] = "ACT-R"
            director.settings['eyetracker'] = False
            self.client_actr = JNI_Server(self)
            self.listener_actr = reactor.listenTCP(6666, self.client_actr)
        elif eyetracking:
            self.client = iViewXClient(director.settings['eyetracker_ip'], int(director.settings['eyetracker_out_port']))
            self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client) 
        
        if platform.system() != 'Windows':
            director.window.set_icon(pyglet.resource.image('logo.png'))
            cursor = director.window.get_system_mouse_cursor(director.window.CURSOR_HAND)
            director.window.set_mouse_cursor(cursor)
        
        # Intro scene and its layers        
        self.introScene = Scene()
                    
        self.mainMenu = MainMenu()
        self.optionsMenu = OptionsMenu()
        self.participantMenu = ParticipantMenu()
        self.introBackground = BackgroundLayer()
        self.eyetrackerScrim = EyetrackerScrim()
        
        self.introScene.add(self.introBackground)
        self.mplxLayer = MultiplexLayer(self.mainMenu, self.optionsMenu, self.participantMenu)
        self.introScene.add(self.mplxLayer, 1)
        
        self.introScene.register_event_type('start_task')
        self.introScene.register_event_type('eyetracker_info_changed')
        self.introScene.push_handlers(self)
        
        # Task scene and its layers
        self.taskScene = Scene()
        
        self.taskBackgroundLayer = TaskBackground()
        self.taskLayer = Task(self.client, self.client_actr)
        self.actrScrim = ACTRScrim()
        
        if self.client:
            self.calibrationLayer = CalibrationLayer(self.client)
            self.calibrationLayer.register_event_type('show_headposition')
            self.calibrationLayer.register_event_type('hide_headposition')
            self.calibrationLayer.push_handlers(self)
            self.headpositionLayer = HeadPositionLayer(self.client)
        
        self.taskLayer.register_event_type('new_trial')
        self.taskLayer.push_handlers(self.taskBackgroundLayer)
        self.taskLayer.register_event_type('start_calibration')
        self.taskLayer.register_event_type('stop_calibration')
        self.taskLayer.register_event_type('show_headposition')
        self.taskLayer.register_event_type('hide_headposition')
        self.taskLayer.register_event_type('actr_wait_connection')
        self.taskLayer.register_event_type('actr_wait_model')
        self.taskLayer.register_event_type('actr_running')
        self.taskLayer.push_handlers(self)
        
        self.taskScene.add(self.taskBackgroundLayer)
        self.taskScene.add(self.taskLayer, 1)
        self.actrScrim.visible = False
        self.taskScene.add(self.actrScrim, 3)
        
        self.taskScene.register_event_type('show_intro_scene')
        self.taskScene.push_handlers(self)
            
        director.window.set_visible(True)
示例#6
0
		draw_text( "%d" % fp.threshold, f, ( 255, 255, 255 ), ( screen_rect.left + 50, screen_rect.bottom - 15 ), screen )
		draw_text( "%d" % fp.nFixations, f, ( 255, 255, 255 ), ( screen_rect.left + 50, screen_rect.top + 15 ), screen )
		pygame.display.flip()

		angle1 += .05
		if angle1 >= 360:
			angle1 = 0

		angle2 -= .025
		if angle2 <= 0:
			angle2 = 360

	def cleanup( *args, **kwargs ):
		reactor.stop()

	def start( lc, results ):
		global state, update, client, cleanup
		state = 0
		client.addDispatcher( d )
		lc = LoopingCall( update )
		dd = lc.start( 1.0 / 30 )
		dd.addCallbacks( cleanup )

	client = iViewXClient( os.environ['EYE_TRACKER'], 4444 )
	reactor.listenUDP( 5555, client )
	calibrator = Calibrator( client, screen, reactor = reactor, eye = 0 )
	fp = VelocityFP(1680,1050,473.76,296.1,500,23,45)
	#calibrator.start(start)
	reactor.callLater(0,lambda:start(None,None))
	reactor.run()
示例#7
0
    def __init__( self, args, subjectInfo ):
        super( World, self ).__init__()

        self.args = args

        self.modifier = pygame.KMOD_CTRL
        if platform.system() == 'Darwin':
            self.modifier = pygame.KMOD_META

        self.lc = None
        self.fix_data = None
        self.eye_position = None
        self.fixating = False
        self.ret = 0

        self.colors = [( 204, 255, 102 ), ( 255, 153, 255 )]
        if args.color:
            self.colors = self.colors[::-1]
        self.bgcolor = ( 0, 0, 0 )
        self.fix_shape = u'\u25CB'

        self.replicates = 10
        self.trialPool = self.generateTrialPool( self.replicates )
        self.blockLength = len( self.trialPool )
        self.lastTrial = self.blockLength * int( self.args.blocks )
        self.colorSetup = 1
        if self.args.color:
            self.colorSetup = 2

        self.subjectInfo = subjectInfo

        self.screenshot = 1

        if self.subjectInfo:
            eid = rin2id( subjectInfo['rin'] )
            subjectInfo['encrypted_rin'] = eid
            subjectInfo['cipher'] = 'AES/CBC (RIJNDAEL) - 16Byte Key'
            self.log_basename = cwsubject.makeLogFileBase( 'SaccadeTask_' + eid[:8] )

        self.logdir = args.logdir
        if self.args.subdir:
            self.logdir = os.path.join(self.logdir, eid[:8])
        if not os.path.exists( self.logdir ):
            os.makedirs( self.logdir )

        self.log_filename = None
        if self.subjectInfo:
            cwsubject.writeHistoryFile( os.path.join( self.logdir, self.log_basename ), self.subjectInfo )
            self.log_filename = os.path.join( self.logdir, self.log_basename + '.txt.incomplete')
            self.output = open( self.log_filename, 'w' )
        else:
            if self.args.logfile:
                self.log_filename = os.path.join( self.logdir, args.logfile + '.incomplete')
                self.output = open( self.log_filename, 'w' )
            else:
                self.output = sys.stdout

        pygame.mouse.set_visible( False )
        if self.args.fullscreen:
            self.screen = pygame.display.set_mode( ( 0, 0 ), pygame.FULLSCREEN )
        else:
            self.screen = pygame.display.set_mode( ( 1024, 768 ), 0 )
        self.width, self.height = self.screen.get_size()
        self.center_x = int( self.width / 2 )
        self.center_y = int( self.height / 2 )
        self.offset = int( self.width / 3 )
        self.offsets = [int( self.center_x - self.offset ), int( self.center_x + self.offset )]
        self.worldsurf = self.screen.copy()
        self.worldsurf_rect = self.worldsurf.get_rect()
        obj_width = int( self.center_y * self.args.arrowsize )
        self.fontname = 'DejaVuSansMono.ttf'
        self.obj_widths = [obj_width, int( math.ceil( obj_width * 1.5 ) ), int( math.ceil( obj_width * 2 ) )]
        self.arrow_font = pygame.font.Font( self.fontname, self.obj_widths[0] )
        self.mask_font = pygame.font.Font( self.fontname, int( self.obj_widths[2] * 1.5 ) )
        self.demo_font = pygame.font.Font( self.fontname, int( self.obj_widths[2] * 4 ) )
        self.cue_fonts = [pygame.font.Font( self.fontname, self.obj_widths[0] ),
                          pygame.font.Font( self.fontname, self.obj_widths[1] ),
                          pygame.font.Font( self.fontname, self.obj_widths[2] )]
        self.arrows = ['', u'\u25B6', u'\u25B2', u'\u25C0']
        self.arrow_text = ['', '>', '^', '<']
        self.clock = pygame.time.Clock()
        self.accuracy = []

        self.EVENT_SHOW_CUE = pygame.USEREVENT + 1
        self.EVENT_SHOW_ARROW = pygame.USEREVENT + 2
        self.EVENT_SHOW_MASK = pygame.USEREVENT + 3
        self.EVENT_HIDE_FIX = pygame.USEREVENT + 4

        self.mode_text = ''

        self.trial = 0
        self.size = self.cue_side = self.fix_delay = -1
        self.answer = self.mask_time = self.cue_time = self.trial_stop = self.trial_start = 0

        if self.args.eyetracker and self.args.fullscreen:
            self.client = iViewXClient( self.args.eyetracker, 4444 )
            self.client.addDispatcher( self.d )
            self.fp = VelocityFP(self.width, self.height, 473.76, 296.1, 500, 23, 45)
            self.calibrator = Calibrator( self.client, self.screen, reactor = reactor)
示例#8
0
文件: main.py 项目: CogWorks/pySnake
    def __init__(self):
        
        if not os.path.exists("data"): os.mkdir("data")
        
        pyglet.resource.path.append('resources')
        pyglet.resource.reindex()
        pyglet.resource.add_font('Pipe_Dream.ttf')
        pyglet.resource.add_font('cutouts.ttf')
        pyglet.resource.add_font('scoreboard.ttf')
        
        p = pyglet.window.get_platform()
        d = p.get_default_display()
        s = d.get_default_screen()
        
        director.init(width=s.width, height=s.height,
                  caption=self.title, visible=False, resizable=True)
        director.window.set_size(int(s.width * .75), int(s.height * .75))
        
        director.window.pop_handlers()
        director.window.push_handlers(DefaultHandler())
            
        director.settings = {'eyetracker': True,
                             'eyetracker_ip': '127.0.0.1',
                             'eyetracker_out_port': '4444',
                             'eyetracker_in_port': '5555',
                             'board_size': '31',
                             'speed_factor': '0.990',
                             'fixation_overlay': False,
                             'player': 'Human',
                             'players': ['Human']}
        
        self.client = None
        self.client_actr = None
        
        if ACTR6:
            director.settings['players'].append("ACT-R")
            #director.settings['player'] = "ACT-R"
            director.settings['eyetracker'] = False
            self.client_actr = JNI_Server(self)
            self.listener_actr = reactor.listenTCP(6666, self.client_actr)
        if eyetracking:
            self.client = iViewXClient(director.settings['eyetracker_ip'], int(director.settings['eyetracker_out_port']))
            self.listener = reactor.listenUDP(int(director.settings['eyetracker_in_port']), self.client) 
        
        director.fps_display = clock.ClockDisplay(font=font.load('', 18, bold=True))
        #fps_display = FPSDisplay(director.window)
        #fps_display.label.font_size = 12
        #director.fps_display = fps_display

        director.set_show_FPS(True)
        director.window.set_fullscreen(False)
        director.window.set_mouse_visible(False)
        
        if platform.system() != 'Windows':
            director.window.set_icon(pyglet.resource.image('logo.png'))
        
        # Intro scene and its layers        
        self.introScene = Scene()
                    
        self.mainMenu = MainMenu()
        self.optionsMenu = OptionsMenu()
        self.participantMenu = ParticipantMenu()
        self.introBackground = BackgroundLayer()
        self.eyetrackerScrim = EyetrackerScrim()
        
        self.introScene.add(self.introBackground)
        self.mplxLayer = MultiplexLayer(self.mainMenu, self.optionsMenu, self.participantMenu)
        self.introScene.add(self.mplxLayer, 1)
        
        self.introScene.register_event_type('start_task')
        self.introScene.register_event_type('eyetracker_info_changed')
        self.introScene.push_handlers(self)
        
        # Task scene and its layers
        self.taskScene = Scene()
        
        self.taskBackgroundLayer = TaskBackground()
        self.taskLayer = Task(self.client, self.client_actr)
        self.scoreLayer = self.taskLayer.score_layer
        self.actrScrim = ACTRScrim()
        
        if self.client:
            self.calibrationLayer = CalibrationLayer(self.client)
            self.calibrationLayer.register_event_type('show_headposition')
            self.calibrationLayer.register_event_type('hide_headposition')
            self.calibrationLayer.push_handlers(self)
            self.headpositionLayer = HeadPositionLayer(self.client)
            self.fixationLayer = FixationLayer(self.client)
        
        self.taskLayer.register_event_type('new_trial')
        self.taskLayer.push_handlers(self.taskBackgroundLayer)
        self.taskLayer.register_event_type('start_calibration')
        self.taskLayer.register_event_type('stop_calibration')
        self.taskLayer.register_event_type('show_headposition')
        self.taskLayer.register_event_type('hide_headposition')
        self.taskLayer.register_event_type('show_fixation')
        self.taskLayer.register_event_type('hide_fixation')
        self.taskLayer.register_event_type('actr_wait_connection')
        self.taskLayer.register_event_type('actr_wait_model')
        self.taskLayer.register_event_type('actr_running')
        self.taskLayer.push_handlers(self)
        
        self.taskScene.add(self.taskBackgroundLayer)
        self.taskScene.add(self.taskLayer, 1)
        self.taskScene.add(self.scoreLayer, 1)
        self.actrScrim.visible = False
        self.taskScene.add(self.actrScrim, 3)
        
        self.taskScene.register_event_type('show_intro_scene')
        self.taskScene.push_handlers(self)
            
        director.window.set_visible(True)