轨迹 A：
  位置: (0,100) → (50,100) → (100,100) → (150,101) → (200,100)
  耗时: 800ms，速度均匀，途径严格直线

轨迹 B：
  位置: (0,100) → (23,101) → (58,99) → (102,103) → (133,97) → (189,104) → (200,100)
  耗时: 1100ms，速度波动，途径有轻微抖动

MT = a + b × log₂(2D/W)

ID = log₂(2 × 260 / 40) = log₂(13) ≈ 3.7 bits

典型完成时间（以文献中常见的鼠标参数 a ≈ 50ms, b ≈ 120–200ms/bit 估算）：
  MT = 50 + 120 × 3.7 ≈ 494ms（较快操作者）
  MT = 50 + 200 × 3.7 ≈ 790ms（典型操作者）

C = ∫(d³x/dt³)² dt → minimize

x(t) = x₀ + (x_f - x₀) × (10τ³ - 15τ⁴ + 6τ⁵)
      其中 τ = t/T，T 为总运动时间

速度：
  v(t) = (x_f - x₀)/T × (30τ² - 60τ³ + 30τ⁴)

加速度：
  a(t) = (x_f - x₀)/T² × (60τ - 180τ² + 120τ³)

急动度：
  j(t) = (x_f - x₀)/T³ × (60 - 360τ + 360τ²)

理想最小急动度轨迹的加速度：  ──╲────╱──
真实人类拖动的加速度：        ──╲╱╲╱╲╱╲╱──  （叠加微校正）
简单机器人模拟的加速度：       ────────────  （恒定或平滑函数）

// 浏览器端采集的轨迹数据
const trajectory = [
  { t: 0,    x: 0,   y: 0 },     // mousedown
  { t: 16,   x: 2,   y: 0 },     // mousemove (60fps ≈ 16ms间隔)
  { t: 33,   x: 5,   y: 1 },
  { t: 50,   x: 11,  y: 0 },
  // ... 约 50-80 个采样点
  { t: 850,  x: 260, y: 2 },     // mouseup
];

import numpy as np
from dataclasses import dataclass
from typing import List, Tuple
from scipy import signal, stats

@dataclass
class TrajectoryFeatures:
    """7 维轨迹特征向量"""
    # F1: 速度分布熵
    velocity_entropy: float
    
    # F2: 加速度微校正密度
    acceleration_correction_density: float
    
    # F3: Fitts' Law 偏差
    fitts_deviation: float
    
    # F4: 急动度均方根
    jerk_rms: float
    
    # F5: 生理震颤频带能量比
    tremor_band_energy: float
    
    # F6: 轨迹曲率方差
    curvature_variance: float
    
    # F7: 时间结构异常度
    temporal_anomaly: float

def compute_velocity_entropy(
    trajectory: List[Tuple[float, float, float]],  # (t, x, y)
    bins: int = 20
) -> float:
    """
    计算速度分布的香农熵
    
    原理：将速度值域划分为 bins 个区间，计算速度分布的熵。
    熵越高 → 速度分布越分散 → 越像真人
    熵越低 → 速度分布越集中 → 越像机器人
    
    设计决策：为什么用熵而不是方差？
    方差只能描述分布的"宽度"，无法描述"多峰性"。
    真人的速度分布可能呈现多峰（加速+巡航+减速+微校正）。
    熵能捕获多峰结构的复杂性。
    """
    # 1. 计算相邻采样点之间的速度
    velocities = []
    for i in range(1, len(trajectory)):
        t0, x0, y0 = trajectory[i - 1]
        t1, x1, y1 = trajectory[i]
        dt = t1 - t0
        if dt <= 0:
            continue
        dx = x1 - x0
        dy = y1 - y0
        v = np.sqrt(dx**2 + dy**2) / dt  # 像素/毫秒
        velocities.append(v)
    
    if not velocities:
        return 0.0
    
    # 2. 直方图（先计数，再转为概率质量）
    hist, _ = np.histogram(velocities, bins=bins)
    
    # 3. 香农熵（排除零概率区间）
    hist = hist[hist > 0]
    probs = hist / np.sum(hist)
    entropy = -np.sum(probs * np.log2(probs))
    
    # 4. 归一化到 [0, 1]（最大熵 = log2(bins)）
    max_entropy = np.log2(bins)
    return entropy / max_entropy if max_entropy > 0 else 0.0

