# stimuli information
stimuli_infos = pd.read_pickle(results_p.joinpath("stimuli_infos.pickle"))

for stim in ["Left_Cross", "Right_Cross", "Probe", "Reference"]:
    stimuli_df = stimuli_infos.query('StimulusName == @stim')
    
    left_border = stimuli_df.query('Border == "Left_Border"').iloc[0]["BorderValue"]
    right_border = stimuli_df.query('Border == "Right_Border"').iloc[0]["BorderValue"]
    top_border = stimuli_df.query('Border == "Upper_Border"').iloc[0]["BorderValue"]
    lower_border = stimuli_df.query('Border == "Lower_Border"').iloc[0]["BorderValue"]
    
    print(stim, left_border, right_border)
    
    hori_pos = np.round(right_border - ((right_border - left_border) / 2))
    vert_pos = np.round(top_border - ((top_border - lower_border) / 2))
    
    hori_size = np.round(right_border - left_border, 2)
    vert_size = np.round(top_border - lower_border, 2)
    
    print(stim.replace("_", " "))
    print("Horizontal Pos: {}, Vertical Pos: {}".format(hori_pos, vert_pos))
    print("Horizontal Size: {}, Vertical Size: {}\n".format(hori_size, vert_size))
    
# stim infos
# fixaton object infos
    # -10 and 10 degree (horizontal axis)
    # 0 degree vertical pos
    # size from center 7.5 cm to both sides
    
# stimulus
    # 0 degree (horizontal axis)
    # 10 cm to both sides
    # 20 cm durchmesser

# stimuli information for pse / jnd calculation
for shift in range(-3,4):
    positions = get_trial_object_positions(shift, 100)["Stimulus"]["Reference"]
    hori_angle_pos = np.round(positions["Right_Border"] + positions["Left_Border"], 2)
    print("Shift in cm: {}, visual angle: {}".format(shift, hori_angle_pos))#, [positions["Left_Border"], positions["Right_Border"]])

# eye fixation accuracy
def angle_of_vectors(vec1, vec2, rel_idx):
    # dont use z
    # vec1, vec2 = vec1[0:2], vec2[0:2]
    
    scalar_product = np.dot(vec1, vec2)
    amount_vec1 = math.sqrt(np.sum([math.pow(x, 2) for x in vec1])) # betrag
    amount_vec2  = math.sqrt(np.sum([math.pow(x, 2) for x in vec2]))
    
    if (amount_vec1 * amount_vec2) != 0:
        angle = math.degrees(math.acos(scalar_product / (amount_vec1 * amount_vec2)))
    else:
        angle = np.nan
        
    if vec1[rel_idx] < vec2[rel_idx]: # angle below / left are negative
        angle = angle * (-1)
        
    return angle

straight_vec = [250, 0, 0]
angle_of_vectors(straight_vec, [250, 5, 0], 1) #- 10

# prep head eye move data - exp 3
move_files = bf.get_data(stats_p.joinpath("effmann","dfs").joinpath("movement_pattern"), "pickle", "", [])
move_data = pd.DataFrame()
# move_data = pd.read_pickle(results_p.joinpath("move_df.pickle")).query('SubjectID.isin(@inc_subs)')
# move_data = move_data.query('Trial > 10')

for f in move_files:
    new_df = pd.read_pickle(f)
    
    head_dfs = []
    movement_conds = []
    gain_conds = []
    
    for idx, row in new_df.iterrows():
        head_df = row["HeadDF"]
        new_col = {"SDTime": [np.nan] + list(head_df["Time"])[:-1]}
        head_df = head_df.assign(**new_col)
        head_df = head_df.query('Time != SDTime')
        head_dfs.append(head_df)
        
        run = row["Run"]
        movement = "Unrestricted"
        gain = "Baseline"
        
        if "NoMovement" in run:
            movement = "Restricted"
        if "GainHigh" in run:
            gain = "High"
        elif "Gain" in run and "GainHigh" not in run:
            gain = "Low"
            
        movement_conds.append(movement)
        gain_conds.append(gain)
        
    new_col = {"HeadDF": head_dfs, "Movement": movement_conds, "Gain": gain_conds}
    new_df = new_df.assign(**new_col)
    
    move_data = pd.concat([move_data, new_df])
    
