两点星位透视矫正：用最少标记完成棋盘校正

// 用户标记的两个像素坐标
Point2f p1 = markPoints[0];  // 左上星位 (3,3) 的像素位置
Point2f p2 = markPoints[1];  // 右下星位 (15,15) 的像素位置

// 天元 = 中点（这是透视投影下的近似，但对仿射足够）
Point2f p_center = (p1 + p2) * 0.5f;

// 棋盘坐标系中的 3 个对应点
vector<Point2f> src = {
    Point2f(3.0f/18,  3.0f/18),   // (3,3) 归一化
    Point2f(9.0f/18,  9.0f/18),   // (9,9) 天元
    Point2f(15.0f/18, 15.0f/18)   // (15,15) 归一化
};

vector<Point2f> dst = { p1, p_center, p2 };

Mat A = getAffineTransform(src, dst);
// A 是 2×3 仿射矩阵：[a b tx; c d ty]

// 用仿射矩阵投影全部 9 个星位→像素坐标
vector<Point2f> predictedStars(9);

int idx = 0;
for (int row_val : {3, 9, 15}) {
    for (int col_val : {3, 9, 15}) {
        // 归一化棋盘坐标
        float u = col_val / 18.0f;
        float v = row_val / 18.0f;

        // 仿射投影
        float px = A.at<double>(0,0) * u + A.at<double>(0,1) * v + A.at<double>(0,2);
        float py = A.at<double>(1,0) * u + A.at<double>(1,1) * v + A.at<double>(1,2);

        predictedStars[idx++] = Point2f(px, py);
    }
}

// 对每个预测位置，在局部 ROI 内搜索实际星位
vector<Point2f> confirmedStars;

for (const auto& pred : predictedStars) {
    // 定义搜索窗口：预测位置 ± 1.5 倍网格间距
    float halfWin = estimatedSpacing * 1.5f;
    Rect roi(pred.x - halfWin, pred.y - halfWin,
             halfWin * 2, halfWin * 2);

    // 确保 ROI 在图像范围内
    roi &= Rect(0, 0, gray.cols, gray.rows);

    // 在 ROI 内做 HoughCircles
    Mat roiImg = gray(roi);
    vector<Vec3f> circles;
    HoughCircles(roiImg, circles, HOUGH_GRADIENT,
                 1,                  // dp
                 estimatedSpacing,   // minDist
                 100,                // param1 (Canny)
                 18,                 // param2 (累加器阈值)
                 minR, maxR);        // 半径范围

    if (!circles.empty()) {
        // 取响应最强的那个，转换回全局坐标
        float gx = circles[0][0] + roi.x;
        float gy = circles[0][1] + roi.y;
        confirmedStars.push_back(Point2f(gx, gy));
    }
}

if (confirmedStars.size() >= 2) {
    // ✅ 加上原有的 2 个标记点，总计 ≥ 4 个
    // 合并并升级为全单应
    vector<Point2f> allSrc;
    // ... 先加入标记点的归一化坐标
    // ... 再按身份匹配加入 confirmedStars
    H = findHomography(allDst, allSrc, RANSAC, 3.0);
    warpPerspective(srcImg, result, H, Size(outSize, outSize));
}
else {
    // ❌ guided search 没找到足够的额外星位
    // 降级为仿射兜底
    // 仿射 = 旋转 + 缩放 + 平移，不校正梯形透视
    // 对正面/接近正面拍摄的照片效果足够好
    warpAffine(srcImg, result2, A, Size(outSize, outSize));
    // 标记为"仿射模式"以便 UI 提示用户精度可能略低
}

class QuickRectifier {
public:
    void setMarkedPoints(cv::Point2f corner1, cv::Point2f corner2) {
        p1 = corner1;
        p2 = corner2;
    }

    bool rectify(const cv::Mat& input, cv::Mat& output, int outSize = 600) {
        // 1. 仿射预估（3 点：P1, 中点, P2）
        cv::Point2f p_center = (p1 + p2) * 0.5f;

        std::vector<cv::Point2f> src = {
            {3.0f/18, 3.0f/18},
            {9.0f/18, 9.0f/18},
            {15.0f/18, 15.0f/18}
        };
        std::vector<cv::Point2f> dst = {p1, p_center, p2};

        cv::Mat A = cv::getAffineTransform(src, dst);

        // 2. 预测 9 星位像素坐标
        auto predicted = predictStars(A);

        // 3. Guided HoughCircles 精搜
        auto found = guidedHoughSearch(input, predicted);

        // 4. 决策：升级 or 兜底
        if (found.size() >= 2) {
            // 升级为单应
            auto allPts = mergePoints(p1, p2, found);
            cv::Mat H = cv::findHomography(allPts.dst, allPts.src,
                                           cv::RANSAC, 3.0);
            cv::warpPerspective(input, output, H,
                                cv::Size(outSize, outSize));
            return true;  // 高精度模式
        } else {
            // 仿射兜底
            cv::warpAffine(input, output, A,
                           cv::Size(outSize, outSize));
            return false; // 降级模式
        }
    }

private:
    cv::Point2f p1, p2;
};