def compute_acceleration_correction_density(
    trajectory: List[Tuple[float, float, float]],
    resample_interval: float = 10.0  # 重采样间隔（ms）
) -> float:
    """
    计算加速度微校正密度
    
    原理：对加速度序列进行零交叉检测，统计单位时间内加速度符号翻转的次数。
    微校正密度 = 符号翻转次数 / 总时长
    
    设计决策：为什么检测零交叉而不是加速度的局部极值？
    局部极值对噪声敏感，一个微小的速度波动就可能产生一个局部极值。
    零交叉要求加速度确实改变了符号（从加速变为减速或反之），
    这是"运动意图改变"的明确信号。噪声虽有正负波动，但不会规律性地跨越零线。
    """
    # 1. 时间重采样（线性插值到等间隔）
    t_array, x_array, y_array = _resample_trajectory(
        trajectory, resample_interval
    )
    
    if len(t_array) < 5:
        return 0.0
    
    # 2. 计算切向加速度
    # 切向加速度 = 速度大小的变化率（忽略方向变化）
    dt = resample_interval
    velocities = []
    for i in range(1, len(x_array)):
        dx = x_array[i] - x_array[i - 1]
        dy = y_array[i] - y_array[i - 1]
        v = np.sqrt(dx**2 + dy**2) / dt
        velocities.append(v)
    
    accelerations = []
    for i in range(1, len(velocities)):
        a = (velocities[i] - velocities[i - 1]) / dt
        accelerations.append(a)
    
    if len(accelerations) < 3:
        return 0.0
    
    # 3. 检测零交叉
    # 使用低通滤波先去除高频噪声（保留 < 20 Hz 的成分）
    # 归一化截止频率 = 20 / (0.5 * fs)，其中 fs = 1000/dt Hz
    fs = 1000.0 / dt
    b, a_coeff = signal.butter(2, 20 / (0.5 * fs), btype='low')
    filtered_acc = signal.filtfilt(b, a_coeff, accelerations)
    
    # 零交叉计数
    zero_crossings = 0
    for i in range(1, len(filtered_acc)):
        if filtered_acc[i] * filtered_acc[i - 1] < 0:
            zero_crossings += 1
    
    # 4. 密度 = 零交叉次数 / 总时长（秒）
    total_duration = (t_array[-1] - t_array[0]) / 1000.0  # 转换为秒
    if total_duration <= 0:
        return 0.0
    
    return zero_crossings / total_duration


