# 硬件平台架构
hardware_config = {
    "vehicle": "Renault Twizy (electric)",
    "eeg": {
        "device": "OpenBCI Cyton + Daisy (wireless, 16-channel)",
        "electrode_system": "10-20 international",
        "sampling_rate": 125,  # Hz
        "electrode_impedance": "<10kΩ",  # gel-free cap
        "channels": ["Fp1","Fp2","F3","F4","Fz","C3","C4","Cz",
                     "T3","T4","P3","P4","Pz","O1","O2","Oz"]
    },
    "vehicle_kinematics": {
        "device": "GNSS/INS with RTK correction via NTRIP",
        "outputs": ["position","velocity","yaw_angle","yaw_rate"],
        "correction": "RTK centimeter-level accuracy"
    },
    "additional_sensors": ["stereo_camera","LiDAR-IMU"],
    "sync_framework": "ROS Noetic (rosbag format)",
    "route": "Durham, UK (~9km, campus+city+residential)"
}

# 参与者
participants = {
    "count": 4,  # 3M, 1F, age 25-45
    "sessions_per_participant": 8,
    "total_sessions": 32,
    "avg_session_duration": 22,  # minutes
    "familiarization_sessions": 2  # per participant
}

import numpy as np
from scipy import signal as sig

class EEGPreprocessor:
    """
    Mind2Drive EEG预处理策略
    
    论文核心发现：最小化预处理 > 复杂预处理
    """
    
    def __init__(self, sampling_rate=125, strategy="minimal"):
        self.fs = sampling_rate
        self.strategy = strategy
    
    def normalize(self, eeg_data):
        """
        Z-score标准化（默认且必需的预处理）
        
        Args:
            eeg_data: shape=(channels, time_points), 16通道
        
        Returns:
            normalized EEG
        """
        mean = np.mean(eeg_data, axis=1, keepdims=True)
        std = np.std(eeg_data, axis=1, keepdims=True)
        return (eeg_data - mean) / (std + 1e-8)
    
    def minimal_pipeline(self, eeg_data):
        """最小化预处理（论文最优方案）"""
        # 仅标准化
        return self.normalize(eeg_data)
    
    def pyprep_pipeline(self, eeg_data):
        """PyPREP-based pipeline（论文对比方案）"""
        # 1. 带通滤波 1-40Hz
        eeg_data = sig.butter(4, [1, 40], btype='band', fs=self.fs)
        # 2. 伪迹剔除
        # 3. 通道插值
        # 论文发现：此pipeline反而降低性能
        return eeg_data
    
    def bandpass_only(self, eeg_data, low=1, high=40):
        """仅带通滤波"""
        b, a = sig.butter(4, [low/(self.fs/2), high/(self.fs/2)], btype='band')
        return sig.filtfilt(b, a, eeg_data, axis=1)


# 预处理策略性能对比（论文Table结果）
preprocessing_results = {
    "Minimal (normalization only)": {"accuracy": 0.907, "macro_f1": 0.901},
    "Bandpass 1-40Hz": {"accuracy": 0.872, "macro_f1": 0.865},
    "PyPREP full pipeline": {"accuracy": 0.834, "macro_f1": 0.828},
    "ICA artefact removal": {"accuracy": 0.812, "macro_f1": 0.805}
}

class IntentionLabeler:
    """
    基于车辆运动学的意图标注
    
    使用GNSS/INS数据定义ground truth意图
    """
    
    def __init__(self, yaw_rate_threshold=0.05, 
                 accel_threshold=0.5,
                 min_duration=1.0):
        self.yaw_rate_thresh = yaw_rate_threshold
        self.accel_thresh = accel_threshold
        self.min_duration = min_duration
    
    def label_intentions(self, kinematics):
        """
        从车辆运动学数据提取意图标签
        
        Args:
            kinematics: dict with 'velocity','yaw_rate','acceleration'
        
        Returns:
            labels: 0=lane_keeping, 1=left_turn, 2=right_turn, 
                    3=braking, 4=accelerating
        """
        labels = np.zeros(len(kinematics['velocity']))
        
        for i in range(len(labels)):
            yaw_rate = kinematics['yaw_rate'][i]
            accel = kinematics['acceleration'][i]
            
            if abs(yaw_rate) > self.yaw_rate_thresh:
                labels[i] = 1 if yaw_rate > 0 else 2  # 左转/右转
            elif accel < -self.accel_thresh:
                labels[i] = 3  # 制动
            elif accel > self.accel_thresh:
                labels[i] = 4  # 加速
            else:
                labels[i] = 0  # 车道保持
        
        return labels
    
    def create_prediction_windows(self, labels, pre_motion_ms=1000):
        """
        创建预测窗口（在manoeuvre执行前pre_motion_ms毫秒）
        
        关键：论文发现最佳预测窗口在 manoeuvre 前400-600ms
        """
        fs = 125  # EEG采样率
        pre_samples = int(pre_motion_ms * fs / 1000)
        windows = []
        
        for i in range(pre_samples, len(labels)):
            if labels[i] != 0:  # 非车道保持
                # 取 manoeuvre 前的EEG窗口
                window_start = i - pre_samples
                window_end = i
                windows.append((window_start, window_end, labels[i]))
        
        return windows

