Eye Touch-实时眼动追踪与注视控制系统

def detect_pupil_centroid(self, eye_roi):
    """
    稳健的瞳孔中心检测
    方法1：阈值分割 + 轮廓质心法（优先）
    方法2：强度加权质心法（备用）
    """
    if eye_roi is None or eye_roi.size == 0:
        return None

    # 第一步：预处理
    gray = cv2.cvtColor(eye_roi, cv2.COLOR_BGR2GRAY)
    k = max(3, int(min(eye_roi.shape[:2]) / 8) | 1)
    gray = cv2.GaussianBlur(gray, (k, k), 0)

    # 第二步：自适应阈值分割（Otsu方法）
    try:
        _, thresh = cv2.threshold(gray, 0, 255,
                                cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    except:
        _, thresh = cv2.threshold(gray, 40, 255, cv2.THRESH_BINARY_INV)

    # 第三步：形态学操作（去除噪点）
    mk = max(3, int(min(eye_roi.shape[:2]) / 20) | 1)
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (mk, mk))
    thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=1)
    thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel, iterations=1)

    # 第四步：寻找轮廓
    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # 第五步：选择最大轮廓（假设是瞳孔）
    if contours:
        c = max(contours, key=cv2.contourArea)
        if cv2.contourArea(c) >= 10:
            M = cv2.moments(c)
            if M["m00"] != 0:
                cx = int(M["m10"]/M["m00"])
                cy = int(M["m01"]/M["m00"])
                return (cx, cy)

    # 备用方案：强度加权质心法
    inv = 255 - gray
    sum_inv = float(np.sum(inv)) + 1e-6
    coords = np.indices(gray.shape)
    cx = int(np.sum(coords[1] * inv) / sum_inv)
    cy = int(np.sum(coords[0] * inv) / sum_inv)
    h, w = gray.shape
    if 0 <= cx < w and 0 <= cy < h:
        return (cx, cy)
    return None

# 步骤1：归一化摄像头坐标（防止数值过大影响回归）
X = np.array(calib_cam, dtype=np.float32)
X_norm = np.stack([X[:,0] / float(self.CAM_W),
                   X[:,1] / float(self.CAM_H)], axis=1)

# 步骤2：多项式特征扩展（2次多项式）
# 原始特征：[x, y]
# 扩展特征：[1, x, y, x^2, xy, y^2]
poly = PolynomialFeatures(degree=2, include_bias=True)
X_poly = poly.fit_transform(X_norm)

# 步骤3：分别对x和y建立回归模型
reg_x = LinearRegression().fit(X_poly, Y[:,0])  # 预测屏幕x坐标
reg_y = LinearRegression().fit(X_poly, Y[:,1])  # 预测屏幕y坐标

# 步骤4：保存模型以备复用
self.save_calibration(poly, reg_x, reg_y)

# 数学原理：
# screen_x = w0 + w1*x + w2*y + w3*x² + w4*xy + w5*y²
# screen_y = v0 + v1*x + v2*y + v3*x² + v4*xy + v5*y²

# 初始化卡尔曼滤波器
# 4个状态变量: [x, y, vx, vy] (位置x, 位置y, 速度x, 速度y)
# 2个观测变量: [x, y] (只能观测到位置)
kf = cv2.KalmanFilter(4, 2)

# 状态转移矩阵: 匀速运动模型
# x_new = x_old + vx, y_new = y_old + vy
kf.transitionMatrix = np.array([[1,0,1,0], [0,1,0,1],
                                [0,0,1,0], [0,0,0,1]], np.float32)

# 观测矩阵：只能观测位置，不能直接观测速度
kf.measurementMatrix = np.array([[1,0,0,0], [0,1,0,0]], np.float32)

# 噪声协方差
kf.processNoiseCov = np.eye(4, dtype=np.float32) * 1e-4     # 过程噪声（很小）
kf.measurementNoiseCov = np.eye(2, dtype=np.float32) * 1e-2 # 观测噪声（中等）

# 在追踪循环中：
# 1. 预测
prediction = kf.predict()

# 2. 获取当前观测值
measurement = np.array([[screen_x], [screen_y]], np.float32)

# 3. 校正
kf.correct(measurement)

# 4. 输出平滑后的结果
smoothed_point = (prediction[0], prediction[1])