move_data = move_data.query('SubjectID.isin(@inc_subs)')
move_data = move_data.query('Trial > 10')

print("move_data")

# stim pres pos - mean pos - exp 3
cols = ['EyePositionsStimPres1', 'EyePositionsStimPres2', 'HeadPositionsStimPres1', 'HeadPositionsStimPres2']
mean_col_names = ["{}MeanYPos".format(x) for x in cols]
new_cols = {}
for key in mean_col_names:
    new_cols[key] = []

for idx, row in move_data.iterrows():
    vals = []
    
    for col in cols:
        df = row[col]
        
        if "Eye" in col:
            vals.append(np.mean(df["EyeAngle_Y"]))
        else:
            try:
                vals.append(np.mean(df["Yaw"]))
            except:
                print(row["SubjectID"], row["Run"])
            
    for key, val in zip(mean_col_names, vals):
        new_cols[key].append(val)
        
move_data = move_data.assign(**new_cols)
print("Added following cols: {}".format(mean_col_names))

# stim pres pos - first pos - exp 3
cols = ['EyePositionsStimPres1', 'EyePositionsStimPres2', 'HeadPositionsStimPres1', 'HeadPositionsStimPres2']
first_col_names = ["{}FirstYPos".format(x) for x in cols]
new_cols = {}
for key in first_col_names:
    new_cols[key] = []

for idx, row in move_data.iterrows():
    vals = []
    
    for col in cols:
        df = row[col]
        
        if "Eye" in col:
            vals.append(list(df["EyeAngle_Y"])[0])
        else:
            try:
                vals.append(list(df["Yaw"])[0])
            except:
                vals.append(np.nan)
                print(row["SubjectID"], row["Run"])
            
    for key, val in zip(first_col_names, vals):
        new_cols[key].append(val)
        
move_data = move_data.assign(**new_cols)
print("Added following cols: {}".format(first_col_names))

# prep move data exp 1/2
move_files_2 = bf.get_data(stats_p.joinpath("effmann 2","dfs").joinpath("movement_pattern"), "pickle", "", [])
move_data_2 = pd.DataFrame()

for f in move_files_2: #[:1]:
    file_infos = f.split("\\")[-1].split(".")[0].replace("[","").replace("]","").replace(" ","").replace("'","").split(",")
    new_df = pd.read_pickle(f)
    new_cols = {
        "Move": [file_infos[2]] * new_df.shape[0],
        "Target": [file_infos[3]] * new_df.shape[0],
        "Gabor": [file_infos[4]] * new_df.shape[0]
    }
    new_df = new_df.assign(**new_cols)
    
    head_dfs = []
    for idx, row in new_df.iterrows():
        head_df = row["HeadDF"]
        new_col = {"SDTime": [np.nan] + list(head_df["Time"])[:-1]}
        head_df = head_df.assign(**new_col)
        head_df = head_df.query('Time != SDTime')
        head_dfs.append(head_df)
        
    new_col = {"HeadDF": head_dfs}
    new_df = new_df.assign(**new_col)
    
    move_data_2 = pd.concat([move_data_2, new_df])
    
move_data_2 = move_data_2.query('SubjectID.isin(@inc_subs_2)')
move_data_2 = move_data_2.query('Trial > 10')
print("move_data_2")

# stim pres pos - mean pos - exp 1/2
cols = ['EyePositionsStimPres1', 'EyePositionsStimPres2', 'HeadPositionsStimPres1', 'HeadPositionsStimPres2']
mean_col_names = ["{}MeanYPos".format(x) for x in cols]
new_cols = {}
for key in mean_col_names:
    new_cols[key] = []

