Add files using upload-large-folder tool

Dataprocessing_code.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a41c9d52a2546e4ec565d011db4e5973af9f2289025b255150093e70c09c770
+size 14123

README.md

@@ -0,0 +1,147 @@
+---
+pretty_name: VR Ray Pointer Landing Pose Dataset
+task_categories:
+  - time-series-forecasting
+  - other
+language:
+  - en
+tags:
+  - virtual-reality
+  - vr
+  - raycasting
+  - multimodal
+  - eye-tracking
+  - motion-capture
+  - time-series
+  - human-computer-interaction
+size_categories:
+  - 1M<n<10M
+configs:
+  - config_name: raw_archives
+    data_files:
+      - split: study1
+        path: Study1_Raw.zip
+      - split: study2
+        path: Study2_Raw.zip
+license: other
+---
+
+# VR Ray Pointer Landing Pose Dataset
+
+This dataset accompanies the paper **"Predicting Ray Pointer Landing Poses in VR Using Multimodal LSTM-Based Neural Networks."** It contains the raw trajectory archives used for the paper's two user studies, plus the original data processing code used to prepare model inputs.
+
+The data captures bare-hand raycasting selection behavior in VR with multimodal time-series signals from hand, head-mounted display (HMD), and gaze channels. The paper reports that the full dataset covers **72,096 trials** across two empirical studies:
+
+- Study 1: 55,296 trials
+- Study 2: 16,800 trials
+
+## Paper Summary
+
+The paper studies target-agnostic prediction of the final ray landing pose during VR pointing and selection. The proposed model is an LSTM-based predictor trained on time-series features derived from three modalities:
+
+- hand movement
+- HMD movement
+- eye gaze movement
+
+According to the paper:
+
+- Study 1 recruited **16 participants**
+- Study 2 recruited **8 new participants**
+- Data was recorded at **90 Hz**
+- Hardware used a **Meta Quest Pro**
+- The model achieved an average prediction error of **4.6 degrees at 50% movement progress**
+
+## Included Files
+
+- `Study1_Raw.zip`
+  Raw CSV trajectories for Study 1.
+- `Study2_Raw.zip`
+  Raw CSV trajectories for Study 2.
+- `Dataprocessing_code.zip`
+  Original preprocessing scripts provided by the authors.
+- `data_processing_code/`
+  Extracted copy of the preprocessing scripts for easier browsing on Hugging Face.
+
+## Data Format
+
+Each raw archive contains per-participant CSV files with frame-level trajectories. Typical columns include:
+
+- participant / block / trial identifiers
+- error flag
+- target geometry variables such as depth, theta, phi, width, and position
+- task progress and distance traveled percentage
+- timestamp
+- HMD position and forward vector
+- hand position and forward vector
+- left-eye position and forward vector
+- right-eye position and forward vector
+- target location and target scale
+
+The data is sampled over time during reciprocal pointing selections.
+
+## Study Design From The Paper
+
+### Study 1
+
+The paper describes Study 1 as a within-subjects design over:
+
+- target depth combinations: `De` and `Ds` in `{3m, 6m, 9m}`
+- theta values: `10, 15, 20, 25, 50, 75` degrees
+- phi values: `0` to `315` degrees in `45` degree steps
+- target widths: `4.5` and `9` degrees
+
+The paper reports:
+
+- `55,296` total trials
+- `16` participants
+- reciprocal 3D pointing with no distractors
+
+### Study 2
+
+The paper describes Study 2 as a validation study with:
+
+- `8` new participants
+- theta varying continuously across all integer values from `15` to `84` degrees
+- `350` trial combinations
+- `50` blocks
+- `6` reciprocal selections per trial combination
+- `2,100` trials per participant
+
+The paper reports `16,800` total trials for Study 2.
+
+## Important Notes About The Raw Archives
+
+This repository preserves the raw files exactly as provided by the dataset owner. A few practical details matter when using the archives:
+
+- `Study1_Raw.zip` currently contains **19 CSV files**
+- `Study2_Raw.zip` currently contains **8 CSV files**
+- the observed raw trial counts are **64,308** trials in `Study1_Raw.zip` and **16,800** trials in `Study2_Raw.zip`
+- some Study 1 CSV files do **not** include a `ParticipantID` column in the header
+- some Study 1 and Study 2 files share participant-like file IDs such as `72`
+- raw archive contents therefore do not map one-to-one to the participant counts reported in the paper without additional curation context
+- specifically, `Study1_Raw.zip` includes a `72_Trajectory.csv` file with **2,100** trials, which matches the Study 2 per-participant protocol rather than the Study 1 per-participant total of **3,456** trials reported in the paper
+
+For reproducibility, this repository keeps the original archives unchanged. When reconstructing participant identity for Study 1, you may need to use the filename as the participant identifier when `ParticipantID` is absent from the CSV header.
+
+## Recommended Usage
+
+- Use `Study1_Raw.zip` and `Study2_Raw.zip` as the authoritative raw data sources.
+- Use the scripts in `data_processing_code/` to reproduce feature engineering and preprocessing.
+- If you build a Hugging Face `datasets` loader on top of this repository, treat the raw zip files as the source of truth rather than assuming fully standardized CSV schemas.
+
+## Citation
+
+If you use this dataset, please cite the paper:
+
+```bibtex
+@inproceedings{xu2025predictingray,
+  title={Predicting Ray Pointer Landing Poses in VR Using Multimodal LSTM-Based Neural Networks},
+  author={Xu, Wenxuan and Wei, Yushi and Hu, Xuning and Stuerzlinger, Wolfgang and Wang, Yuntao and Liang, Hai-Ning},
+  booktitle={IEEE Conference on Virtual Reality and 3D User Interfaces},
+  year={2025}
+}
+```
+
+## Acknowledgements
+
+This dataset was collected for the paper above and uploaded to Hugging Face by the dataset owner.

Study1_Raw.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c4dad3bcab68216faa886cd7d2eb32c2f39dfcf189aae38191aa7ab8558beac
+size 606994834

