main.py

Ir a la documentación de este archivo.

import sys  # Para acceder a argumentos del sistema o finalizar la app si hace falta
import random  # Para aleatorizar condiciones o estímulos
import time  # Para pausas o cálculos de tiempo
from matplotlib.pyplot import margins  # (Parece innecesaria, no se usa en el script)
import pygame  # Para gestionar eventos de teclado y control del flujo durante el test
from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QLabel, QMessageBox  # Elementos de la interfaz gráfica
from PyQt6.QtCore import Qt  # Para definir tipos de alineación y eventos en Qt
from PyQt6.QtGui import QFont  # Para modificar fuentes en elementos de la interfaz
 
# Importaciones de PyGaze
from pygaze import eyetracker, libinput, libscreen, liblog
from pygaze import libtime
 
import tobii_research as tr  # Librería oficial para interactuar con dispositivos Tobii
 
import constants  # Módulo personalizado que debe contener parámetros como DISPSIZE = (1920, 1080)
import pandas as pd  # Para trabajar con datos y guardar los resultados en Excel
import subprocess  # Para abrir archivos con el programa predeterminado del sistema operativo
import os  # Para comprobar si existen archivos o rutas
 
 
# ============ FUNCIÓN DE CALIBRACIÓN ============ 
def calibrate_tobii(self):
    try:
        print("Buscando dispositivo...")
        found_eyes = tr.find_all_eyetrackers()  # Busca todos los eye trackers conectados
 
        if not found_eyes:
            raise Exception("No se encontró ningún dispositivo Tobii Pro.")
        
        eye_tracker = found_eyes[0]  # Selecciona el primer dispositivo encontrado
        print(f"Dispositivo encontrado: {eye_tracker}")
 
        self.disp = libscreen.Display(bgcolor=(0, 0, 0))  # Crea una pantalla negra
        self.tracker = eyetracker.EyeTracker(self.disp)  # Crea el objeto de seguimiento ocular
 
        instruction_screen = libscreen.Screen()  # Crea una pantalla para mostrar instrucciones
        instruction_screen.clear(colour=(0, 0, 0))  # Fondo negro
        instruction_screen.draw_text("Presiona espacio para calibrar", fontsize=24, colour=(255, 255, 255))  # Texto en blanco
        self.disp.fill(instruction_screen)  # Muestra las instrucciones
        self.disp.show()
 
        print("Iniciando calibración...")
        self.tracker.calibrate()  # Ejecuta el proceso de calibración
        print("Calibración completada.")
 
        return True  # Devuelve True si fue exitoso
    except Exception as e:
        print(f"Error durante calibración: {e}")
        return False  # Devuelve False si hubo error
 
# ============ TEST GO/NOGO ======================
 