for idx, row in move_data_2.iterrows():
    vals = []
    
    for col in cols:
        df = row[col]
        
        if "Eye" in col:
            vals.append(np.mean(df["EyeAngle_Y"]))
        else:
            vals.append(np.mean(df["Yaw"]))
            
    for key, val in zip(mean_col_names, vals):
        new_cols[key].append(val)
        
move_data_2 = move_data_2.assign(**new_cols)
print("Added following cols: {}".format(mean_col_names))

# stim pres pos - first pos - exp 1/2
cols = ['EyePositionsStimPres1', 'EyePositionsStimPres2', 'HeadPositionsStimPres1', 'HeadPositionsStimPres2']
first_col_names = ["{}FirstYPos".format(x) for x in cols]
new_cols = {}
for key in first_col_names:
    new_cols[key] = []

for idx, row in move_data_2.iterrows():
    vals = []
    
    for col in cols:
        df = row[col]
        
        if "Eye" in col:
            try:
                vals.append(list(df["EyeAngle_Y"])[0])
            except:
                print(row["SubjectID"], row["Run"])
                vals.append(np.nan)
        else:
            try:
                vals.append(list(df["Yaw"])[0])
            except:
                vals.append(np.nan)
                print(row["SubjectID"], row["Run"])
            
    for key, val in zip(first_col_names, vals):
        new_cols[key].append(val)
        
move_data_2 = move_data_2.assign(**new_cols)
print("Added following cols: {}".format(first_col_names))

# add mean head pos
new_col = {"MeanHeadPos": []}

for idx, row in move_data_2.iterrows():
    new_col["MeanHeadPos"].append(np.mean(row["HeadDF"]["Yaw"]))
    
move_data_2 = move_data_2.assign(**new_col)

print("Added MeanHeadPos")

# demographics
def print_demo_info(data):
    print("Num: {}, Age: Mean: {}, SD: {}, SE: {}".format(
        len(data["Alter"]),
        np.round(np.mean(data["Alter"]), 2),
        np.round(np.std(data["Alter"]), 2),
        np.round(np.std(data["Alter"]) / np.sqrt(data.shape[0]), 2)
    )
)
print("Study 1 + 2")
demo_data_2 = pd.read_csv(results_p.joinpath("demographics_2.csv"))
balanced_pse_df_2 = pd.read_pickle(results_p.joinpath("balanced_pse_df_2.pickle"))

# inc_subs_2 = np.sort(np.unique(balanced_pse_df_2["SubjectID"]))
# inc_subs_2 = [x for x in inc_subs_2 if x != "DC21"]
inc_subs_2 = [
    'AD21', 'AO23', 'AP28', 'AS27', 'BW21', 'CF03', 'EW22', 'FA24', 'FH26', 'FS28', 
    'IB16', 'LC10', 'LK23', 'MF26', 'SH08', 'SJ24', 'SK29', 'SM03', 'ST07', 
    'SW217', 'TK15', 'TT12', 'VM20', 'YS24'
] # 'MM09' excluded based on 3000 JND in 1 cond

balanced_pse_df_2 = balanced_pse_df_2.query('SubjectID.isin(@inc_subs_2)')
demo_data_cut_2 = demo_data_2.query('SubjectID.isin(@inc_subs_2)')

print("Whole Sample")
print_demo_info(demo_data_2)

print("\nCut Sample (based on balanced pse df)")
print_demo_info(demo_data_cut_2)
print(np.unique(demo_data_cut_2["Geschlecht"], return_counts=True))

print("\nExcluded subs for exp 2: {}".format([x for x in list(np.unique(demo_data_2["SubjectID"])) if x not in inc_subs_2]))

balanced_pse_df_2 = None

#######################################

