codes/eye_track.py

"""This module contains the EyeTrack method. In this method, the eye movements will be predicted using the inputs and retrained models.
Also the fixations will be calculated."""

from tensorflow.keras.models import load_model
import numpy as np
from joblib import load as j_load
from codes.base import eyeing as ey
from scipy import signal
from openpyxl import Workbook, load_workbook
import os


class EyeTrack(object):
    @staticmethod
    def get_pixels(
        subjects,
        models_list=[1],
        target_fol=ey.SMP,
        shift_samples=None,
        blinking_threshold="uo",
        use_io=False,
        delete_files=False
        ):
        """
        Predicting the eye movements using the inputs (eyes images and face vectors). This can be done on sampling (smp) data,
        tsting (acc) data or latency (ltn) data. You can predict outputs for several subjects and with several models, to exactly know
        which one is working better. In this method, the samples that are during blinking, will be deleted. The values for eye movements
        are between 0 and 1. It means it is independant to the size of screen.

        Parameters:
            subjects: list of subjects that we want to predict their eye viewpoints
            models_list: list of models that we want to use them to predict the eye viewpoints
            target_fol: the targeted folder that we want to predict its data. smp, acc, or ltn
            shift_smaples: whether or not shift the inputs
            blinking_threshold: blinking threshold. It can takes "d" as default, "uo" as user offered and "ao" as app offered.
            use_io: whether or not use the io model
            delete_files: whethere or not remove the inputs after prediction. Because of size of the saved images
        """
        tfn = 1         # For sampling data
        if target_fol == ey.ACC:
            tfn = 2     # For testing data
        elif target_fol == ey.LTN:
            tfn = 3     # For latency data

        out_threshold_min = 0.005
        out_threshold_max = 0.995
        latency_radius = 0.33
        median_filter_window_size = 5

        x1_scaler_et, x2_scaler_et, y_scaler = j_load(ey.scalers_dir + "scalers_et_main.bin")
        if tfn == 1:
            x1_scaler_io, x2_scaler_io = j_load(ey.scalers_dir + "scalers_io_main.bin")
            mdl_io = load_model(ey.io_trained_dir + ey.MDL + "1.h5")

        # Going through each subject's folder to predict their eye movement
        kk = 0
        for num in subjects:
            print(f"<<<<<<<<<<<<<<<<<<<<< Subject {num} >>>>>>>>>>>>>>>>>>>>>>>")
            sbj_dir = ey.create_dir([ey.subjects_dir, f"{num}"])
            sbj_models_dir = ey.create_dir([sbj_dir, ey.MDL])
            target_dir = ey.create_dir([sbj_dir, target_fol])

            # Loading the data and shifting the inputs if it's needed
            if ey.file_existing(target_dir, ey.X1+".pickle"):
                if tfn == 1:
                    t_load, sys_time_load, x1_load, x2_load, eyes_ratio = ey.load(target_dir, [ey.T, "sys_time", ey.X1, ey.X2, ey.ER])
                    if shift_samples:
                        if shift_samples[kk]:
                            ii = 0
                            for (x11, x21, t1, st1, eyr1) in zip(x1_load, x2_load, t_load, sys_time_load, eyes_ratio):
                                t_load[ii] = t1[:-shift_samples[kk]]
                                sys_time_load[ii] = st1[:-shift_samples[kk]]
                                x1_load[ii] = x11[shift_samples[kk]:]
                                x2_load[ii] = x21[shift_samples[kk]:]
                                eyes_ratio[ii] = eyr1[shift_samples[kk]:]
                                ii += 1
                elif tfn == 2:
                    t_load, x1_load, x2_load, y_load, eyes_ratio = ey.load(target_dir, [ey.T, ey.X1, ey.X2, ey.Y, ey.ER])
                    if shift_samples:
                        if shift_samples[kk]:
                            ii = 0
                            for (x11, x21, y1, t1, eyr1) in zip(x1_load, x2_load, y_load, t_load, eyes_ratio):
                                t_load[ii] = t1[:-shift_samples[kk]]
                                x1_load[ii] = x11[shift_samples[kk]:]
                                x2_load[ii] = x21[shift_samples[kk]:]
                                y_load[ii] = y1[:-shift_samples[kk]]
                                eyes_ratio[ii] = eyr1[shift_samples[kk]:]
                                ii += 1
                else:
                    t_load, x1_load, x2_load = ey.load(target_dir, [ey.T, ey.X1, ey.X2])
                    if shift_samples:
                        if shift_samples[kk]:
                            ii = 0
                            for (x11, x21, t1) in zip(x1_load, x2_load, t_load):
                                t_load[ii] = t1[:-shift_samples[kk]]
                                x1_load[ii] = x11[shift_samples[kk]:]
                                x2_load[ii] = x21[shift_samples[kk]:]
                                ii += 1
                kk += 1

                # Going through each model to predict the output
                for mdl_num in models_list:
                    mdl_et_name = ey.MDL + f"{mdl_num}"
                    mdl_et_hrz_dir = sbj_models_dir + mdl_et_name + "-hrz.h5"
                    mdl_et_vrt_dir = sbj_models_dir + mdl_et_name + "-vrt.h5"
                    if ey.file_existing(sbj_models_dir, mdl_et_name + "-hrz.h5"):
                        info = ey.load(sbj_models_dir, [mdl_et_name])[0]
                        x2_chosen_features = info["x2_chosen_features"]
                        mdl_et_hrz = load_model(mdl_et_hrz_dir)
                        mdl_et_vrt = load_model(mdl_et_vrt_dir)

                        # x1_load and x2_load are lists of lists. So, we should predict each list
                        y_prd = []
                        for (x11, x21) in zip(x1_load, x2_load):
                            n_smp_vec = x11.shape[0]
                            x21_new = x21[:, x2_chosen_features]
                            x11_nrm = x11 / x1_scaler_et
                            x21_nrm = x2_scaler_et.transform(x21_new)
                            x0_nrm = [x11_nrm, x21_nrm]

                            y_hrz_prd = np.expand_dims(mdl_et_hrz.predict(x0_nrm).reshape((n_smp_vec,)), 1) / y_scaler
                            y_vrt_prd = np.expand_dims(mdl_et_vrt.predict(x0_nrm).reshape((n_smp_vec,)), 1) / y_scaler

                            y_prd.append(np.concatenate([y_hrz_prd, y_vrt_prd], 1))

                        # For calculation of latency, it's just needed to see if the subject is looking in left or right, not exact location
                        if tfn == 3:
                            t_delay = []
                            j = 0
                            for (t1, y1_prd) in zip(t_load, y_prd):
                                for (t0, y0_prd) in zip(t1, y1_prd):
                                    if j % 2 == 0:
                                        d = y0_prd[0] - 0.66
                                    else:
                                        d = 0.33 - y0_prd[0]
                                    if 0 < d < latency_radius:
                                        t_delay.append(t0 - t1[0])
                                        break
                                j += 1
                            print(t_delay)
                            t_delay = np.array(t_delay).mean() - ey.LATENCY_WAITING_TIME/1000.0
                            print(t_delay)
                            ey.save([t_delay], target_dir, ["t_delay"])

                        else:
                            # predict the samples that are looking outside of the screen
                            y_in = y_prd.copy()
                            if (tfn == 1) and use_io:
                                for (x11, x21, yi1) in zip(x1_load, x2_load, y_in):
                                    x1_io = x11 / x1_scaler_io
                                    x2_io = x2_scaler_io.transform(x21)
                                    y_io_prd = mdl_io.predict([x1_io, x2_io]).round()
                                    
                                    for (et0, yio) in zip(yi1, y_io_prd):
                                        if yio == 1:
                                            et0[0] = -1
                                            et0[1] = -1

                            er_dir = ey.create_dir([sbj_dir, ey.ER])

                            # Removing the samples that are during blinking
                            blinking_threshold = ey.get_threshold(er_dir, blinking_threshold)
                            blinking = ey.get_blinking(t_load, eyes_ratio, blinking_threshold)[1]
                            for (yi1, bl1) in zip(y_in, blinking):
                                for (yi0, bl0) in zip(yi1, bl1):
                                    if bl0:
                                        yi0[0] = -1
                                        yi0[1] = -1

                            """Putting the values that are consecuitive and are looking inside the screen and they are not blink,
                            into one list"""
                            y_prd_mat = []
                            for yi1 in y_in:
                                blinking_out = (yi1[:, 0] == -1)
                                n_smp = yi1.shape[0]
                                i = 0
                                while i < (n_smp):
                                    bo_vec = []
                                    in_vec = []
                                    now = blinking_out[i]
                                    if now:
                                        bo_vec.append(yi1[i])
                                    else:
                                        in_vec.append(yi1[i])
                                    j = 1
                                    if (i+j) < n_smp:
                                        while blinking_out[i+j] == now:
                                            if now:
                                                bo_vec.append(yi1[i+j])
                                            else:
                                                in_vec.append(yi1[i+j])
                                            j += 1
                                            if (i+j) >= n_smp:
                                                break
                                    if now:
                                        y_prd_mat.append(np.array(bo_vec))
                                    else:
                                        y_prd_mat.append(np.array(in_vec))
                                    i += j

                            # Implementing median filter to the predicted values
                            for y_prd_vec in y_prd_mat:
                                if y_prd_vec[0, 0] != -1:
                                    if 3 < y_prd_vec.shape[0] < (median_filter_window_size+2):
                                        y_prd_vec[:, 0] = signal.medfilt(y_prd_vec[:, 0], 3)
                                        y_prd_vec[:, 1] = signal.medfilt(y_prd_vec[:, 1], 3)
                                    elif y_prd_vec.shape[0] >= (median_filter_window_size+2):
                                        y_prd_vec[:, 0] = signal.medfilt(y_prd_vec[:, 0], median_filter_window_size)
                                        y_prd_vec[:, 1] = signal.medfilt(y_prd_vec[:, 1], median_filter_window_size)

                            # Concatenating y
                            y_prd_fnl = y_prd_mat[0]
                            for (i, y_prd_vec) in enumerate(y_prd_mat):
                                if i == 0:
                                    continue
                                y_prd_fnl = np.concatenate([y_prd_fnl, y_prd_vec], 0)

                            # Saving the data
                            if tfn == 1:
                                t = []
                                sys_time = []
                                for (t1, st1) in zip(t_load, sys_time_load):
                                    for (t0, st0) in zip(t1, st1):
                                        t.append(t0)
                                        sys_time.append(st0)
                                t = np.array(t)
                                wb = Workbook()
                                ws = wb.active
                                ws['A1'] = "Time"
                                ws['A2'] = "sec"
                                ws['B1'] = "SystemTime"
                                ws['C1'] = "EyeTrack"
                                ws['C2'] = "(p_x/scr_w,p_y/scr_h)"
                                ws['D1'] = "Condition"
                                ws['D2'] = "{start,stop}"
                                ws['D3'] = "start"
                                for i in range(y_prd_fnl.shape[0]):
                                    ws[f'A{i+3}'] = f"{t[i]}"
                                    ws[f'B{i+3}'] = sys_time[i]
                                    ws[f'C{i+3}'] = f"({round(y_prd_fnl[i, 0] * 10000)/10000},{round(y_prd_fnl[i, 1] * 10000)/10000})"
                                ws[f'D{i+3}'] = "stop"
                                wb.save(target_dir + "eye_track.xlsx")
                                ey.save([t, y_prd_fnl], target_dir, ["t_vec", "y_prd"])

                                if delete_files:
                                    ey.remove(target_dir, [ey.FV])
                            else:
                                y_vec = []
                                for y1 in y_load:
                                    for y0 in y1:
                                        y_vec.append(y0)
                                y_vec = np.array(y_vec)

                                y_vec = y_vec[y_prd_fnl[:, 0] != -1]
                                y_prd_fnl = y_prd_fnl[y_prd_fnl[:, 0] != -1]

                                losses = np.sum(((y_prd_fnl-y_vec)*y_scaler)**2, 0) / y_vec.shape[0]

                                print(f"Lossess for two hrz and vrt models: {losses}")

                                info["hrz_retrain_test_loss"] = losses[0]
                                info["vrt_retrain_test_loss"] = losses[1]

                                y_prd_fnl[y_prd_fnl < out_threshold_min] = out_threshold_min
                                y_prd_fnl[y_prd_fnl > out_threshold_max] = out_threshold_max

                                ey.save([info], sbj_models_dir, [mdl_et_name])
                                ey.save([y_vec, y_prd_fnl], target_dir, ["y_mdf", "y_prd_mdf"])

                                if delete_files:
                                    ey.remove(target_dir, [ey.Y])
                            
                            if delete_files:
                                ey.remove(sbj_models_dir)
                                ey.remove(target_dir, [ey.ER, ey.X1, ey.X2, ey.T])
                    else:
                        print(f"Data does not exist in {sbj_models_dir}")
            else:
                print(f"Data does not exist in {target_dir}")


    @staticmethod
    def get_fixations(
        subjects,
        n_monitors_data=1,
        t_discard=0.1,
        x_merge=0.2/2,
        y_merge=0.25/2,
        vx_thr=2.5,
        vy_thr=2.5
        ):
        """
        Compute the fixations using eye movements. IV-T method is implemented for this. Visit README.md for more details.
        You can do this for all the subjets once.

        Parameters:
            subjects: subjects list
            n_monitors_data: The number of monitors while the data is collected.
            t_discard: fixations lower than this will be removed.
            x_merge: fixations closer than this value (horizontal direction) will be added together.
            y_merge: fixations closer than this value (vertical direction) will be added together.
            vx_thr: This is the threshold for detecting saccades in the x direction.
            vy_thr: This is the threshold for detecting saccades in the y direction.
        
        Returns:
            None
        """

        # Going through each subject's folder to compute their fixations
        for num in subjects:
            smp_dir = ey.create_dir([ey.subjects_dir, f"{num}", ey.SMP])

            if ey.file_existing(smp_dir, "eye_track.xlsx"):
                sheet = load_workbook(smp_dir + "eye_track.xlsx")["Sheet"]
                max_row = sheet.max_row
                et_xl = []
                for i in range(3, max_row+1):
                    et_cell_list = sheet[f"C{i}"].value[1:-1].split(',')
                    et_xl.append(
                        [float(sheet[f"A{i}"].value),
                         sheet[f"B{i}"].value,
                         float(et_cell_list[0]),
                         float(et_cell_list[1]),
                         sheet[f"D{i}"].value]
                        )
                n_smp_all = len(et_xl)

                """There is some tims that you don't want to calculate the fixations. you can simply put 'start' and 'stop'
                in the last column in the eye_track.xlsx file to determine the moments that you want be calculated. So, each
                series of values that are between 'start' and 'stop' is considered as a vector and in this way, these vectors
                go to matrices (each matrix contains several vectors). for example, t_mat_seq"""
                i = 0
                t_mat_seq = []
                t_sys_mat_seq = []
                et_mat_seq = []
                while i < n_smp_all:
                    if (et_xl[i][4] == "start") or (et_xl[i][4] == "Start"):
                        t1 = []
                        ts1 = []
                        et1 = []
                        j = 0
                        while True:
                            t1.append([et_xl[i+j][0]])
                            ts1.append([et_xl[i+j][1]])
                            et1.append([et_xl[i+j][2], et_xl[i+j][3]])
                            if et_xl[i+j][4] == "stop" or et_xl[i+j][4] == "Stop":
                                break
                            j += 1
                        t_mat_seq.append(np.array(t1).reshape((len(t1),)))
                        t_sys_mat_seq.append(ts1)
                        et_mat_seq.append(np.array(et1))
                        i += j
                    i += 1

                # Creating the the vectors for time and eye track
                t = t_mat_seq[0]
                t_sys = t_sys_mat_seq[0]
                et = et_mat_seq[0]
                for (i, t1) in enumerate(t_mat_seq):
                    if i == 0:
                        continue
                    t = np.concatenate([t, t1])
                    t_sys += t_sys_mat_seq[i]
                    et = np.concatenate([et, et_mat_seq[i]])

                # Removing the samples that are during blinking or are looking outside of the screen
                t_mat = []
                t_sys_mat = []
                et_mat = []
                for (t1, ts1, et1) in zip(t_mat_seq, t_sys_mat_seq, et_mat_seq):
                    n_smp1 = t1.shape[0]
                    blinking_out = (et1[:, 0] == -1)
                    t_mat1 = []
                    ts_mat1 = []
                    et_mat1 = []
                    i = 0
                    while i < (n_smp1):
                        t0 = [t1[i]]
                        ts0 = [ts1[i]]
                        bo_vec = []
                        in_vec = []
                        now = blinking_out[i]
                        if now:
                            bo_vec.append(et1[i])
                        else:
                            in_vec.append(et1[i])
                        j = 1
                        if (i+j) < n_smp1:
                            while blinking_out[i+j] == now:
                                t0.append(t1[i+j])
                                ts0.append(ts1[i+j])
                                if now:
                                    bo_vec.append(et1[i+j])
                                else:
                                    in_vec.append(et1[i+j])
                                j += 1
                                if (i+j) >= n_smp1:
                                    break
                        t_mat1.append(np.array(t0))
                        ts_mat1.append(ts0)
                        if now:
                            et_mat1.append(np.array(bo_vec))
                        else:
                            et_mat1.append(np.array(in_vec))
                        i += j
                    t_mat.append(t_mat1)
                    t_sys_mat.append(ts_mat1)
                    et_mat.append(et_mat1)

                # Calculating the saccades
                saccades = []
                vet_mat = []
                for (t2, et2) in zip(t_mat, et_mat):
                    saccades1 = []
                    vet_mat1 = []
                    for (t1, et1) in zip(t2, et2):
                        if et1[0, 0] != -1:
                            if et1.shape[0] == 1:
                                vet1 = np.zeros((1,2))
                                s1 = [None]
                            else:
                                vet1 = et1.copy()
                                vet1[1:, 0] = (et1[1:, 0] - et1[:-1, 0]) / (t1[1:] - t1[:-1])
                                vet1[1:, 1] = (et1[1:, 1] - et1[:-1, 1]) / (t1[1:] - t1[:-1])
                                vet1[0] = vet1[1]

                                s1 = ((vet1[:, 0]>vx_thr)+(vet1[:, 0]<-vx_thr))+((vet1[:, 1]>vy_thr)+(vet1[:, 1]<-vy_thr))
                        else:
                            et_shape = et1.shape[0]
                            vet1 = np.zeros(et1.shape)
                            s1 = np.array([None] * et_shape)
                        vet_mat1.append(vet1)
                        saccades1.append(s1)
                    saccades.append(saccades1)
                    vet_mat.append(vet_mat1)

                # Creating a vector of eye movement velocity
                vet4 = []
                for vet3 in vet_mat:
                    vet2 = vet3[0].copy()
                    for (i, vet1) in enumerate(vet3):
                        if i == 0:
                            continue
                        vet2 = np.concatenate([vet2, vet1], 0)
                    vet4.append(np.array(vet2))
                vet = vet4[0]
                for (i, vet1) in enumerate(vet4):
                    if i == 0:
                        continue
                    vet = np.concatenate([vet, vet1])

                """Separating the time and eye movements based on the saccades. It means we are considering a vector for
                each series of values that we think they are one fixation."""
                sac_mat_new = []
                t_mat_new = []
                t_sys_mat_new = []
                et_mat_new = []
                for (t_mat1, ts_mat1, et_mat1, saccades1) in zip(t_mat, t_sys_mat, et_mat, saccades):
                    k = 0
                    sac_mat_new1 = []
                    t_mat_new1 = []
                    t_sys_mat_new1 = []
                    et_mat_new1 = []
                    for (t1, ts1, et1, sac1) in zip(t_mat1, ts_mat1, et_mat1, saccades1):
                        if et1[0, 0] != -1:
                            n_smp = t1.shape[0]
                            i = 0
                            while i < (n_smp):
                                s0 = [sac1[i]]
                                t0 = [t1[i]]
                                ts0 = [ts1[i]]
                                et0 = [et1[i]]
                                now = sac1[i]
                                j = 1
                                if (i+j) < n_smp:
                                    while sac1[i+j] == now:
                                        s0.append(sac1[i+j])
                                        t0.append(t1[i+j])
                                        ts0.append(ts1[i+j])
                                        et0.append(et1[i+j])
                                        j += 1
                                        if (i+j) >= n_smp:
                                            break
                                sac_mat_new1.append(np.array(s0))
                                t_mat_new1.append(np.array(t0))
                                t_sys_mat_new1.append(ts0)
                                et_mat_new1.append(np.array(et0))
                                i += j
                        else:
                            sac_mat_new1.append(sac1)
                            t_mat_new1.append(t1)
                            t_sys_mat_new1.append(ts1)
                            et_mat_new1.append(et1)
                    sac_mat_new.append(sac_mat_new1)
                    t_mat_new.append(t_mat_new1)
                    t_sys_mat_new.append(t_sys_mat_new1)
                    et_mat_new.append(et_mat_new1)

                """We are turing each vector of fixations to a list of some information, like the number of values that it contains,
                The start time, mean of the eye movements, and sys mean time."""
                fix = []
                k = 0
                for (sac_mat_new1, t_mat_new1, t_sys_mat_new1, et_mat_new1) in zip(sac_mat_new, t_mat_new, t_sys_mat_new, et_mat_new):
                    fix1 = []
                    for (s1, t1, ts1, et1) in zip(sac_mat_new1, t_mat_new1, t_sys_mat_new1, et_mat_new1):
                        sac_shp = s1.shape
                        if s1[0] == False:
                            if not s1[0]:
                                fix1.append([k,
                                             sac_shp[0],
                                             t1[0],
                                             round(t1[-1]-t1[0], 2),
                                             round(et1[:, 0].mean(), 4),
                                             round(et1[:, 1].mean(), 4),
                                             ts1[0]])
                        k += sac_shp[0]
                    fix.append(fix1)

                # Merging the fixations that are near together
                fix_mrg_one = []
                for fix1 in fix:
                    fix_mrg1 = []
                    n_fix = len(fix1)
                    i = 0
                    while i < n_fix:
                        f_new = fix1[i]
                        j = 1
                        while (i+j) < n_fix:
                            fj = fix1[i+j]
                            fj_d = ((fj[4]-f_new[4])/(x_merge/n_monitors_data))**2+((fj[5]-f_new[5])/(y_merge))**2
                            if fj_d < 1:
                                f_new = [f_new[0],
                                         f_new[1] + fj[1],
                                         f_new[2],
                                         round(f_new[3] + fj[3], 2),
                                         round((f_new[4]*f_new[1]+fj[4]*fj[1])/(f_new[1]+fj[1]), 4),
                                         round((f_new[5]*f_new[1]+fj[5]*fj[1])/(f_new[1]+fj[1]), 4),
                                         f_new[-1]]
                                if (i+j) == n_fix-1:
                                    fix_mrg1.append(f_new)
                                not_joined = False
                            else:
                                fix_mrg1.append(f_new)
                                not_joined = True
                                break
                            j += 1
                        i += j
                    if not_joined:
                        fix_mrg1.append(fix1[-1])
                        
                    fix_mrg_one.append(fix_mrg1)

                # Removing the fixations that are short
                fix_dcd = []
                for fix_mrg1 in fix_mrg_one:
                    fix_dcd1 = []
                    for f in fix_mrg1:
                        if f[3] >= t_discard:
                            fix_dcd1.append(f)
                    fix_dcd.append(fix_dcd1)

                # Merging the fixations that are near together
                fix_mrg_two = []
                for fix1 in fix_dcd:
                    fix_mrg1 = []
                    n_fix = len(fix1)
                    i = 0
                    while i < n_fix:
                        f_new = fix1[i]
                        j = 1
                        while (i+j) < n_fix:
                            fj = fix1[i+j]
                            fj_d = ((fj[4]-f_new[4])/(x_merge/n_monitors_data))**2+((fj[5]-f_new[5])/(y_merge))**2
                            if fj_d < 1:
                                f_new = [f_new[0],
                                         f_new[1] + fj[1],
                                         f_new[2],
                                         round(f_new[3] + fj[3], 2),
                                         round((f_new[4]*f_new[1]+fj[4]*fj[1])/(f_new[1]+fj[1]), 4),
                                         round((f_new[5]*f_new[1]+fj[5]*fj[1])/(f_new[1]+fj[1]), 4),
                                         f_new[-1]]
                                if (i+j) == n_fix-1:
                                    fix_mrg1.append(f_new)
                                not_joined = False
                            else:
                                fix_mrg1.append(f_new)
                                not_joined = True
                                break
                            j += 1
                #             if (i+j) >= n_fix:
                #                 break
                        i += j
                    if not_joined:
                        fix_mrg1.append(fix1[-1])
                        
                    fix_mrg_two.append(fix_mrg1)

                # Saving the fixations into the fixations.xlsx
                wb = Workbook()
                ws = wb.active
                ws['A1'] = "FixationTime"
                ws['A2'] = "sec"
                ws['B1'] = "FixationSystemTime"
                ws['C1'] = "FixationDuration"
                ws['C2'] = "sec"
                ws['D1'] = "FixationLocation"
                ws['D2'] = "(p_x/scr_w,p_y/scr_h)"
                i = 0
                for f_seq in fix_mrg_two:
                    for f in f_seq:
                        ws[f'A{i+3}'] = f"{f[2]}"
                        ws[f'B{i+3}'] = f[6][0]
                        ws[f'C{i+3}'] = f"{f[3]}"
                        ws[f'D{i+3}'] = f"({f[4]},{f[5]})"
                        i += 1
                
                wb.save(smp_dir + "fixations.xlsx")
            else:
                print(f"Data does not exist in {smp_dir}")

    @staticmethod
    def get_models_information(show_model=False):
        """Writing the NN models' information in the xlsx files.
        
        Parameters:
            show_model: Whether or not show the model
        
        Returns:
            None
        """
        
        wb = Workbook()
        ws = wb.active
        ws['A1'] = "subject"
        ws['B1'] = "model"
        ws['C1'] = "trained model"
        ws['D1'] = "weights"
        ws['E1'] = "input 1 shape"
        ws['F1'] = "input 2 shape"
        ws['G1'] = "x2 chosen features"
        ws['H1'] = "min-Max brightness ratio"
        ws['I1'] = "r_train"
        ws['J1'] = "epochs and patience"
        ws['K1'] = "model-hrz train loss"
        ws['L1'] = "model-hrz val loss"
        ws['M1'] = "model-vrt train loss"
        ws['N1'] = "model-vrt val loss"
        ws['O1'] = "r_retrain"
        ws['P1'] = "epochs and patience-retrain"
        ws['Q1'] = "trainable layers"
        ws['R1'] = "model-hrz-retrain train loss"
        ws['S1'] = "model-hrz-retrain val loss"
        ws['T1'] = "model-vrt-retrain train loss"
        ws['U1'] = "model-vrt-retrain val loss"
        ws['V1'] = "model-hrz-retrain test loss"
        ws['W1'] = "model-vrt-retrain test loss"


        subjects = os.listdir(ey.subjects_dir)
        i = 2
        for sbj in subjects:
            sbj = int(sbj)
            models_dir = ey.create_dir([ey.subjects_dir, f"{sbj}", ey.MDL])
            files_name = os.listdir(models_dir)
            if files_name:
                for fn in files_name:
                    if fn[-7:] == ".pickle":
                        mdl_num = int(fn[3:-7])
                        mdl_name = ey.MDL + f"{mdl_num}"
                        if show_model:
                            mdl = load_model(models_dir + mdl_name + "-hrz.h5")
                            print(mdl.summary())
                        info = ey.load(models_dir, [ey.MDL + f"{mdl_num}"])[0]

                        ws[f'A{i}'] = str(sbj)
                        ws[f'B{i}'] = str(mdl_num)
                        ws[f'C{i}'] = str(info['trained_mdl_num'])
                        ws[f'D{i}'] = str(info['n_weights'])
                        ws[f'E{i}'] = str(info['input1_shape'])
                        ws[f'F{i}'] = str(info['input2_shape'])
                        ws[f'G{i}'] = str(info['x2_chosen_features'])
                        ws[f'H{i}'] = str(info['min_max_brightness_ratio'])
                        ws[f'I{i}'] = str(info['r_train'])
                        ws[f'J{i}'] = str(info['n_epochs_patience'])
                        ws[f'K{i}'] = str(info['hrz_train_loss'])
                        ws[f'L{i}'] = str(info['hrz_val_loss'])
                        ws[f'M{i}'] = str(info['vrt_train_loss'])
                        ws[f'N{i}'] = str(info['vrt_val_loss'])
                        ws[f'O{i}'] = str(info['r_retrain'])
                        ws[f'P{i}'] = str(info['n_epochs_patience_retrain'])
                        ws[f'Q{i}'] = str(info['trainable_layers'])
                        ws[f'R{i}'] = str(info['hrz_retrain_train_loss'])
                        ws[f'S{i}'] = str(info['hrz_retrain_val_loss'])
                        ws[f'T{i}'] = str(info['vrt_retrain_train_loss'])
                        ws[f'U{i}'] = str(info['vrt_retrain_val_loss'])
                        ws[f'V{i}'] = str(info['hrz_retrain_test_loss'])
                        ws[f'W{i}'] = str(info['vrt_retrain_test_loss'])

                        i += 1

        wb.save(ey.files_dir + "info_et_retrains.xlsx")