gonogo_test.py

Ir a la documentación de este archivo.

# Importación de librerías necesarias
import random           # Para seleccionar aleatoriamente condiciones
import pygame           # Librería gráfica para mostrar estímulos
import time             # Para medir tiempos y controlar la secuencia temporal
from pygaze import libscreen, liblog, libinput, eyetracker  # Módulos clave de PyGaze
import constants        # Constantes como tamaño de pantalla, etc.
 
# Inicialización de Pygame (motor gráfico)
pygame.init()
 
# Crear una pantalla para mostrar los estímulos
disp = libscreen.Display()
 
# Inicializar el eye tracker conectado
tracker = eyetracker.EyeTracker(disp)
 
# Crear un detector de teclado para capturar pulsaciones como 'space' y 'escape'
keyboard = libinput.Keyboard(keylist=['space', 'escape'], timeout=None)
 
# Crear el archivo de log para guardar los datos del experimento
log = liblog.Logfile()
log.write(["trialnr", "trialtype", "targetside", "gaze_endpos", "latency", "correct"])
 
# Definición de dimensiones y posiciones clave en pantalla
SCREEN_WIDTH, SCREEN_HEIGHT = 1920, 1800
CENTER = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
CENTER1 = (constants.DISPSIZE[0] // 2, constants.DISPSIZE[1] // 2)
 
# Offset horizontal para colocar los estímulos a izquierda y derecha del centro
TARGET_OFFSET = 382
 
# Elegir aleatoriamente un desplazamiento vertical para evitar que el sujeto anticipe la posición
vertical_offset = random.choice([386, -386])
 
# Posiciones de los estímulos en la pantalla
left_pos = (CENTER[0] - TARGET_OFFSET, CENTER[1] + vertical_offset)
right_pos = (CENTER[0] + TARGET_OFFSET, CENTER[1] + vertical_offset)
 
# Crear pantalla con instrucciones iniciales
inscreen = libscreen.Screen()
inscreen.draw_text(
    text="Pulsa la tecla ESPACIO para comenzar.",
    fontsize=40,
    pos=CENTER,
    colour=(255, 255, 255),
)
 
# Pantalla con la cruz de fijación para centrar la vista del participante
fixscreen = libscreen.Screen()
fixscreen.draw_fixation(fixtype='cross', colour=(255, 255, 255), pw=2)
 
# Crear pantallas para los diferentes tipos de estímulo de inicio (Go, Anti-Go, NoGo)
signal_screens = {
    'PS': libscreen.Screen(),     # Pro-sácadico → círculo verde
    'AS': libscreen.Screen(),     # Anti-sácadico → círculo rojo
    'NoGo': libscreen.Screen(),   # No mirar → círculo naranja
}
signal_screens['PS'].draw_circle(colour=(0, 255, 0), pos=CENTER, r=50)
signal_screens['AS'].draw_circle(colour=(255, 0, 0), pos=CENTER, r=50)
signal_screens['NoGo'].draw_circle(colour=(255, 165, 0), pos=CENTER, r=50)
 
# Crear pantallas para feedback (acierto o error)
feedbackscreens = {
    True: libscreen.Screen(),
    False: libscreen.Screen(),
}
feedbackscreens[True].draw_text(text="¡Correcto!", fontsize=40, pos=CENTER, colour=(0, 255, 0))
feedbackscreens[False].draw_text(text="Incorrecto", fontsize=40, pos=CENTER, colour=(255, 0, 0))
 
# Mostrar la pantalla de instrucciones y esperar a que se pulse la tecla espacio
disp.fill(inscreen)
disp.show()
keyboard.get_key()
 
# Número de bloques (con 3 ensayos cada uno: PS, AS, NoGo)
max_blocks = 30
 
for block in range(1, max_blocks + 1):
 
    # Lista con los tres tipos de ensayo
    trials = ['PS', 'AS', 'NoGo']
    random.shuffle(trials)  # Aleatorizar orden
 
    for trialnr, trialtype in enumerate(trials, 1):
 
        # Mostrar cruz de fijación durante 0.5 segundos
        disp.fill(fixscreen)
        disp.show()
        time.sleep(0.5)
 
        # Mostrar el estímulo de inicio (círculo de color) durante 0.8 segundos
        disp.fill(signal_screens[trialtype])
        disp.show()
        time.sleep(0.8)
 
        # Determinar aleatoriamente si el estímulo aparecerá a la izquierda o derecha
        targetside = random.choice(['left', 'right'])
        target_pos = left_pos if targetside == 'left' else right_pos
        nontarget_pos = right_pos if targetside == 'left' else left_pos
 
        # Crear la pantalla con los estímulos en los laterales
        dualsim_screen = libscreen.Screen()
 
        # Estímulo objetivo → círculo blanco
        dualsim_screen.draw_circle(colour=(255, 255, 255), pos=target_pos, r=50)
 
        # Estímulo distractor → blanco-negro-blanco (como en tareas anti-sácadicas)
        dualsim_screen.draw_circle(colour=(255, 255, 255), pos=nontarget_pos, r=60)
        dualsim_screen.draw_circle(colour=(0, 0, 0), pos=nontarget_pos, r=40)
        dualsim_screen.draw_circle(colour=(255, 255, 255), pos=nontarget_pos, r=20)
 
        # Mostrar los estímulos y empezar grabación
        disp.fill(dualsim_screen)
        disp.show()
 
        # Comenzar grabación del eye tracker y medir el tiempo
        tracker.start_recording()
        t0 = time.time()
        time.sleep(1.0)  # Tiempo disponible para responder
        tracker.stop_recording()
 
        # Obtener la última muestra del eye tracker (posición final de la mirada)
        sample = tracker.sample()
        endpos = sample[:2] if sample else (CENTER[0], CENTER[1])  # Si no hay muestra, usar centro
 
        # Calcular la latencia de la respuesta
        latency = time.time() - t0
 
        # Verificar si se ha pulsado la tecla escape para salir del experimento
        key_pressed = keyboard.get_key()
        if key_pressed == 'escape':
            tracker.close()
            disp.close()
            log.close()
            exit()
 
        # Calcular distancia euclidiana entre mirada y los estímulos
        def euclidean(p1, p2):
            return ((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2) ** 0.5
 
        dist_target = euclidean(endpos, target_pos)
        dist_nontarget = euclidean(endpos, nontarget_pos)
 
        # Determinar si la respuesta fue correcta
        if trialtype == 'PS':  # Pro-sácadico: mirar al estímulo blanco
            correct = dist_target < dist_nontarget
        elif trialtype == 'AS':  # Anti-sácadico: mirar al estímulo distractor (opuesto al target)
            correct = dist_nontarget < dist_target
        elif trialtype == 'NoGo':  # NoGo: no mirar a ninguno
            correct = dist_target > 150 and dist_nontarget > 150
 
        # Mostrar feedback de acierto/error durante 0.5 segundos
        disp.fill(feedbackscreens[correct])
        disp.show()
        time.sleep(0.5)
 
        # Registrar datos del ensayo en el archivo de log
        log.write([trialnr, trialtype, targetside, endpos, latency, correct])
 
# Al terminar todos los bloques, cerrar el log y el eye tracker correctamente
log.close()
tracker.close()
disp.close()