print("\n----------------------------")
print("Study 3")
demo_data = pd.read_csv(results_p.joinpath("demographics.csv"))
balanced_pse_df = pd.read_pickle(results_p.joinpath("balanced_pse_df.pickle"))

inc_subs = np.sort(np.unique(balanced_pse_df["SubjectID"]))
demo_data_cut = demo_data.query('SubjectID.isin(@inc_subs)')

print("Whole Sample")
print_demo_info(demo_data)

print("\nCut Sample (based on balanced pse df)")
print_demo_info(demo_data_cut)
print(np.unique(demo_data_cut["Geschlecht"], return_counts=True))

# check real exclusions - exp 1/2
move_data_2_cut = move_data_2
cols = ['EyePositionsStimPres1MeanYPos', 'EyePositionsStimPres2MeanYPos']#, 'HeadPositionsStimPres1MeanYPos', 'HeadPositionsStimPres2MeanYPos']
# cols = [x.replace("Mean", "First") for x in cols]

# old exclusion based on fixation
# for col in cols:
#     if "Pres1" in col:
#         move_data_2_cut = move_data_2_cut.query("`{0}` >= -13 & `{0}` <= -7".format(col))
#     else:
#         move_data_2_cut = move_data_2_cut.query("`{0}` >= 7 & `{0}` <= 13".format(col))

move_data_2_cut = move_data_2_cut.query('HeadMoveAmplitudeY >= 10 | Run == "Eye"')
    
print("Exp 1 & 2: included {} of {} trials ({:.2f} %) based on head amplitude".format(move_data_2_cut.shape[0], move_data_2.shape[0], move_data_2_cut.shape[0] / move_data_2.shape[0] * 100))

num_3 = move_data_2_cut.shape[0]
num_4 = move_data_2.shape[0]

move_data_2 = move_data_2_cut

# check real exclusions - exp 3
move_data_cut = move_data
cols = ['EyePositionsStimPres1MeanYPos', 'EyePositionsStimPres2MeanYPos']#, 'HeadPositionsStimPres1MeanYPos', 'HeadPositionsStimPres2MeanYPos']
cols = [x.replace("Mean", "First") for x in cols]

# old exclusion based on fixation
# for col in cols:
#     if "Pres1" in col:
#         move_data_cut = move_data_cut.query("`{0}` >= -13 & `{0}` <= -7".format(col))
#     else:
#         move_data_cut = move_data_cut.query("`{0}` >= 7 & `{0}` <= 13".format(col))
    
# new exclusion based on head movement
move_data_cut = move_data_cut.query('HeadMoveAmplitudeY >= 10')
    
print("Exp 3: included {} of {} trials ({:.2f} %) based on head amplitude".format(move_data_cut.shape[0], move_data.shape[0], move_data_cut.shape[0] / move_data.shape[0] * 100))

num_1 = move_data_cut.shape[0]
num_2 = move_data.shape[0]

move_data = move_data_cut

# total exclusions based on head movement data (fixed vals)
num = num_2 - num_1 + num_4 - num_3
total = num_1 + num_4

print("Total trials based on head movement excluded: {:.2f} ({:.2f})".format(num, num / total * 100))

# get python app head hz recording
all_in_one = pd.concat([move_data, move_data_2])
for exp, data in [["Whole Exp", all_in_one], ["Exp 1/2", move_data_2], ["Exp 3", move_data]]:
    hzs = []

    for idx, row in data.iterrows():
        row_head_df = row["HeadDF"]
        num_samples = row_head_df.shape[0]
        dur = (row_head_df["Time"].iloc[-1] - row_head_df["Time"].iloc[0]) / 1_000
        hz = num_samples / dur
        hzs.append(hz)
        
    data = data.assign(HeadHZ = hzs)
    hz_vals = list(data["HeadHZ"])
    print("{}: Head recording hz: {:.2f} ({:.2f})".format(exp, np.mean(hz_vals), np.std(hz_vals) / np.sqrt(len(hz_vals))))