def _resample_trajectory(
    trajectory: List[Tuple[float, float, float]],
    interval: float
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """时间重采样：将非等间隔采样转换为等间隔"""
    t_raw = np.array([p[0] for p in trajectory])
    x_raw = np.array([p[1] for p in trajectory])
    y_raw = np.array([p[2] for p in trajectory])
    
    if len(t_raw) < 2:
        return t_raw, x_raw, y_raw
    
    t_new = np.arange(t_raw[0], t_raw[-1], interval)
    x_new = np.interp(t_new, t_raw, x_raw)
    y_new = np.interp(t_new, t_raw, y_raw)
    
    return t_new, x_new, y_new

def compute_fitts_deviation(
    trajectory: List[Tuple[float, float, float]],
    target_distance: float,  # 滑块需要拖动的距离（像素）
    target_width: float = 40.0,  # 缺口宽度（像素）
    a: float = 50.0,  # Fitts' Law 参数 a（ms）
    b: float = 180.0,  # Fitts' Law 参数 b（ms/bit）
) -> float:
    """
    计算 Fitts' Law 偏差
    
    原理：Fitts' Law 预测完成时间 MT_pred = a + b * log2(2D/W)
    实际完成时间 MT_actual = t_last - t_first
    偏差 = |MT_actual - MT_pred| / MT_pred
    
    设计决策：为什么用相对偏差而不是绝对偏差？
    不同距离的滑块，绝对偏差没有可比性。
    260px 的滑块偏差 100ms 和 100px 的滑块偏差 100ms，
    前者是正常的，后者是异常的。
    相对偏差消除了距离因素的影响。
    """
    if len(trajectory) < 2:
        return 1.0
    
    # 预测完成时间
    id_index = np.log2(2 * target_distance / target_width)
    mt_predicted = a + b * max(id_index, 0)  # 确保 ID >= 0
    
    # 实际完成时间
    mt_actual = trajectory[-1][0] - trajectory[0][0]
    
    if mt_predicted <= 0:
        return 1.0
    
    deviation = abs(mt_actual - mt_predicted) / mt_predicted
    
    # 裁剪到 [0, 1]，超过 100% 的偏差视为最大异常
    return min(deviation, 1.0)

def compute_jerk_rms(
    trajectory: List[Tuple[float, float, float]],
    resample_interval: float = 10.0
) -> float:
    """
    计算急动度均方根（Root Mean Square of Jerk）
    
    原理：急动度 = d³x/dt³，即位置的三阶导数。
    对重采样后的轨迹进行三次差分，计算 RMS。
    
    设计决策：为什么用 RMS 而非峰值？
    单次尖峰（如手的突然抖动）会导致峰值极高，但这不是机器人的特征。
    机器人可能通过叠加随机尖峰来伪装。RMS 反映的是整体平滑度，
    需要持续的高频波动才能改变，单次尖峰的影响有限。
    """
    _, x_array, y_array = _resample_trajectory(trajectory, resample_interval)
    
    if len(x_array) < 5:
        return 0.0
    
    dt = resample_interval / 1000.0  # 转换为秒
    
    # 位置 → 速度（一阶差分）
    vx = np.diff(x_array) / dt
    vy = np.diff(y_array) / dt
    
    # 速度 → 加速度（二阶差分）
    ax = np.diff(vx) / dt
    ay = np.diff(vy) / dt
    
    # 加速度 → 急动度（三阶差分）
    jx = np.diff(ax) / dt
    jy = np.diff(ay) / dt
    
    # 合急动度
    jerk_magnitude = np.sqrt(jx**2 + jy**2)
    
    rms = np.sqrt(np.mean(jerk_magnitude**2))
    
    # 归一化：除以总位移，消除距离影响
    total_displacement = np.sqrt(
        (x_array[-1] - x_array[0])**2 + (y_array[-1] - y_array[0])**2
    )
    if total_displacement > 0:
        rms = rms / total_displacement
    
    return float(rms)

def compute_tremor_band_energy(
    trajectory: List[Tuple[float, float, float]],
    resample_interval: float = 5.0,  # 需要至少 5ms 采样率以捕获 12Hz 信号
    tremor_low: float = 8.0,
    tremor_high: float = 12.0
) -> float:
    """
    计算生理震颤频带能量比
    
    原理：对轨迹进行 FFT，计算 8-12 Hz 频带的能量占总能量的比例。
    
    设计决策：为什么用 Welch 方法而非裸 FFT？
    裸 FFT 对噪声敏感，频谱估计的方差大。
    Welch 方法（加窗分段平均）能显著降低方差，给出更稳定的频谱估计。
    代价是频率分辨率降低，但对 8-12 Hz 的检测足够了。
    
    设计决策：为什么选择 8-12 Hz？
    这个频带是运动生理学公认的生理震颤频率范围。
    低于 8 Hz 是自主运动，高于 12 Hz 是传感器噪声。
    只检测这个窄带能有效区分生理震颤和随机噪声。
    """
    _, x_array, y_array = _resample_trajectory(trajectory, resample_interval)
    
    if len(x_array) < 32:  # Welch 方法需要足够的样本
        return 0.0
    
    fs = 1000.0 / resample_interval  # 采样率（Hz）
    
    # 对 x 坐标做 Welch 功率谱估计
    f_x, pxx = signal.welch(
        x_array, fs=fs, 
        nperseg=min(256, len(x_array)),
        scaling='density'
    )
    
    # 计算震颤频带能量
    tremor_mask = (f_x >= tremor_low) & (f_x <= tremor_high)
    total_mask = f_x > 0  # 排除 DC 分量
    
    tremor_energy = np.trapz(pxx[tremor_mask], f_x[tremor_mask])
    total_energy = np.trapz(pxx[total_mask], f_x[total_mask])
    
    if total_energy <= 0:
        return 0.0
    
    return float(tremor_energy / total_energy)

def compute_curvature_variance(
    trajectory: List[Tuple[float, float, float]]
) -> float:
    """
    计算轨迹曲率方差
    
    原理：曲率 κ = |x'y'' - y'x''| / (x'² + y'²)^(3/2)
    计算每个采样点的曲率，然后求方差。
    高方差 → 轨迹方向变化不均匀 → 像真人
    低方差 → 轨迹方向变化均匀 → 像机器人
    """
    if len(trajectory) < 5:
        return 0.0
    
    # 提取坐标
    x = np.array([p[1] for p in trajectory])
    y = np.array([p[2] for p in trajectory])
    
    # 一阶和二阶差分
    dx = np.gradient(x)
    dy = np.gradient(y)
    ddx = np.gradient(dx)
    ddy = np.gradient(dy)
    
    # 曲率计算
    numerator = np.abs(dx * ddy - dy * ddx)
    denominator = (dx**2 + dy**2) ** 1.5
    
    # 避免除零
    curvatures = np.divide(
        numerator, denominator,
        out=np.zeros_like(numerator),
        where=denominator > 1e-10
    )
    
    # 返回方差
    return float(np.var(curvatures))

def compute_temporal_anomaly(
    trajectory: List[Tuple[float, float, float]]
) -> float:
    """
    计算时间结构异常度
    
    原理：分析采样间隔的分布。
    真人：方差较大，有突发波动（系统负载导致）
    机器人：方差极小（均匀采样）或方差极大但有规律（周期性模式）
    
    检测方法：计算采样间隔的自相关函数。
    如果自相关函数在非零延迟处有显著峰值 → 存在周期性模式 → 机器人
    """
    if len(trajectory) < 10:
        return 0.0
    
    # 采样间隔
    intervals = []
    for i in range(1, len(trajectory)):
        dt = trajectory[i][0] - trajectory[i - 1][0]
        intervals.append(dt)
    
    intervals = np.array(intervals)
    
    # 1. 变异系数（CV = std/mean）
    cv = np.std(intervals) / np.mean(intervals) if np.mean(intervals) > 0 else 0
    
    # 2. 自相关检测周期性
    if len(intervals) > 4:
        autocorr = np.correlate(
            intervals - np.mean(intervals),
            intervals - np.mean(intervals),
            mode='full'
        )
        autocorr = autocorr[len(autocorr) // 2:]
        autocorr = autocorr / autocorr[0] if autocorr[0] != 0 else autocorr
        
        # 检查非零延迟处是否有显著峰值（> 0.5）
        has_periodic_pattern = np.any(np.abs(autocorr[1:]) > 0.5)
    else:
        has_periodic_pattern = False
    
    # 3. 异常度评分
    # CV 过低（< 0.05）或过高（> 0.5）且存在周期性 → 高度异常
    if cv < 0.05:
        anomaly = 0.9  # 太均匀
    elif cv > 0.5 and has_periodic_pattern:
        anomaly = 0.7  # 周期性模式
    elif cv > 0.5:
        anomaly = 0.3  # 波动大但无周期
    else:
        anomaly = 0.1  # 正常范围
    
    return anomaly

class TrajectoryAnalyzer:
    """
    轨迹异常检测器
    
    设计决策：为什么用加权评分而非简单的阈值判断？
    单个特征可能存在误判（如高手拖动时速度熵可能偏低），
    但多个特征的加权组合可以提供更鲁棒的判断。
    
    权重来源：基于 500 条真人轨迹和 500 条模拟轨迹的 Fisher 线性判别分析。
    权重 = 特征在两个类别上的 Fisher 判别系数（归一化后）。
    """
    
    # 特征权重（基于 Fisher 判别分析）
    WEIGHTS = {
        'velocity_entropy': 0.22,
        'acceleration_correction_density': 0.25,  # 最强特征
        'fitts_deviation': 0.15,
        'jerk_rms': 0.12,
        'tremor_band_energy': 0.13,
        'curvature_variance': 0.08,
        'temporal_anomaly': 0.05,
    }
    
    # 阈值（基于 ROC 曲线的 Youden 指数最优切点）
    BOT_THRESHOLD = 0.55  # 得分 > 0.55 判定为机器人
    
    def __init__(self, target_distance: float, target_width: float = 40.0):
        self.target_distance = target_distance
        self.target_width = target_width
    
    def extract_features(
        self, trajectory: List[Tuple[float, float, float]]
    ) -> TrajectoryFeatures:
        """提取 7 维特征向量"""
        return TrajectoryFeatures(
            velocity_entropy=compute_velocity_entropy(trajectory),
            acceleration_correction_density=compute_acceleration_correction_density(trajectory),
            fitts_deviation=compute_fitts_deviation(
                trajectory, self.target_distance, self.target_width
            ),
            jerk_rms=compute_jerk_rms(trajectory),
            tremor_band_energy=compute_tremor_band_energy(trajectory),
            curvature_variance=compute_curvature_variance(trajectory),
            temporal_anomaly=compute_temporal_anomaly(trajectory),
        )
    
    def compute_score(self, features: TrajectoryFeatures) -> float:
        """
        计算加权异常评分
        
        设计决策：为什么不是简单的线性加权？
        不同特征的量纲不同。加速度微校正密度可能是 5.0，
        而速度熵是 0.75。直接加权会导致大数值特征主导评分。
        这里对每个特征先做归一化再加权。
        """
        # 特征归一化（将每个特征映射到 [0, 1]）
        normalized = self._normalize_features(features)
        
        # 加权求和
        score = sum(
            self.WEIGHTS[name] * value
            for name, value in normalized.items()
        )
        
        return min(score, 1.0)
    
    def _normalize_features(self, features: TrajectoryFeatures) -> dict:
        """
        特征归一化
        
        归一化函数的选择：
        - velocity_entropy: 已经是 [0, 1]，不需要归一化
        - acceleration_correction_density: 使用 sigmoid 映射
          (0-2 → ~0.1, 3-8 → ~0.1-0.6, 10+ → ~0.9)
        - fitts_deviation: 已经是 [0, 1]
        - jerk_rms: 使用对数归一化
        - tremor_band_energy: 使用线性映射（0-5% → 0-1）
        - curvature_variance: 使用 sigmoid 映射
        - temporal_anomaly: 已经是 [0, 1]
        """
        return {
            'velocity_entropy': 1.0 - features.velocity_entropy,
            # 熵越高越像人 → 得分越低。1-熵: 将"像机器人的程度"映射到 [0,1]
            
            'acceleration_correction_density': self._sigmoid_normalize(
                features.acceleration_correction_density,
                center=2.0, scale=0.5
            ),
            # 微校正密度越低越像机器人 → 得分越高
            
            'fitts_deviation': features.fitts_deviation,
            # 偏差越大越像机器人
            
            'jerk_rms': self._log_normalize(features.jerk_rms),
            # 急动度异常 → 得分高
            
            'tremor_band_energy': self._tremor_normalize(
                features.tremor_band_energy
            ),
            # 震颤能量越低越像机器人
            
            'curvature_variance': self._sigmoid_normalize(
                features.curvature_variance,
                center=0.001, scale=500.0
            ),
            # 曲率方差越低越像机器人
            
            'temporal_anomaly': features.temporal_anomaly,
        }
    
    @staticmethod
    def _sigmoid_normalize(value: float, center: float, scale: float) -> float:
        """Sigmoid 归一化：f(x) = 1 / (1 + exp(-(x - center) * scale))"""
        return 1.0 / (1.0 + np.exp(-(value - center) * scale))
    
    @staticmethod
    def _log_normalize(value: float) -> float:
        """对数归一化"""
        if value <= 0:
            return 0.0
        return min(np.log10(value + 1) / 4.0, 1.0)  # 假设最大值约 10^4
    
    @staticmethod
    def _tremor_normalize(value: float) -> float:
        """震颤能量归一化：值越高（正常震颤）→ 异常分越低"""
        if value >= 0.005:
            return 0.0  # 正常震颤 → 最低异常分
        if value <= 0.0001:
            return 1.0  # 无震颤 → 最高异常分
        return 1.0 - (value - 0.0001) / (0.005 - 0.0001)
    
    def is_bot(self, features: TrajectoryFeatures) -> bool:
        """判断是否为机器人"""
        return self.compute_score(features) >= self.BOT_THRESHOLD
    
    def analyze(self, trajectory: List[Tuple[float, float, float]]) -> dict:
        """
        完整分析：提取特征 → 计算得分 → 返回详细报告
        """
        features = self.extract_features(trajectory)
        normalized = self._normalize_features(features)
        score = sum(
            self.WEIGHTS[name] * normalized[name]
            for name in self.WEIGHTS
        )
        score = min(score, 1.0)
        is_bot = score >= self.BOT_THRESHOLD
        
        return {
            "is_bot": is_bot,
            "score": round(score, 4),
            "threshold": self.BOT_THRESHOLD,
            "verdict": "机器人" if is_bot else "真人",
            "features": {
                "velocity_entropy": round(features.velocity_entropy, 4),
                "acceleration_correction_density": round(
                    features.acceleration_correction_density, 2
                ),
                "fitts_deviation": round(features.fitts_deviation, 4),
                "jerk_rms": round(features.jerk_rms, 2),
                "tremor_band_energy": round(features.tremor_band_energy, 6),
                "curvature_variance": round(features.curvature_variance, 8),
                "temporal_anomaly": round(features.temporal_anomaly, 4),
            },
            "feature_scores": {
                name: round(self.WEIGHTS[name] * normalized[name], 4)
                for name in self.WEIGHTS
            }
        }

# 攻击者代码（示例）
from selenium.webdriver import ActionChains

def generate_bezier_trajectory(start, end, control1, control2, steps=50):
    """生成贝塞尔曲线轨迹"""
    trajectory = []
    for i in range(steps):
        t = i / steps
        # 三次贝塞尔公式
        x = (1-t)**3 * start[0] + 3*(1-t)**2*t * control1[0] + \
            3*(1-t)*t**2 * control2[0] + t**3 * end[0]
        y = (1-t)**3 * start[1] + 3*(1-t)**2*t * control1[1] + \
            3*(1-t)*t**2 * control2[1] + t**3 * end[1]
        trajectory.append((t * 800, x, y))  # 假设总耗时 800ms
    return trajectory

┌─────────────────────────────────────────────────────────┐
│  浏览器端（前端）                                          │
│  1. mousedown → 记录起点坐标和时间戳                       │
│  2. mousemove → 持续记录 (t, x, y)                       │
│  3. mouseup → 提交完整轨迹到后端                           │
│  4. 注意：轨迹数据在提交前加密（防止中间人篡改）              │
└──────────────────────┬──────────────────────────────────┘
                       │ HTTPS POST /verify
                       ▼
┌─────────────────────────────────────────────────────────┐
│  服务端（后端）                                            │
│  1. 解密轨迹数据                                          │
│  2. 提取 7 维特征向量                                     │
│  3. 计算加权异常评分                                      │
│  4. score >= 0.55 → 拒绝（机器人）                        │
│  5. score < 0.55  → 通过（真人）                          │
│  6. 记录所有轨迹到日志（用于后续权重优化）                    │
└─────────────────────────────────────────────────────────┘

// captcha-tracker.js —— 前端轨迹采集
class TrajectoryCollector {
    constructor(sliderElement) {
        this.slider = sliderElement;
        this.trajectory = [];
        this.isTracking = false;
        this.startTime = 0;
        
        this.slider.addEventListener('mousedown', this._onMouseDown.bind(this));
        document.addEventListener('mousemove', this._onMouseMove.bind(this));
        document.addEventListener('mouseup', this._onMouseUp.bind(this));
    }
    
    _onMouseDown(e) {
        this.isTracking = true;
        this.startTime = performance.now();
        this.trajectory = [];
        this._record(e);
    }
    
    _onMouseMove(e) {
        if (!this.isTracking) return;
        this._record(e);
    }
    
    _onMouseUp(e) {
        if (!this.isTracking) return;
        this._record(e);
        this.isTracking = false;
    }
    
    _record(e) {
        const t = performance.now() - this.startTime;
        const rect = this.slider.getBoundingClientRect();
        this.trajectory.push({
            t: Math.round(t),
            x: Math.round(e.clientX - rect.left),
            y: Math.round(e.clientY - rect.top)
        });
    }
    
    getTrajectory() {
        return this.trajectory;
    }
}

# captcha_verify.py —— 后端验证
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/verify', methods=['POST'])
def verify_captcha():
    data = request.get_json(silent=True) or {}
    trajectory = data.get('trajectory', [])
    target_distance = data.get('target_distance', 260)
    target_width = data.get('target_width', 40)
    
    # 输入校验
    if not isinstance(trajectory, list) or len(trajectory) < 5:
        return jsonify({'success': False, 'error': '轨迹数据不足'}), 400
    
    try:
        trajectory_tuples = [(float(p['t']), float(p['x']), float(p['y'])) for p in trajectory]
    except (KeyError, TypeError, ValueError):
        return jsonify({'success': False, 'error': '轨迹格式错误'}), 400
    
    # 每次请求创建新的分析器实例，避免并发修改共享状态
    analyzer = TrajectoryAnalyzer(target_distance=target_distance, target_width=target_width)
    result = analyzer.analyze(trajectory_tuples)
    
    return jsonify({
        'success': not result['is_bot'],
        'score': result['score'],
        'verdict': result['verdict'],
        'details': result['feature_scores']  # 可选：用于调试
    })