def run_gonogo_test(self):
    pygame.init()  # Inicializa Pygame
 
    log = liblog.Logfile()  # Crea un archivo de log
    log.write(["trialnr", "trialtype", "targetside", "gaze_endpos", "latency", "correct"])  # Define las columnas del log
 
    SCREEN_WIDTH, SCREEN_HEIGHT = constants.DISPSIZE  # Tamaño de la pantalla
    CENTER = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)  # Coordenadas del centro
    TARGET_OFFSET = 382  # Distancia desde el centro hacia los lados para colocar estímulos
 
    left_pos = (CENTER[0] - TARGET_OFFSET, CENTER[1])  # Posición del estímulo izquierdo
    right_pos = (CENTER[0] + TARGET_OFFSET, CENTER[1])  # Posición del estímulo derecho
 
    blackscreen = libscreen.Screen()  # Pantalla negra para limpiar entre estímulos
    blackscreen.clear(colour=(0, 0, 0))
 
    # Pantalla de instrucciones
    inscreen = libscreen.Screen()
    inscreen.clear(colour=(0, 0, 0))  # Fondo negro
    ins_text = (
        "Mira la cruz central y presiona 'espacio'.\n\n"
        "El color indicará la acción:\n"
        "- Verde: mira al círculo blanco y negro (Pro-sácadico)\n"
        "- Rojo: mira al estímulo blanco  (Anti-sácadico)\n"
        "- Naranja: NO mires a ningún estímulo (NoGo)\n\n"
        "Presiona 'espacio' para comenzar.\n"
        "Pulsa 'E' en cualquier momento para salir."
    )
    inscreen.draw_text(text=ins_text, fontsize=30, pos=CENTER, colour=(255, 255, 255), center=True)
 
    # Pantalla con cruz de fijación
    fixscreen = libscreen.Screen()
    fixscreen.clear(colour=(0, 0, 0))
    fixscreen.draw_fixation(fixtype='cross', diameter=57, pos=CENTER, colour=(255, 255, 255))  # Cruz blanca
 
    # Pantallas para cada condición de color (verde, rojo, naranja)
    signal_screens = {
        'PS': libscreen.Screen(),
        'AS': libscreen.Screen(),
        'NoGo': libscreen.Screen()
    }
    for key, color in [('PS', (0, 255, 0)), ('AS', (255, 0, 0)), ('NoGo', (255, 165, 0))]:
        signal_screens[key].clear(colour=(0, 0, 0))
        signal_screens[key].draw_circle(pos=CENTER, r=38, fill=True, colour=color)  # Círculo central de señal
 
    # Pantallas para feedback
    feedbackscreens = {
        1: libscreen.Screen(),
        0: libscreen.Screen()
    }
    feedbackscreens[1].clear(colour=(0, 0, 0))
    feedbackscreens[1].draw_text(text='Correcto', fontsize=30, pos=CENTER, colour=(0, 255, 0), center=True)
    feedbackscreens[0].clear(colour=(0, 0, 0))
    feedbackscreens[0].draw_text(text='Incorrecto', fontsize=30, pos=CENTER, colour=(255, 0, 0), center=True)
 
    self.disp.fill(inscreen)  # Muestra pantalla de instrucciones
    self.disp.show()
 
    # Espera a que el usuario presione espacio o E para salir
    waiting = True
    while waiting:
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    waiting = False
                elif event.key == pygame.K_e:
                    pygame.quit()
                    return
 
    max_blocks = 30  # Número de bloques de ensayo
    results = []  # Lista para guardar resultados
 
    try:
        for block in range(max_blocks):
            trials = ['PS', 'AS', 'NoGo']  # Tipos de ensayo
            random.shuffle(trials)  # Aleatoriza el orden
 
            for trialnr, trialtype in enumerate(trials, start=1):  # Recorre los tres ensayos del bloque
                for event in pygame.event.get():
                    if event.type == pygame.KEYDOWN and event.key == pygame.K_e:
                        raise KeyboardInterrupt  # Permite salir del test
 
                self.disp.fill(fixscreen)
                self.disp.show()
                libtime.pause(random.randint(750, 1250))  # Tiempo aleatorio de fijación
 
                waiting = True
                while waiting:
                    for event in pygame.event.get():
                        if event.type == pygame.KEYDOWN:
                            if event.key == pygame.K_SPACE:
                                waiting = False
                            elif event.key == pygame.K_e:
                                raise KeyboardInterrupt
 
                time.sleep(0.2)  # Pequeña pausa antes de comenzar a grabar
                self.tracker.start_recording()  # Comienza a registrar movimientos oculares
 
                self.disp.fill(signal_screens[trialtype])  # Muestra señal central
                self.disp.show()
                time.sleep(0.8)  # Se muestra durante 0.8 segundos
 
                self.disp.fill(blackscreen)  # Limpia pantalla
                self.disp.show()
                time.sleep(0.2)
 
                targetside = random.choice(['left', 'right'])  # Aleatoriza la posición del objetivo
                target_pos = left_pos if targetside == 'left' else right_pos
                nontarget_pos = right_pos if targetside == 'left' else left_pos
 
                dualstim_screen = libscreen.Screen()
                dualstim_screen.clear(colour=(0, 0, 0))
                dualstim_screen.draw_circle(pos=nontarget_pos, r=28, fill=True, colour=(255, 255, 255))  # Non-target
                dualstim_screen.draw_circle(pos=target_pos, r=38, fill=True, colour=(255, 255, 255))  # Círculo externo
                dualstim_screen.draw_circle(pos=target_pos, r=32, fill=True, colour=(0, 0, 0))  # Círculo medio
                dualstim_screen.draw_circle(pos=target_pos, r=28, fill=True, colour=(255, 255, 255))  # Círculo interno
 
                self.disp.fill(dualstim_screen)
                self.disp.show()
 
                t0 = pygame.time.get_ticks()  # Tiempo inicial
                self.tracker.log(f"target {targetside}")  # Escribe en el log
 
                t1, startpos = self.tracker.wait_for_saccade_start()  # Espera el inicio de la sacada
                endtime, startpos, endpos = self.tracker.wait_for_saccade_end()  # Obtiene datos del final de la sacada
 
                latency = (t1 - t0) / 1000  # Latencia en segundos
                self.tracker.stop_recording()  # Detiene el registro de datos
 
                margin = 100  # Margen de tolerancia (no usado aún)
                
           # Creamos una condición para indicar cuándo el movimiento prosacádico, antisacádico o NoGo es correcto o incorrecto
            if trialtype == 'PS':  # Si el círculo central es verde → condición Pro-saccádica
                correct = int(
                    # Es correcto si el participante mira hacia el lado donde aparece el target:
                    # si el target está a la izquierda y la mirada termina en la mitad izquierda de la pantalla,
                    # o si el target está a la derecha y la mirada termina en la mitad derecha
                    (targetside == 'left' and endpos[0] <= constants.DISPSIZE[0]/2) or
                    (targetside == 'right' and endpos[0] >= constants.DISPSIZE[0]/2)
                )
                print(correct)  # Imprime 1 si es correcto, 0 si es incorrecto
            
            elif trialtype == 'AS':  # Si el círculo central es rojo → condición Anti-saccádica
                correct = int(
                    # Es correcto si el participante mira hacia el lado opuesto al target (al non-target):
                    # si el target está a la izquierda y la mirada termina en la mitad derecha,
                    # o si el target está a la derecha y la mirada termina en la mitad izquierda
                    (targetside == 'left' and endpos[0] >= constants.DISPSIZE[0]/2) or
                    (targetside == 'right' and endpos[0] <= constants.DISPSIZE[0]/2)
                )
            
            elif trialtype == 'NoGo':  # Si el círculo central es naranja → condición NoGo
                # En NoGo no debe haber movimiento ocular (sacada)
                try:
                    # Espera hasta 900 ms para detectar el inicio de una sacada
                    t1, _ = self.tracker.wait_for_saccade_start(timeout=900)
                    correct = 0  # Si hay una sacada, se considera incorrecto
                    latency = (t1 - t0) / 1000  # Calcula la latencia en segundos
                    print("Incorrecto")
                except Exception:
                    # Si no se detecta ninguna sacada en ese tiempo, se considera correcto
                    correct = 1
                    latency = 0  # No hay latencia porque no hubo movimiento
                    print("Correcto")
            
            # correct toma valor 1 si es correcto, 0 si es incorrecto
            
            if correct >= 0:
                dualstim_screen.clear(colour=(0, 0, 0))  # Limpia la pantalla
                self.disp.show()  # Actualiza la pantalla para reflejar los cambios
            
            self.disp.fill(feedbackscreens[correct])  # Muestra la pantalla de feedback correspondiente (correcta o incorrecta)
            self.disp.show()  # Refresca la pantalla para mostrar el feedback
            time.sleep(0.5)  # Muestra el feedback durante 0.5 segundos
            
            # Almacena los resultados del ensayo en una lista para análisis posterior
            results.append([trialnr, trialtype, targetside, endpos, round(latency, 3), correct])
            
    except KeyboardInterrupt:
        print("Test interrumpido por el usuario con la tecla 'E'.")  # Si el usuario presiona 'E', se detiene el test
    
    finally:
        log.close()  # Cierra el archivo de log
        self.tracker.close()  # Cierra la conexión con el eyetracker
        self.disp.close()  # Cierra la pantalla de presentación de estímulos
        print("Test Go/NoGo finalizado.")
    
        # Crea un DataFrame con los resultados recogidos y lo guarda en un archivo Excel
        df = pd.DataFrame(results, columns=["trialnr", "trialtype", "targetside", "gaze_endpos", "latency", "correct"])
        df.to_excel("gonogo_results.xlsx", index=False)  # Guarda el archivo sin incluir los índices
        print("Resultados guardados en 'gonogo_results.xlsx'.")  # Informa que los datos han sido guardados correctamente
 
 