# head inference stats desc - exp 2
move_data_means = move_data_2.query('Run == "HeadEye"').groupby(["SubjectID", "Move", "Target", "Gabor"]).mean().reset_index()
head_desc_2 = get_anova_desc_2(move_data_means, ["Move", "Target", "Gabor"], ["HeadMovePeakVelocityY", "HeadMoveAmplitudeY", "HeadMoveDurationY"])
# head_desc_2
print("head_desc_2")

# head main sequence - exp 2
plot_data = move_data_2.query('Run == "HeadEye"')

fig = plt.figure(figsize=[10, 8], tight_layout=True)
gs = gridspec.GridSpec(3, 2)

ax1 = fig.add_subplot(gs[0, :])
ax2 = fig.add_subplot(gs[1, 0])
ax3 = fig.add_subplot(gs[1, 1])

axs = [ax1, ax2, ax3]
letters = ["a)", "b)", "c)"]

for idx, plot in enumerate(["Seq", "ExampleMove", "ExampleNoMove"]):
    ax = axs[idx]
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    
    if idx == 0:
        ax.text(-0.085, 1.1, letters[idx], horizontalalignment='left', verticalalignment='center', transform=ax.transAxes, fontsize=14, fontweight= "bold")
    else:
        ax.text(-0.2, 1.1, letters[idx], horizontalalignment='left', verticalalignment='center', transform=ax.transAxes, fontsize=14, fontweight= "bold")
    
    if plot == "Seq":
        end_positions = plot_data["HeadMoveAmplitudeY"] #main_sequence_plot_data["Scatter"]["EndPositions"]
        velocities = plot_data["HeadMovePeakVelocityY"] #main_sequence_plot_data["Scatter"]["Velocities"]
        plot_x = np.linspace(np.min(end_positions), np.max(end_positions), 1000)
        
        end_positions = [x for x in end_positions if not np.isnan(x)]
        velocities = [x for x in velocities if not np.isnan(x)]
        
        slope, intercept = curve_fit(lin_func, end_positions, velocities)[0]
        
        print("Main Sequence")
        print("Formula: y = {} + {}x".format(np.round(intercept, 2), np.round(slope, 2)))
        
        ax.scatter(end_positions, velocities, marker="o", color="r", s=2)#, alpha=0.5)
        ax.plot(plot_x, lin_func(plot_x, slope, intercept), color="k", linewidth=4)#, path_effects=[pe.Stroke(linewidth=6, foreground='k'), pe.Normal()])
        
        ax.set_ylabel("Head peak velocity [°/s]")
        ax.set_xlabel("Head movement amplitude [°]")
        ax.set_xticks([10,15,20,25,30,35,40])
        ax.set_xlim([10, 40])
        ax.set_ylim([0, 150])
        
        # slope inference
        slopes = []
        
        for sub in np.unique(plot_data["SubjectID"]):
            sub_df = plot_data.query('SubjectID == @sub')
            end_positions = sub_df["HeadMoveAmplitudeY"]
            velocities = sub_df["HeadMovePeakVelocityY"]
            
            end_positions = [x for x in end_positions if not np.isnan(x)]
            velocities = [x for x in velocities if not np.isnan(x)]
            
            slope, intercept = curve_fit(lin_func, end_positions, velocities)[0]
            slopes.append(slope)
            
        t,p = ttest_1samp(slopes, popmean=0, alternative="greater")
        print("Single subject slopes vs. 0 (one-sided): t({}) = {}, p = {}".format(len(slopes) - 1, np.round(t,2), np.round(p,3)))
    elif plot == "ExampleMove":
        # LC10_HeadEye_Movement_TemporaryTargets_Gabor_60
        # LC10_HeadEye_Movement_TemporaryTargets_Gabor_53
        # LC10_HeadEye_Movement_TemporaryTargets_Gabor_52
        # LC10_HeadEye_Movement_TemporaryTargets_Gabor_50
        # LC10_HeadEye_Movement_TemporaryTargets_Gabor_18
        
        sub, run, move, target, gabor, trial = ["LC10", "HeadEye", "Movement", "TemporaryTargets", "Gabor", 18] # ALKA_Movement_23
        example_df = plot_data.query('SubjectID == @sub & Run == @run & Move == @move & Target == @target & Gabor == @gabor & Trial == @trial')

        trial_eye_df = example_df["EyeDF"].iloc[0]
        trial_head_df = example_df["HeadDF"].iloc[0]
        
        new_col = {"SDYaw": [np.nan] + list(trial_head_df["Yaw"])[:-1]}
        trial_head_df = trial_head_df.assign(**new_col)
        trial_head_df = trial_head_df.query('Yaw != SDYaw')
        
        new_col = {"SDEyeAngle_Y": [np.nan] + list(trial_eye_df["EyeAngle_Y"])[:-1]}
        trial_eye_df = trial_eye_df.assign(**new_col)
        trial_eye_df = trial_eye_df.query('SDEyeAngle_Y != EyeAngle_Y')
        
        # print_df(trial_eye_df.head(10))

        d_timing_files = np.sort(bf.get_data(stats_p.joinpath("effmann 2", "data","preprocessed"),"pickle","timings", []))
        timing_f = [x for x in d_timing_files if sub in x and "{}_{}_{}_{}_{}".format(sub, run, move, target, gabor) in x][0]
        timing_df = pd.read_pickle(timing_f)
        trial_timing_df = timing_df.query('Trial == @trial')

        trial, pre, start, end, f_onset, f_offset, s_onset, s_offset = trial_timing_df.iloc[0] 
        f_onset, f_offset, s_onset, s_offset = [(x - start) / 1_000_000 for x in [f_onset, f_offset, s_onset, s_offset]]

        example_trial_dict = {"EyeDF": trial_eye_df, "HeadDF": trial_head_df, "FirstStimulus": [f_onset, f_offset], "SecondStimulus": [s_onset, s_offset]}
        
        ax.set_xlabel("Time [ms]")
        ax.set_ylabel("Position [°]")
        ylims = [-15, 15]
        ax.set_ylim(ylims)
        ax.set_yticks([-15,-7.5,0,7.5,15])
        
        first_stim_info = example_trial_dict["FirstStimulus"]
        second_stim_info = example_trial_dict["SecondStimulus"]
        line_width = 1
        ax.hlines(-10, xmin=first_stim_info[0], xmax=first_stim_info[-1], color="k", ls="--", lw=line_width, zorder=10, label="Fixation cross")
        ax.hlines(10, xmin=second_stim_info[0], xmax=second_stim_info[-1], color="k", ls="--", lw=line_width, zorder=10)
        
        eye_time = example_trial_dict["EyeDF"]["Time"]
        eye_pos = example_trial_dict["EyeDF"]["EyeAngle_Y"]
        
        head_time = example_trial_dict["HeadDF"]["Time"]
        head_pos = example_trial_dict["HeadDF"]["Yaw"]
        
        ax.plot(eye_time, eye_pos, color="tab:blue", label="Eye")
        ax.plot(head_time, head_pos, color="r", label="Head")
        
        
        times = list(eye_time) + list(head_time)
        ax.set_xlim([0, 2500])
        ax.legend(loc="upper left", frameon=False, fontsize="11")
    elif plot == "ExampleNoMove":
        # AD21_HeadEye_NoMovement_PermanentTargets_Gabor_15
        # ML27_HeadEye_NoMovement_TemporaryTargets_NoGabor_59
        # ML27_HeadEye_NoMovement_TemporaryTargets_NoGabor_43
        # ML27_HeadEye_NoMovement_TemporaryTargets_NoGabor_40
        # LC10_HeadEye_NoMovement_TemporaryTargets_NoGabor_63
        # LC10_HeadEye_NoMovement_TemporaryTargets_NoGabor_62
        sub, run, move, target, gabor, trial = ["LC10", "HeadEye", "NoMovement", "TemporaryTargets", "NoGabor", 63] # ALKA_Movement_23
        example_df = plot_data.query('SubjectID == @sub & Run == @run & Move == @move & Target == @target & Gabor == @gabor & Trial == @trial')
        
        # sub, move, trial = ["ALKA", "NoMovement", 65] # ALKA_Movement_23
        # example_df = move_data_2.query('SubjectID == @sub & Run == @move & Trial == @trial')

        trial_eye_df = example_df["EyeDF"].iloc[0]
        trial_head_df = example_df["HeadDF"].iloc[0]
        
        new_col = {"SDYaw": [np.nan] + list(trial_head_df["Yaw"])[:-1]}
        trial_head_df = trial_head_df.assign(**new_col)
        trial_head_df = trial_head_df.query('Yaw != SDYaw')
        
        new_col = {"SDEyeAngle_Y": [np.nan] + list(trial_eye_df["EyeAngle_Y"])[:-1]}
        trial_eye_df = trial_eye_df.assign(**new_col)
        trial_eye_df = trial_eye_df.query('SDEyeAngle_Y != EyeAngle_Y')

        d_timing_files = np.sort(bf.get_data(stats_p.joinpath("effmann 2", "data","preprocessed"),"pickle","timings", []))
        timing_f = [x for x in d_timing_files if sub in x and "{}_{}_{}_{}_{}".format(sub, run, move, target, gabor) in x][0]
        timing_df = pd.read_pickle(timing_f)
        trial_timing_df = timing_df.query('Trial == @trial')

        trial, pre, start, end, f_onset, f_offset, s_onset, s_offset = trial_timing_df.iloc[0] 
        f_onset, f_offset, s_onset, s_offset = [(x - start) / 1_000_000 for x in [f_onset, f_offset, s_onset, s_offset]]

        example_trial_dict = {"EyeDF": trial_eye_df, "HeadDF": trial_head_df, "FirstStimulus": [f_onset, f_offset], "SecondStimulus": [s_onset, s_offset]}
        
        ax.set_xlabel("Time [ms]")
        # ax.set_ylabel("Position [°]")
        ylims = [-15, 15]
        ax.set_ylim(ylims)
        ax.set_yticks([-15,-7.5,0,7.5,15])
        ax.set_yticklabels([])
        
        first_stim_info = example_trial_dict["FirstStimulus"]
        second_stim_info = example_trial_dict["SecondStimulus"]
        line_width = 1
        ax.hlines(-10, xmin=first_stim_info[0], xmax=first_stim_info[-1], color="k", ls="--", lw=line_width, zorder=10, label="Fixation cross")
        ax.hlines(10, xmin=second_stim_info[0], xmax=second_stim_info[-1], color="k", ls="--", lw=line_width, zorder=10)
        
        eye_time = example_trial_dict["EyeDF"]["Time"]
        eye_pos = example_trial_dict["EyeDF"]["EyeAngle_Y"]
        
        head_time = example_trial_dict["HeadDF"]["Time"]
        head_pos = example_trial_dict["HeadDF"]["Yaw"]
        
        ax.plot(eye_time, eye_pos, color="tab:blue", label="Eye")
        ax.plot(head_time, head_pos, color="r", label="Head")
        
        times = list(eye_time) + list(head_time)
        ax.set_xlim([0, 2500])
        # ax.legend(loc="upper left", frameon=False, fontsize="11")
        
plt.savefig(figure_p.joinpath("exp2_main_seq.png"), dpi=300, facecolor="white", bbox_inches="tight")
plt.savefig(figure_p.joinpath("exp2_main_seq.pdf"), dpi=300, facecolor="white", bbox_inches="tight")