Study2_Raw.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:549a942f9c5c72c92a54266269e0b796d5f9c3303c7403f47077340c4c5f0547
+size 186961994

data_processing_code/Augumentation.py

@@ -0,0 +1,95 @@
+import pandas as pd
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+max_timesteps=299
+feature_num=16
+label_nums=9
+
+def generate_partial_sequences(row, max_timesteps=max_timesteps, features_per_timestep=feature_num, fill_value=-10):
+    # 确定实际长度
+    actual_length_indices = np.where(row[:-label_nums] != fill_value)[0]  # 排除最后的标签列
+    if len(actual_length_indices) > 0:
+        actual_length = (actual_length_indices[-1] // features_per_timestep) + 1
+    else:
+        actual_length = 0
+    partial_sequences = []
+    # step_size = max(1, int(actual_length * 0.1))  # 步长为实际长度的10%，至少为1
+    step_size =5
+
+    for end_length in range(step_size, actual_length + step_size, step_size):
+        # 计算结束点，不超过实际长度
+        end_length = min(end_length, actual_length)
+        partial_sequence_list = row[:end_length * features_per_timestep].tolist()
+
+        selected_features_list = [partial_sequence_list[i:i + 10] for i in
+                                  range(0, len(partial_sequence_list), features_per_timestep)]
+        selected_features_list = [item for sublist in selected_features_list for item in sublist]
+
+        ProgressOfTask= end_length/actual_length
+
+        hand_rotation_axis = partial_sequence_list[-6:-3]
+        hand_direction = partial_sequence_list[-3:]
+
+        padding_length = (max_timesteps - end_length) * (features_per_timestep-6)  # 计算填充长度
+        selected_features_list.extend([fill_value] * padding_length)  # 添加填充
+
+        selected_features_list.extend(row[-9:])  # 添加标签
+        selected_features_list.extend(hand_rotation_axis)  # 添加HandRotationAxis和HandDirection
+        selected_features_list.extend(hand_direction)
+        selected_features_list.append(ProgressOfTask)  # 添加ProgressOfTask
+
+        partial_sequences.append(selected_features_list)
+    return partial_sequences
+
+
+def process_row(index, df):
+    """Wrapper function to handle the DataFrame row."""
+    row=df.iloc[index]
+    return generate_partial_sequences(row)
+
+
+def main(df, num_threads=20):
+    """Process the DataFrame using multiple threads."""
+    with ThreadPoolExecutor(max_workers=num_threads) as executor:
+        # 创建一个future列表，对每一行数据并行应用 process_row 函数
+        futures = [executor.submit(process_row, index, df) for index in range(len(df))]
+        # 使用 as_completed 来获取已完成的future结果
+        results = []
+        for future in futures:
+            results.extend(future.result())
+    # 将结果转换为 DataFrame
+
+    columns = df.columns
+    # 选择不以'HandRotationAxis'和'HandDirection'开头的列
+    columns_to_keep = [column for column in columns if
+                       not column.startswith('HandRotationAxis') and not column.startswith('HandDirection')]
+
+    # 现在添加具体的旋转轴和方向列到列表的末尾
+    # 如果有特定的顺序要求，这里按照特定顺序添加
+    columns_to_keep.extend([
+        'HandRotationAxis_X', 'HandRotationAxis_Y', 'HandRotationAxis_Z',
+        'HandDirection_X', 'HandDirection_Y', 'HandDirection_Z',
+        'ProgressOfTask'
+    ])
+    #print(len(columns_to_keep))
+    partial_sequences_df = pd.DataFrame(results, columns=columns_to_keep)
+    return partial_sequences_df
+
+if __name__ == '__main__':
+    #加载数据集
+    for i in range(79, 80):
+        # if i ==3 or i ==6 or i ==15 or i ==19 or i== 22:
+        #     continue
+        file_path = f'../Data/Study2Evaluation/Supervised/{i}_train_data_preprocessed_evaluation.csv'
+        df = pd.read_csv(file_path)
+        partial_sequences_df = main(df)
+        save_path_csv = f'../Data/Study2Evaluation/Dataset/{i}_traindataset.csv'
+        partial_sequences_df.to_csv(save_path_csv, index=False)
+
+        file_path = f'../Data/Study2Evaluation/Supervised/{i}_test_data_preprocessed_evaluation.csv'
+        df = pd.read_csv(file_path)
+        partial_sequences_df = main(df)
+        save_path_csv = f'../Data/Study2Evaluation/Dataset/{i}_testdataset.csv'
+        partial_sequences_df.to_csv(save_path_csv, index=False)
+
+

data_processing_code/DA.py

@@ -0,0 +1,214 @@
+#%%
+import pandas as pd
+import pandas as pd
+
+data = pd.read_csv("D:\\NN\\Data\\Study1AllUsers\\Cleaned_TrialResultsFull.csv")
+
+# 分组并计算均值
+grouped_data = data.groupby(['ParticipantID']).agg({
+    'AngularDistanceHMD': 'mean',
+    'AngularDistanceHand': 'mean',
+    'AngularDistanceLeye': 'mean'
+}).reset_index()
+
+print(grouped_data)
+
+output_path = 'D:\\NN\\Data\\Study1AllUsers\\ModalityAnalyse.csv'  # 替换为你的输出文件路径
+grouped_data.to_csv(output_path)
+# # 创建一个唯一的条件列，将 Depth, Theta, Width, Position 的组合转为单一标识符
+# grouped_data['Condition'] = grouped_data['Depth'].astype(str) + '_' + grouped_data['Theta'].astype(str) + '_' + grouped_data['Width'].astype(str) + '_' + grouped_data['Position'].astype(str)
+# # 转换数据为宽格式
+# wide_data = grouped_data.pivot_table(index='ParticipantID',
+#                                      columns='Condition',
+#                                      values=['MovementTime', 'AngularDistanceHMD', 'AngularDistanceHand', 'AngularDistanceLeye'])
+#
+# # 为了更好地兼容性，重命名列
+# wide_data.columns = ['_'.join(col).strip() for col in wide_data.columns.values]
+#
+# # 输出查看转换后的数据
+# print(wide_data.head())
+#
+# # 保存为CSV文件，以便于导入SPSS
+# output_path = 'path_to_your_output_file.csv'  # 替换为你的输出文件路径
+# wide_data.to_csv(output_path)
+
+#%%
+import pandas as pd
+import numpy as np
+from statsmodels.stats.correlation_tools import cov_nearest
+from scipy.stats import chi2
+
+
+# Load your data
+data = pd.read_csv("D:\\NN\\Data\\Study1AllUsers\\Cleaned_TrialResultsFull.csv")
+# data['Depth'] = data['Depth'].astype(str)
+# data['Theta'] = data['Theta'].astype(str)
+# data['Width'] = data['Width'].astype(str)
+# data['Position'] = data['Position'].astype(str)
+# columns = ['ParticipantID', 'BlockID', 'TrialID', 'MovementTime', 'Depth', 'Theta', 'Width','Position']
+columns = ['ParticipantID', 'BlockID', 'TrialID', 'MovementTime','AngularDistanceHMD','AngularDistanceHand','AngularDistanceLeye', 'Depth', 'Theta', 'Width','Position']
+# Aggregating data for each user under each condition
+data= data[columns]
+
+grouped_data = data.groupby(['ParticipantID', 'Depth', 'Theta', 'Width','Position']).agg({
+    'AngularDistanceLeye': 'mean'
+}).reset_index()
+
+# 创建一个唯一的条件列，将 Depth, Theta, Width, Position 的组合转为单一标识符
+grouped_data['Condition'] = grouped_data['Depth'].astype(str) + '_' + grouped_data['Theta'].astype(str) + '_' + grouped_data['Width'].astype(str)+ '_' + grouped_data['Position'].astype(str)
+
+# 转换数据为宽格式
+wide_data = grouped_data.pivot_table(index='ParticipantID',
+                                     columns='Condition',
+                                     values=['AngularDistanceLeye'])
+# 为了更好地兼容性，重命名列
+wide_data.columns = ['_'.join(col).strip() for col in wide_data.columns.values]
+
+# 输出查看转换后的数据
+print(wide_data.head())
+output_path = 'D:\\NN\\Data\\Study1AllUsers\\EyeDistance.csv'  # 替换为你的输出文件路径
+wide_data.to_csv(output_path)
+
+
+# output_path = 'D:\\NN\\Data\\Study1AllUsers\\Cleaned_TrialResultsFull1.csv'  # 替换为你的输出文件路径
+# grouped_data.to_csv(output_path, index=False)
+# grouped_data = data.groupby(['ParticipantID', 'Depth', 'Theta', 'Width', 'Position']).agg({
+#     'MovementTime': 'mean',
+#     'AngularDistanceHMD': 'mean',
+#     'AngularDistanceHand': 'mean',
+#     'AngularDistanceLeye': 'mean'
+# }).reset_index()
+
+
+
+
+
+# #%%
+# import pandas as pd
+# import numpy as np
+# from sklearn.linear_model import LinearRegression
+# import matplotlib.pyplot as plt
+#
+# # Correcting the data based on the user's indication
+# data_corrected = {
+#     "Theta": [10, 10, 15, 15, 20, 20, 25, 25, 50, 50, 75, 75],
+#     "Width": [4.5, 9.0, 4.5, 9.0, 4.5, 9.0, 4.5, 9.0, 4.5, 9.0, 4.5, 9.0],
+#     "Mean": [704.222126, 508.689598, 797.962563, 560.906088, 904.062486, 646.458888,
+#              1183.485047, 796.196496, 1464.353523, 1034.035743, 1728.876132, 1266.901965]
+# }
+#
+#
+# model = LinearRegression()
+#
+# df_corrected = pd.DataFrame(data_corrected)
+#
+# # Compute the index of difficulty again
+# df_corrected['ID'] = np.log2(df_corrected['Theta'] / df_corrected['Width'] + 1)
+#
+# # Re-run linear regression
+# model.fit(df_corrected[['ID']], df_corrected['Mean'])
+#
+# # Predict values using the fitted model
+# df_corrected['Predicted'] = model.predict(df_corrected[['ID']])
+# a_corrected = model.intercept_
+# b_corrected = model.coef_[0]
+#
+# # Recalculate R-squared value
+# r_squared_corrected = model.score(df_corrected[['ID']], df_corrected['Mean'])
+#
+# # Plotting the corrected data
+# plt.figure(figsize=(16, 9))
+# plt.scatter(df_corrected['ID'], df_corrected['Mean'], color='blue', label='Observed Data')
+# plt.plot(df_corrected['ID'], df_corrected['Predicted'], color='darkblue', linestyle='dashed', label='Fitted Line')
+#
+# plt.xlabel('Index of Difficulty (bits)')
+# plt.ylabel('Movement Time (ms)')
+# plt.grid(True)
+# plt.legend()
+# plt.text(3.5, 1100, f'R² = {r_squared_corrected:.4f}', fontsize=12)
+#
+# plt.show(), (a_corrected, b_corrected, r_squared_corrected)
+
+import pandas as pd
+#%%
+import pandas as pd
+from statsmodels.stats.anova import AnovaRM
+import statsmodels.api as sm
+# 加载数据
+# 读取数据
+data = pd.read_csv("D:\\NN\\Data\\Study1AllUsers\\Cleaned_TrialResultsFull.csv")
+# 确保分类变量为字符串格式
+data['Depth'] = data['Depth'].astype(str)
+data['Theta'] = data['Theta'].astype(str)
+data['Width'] = data['Width'].astype(str)
+
+# 筛选掉特定参与者的数据
+filtered_data = data[~data['ParticipantID'].isin([3, 6, 15, 19, 18, 20, 22])]
+# 重新进行数据聚合
+filtered_aggregated_data = filtered_data.groupby(['ParticipantID', 'Depth', 'Theta', 'Width']).mean().reset_index()
+print(filtered_aggregated_data)
+
+# 执行重复测量ANOVA，并应用Greenhouse-Geisser校正
+rm_anova_results = AnovaRM(filtered_aggregated_data, 'MovementTime', 'ParticipantID',
+                           within=['Depth', 'Theta', 'Width'])
+
+# 打印ANOVA结果摘要
+print(rm_anova_results.summary())
+
+# 计算eta squared
+anova_table = rm_anova_results.anova_table
+anova_table['eta_squared'] = (anova_table['F Value'] * anova_table['Num DF']) / \
+                             (anova_table['F Value'] * anova_table['Num DF'] + anova_table['Den DF'])
+
+# 打印带有eta squared的结果表格
+print(anova_table[['F Value', 'Pr > F', 'eta_squared']])
+
+#%%
+from statsmodels.stats.multicomp import pairwise_tukeyhsd
+
+# Prepare the data for Tukey HSD tests
+tukey_data = filtered_aggregated_data[['Theta', 'Width', 'MovementTime']]
+
+# Perform Tukey HSD test for Theta
+tukey_result_theta = pairwise_tukeyhsd(endog=tukey_data['MovementTime'], groups=tukey_data['Theta'], alpha=0.05)
+# Perform Tukey HSD test for Width
+tukey_result_width = pairwise_tukeyhsd(endog=tukey_data['MovementTime'], groups=tukey_data['Width'], alpha=0.05)
+
+tukey_result_theta.summary(), tukey_result_width.summary()
+
+#%%
+print(tukey_result_theta.summary())
+print(tukey_result_width.summary())
+#%%
+for width_level in filtered_aggregated_data['Width'].unique():
+    subset = filtered_aggregated_data[filtered_aggregated_data['Width'] == width_level]
+    print(f'Tukey HSD for Width {width_level}:')
+    print(pairwise_tukeyhsd(subset['MovementTime'], subset['Theta'], alpha=0.05).summary())
+
+# 遍历每个Theta水平
+for theta_level in filtered_aggregated_data['Theta'].unique():
+    subset = filtered_aggregated_data[filtered_aggregated_data['Theta'] == theta_level]
+    print(f'Tukey HSD for Theta {theta_level}:')
+    print(pairwise_tukeyhsd(subset['MovementTime'], subset['Width'], alpha=0.05).summary())
+
+
+#%%
+import pandas as pd
+from statsmodels.stats.anova import AnovaRM
+# 加载数据
+data = pd.read_csv("D:\\NN\\Data\\Study1AllUsers\\TrialResultsFull.csv")
+# 选择需要分析的列，并确保分类变量为字符串格式
+data['Depth'] = data['Depth'].astype(str)
+data['Theta'] = data['Theta'].astype(str)
+data['Width'] = data['Width'].astype(str)
+# 筛选掉特定参与者的数据
+filtered_data = data[~data['ParticipantID'].isin([3, 6, 15, 19, 18, 20, 22])]
+filtered_aggregated_data = filtered_data.groupby(['ParticipantID', 'Depth', 'Theta', 'Width', 'Position']).mean().reset_index()
+print(filtered_aggregated_data)
+# 执行重复测量ANOVA
+rm_anova_results = AnovaRM(filtered_aggregated_data, 'AngularDistanceHand', 'ParticipantID', within=['Depth', 'Theta', 'Width', 'Position']).fit()
+print(rm_anova_results.summary())
+anova_table = rm_anova_results.anova_table
+anova_table['eta_squared'] = (anova_table['F Value'] * anova_table['Num DF']) / \
+                             (anova_table['F Value'] * anova_table['Num DF'] + anova_table['Den DF'])
+print(anova_table[['F Value', 'Pr > F', 'eta_squared']])

data_processing_code/DA2.py

@@ -0,0 +1,85 @@
+#%%
+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()

data_processing_code/WIdeFormat.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import numpy as np
+
+# 加载数据
+def load_data(file_path):
+    return pd.read_csv(file_path)
+# 数据预处理，包括特征选择、后填充和展平
+def preprocess_data(data, features, label):
+    # 根据ParticipantID, BlockID, 和 TrialID对数据进行分组
+    grouped = data.groupby(['ParticipantID', 'BlockID', 'TrialID'])
+    # 提取特征和标签，进行后填充处理
+    sequences = []
+    labels = []
+    for _, group in grouped:
+        sequence = group[features].values
+        sequence_label = group[label].values[0]  # 假设每个序列的标签是相同的
+        sequences.append(sequence)
+        labels.append(sequence_label)
+    # 获取最大序列长度
+    max_len = 299
+    # 后填充处理
+    sequences_padded = [np.pad(seq, ((0, max_len - len(seq)), (0, 0)), 'constant', constant_values=(-10, -10)) for seq
+                        in sequences]
+
+    # 展平每个序列
+    flattened_sequences = np.array([seq.flatten() for seq in sequences_padded])
+
+    return flattened_sequences, labels, max_len
+
+# 保存处理后的数据
+def save_transformed_data(flattened_sequences, labels_sequence, max_len, features,labels,output_file_path):
+    # 创建列名
+    column_names = [f"{feature}_t{time_step}" for time_step in range(1, max_len + 1) for feature in features]
+    # 创建DataFrame
+    flattened_df = pd.DataFrame(flattened_sequences, columns=column_names)
+    label_column_names=[f"{label}" for label in labels]
+    flattened_df[label_column_names]=labels_sequence
+    # 保存到Excel
+    flattened_df.to_csv(output_file_path, index=False)
+
+# 主函数
+if __name__ == "__main__":
+    # 定义文件路径和特征
+    for i in range(79, 80):
+        # if i ==3 or i ==6 or i ==15 or i ==19 or i== 22:
+        #     continue
+        file_path = f'../Data/Study2Evaluation/Preprocessed/cleaned/{i}_train_data_preprocessed_evaluation.csv'  # 更新为实际文件路径
+        output_file_path = f'../Data/Study2Evaluation/Supervised/{i}_train_data_preprocessed_evaluation.csv'
+
+        features = ["HMDA", "HMDAV", "HandA", "HandAV", "LeyeA", "LeyeAV", 'HMDL', "HMDLV", "HandL", "HandLV",
+                    'HandRotationAxis_X', 'HandRotationAxis_Y', 'HandRotationAxis_Z', 'HandDirection_X',
+                    'HandDirection_Y', 'HandDirection_Z']
+        labels = ['ParticipantID', 'BlockID', 'TrialID', 'TargetLocationX', 'TargetLocationY', 'TargetLocationZ',
+                  'TargetScale', 'LLabel', 'ALabel']
+        # 加载和处理数据
+        data = load_data(file_path)
+        flattened_sequences, labels_sequence, max_len = preprocess_data(data, features, labels)
+        # 保存转换后的数据
+        save_transformed_data(flattened_sequences, labels_sequence, max_len, features, labels, output_file_path)
+        print(f"Data transformed and saved to {output_file_path}")
+        file_path = f'../Data/Study2Evaluation/Preprocessed/cleaned/{i}_test_data_preprocessed_evaluation.csv'  # 更新为实际文件路径
+        output_file_path = f'../Data/Study2Evaluation/Supervised/{i}_test_data_preprocessed_evaluation.csv'
+        data = load_data(file_path)
+        flattened_sequences, labels_sequence, max_len = preprocess_data(data, features, labels)
+        save_transformed_data(flattened_sequences, labels_sequence, max_len, features, labels, output_file_path)
+        print(f"Data transformed and saved to {output_file_path}")
+
+

data_processing_code/concact数据.py

@@ -0,0 +1,35 @@
+import pandas as pd
+
+# Define user IDs and ignored users
+
+user_ids = {75,79}
+
+# Define the dataset path templates
+train_dataset_path_template = '../Data/Study2Evaluation/preprocessed/cleaned/{user_id}_train_data_preprocessed_evaluation.csv'
+test_dataset_path_template = '../Data/Study2Evaluation/preprocessed/cleaned/{user_id}_test_data_preprocessed_evaluation.csv'
+
+# Initialize empty lists to store DataFrames
+
+dataframes=[]
+
+# Loop through each user ID
+for user_id in user_ids:
+    # Construct file paths
+    train_file_path = train_dataset_path_template.format(user_id=user_id)
+    test_file_path = test_dataset_path_template.format(user_id=user_id)
+
+    # Read and concatenate train datasets
+    try:
+        train_df = pd.read_csv(train_file_path)
+        test_df = pd.read_csv(test_file_path)
+        dataframes.append(train_df)
+        dataframes.append(test_df)
+    except FileNotFoundError as e:
+        print(f"Train file not found for user {user_id}: {e}")
+
+# Concatenate all train DataFrames into one large DataFrame
+combined_train_df = pd.concat(dataframes, ignore_index=True)
+# Optionally, you can save the combined DataFrames to new CSV files
+combined_train_df.to_csv('../Data/Study2Evaluation/Dataset/combined_preprocessed_evaluation.csv', index=False)
+
+print("Combined train and test datasets created successfully.")

data_processing_code/para.py

@@ -0,0 +1,81 @@
+import pandas as pd
+import numpy as np
+#
+#
+#
+# def load_data(file_path):
+#     return pd.read_csv(file_path)
+#
+#
+# def preprocess_data(data):
+#     # 按指定列分组
+#     grouped = data.groupby(['ParticipantID', 'BlockID', 'TrialID'])
+#
+#     # 计算每个组的均值和标准差，再计算尺寸的上限
+#     group_sizes = grouped.size()
+#     upper_limit = group_sizes.mean() + 1 * group_sizes.std()
+#
+#     # 使用filter方法保留组大小小于上限的数据
+#     filtered_data = grouped.filter(lambda x: len(x) < upper_limit)
+#     return filtered_data
+#
+#
+# def save_data(data, path):
+#     # 确保目标文件夹存在
+#     os.makedirs(os.path.dirname(path), exist_ok=True)
+#     # 保存数据
+#     data.to_csv(path, index=False)
+#
+#
+# # 主函数
+# if __name__ == "__main__":
+#     for i in range(79, 80):
+#         output_train_path = f'../Data/Study2Evaluation/Preprocessed/{i}_train_data_preprocessed_evaluation.csv'
+#         output_test_path = f'../Data/Study2Evaluation/Preprocessed/{i}_test_data_preprocessed_evaluation.csv'
+#
+#         data1 = load_data(output_train_path)
+#         data2 = load_data(output_test_path)
+#
+#         cleaned_data1 = preprocess_data(data1)
+#         cleaned_data2 = preprocess_data(data2)
+#
+#         # 定义保存路径
+#         save_path_train = f'../Data/Study2Evaluation/Preprocessed/cleaned/{i}_train_data_preprocessed_evaluation.csv'
+#         save_path_test = f'../Data/Study2Evaluation/Preprocessed/cleaned/{i}_test_data_preprocessed_evaluation.csv'
+#
+#         # 保存清洗后的数据
+#         save_data(cleaned_data1, save_path_train)
+#         save_data(cleaned_data2, save_path_test)
+#
+#         print(f"Cleaned data saved for {i} train and test.")
+
+def load_data(file_path):
+    return pd.read_csv(file_path)
+
+# 数据预处理，包括特征选择、后填充和展平
+def preprocess_data(data):
+    grouped = data.groupby(['ParticipantID', 'BlockID', 'TrialID'])
+    group_sizes = grouped.size()
+    max_group_index = group_sizes.idxmax()
+    max_group_rows = grouped.get_group(max_group_index).shape[0]
+    return max_group_rows
+
+if __name__ == "__main__":
+    max_rows=0
+    for i in range(79, 80):
+        # if i ==3 or i ==6 or i ==15 or i ==19 or i== 22:
+        #     continue
+        output_train_path = f'../Data/Study2Evaluation/Preprocessed/cleaned/{i}_train_data_preprocessed_evaluation.csv'
+        output_test_path = f'../Data/Study2Evaluation/Preprocessed/cleaned/{i}_test_data_preprocessed_evaluation.csv'
+        data1=load_data(output_train_path)
+        data2=load_data(output_test_path)
+        max_group_rows1 = preprocess_data(data1)
+        max_group_rows2 = preprocess_data(data2)
+        max_rows=max(max_group_rows1,max_group_rows2)
+        print(max_rows)
+
+
+
+
+
+

data_processing_code/preprocess.py

@@ -0,0 +1,252 @@
+import pandas as pd
+import argparse
+import os
+import numpy as np
+from scipy.ndimage import gaussian_filter1d
+from sklearn.preprocessing import MinMaxScaler
+
+
+
+#这个文件是用来在原始文件的基础上删除一些Trial，进行特征工程，然后再打上标签
+def angle_between_vectors(v1, v2):
+    """Calculate the angle between two vectors."""
+    v1 = v1 / np.linalg.norm(v1)
+    v2 = v2 / np.linalg.norm(v2)
+    u_minus_v = v1 - v2
+    u_plus_v = v1 + v2
+    angle = 2 * np.arctan2(np.linalg.norm(u_minus_v), np.linalg.norm(u_plus_v))
+    return np.degrees(angle)
+def smooth_velocity(velocity, sigma=5):
+    return gaussian_filter1d(velocity, sigma=sigma)
+def calculate_angular_velocity(forward_vectors, timestamps):
+    """计算角速度"""
+    angles = np.array(
+        [angle_between_vectors(forward_vectors[i], forward_vectors[i + 1]) if i + 1 < len(forward_vectors) else 0 for i
+         in range(len(forward_vectors) - 1)])  # 注意这里的变化，排除了最后一个向量的计算
+    # 计算时间间隔
+    times = np.diff(timestamps)/1000
+    # 计算角速度，对于第一个时间点，将角度设置为0
+    if len(times) > 0:  # 检查times是否非空，避免除以空数组
+        angular_velocities = np.insert(angles / times, 0, 0)  # 在结果数组的开始插入0
+    else:
+        angular_velocities = np.array([0])  # 如果times为空，说明只有一个时间点，无法计算速度
+    return angular_velocities
+def calculate_linear_velocity(positions, timestamps):
+    """计算线性速度"""
+    distances = np.linalg.norm(np.diff(positions, axis=0), axis=1)
+    times = np.diff(timestamps)/1000
+    linear_velocities = np.insert(distances / times, 0,0)  # Insert 0 at the start as there's no velocity at the first timestamp
+    return linear_velocities
+def calculate_direction(start_position, current_position):
+    """计算方向"""
+    direction = current_position - start_position
+    norm = np.linalg.norm(direction)
+    return direction / norm if norm != 0 else np.zeros_like(direction)
+def calculate_acceleration(velocities, timestamps):
+    """根据速度计算加速度"""
+    accels = [0]  # 第一个时间点的加速度假设为0
+    for i in range(1, len(velocities)):
+        accel = (velocities[i] - velocities[i-1]) / ((timestamps[i] - timestamps[i-1])/1000)
+        accels.append(accel)
+    return np.array(accels)
+
+## 特征工程，先加上三个模态的角速度，和旋转角，再加上手的线性速度和移动距离
+def process_single_sequence(df):
+    """处理groupBy之后的单个序列DataFrame，计算所有模态的角速度、线性速度、方向和旋转轴"""
+    # 提取时间戳
+    timestamps = df['TimeStamp'].values
+    # 定义所有需要计算的模态
+    modalities = ['HMD', 'Hand', 'Leye']
+    for modality in modalities:
+        # 计算角速度和旋转轴
+        if all(f'{modality}ForwardV{i}' in df.columns for i in ['X', 'Y', 'Z']):
+            forward_vectors = df[[f'{modality}ForwardVX', f'{modality}ForwardVY', f'{modality}ForwardVZ']].values
+            initial_forward_vector = forward_vectors[0]
+            df[f'{modality}A'] = [(angle_between_vectors(initial_forward_vector, fv)) for fv in forward_vectors]
+            angular_velocity = calculate_angular_velocity(forward_vectors, timestamps)
+            smoothed_angular_velocity = smooth_velocity(angular_velocity)
+            df[f'{modality}AV'] = smoothed_angular_velocity
+            df[f'{modality}AAcc'] = calculate_acceleration(smoothed_angular_velocity, timestamps)
+            # 计算旋转轴并进行标准化以仅保留方向信息
+            if modality == 'Hand':
+                initial_forward_vector = forward_vectors[0]
+                rotation_axes = np.array([np.cross(initial_forward_vector, fv) for fv in forward_vectors])
+                rotation_axes_normalized = np.array(
+                    [axis / np.linalg.norm(axis) if np.linalg.norm(axis) != 0 else np.array([0.0, 0.0, 0.0]) for axis in
+                     rotation_axes]
+                )
+                df[f'{modality}RotationAxis_X'] = rotation_axes_normalized[:, 0]
+                df[f'{modality}RotationAxis_Y'] = rotation_axes_normalized[:, 1]
+                df[f'{modality}RotationAxis_Z'] = rotation_axes_normalized[:, 2]
+
+        # 对于HMD和Hand，还需计算线性速度和方向还有移动距离
+        if modality in ['HMD', 'Hand'] and all(f'{modality}Position{i}' in df.columns for i in ['X', 'Y', 'Z']):
+            positions = df[[f'{modality}PositionX', f'{modality}PositionY', f'{modality}PositionZ']].values
+            initial_position = positions[0]
+            linear_velocity = calculate_linear_velocity(positions, timestamps)
+            df[f'{modality}L'] = [np.linalg.norm(pos-initial_position) for pos in positions]
+            smoothed_velocity = smooth_velocity(linear_velocity)
+            df[f'{modality}LV'] = smoothed_velocity
+            df[f'{modality}LAcc'] = calculate_acceleration(smoothed_velocity, timestamps)  # 新特性：加速度
+            # 计算方向
+            if modality == 'Hand':
+                start_position = positions[0]
+                directions = np.array([calculate_direction(start_position, pos) for pos in positions])
+                df[f'{modality}Direction_X'] = directions[:, 0]
+                df[f'{modality}Direction_Y'] = directions[:, 1]
+                df[f'{modality}Direction_Z'] = directions[:, 2]
+
+    return df
+
+
+def label_trials_with_motion_metrics(df):
+    # Define a helper function for labeling each group
+    def label_group(group):
+        # For the 'HandLinearDistance' and 'HandAngularDistance', take the last value in the group as it represents the total
+        total_linear_distance = group['HandL'].iloc[-1]
+        total_angular_distance = group['HandA'].iloc[-1]
+        # Assign these totals to new columns for every row in the group
+        group['LLabel'] = total_linear_distance
+        group['ALabel'] = total_angular_distance
+        return group
+    # Apply the labeling function to each trial group
+    df_labeled = df.groupby(['ParticipantID', 'BlockID', 'TrialID'], group_keys=False).apply(label_group)
+    return df_labeled
+
+
+def split_data_by_theta_grouped(df):
+    grouped = df.groupby(['ParticipantID', 'BlockID', 'TrialID'])
+    theta_groups = {}
+    # 将每个组添加到对应Theta值的列表中
+    for _, group in grouped:
+        theta_value = group['Theta'].iloc[0]
+        if theta_value not in theta_groups:
+            theta_groups[theta_value] = []
+        theta_groups[theta_value].append(group)
+    train_dfs = []
+    test_dfs = []
+    for theta_value, groups in theta_groups.items():
+        # 计算训练集大小
+        n_train = int(len(groups) * 0.8)
+        # 随机选择训练集序列
+        np.random.seed(1)  # 确保可重复性
+        train_indices = np.random.choice(len(groups), size=n_train, replace=False)
+        train_groups = [groups[i] for i in train_indices]
+        # 选择测试集序列
+        test_groups = [groups[i] for i in range(len(groups)) if i not in train_indices]
+        # 将训练集和测试集序列合并
+        train_df = pd.concat(train_groups)
+        test_df = pd.concat(test_groups)
+        train_dfs.append(train_df)
+        test_dfs.append(test_df)
+    # 合并所有训练集和测试集的DataFrame
+    final_train_df = pd.concat(train_dfs).sort_index()
+    final_test_df = pd.concat(test_dfs).sort_index()
+    return final_train_df, final_test_df
+
+
+def split_data_by_theta_grouped(df):
+    grouped = df.groupby(['ParticipantID', 'BlockID', 'TrialID'])
+    theta_groups = {}
+    # 将每个组添加到对应Theta值的列表中
+    for _, group in grouped:
+        theta_value = group['Theta'].iloc[0]
+        if theta_value not in theta_groups:
+            theta_groups[theta_value] = []
+        theta_groups[theta_value].append(group)
+    train_dfs = []
+    test_dfs = []
+    for theta_value, groups in theta_groups.items():
+        # 计算训练集大小
+        n_train = int(len(groups) * 0.8)
+        # 随机选择训练集序列
+        np.random.seed(1)  # 确保可重复性
+        train_indices = np.random.choice(len(groups), size=n_train, replace=False)
+        train_groups = [groups[i] for i in train_indices]
+        # 选择测试集序列
+        test_groups = [groups[i] for i in range(len(groups)) if i not in train_indices]
+        # 将训练集和测试集序列合并
+        train_df = pd.concat(train_groups)
+        test_df = pd.concat(test_groups)
+        train_dfs.append(train_df)
+        test_dfs.append(test_df)
+    # 合并所有训练集和测试集的DataFrame
+    final_train_df = pd.concat(train_dfs).sort_index()
+    final_test_df = pd.concat(test_dfs).sort_index()
+    return final_train_df, final_test_df
+
+
+# 定义一个函数，将特征缩放到指定的范围内
+def preprocess_features(train_df, test_df):
+    # 定义包含负值的特征列和其他特征列
+    negative_value_features = ['HandAAcc', 'HMDAAcc',"LeyeAAcc","HandLAcc","HMDLAcc"]
+    other_features = ["HMDA", "HMDAV", "HandA", "HandAV", "LeyeA", "LeyeAV","HMDL", "HMDLV","HandL", "HandLV"]
+    # 为包含负值的特征和其他特征创建两个不同的缩放器
+    scaler_negatives = MinMaxScaler(feature_range=(-1, 1))
+    scaler_others = MinMaxScaler(feature_range=(0, 1))
+    # 对训练集应用fit_transform，对测试集应用transform
+    train_df[negative_value_features] = scaler_negatives.fit_transform(train_df[negative_value_features])
+    test_df[negative_value_features] = scaler_negatives.transform(test_df[negative_value_features])
+    train_df[other_features] = scaler_others.fit_transform(train_df[other_features])
+    test_df[other_features] = scaler_others.transform(test_df[other_features])
+    return train_df, test_df
+
+ #这��function用于修改Evaluation的数据集
+def main(Participant_ID):
+    # 读入数据
+    input_file_path = f'../Data/Study2Evaluation/{Participant_ID}_Trajectory.csv'
+    output_train_path = f'../Data/Study2Evaluation/Preprocessed/{Participant_ID}_train_data_preprocessed_evaluation.csv'
+    output_test_path = f'../Data/Study2Evaluation/Preprocessed/{Participant_ID}_test_data_preprocessed_evaluation.csv'
+
+    data=pd.read_csv(input_file_path)
+    data_cleaned = data.loc[:, ~data.columns.str.contains('^Unnamed')]
+    data_no_error = data_cleaned[data_cleaned['isError'] == False]
+    final_data = data_no_error[(data_no_error['TrialID'] != 0) & (data_no_error['TrialID'] != 6) & (data_no_error['TrialID'] != 12)
+                               & (data_no_error['TrialID'] != 18) & (data_no_error['TrialID'] != 24) & (data_no_error['TrialID'] != 30) & (data_no_error['TrialID'] != 36)]
+    # 特征工程
+    processed_groups = final_data.groupby(['ParticipantID','BlockID', 'TrialID']).apply(process_single_sequence)
+    processed_df = processed_groups.reset_index(drop=True)
+
+    # 为处理完的数据添加标签
+    df_with_features_labelled = label_trials_with_motion_metrics(processed_df.copy())
+    final_train_df, final_test_df = split_data_by_theta_grouped(df_with_features_labelled)
+    # 特征预处理
+    final_train_df_preprocessed, final_test_df_preprocessed = preprocess_features(final_train_df.copy(), final_test_df.copy())
+    # 保存处理后的数据集到CSV文件
+    final_train_df_preprocessed.to_csv(output_train_path, index=False)
+    final_test_df_preprocessed.to_csv(output_test_path, index=False)
+
+
+# def main(Participant_ID):
+#     # 读入数据
+#     input_file_path = f'../Data/{Participant_ID}_Trajectory.csv'
+#     output_train_path = f'../Data/Study1AllUSers/Preprocessed/{Participant_ID}_train_data_preprocessed.csv'
+#     output_test_path = f'../Data/Study1AllUSers/Preprocessed/{Participant_ID}_test_data_preprocessed.csv'
+#     data = pd. read_csv(input_file_path)
+#     participant_id = int(os.path.basename(input_file_path).split('_')[0])
+#     data.insert(0, 'ParticipantID', participant_id)
+#     data_cleaned = data.loc[:, ~data.columns.str.contains('^Unnamed')]
+#     data_no_error = data_cleaned[data_cleaned['isError'] == False]
+#     cleaned_data_path = '../Data/cleaned_data_trimmed.xlsx'
+#     cleaned_data = pd.read_excel(cleaned_data_path)
+#     filtered_data = pd.merge(data_no_error, cleaned_data, on=['ParticipantID', 'BlockID', 'TrialID'], how='inner')
+#     final_data = filtered_data[(filtered_data['TrialID'] != 0) & (filtered_data['TrialID'] != 8) & (filtered_data['TrialID'] != 16) & (filtered_data['TrialID'] != 24)]
+#     # 特征工程
+#     processed_groups = final_data.groupby(['ParticipantID','BlockID', 'TrialID']).apply(process_single_sequence)
+#     processed_df = processed_groups.reset_index(drop=True)
+#     # 为处理完的数据添加标签
+#     df_with_features_labelled = label_trials_with_motion_metrics(processed_df.copy())
+#     final_train_df, final_test_df = split_data_by_theta_grouped(df_with_features_labelled)
+#     # 特征预处理
+#     final_train_df_preprocessed, final_test_df_preprocessed = preprocess_features(final_train_df.copy(), final_test_df.copy())
+#     # 保存处理后的数据集到CSV文件
+#     final_train_df_preprocessed.to_csv(output_train_path, index=False)
+#     final_test_df_preprocessed.to_csv(output_test_path, index=False)
+
+if __name__ == '__main__':
+    for i in range(79, 80):
+        main(str(i))
+
+
+
+

data_processing_code/test.py

@@ -0,0 +1,53 @@
+#%%
+import pandas as pd
+import numpy as np
+df=pd.read_csv('../Data/72_Trajectory.csv')
+
+
+
+
+# from concurrent.futures import ThreadPoolExecutor
+# max_timesteps=296
+# feature_num=16
+# label_nums=9
+#
+# ##数据增强，准确版本
+# def generate_partial_sequences(row, max_timesteps=max_timesteps, features_per_timestep=feature_num, fill_value=-10):
+#     # 确定实际长度
+#     actual_length_indices = np.where(row[:-label_nums] != fill_value)[0]  # 排除最后的标签列
+#     if len(actual_length_indices) > 0:
+#         actual_length = (actual_length_indices[-1] // features_per_timestep) + 1
+#     else:
+#         actual_length = 0
+#     partial_sequences = []
+#     step_size = max(1, int(actual_length * 0.1))  # 步长为实际长度的10%，至少为1
+#     print(f'{actual_length},{step_size}')
+#
+#     for end_length in range(step_size, actual_length + step_size, step_size):
+#         # 计算结束点，不超过实际长度
+#         end_length = min(end_length, actual_length)
+#         partial_sequence_list = row[:end_length * features_per_timestep].tolist()
+#
+#         selected_features_list = [partial_sequence_list[i:i + 10] for i in
+#                                   range(0, len(partial_sequence_list), features_per_timestep)]
+#         selected_features_list = [item for sublist in selected_features_list for item in sublist]
+#
+#         hand_rotation_axis = partial_sequence_list[-6:-3]
+#         hand_direction = partial_sequence_list[-3:]
+#
+#         padding_length = (max_timesteps - end_length) * 10  # 计算填充长度
+#         selected_features_list.extend([fill_value] * padding_length)  # 添加填充
+#
+#         selected_features_list.extend(row[-9:])  # 添加标签
+#         selected_features_list.extend(hand_rotation_axis)  # 添加HandRotationAxis和HandDirection
+#         selected_features_list.extend(hand_direction)
+#
+#         print(len(selected_features_list))
+#
+#         partial_sequences.append(selected_features_list)
+#     return partial_sequences
+#
+#
+#
+# df = pd.read_csv('../Data/testing/test_data_supervised.csv')
+# partial_sequences_df = generate_partial_sequences(df.iloc[0])

upload_to_hf.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+
+REPO_ID = "Gilfoyle727/vr-ray-pointer-landing-pose"
+REPO_TYPE = "dataset"
+LOCAL_DIR = Path(__file__).resolve().parent
+
+
+def main() -> None:
+    api = HfApi()
+    api.create_repo(repo_id=REPO_ID, repo_type=REPO_TYPE, private=False, exist_ok=True)
+    api.upload_large_folder(
+        repo_id=REPO_ID,
+        repo_type=REPO_TYPE,
+        folder_path=str(LOCAL_DIR),
+    )
+    print(f"https://huggingface.co/datasets/{REPO_ID}")
+
+
+if __name__ == "__main__":
+    main()