# ============ INTERFAZ PYQT ===================
 
class EyeTrackingApp(QWidget):  # Define una clase que hereda de QWidget para crear una ventana principal
    def __init__(self):  # Método constructor
        super().__init__()  # Llama al constructor de la clase padre (QWidget)
        self.setWindowTitle("Test Go/NoGo con Tobii")  # Establece el título de la ventana
        self.setGeometry(100, 100, 400, 300)  # Define posición (x=100, y=100) y tamaño (400x300) de la ventana
        self.calibrated = False  # Variable para controlar si el eye tracker ha sido calibrado
        self.setup_ui()  # Llama a la función que crea los componentes de la interfaz
        self.disp = None  # Inicializa el objeto de pantalla (se asignará más adelante)
        self.tracker = None  # Inicializa el objeto del eye tracker (se asignará más adelante)
 
        def setup_ui(self):  # Método que crea y organiza los elementos visuales
         self.setStyleSheet("background-color: #e6f0ff;")  # Cambia el color de fondo de la ventana
 
        layout = QVBoxLayout()  # Crea un layout vertical para organizar los elementos de arriba hacia abajo
 
        title = QLabel("Test Go/NoGo con Tobii")  # Crea una etiqueta de título
        title.setFont(QFont("Arial", 18, QFont.Weight.Bold))  # Establece la fuente, tamaño y negrita
        title.setAlignment(Qt.AlignmentFlag.AlignCenter)  # Centra el texto horizontalmente
        layout.addWidget(title)  # Añade la etiqueta al layout
 
        # Botón para calibrar el eye tracker
        self.btn_calibrate = QPushButton("Calibrar")
        self.btn_calibrate.setFont(QFont("Arial", 14))  # Fuente y tamaño
        self.btn_calibrate.setStyleSheet("background-color: #3399ff; color: white; padding: 10px; border-radius: 5px;")
        self.btn_calibrate.clicked.connect(self.calibrate)  # Conecta el clic del botón a la función de calibración
        layout.addWidget(self.btn_calibrate)  # Añade el botón al layout
 
        # Botón para iniciar el test Go/NoGo
        self.btn_test = QPushButton("Iniciar test Go/NoGo")
        self.btn_test.setFont(QFont("Arial", 14))
        self.btn_test.setStyleSheet("background-color: #3399ff; color: white; padding: 10px; border-radius: 5px;")
        self.btn_test.clicked.connect(self.start_test)  # Conecta a la función que lanza el test
        layout.addWidget(self.btn_test)
 
        # Botón para consultar los resultados del test
        self.btn_results = QPushButton("Consultar resultados")
        self.btn_results.setFont(QFont("Arial", 14))
        self.btn_results.setStyleSheet("background-color: #3399ff; color: white; padding: 10px; border-radius: 5px;")
        self.btn_results.clicked.connect(self.view_results)  # Conecta al método para visualizar resultados
        layout.addWidget(self.btn_results)
 
        self.setLayout(layout)  # Establece el layout creado como layout principal de la ventana
 
    def calibrate(self):
        result = calibrate_tobii(self)
        if result:
            self.calibrated = True
            QMessageBox.information(self, "Calibración", "Calibración completada con éxito.")
        else:
            QMessageBox.critical(self, "Error", "La calibración ha fallado.")
 
        def start_test(self):  # Método que inicia el test
        # Código comentado para forzar calibración antes del test:
        # if not self.calibrated:
        #     QMessageBox.warning(self, "Calibración requerida", "Debes calibrar antes de realizar el test.")
        #     return
         run_gonogo_test(self)  # Llama a la función que ejecuta el test Go/NoGo
 
 
    def view_results(self):
        file_path = "gonogo_results.xlsx"
        
        # Verificamos si el archivo existe antes de intentar abrirlo
        if os.path.exists(file_path):
            try:
                # Abrimos el archivo con el programa predeterminado (Windows)
                subprocess.Popen([file_path], shell=True)
            except Exception as e:
                QMessageBox.critical(self, "Error", f"No se pudo abrir el archivo Excel. {e}")
        else:
            QMessageBox.warning(self, "Archivo no encontrado", "El archivo de resultados no existe.")
 
 
if __name__ == "__main__":  # Si este archivo se ejecuta directamente
    app = QApplication(sys.argv)  # Crea la aplicación Qt
    window = EyeTrackingApp()  # Crea una instancia de la ventana principal
    window.show()  # Muestra la ventana
    sys.exit(app.exec())  # Inicia el bucle de eventos y cierra correctamente al salir