#%%
import numpy as np
import pandas as pd


# Function to calculate the angle between two vectors
def angle_between_vectors(v1, v2):
    unit_v1 = v1 / np.linalg.norm(v1)
    unit_v2 = v2 / np.linalg.norm(v2)
    dot_product = np.dot(unit_v1, unit_v2)
    angle = np.arccos(np.clip(dot_product, -1.0, 1.0))
    return angle


# Function to process each group and add new column
def process_and_add_columns(group):
    if group['isError'].iloc[0]:  # Skip groups where isError is True
        group['HMD'] = np.nan  # Assign NaN for HMD vectors
        group['EYE'] = np.nan  # Assign NaN for Leye vectors
        return group

    # Extract HMD vectors
    hmd_vectors = group[['HMDForwardVX', 'HMDForwardVY', 'HMDForwardVZ']].to_numpy()
    start_hmd_vector = hmd_vectors[0]
    end_hmd_vector = hmd_vectors[-1]

    # Calculate angle A for HMD vectors
    hmd_angle_A = angle_between_vectors(start_hmd_vector, end_hmd_vector)

    # Calculate angle B for each HMD vector and then B/A
    group['HMD'] = [angle_between_vectors(start_hmd_vector, vec) / hmd_angle_A if hmd_angle_A != 0 else 0 for vec in hmd_vectors]

    # Extract Leye vectors
    leye_vectors = group[['LeyeForwardVX', 'LeyeForwardVY', 'LeyeForwardVZ']].to_numpy()
    start_leye_vector = leye_vectors[0]
    end_leye_vector = leye_vectors[-1]

    # Calculate angle A for Leye vectors
    leye_angle_A = angle_between_vectors(start_leye_vector, end_leye_vector)

    # Calculate angle B for each Leye vector and then B/A
    group['EYE'] = [angle_between_vectors(start_leye_vector, vec) / leye_angle_A if leye_angle_A != 0 else 0 for vec in leye_vectors]

    return group


# Load your data

data = pd.read_csv('../Data/1_Trajectory.csv')
# Group by 'BlockID' and 'TrialID', then apply the function
processed_data = data.groupby(['BlockID', 'TrialID']).apply(process_and_add_columns).reset_index(drop=True)
# Now you can use processed_data as needed
print(processed_data.head())


#%%
import matplotlib.pyplot as plt
from scipy.ndimage import gaussian_filter1d
from scipy.interpolate import interp1d

filtered_data = processed_data[~processed_data['isError'] & processed_data['HMD'].notna() & processed_data['EYE'].notna() & processed_data['DistanceTraveledPercentage'].notna()]
filtered_data = filtered_data[filtered_data['ProgressofTask'] % 1 == 0]
# Group by ProgressofTask and calculate the mean for HMD and EYE
average_data = filtered_data.groupby('ProgressofTask')[['DistanceTraveledPercentage','HMD', 'EYE']].mean()

task_points = np.linspace(average_data.index.min(), average_data.index.max(), 500)  # 创建100个均匀分布的点
interp_HMD = interp1d(average_data.index, average_data['HMD'], kind='cubic', fill_value='extrapolate')
interp_EYE = interp1d(average_data.index, average_data['EYE'], kind='cubic', fill_value='extrapolate')
interp_HAND = interp1d(average_data.index, average_data['DistanceTraveledPercentage']/100, kind='cubic', fill_value='extrapolate')

smoothed_HMD = gaussian_filter1d(interp_HMD(task_points), sigma=5)
smoothed_EYE = gaussian_filter1d(interp_EYE(task_points), sigma=7)
smoothed_HAND = gaussian_filter1d(interp_HAND(task_points), sigma=5)

# Plotting the curves
plt.figure(figsize=(16, 9))
plt.plot(task_points, smoothed_HAND, label='Hand')
plt.plot(task_points, smoothed_HMD, label='HMD')
plt.plot(task_points, smoothed_EYE, label='EYE')

plt.xlabel('Progress Of Task (%)')
plt.ylabel('Current Angular Movement / Final Angular Movement')
plt.legend()
plt.grid(True)
plt.show()