import torch
import torch.nn as nn

class TSCeption(nn.Module):
    """
    TSCeption: EEG意图预测最优模型
    
    论文中最优架构，90.7%准确率
    基于多尺度时序卷积，提取EEG时空特征
    
    参考: arXiv:2604.19368
    """
    
    def __init__(self, num_channels=16, num_classes=5, 
                 sampling_rate=125, hidden_units=128,
                 dropout_rate=0.5):
        super().__init__()
        
        self.num_channels = num_channels
        self.sampling_rate = sampling_rate
        
        # 空间卷积：跨通道特征提取
        self.spatial_conv = nn.Conv2d(1, hidden_units, 
                                      kernel_size=(num_channels, 1),
                                      padding=0)
        
        # 多尺度时序卷积
        self.temporal_kernels = [5, 10, 20, 40]  # 不同时间尺度
        self.temporal_convs = nn.ModuleList([
            nn.Conv2d(hidden_units, hidden_units // 4,
                      kernel_size=(1, k), padding=(0, k//2))
            for k in self.temporal_kernels
        ])
        
        self.batch_norm = nn.BatchNorm2d(hidden_units)
        self.dropout = nn.Dropout(dropout_rate)
        self.relu = nn.ReLU()
        
        # 分类头
        self.feature_size = self._get_feature_size()
        self.classifier = nn.Sequential(
            nn.Linear(self.feature_size, 256),
            nn.ReLU(),
            nn.Dropout(dropout_rate),
            nn.Linear(256, num_classes)
        )
    
    def _get_feature_size(self):
        """计算展平后的特征维度"""
        # 模拟前向传播获取特征尺寸
        x = torch.randn(1, 1, self.num_channels, self.sampling_rate)
        x = self.spatial_conv(x)
        outputs = [conv(x) for conv in self.temporal_convs]
        x = torch.cat(outputs, dim=1)
        x = torch.mean(x, dim=2)  # 全局平均池化
        return x.numel()
    
    def forward(self, x):
        """
        前向传播
        
        Args:
            x: EEG信号, shape=(batch, 1, channels, time)
               channels=16, time=125 (1秒@125Hz)
        
        Returns:
            logits: shape=(batch, num_classes)
        """
        # 空间卷积
        x = self.spatial_conv(x)  # (B, H, 1, T)
        x = self.batch_norm(x)
        x = self.relu(x)
        x = self.dropout(x)
        
        # 多尺度时序卷积
        temporal_outputs = [conv(x) for conv in self.temporal_convs]
        x = torch.cat(temporal_outputs, dim=1)  # (B, H, 1, T)
        x = self.relu(x)
        
        # 全局平均池化
        x = torch.mean(x, dim=2)  # (B, H, T)
        
        # 展平
        x = x.flatten(1)
        
        # 分类
        return self.classifier(x)


# 测试
if __name__ == "__main__":
    model = TSCeption(num_channels=16, num_classes=5, sampling_rate=125)
    
    # 模拟1秒EEG数据（16通道, 125采样点）
    eeg_input = torch.randn(32, 1, 16, 125)  # batch=32
    output = model(eeg_input)
    
    print(f"输入: {eeg_input.shape}")
    print(f"输出: {output.shape}")
    print(f"参数量: {sum(p.numel() for p in model.parameters()):,}")

# 论文中评估的12种架构及其性能
architectures_results = {
    "TSCeption":         {"accuracy": 0.907, "macro_f1": 0.901, "params": "0.8M"},
    "EEGNet":            {"accuracy": 0.882, "macro_f1": 0.876, "params": "0.05M"},
    "DeepConvNet":       {"accuracy": 0.871, "macro_f1": 0.865, "params": "1.2M"},
    "ShallowConvNet":    {"accuracy": 0.858, "macro_f1": 0.852, "params": "0.4M"},
    "EEG-Conformer":     {"accuracy": 0.891, "macro_f1": 0.885, "params": "2.1M"},
    "Transformer-EEG":   {"accuracy": 0.876, "macro_f1": 0.870, "params": "1.5M"},
    "CTransformer":      {"accuracy": 0.865, "macro_f1": 0.859, "params": "0.9M"},
    "ViT-EEG":           {"accuracy": 0.843, "macro_f1": 0.837, "params": "3.2M"},
    "ConvNet-EEG":       {"accuracy": 0.829, "macro_f1": 0.823, "params": "0.6M"},
    "LSTM-EEG":          {"accuracy": 0.798, "macro_f1": 0.792, "params": "0.7M"},
    "GRU-EEG":           {"accuracy": 0.781, "macro_f1": 0.775, "params": "0.5M"},
    "MLP-EEG":           {"accuracy": 0.712, "macro_f1": 0.706, "params": "0.1M"}
}

import matplotlib.pyplot as plt

# 不同预测horizon下的性能
horizons_ms = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
accuracies = [0.907, 0.905, 0.902, 0.908, 0.911, 0.909, 0.895, 0.881, 0.872, 0.858]
macro_f1s =  [0.901, 0.899, 0.896, 0.902, 0.905, 0.903, 0.889, 0.875, 0.866, 0.852]

# 关键发现
key_findings = {
    "最佳预测窗口": "400-600ms before manoeuvre",
    "提前1000ms仍可用": "85.8% accuracy (仅降低5%)",
    "神经准备期": "400-600ms 对应认知-运动准备阶段",
    "实际意义": "为ADAS系统提供约1秒的反应提前量"
}

# 论文的EEG通道分析结果
channel_importance = {
    "最高贡献区域": {
        "额叶 Frontal": ["F3","F4","Fz","Fp1","Fp2"],
        "中央 Central": ["C3","C4","Cz"],
        "贡献说明": "运动准备和决策相关"
    },
    "中等贡献区域": {
        "颞叶 Temporal": ["T3","T4"],
        "顶叶 Parietal": ["P3","P4","Pz"],
        "贡献说明": "感知整合"
    },
    "较低贡献区域": {
        "枕叶 Occipital": ["O1","O2","Oz"],
        "贡献说明": "视觉处理（与意图直接关联较弱）"
    }
}

# SHAP值分析结果
# 额叶信号在意图预测中贡献最大，对应前额叶皮层的运动准备功能

class DMSADASNeuralInterface:
    """
    DMS-ADAS神经接口架构
    
    基于Mind2Drive的EEG意图预测
    为IMS系统提供1秒前瞻窗口
    """
    
    def __init__(self):
        self.eeg_model = TSCeption(num_channels=16, num_classes=5)
        self.prediction_buffer = []
        self.confidence_threshold = 0.85
        self.lead_time_ms = 500  # 使用500ms前瞻窗口（最佳性能）
    
    def predict_intention(self, eeg_window):
        """
        从500ms EEG窗口预测驾驶意图
        
        Args:
            eeg_window: shape=(16, 62) # 500ms @ 125Hz
        
        Returns:
            intention: 预测的驾驶意图
            confidence: 置信度
        """
        with torch.no_grad():
            x = torch.FloatTensor(eeg_window).unsqueeze(0).unsqueeze(0)
            logits = self.eeg_model(x)
            probs = torch.softmax(logits, dim=1)
            
            confidence, predicted = probs.max(dim=1)
            
        return predicted.item(), confidence.item()
    
    def adas_decision(self, intention, confidence, vehicle_state):
        """
        ADAS决策层：基于EEG意图预测调整ADAS策略
        
        应用场景：
        - 左/右转意图 → 提前调整车速/转向辅助
        - 制动意图 → 预激活紧急制动
        - 加速意图 → 调整动力分配
        """
        if confidence < self.confidence_threshold:
            return "MAINTAIN"  # 低置信度不干预
        
        if intention == 3:  # 制动意图
            return "PRE_ARM_EMERGENCY_BRAKE"
        elif intention in [1, 2]:  # 转向意图
            return "PREPARE_LANE_CHANGE_ASSIST"
        elif intention == 4:  # 加速意图
            return "OPTIMIZE_POWER_DELIVERY"
        else:
            return "MAINTAIN"