Part 0: 基础视觉系统 —— 从摄像头到棋盘矫正

// esp32-cam/main/esp32-cam.c — camera_init()
static esp_err_t camera_init(void)
{
    camera_config_t config = {
        .pin_pwdn    = 32,          // 电源控制
        .pin_reset   = -1,          // 不复用 reset
        .pin_xclk    = 0,           // 主时钟
        .pin_sccb_sda = 26,         // I²C 数据
        .pin_sccb_scl = 27,         // I²C 时钟
        // D0-D7 并行数据
        .pin_d7 = 35, .pin_d6 = 34, .pin_d5 = 39, .pin_d4 = 36,
        .pin_d3 = 21, .pin_d2 = 19, .pin_d1 = 18, .pin_d0 = 5,
        // 同步信号
        .pin_vsync = 25, .pin_href = 23, .pin_pclk = 22,

        .xclk_freq_hz = 20000000,   // 20MHz 主频
        .pixel_format  = PIXFORMAT_JPEG,  // 关键：硬件 JPEG 输出
        .frame_size    = FRAMESIZE_SVGA,   // 800×600
        .jpeg_quality  = 12,              // 0-63, 越小越好
        .fb_count      = 2,               // 双缓冲
        .fb_location   = CAMERA_FB_IN_PSRAM,
    };
    return esp_camera_init(&config);
}

// MjpegStream.cpp — parseBuffer()
void MjpegStream::parseBuffer()
{
    // boundary 分隔符: "--BOUNDARY\r\n"
    QByteArray delimiter = "--" + m_boundary + "\r\n";

    while (true) {
        // 找下一帧的起始边界
        int startIdx = m_buffer.indexOf(delimiter);
        if (startIdx < 0) {
            // 数据不完整，保留尾部等待更多数据
            int keep = qMax(0, m_buffer.size() - delimiter.size() - 2);
            if (keep < m_buffer.size())
                m_buffer = m_buffer.right(keep);
            break;
        }

        // 跳过 delimiter → 读 MIME headers
        int headersStart = startIdx + delimiter.size();
        int headersEnd = m_buffer.indexOf("\r\n\r\n", headersStart);
        if (headersEnd < 0) break; // headers 不完整

        int jpegStart = headersEnd + 4; // 跳过 \r\n\r\n

        // 找下一个 delimiter，确定 JPEG 数据结束位置
        int nextDelim = m_buffer.indexOf(delimiter, jpegStart);

        if (nextDelim < 0) {
            // 可能是最后一帧，找结束标记 "--BOUNDARY--"
            QByteArray endDelim = "--" + m_boundary + "--";
            int endIdx = m_buffer.indexOf(endDelim, jpegStart);
            if (endIdx >= 0) {
                // 最后一帧处理...
            }
            break; // 等更多数据
        }

        QByteArray jpegData = m_buffer.mid(jpegStart, nextDelim - jpegStart);
        // 去掉末尾 \r\n
        while (jpegData.endsWith('\n') || jpegData.endsWith('\r'))
            jpegData.chop(1);

        QImage frame;
        if (frame.loadFromData(jpegData, "JPEG"))
            emit frameReady(frame);  // 🔥 发射信号！

        m_buffer = m_buffer.mid(nextDelim); // 推进指针
    }
}

// GoBoardDetector.cpp — preprocess()
cv::Mat GoBoardDetector::preprocess(const cv::Mat &bgr)
{
    cv::Mat gray, temp;
    cv::cvtColor(bgr, gray, cv::COLOR_BGR2GRAY);

    // Bilateral: 去噪保边缘（棋盘线是关键特征，不能模糊）
    cv::bilateralFilter(gray, temp, 9, 75, 75);
    gray = temp;

    // CLAHE: 自适应直方图均衡（应对不均匀光照）
    auto clahe = cv::createCLAHE(2.0, cv::Size(8, 8));
    clahe->apply(gray, gray);

    return gray;
}

std::vector<cv::Point2f> GoBoardDetector::detectStarPoints(const cv::Mat &gray) const
{
    // 先用 FFT 自相关估算格子间距
    double spacing = estimateSpacing(gray);

    // 根据间距自适应参数 —— 不是写死数值！
    int minR = std::max(2, (int)(spacing * 0.04));    // 最小圆半径
    int maxR = std::max(minR + 2, (int)(spacing * 0.20)); // 最大圆半径
    int minDist = std::max(8, (int)(spacing * 0.3));  // 圆心最小间距

    // L1: 激进参数（要求高质量圆）
    std::vector<cv::Vec3f> circles;
    cv::HoughCircles(gray, circles, cv::HOUGH_GRADIENT,
                     1.0, minDist, 100, 18, minR, maxR);

    // L2: 如果 L1 结果不够, 降参数再试
    if (circles.size() < 6) {
        circles.clear();
        cv::HoughCircles(gray, circles, cv::HOUGH_GRADIENT,
                         1.0, minDist, 60, 8, minR, maxR);
    }

    std::vector<cv::Point2f> points;
    for (const auto &c : circles)
        points.emplace_back(c[0], c[1]);
    return points;
}

// BoardRectifier.cpp — computeHomography()
bool BoardRectifier::computeHomography(double ransacThresh)
{
    if (m_srcPts.size() < 4) return false;

    std::vector<cv::Point2f> dst = standardStarNormCoords();
    // {(3/18,3/18), (3/18,9/18), ..., (15/18,15/18)}

    size_t n = std::min(m_srcPts.size(), dst.size());
    std::vector<cv::Point2f> useDst(dst.begin(), dst.begin() + n);
    std::vector<cv::Point2f> useSrc(m_srcPts.begin(), m_srcPts.begin() + n);

    cv::Mat mask;
    m_H = cv::findHomography(useDst, useSrc, cv::RANSAC, ransacThresh, mask);
    return !m_H.empty();
}

// BoardRectifier.cpp — rectify()
cv::Mat BoardRectifier::rectify(int outputSize, int margin, ...) const
{
    cv::Point2f srcCorners[4];
    getProjectedCorners(srcCorners);  // 通过 H 投影四角

    cv::Point2f dstCorners[4];
    getDstCorners(outputSize, m, dstCorners);

    cv::Mat M = cv::getPerspectiveTransform(srcCorners, dstCorners);
    cv::Mat warped;
    cv::warpPerspective(m_source, warped, M,
                        cv::Size(outputSize, outputSize),
                        cv::INTER_LINEAR, cv::BORDER_CONSTANT,
                        cv::Scalar(50, 50, 50));

    // 绘制网格线 + 星位
    double cell = (outputSize - 2.0 * m) / 18.0;
    for (int i = 0; i < 19; i++) {
        int pos = m + (int)(i * cell + 0.5);
        cv::line(warped, {m, pos}, {outputSize-m, pos}, {80,80,80});
        cv::line(warped, {pos, m}, {pos, outputSize-m}, {80,80,80});
    }
    return warped;
}

// MarkWidget.cpp — 坐标转换
QPointF MarkWidget::widgetToImage(const QPointF &wp) const
{
    QRectF r = imageRect();  // 图像在 widget 内的缩放矩形
    return QPointF(
        (wp.x() - r.x()) * m_image.width()  / r.width(),
        (wp.y() - r.y()) * m_image.height() / r.height()
    );
}

QRectF MarkWidget::imageRect() const
{
    qreal iw = m_image.width(), ih = m_image.height();
    qreal ww = width(), wh = height();
    qreal scale = qMin(ww / iw, wh / ih);  // 等比缩放取较小值
    qreal dw = iw * scale, dh = ih * scale;
    qreal dx = (ww - dw) / 2.0, dy = (wh - dh) / 2.0; // 居中
    return QRectF(dx, dy, dw, dh);
}

// MarkWidget.cpp — paintEvent() 关键部分
for (int i = 0; i < m_points.size(); i++) {
    QPointF pw = imageToWidget(m_points[i]);

    // 十字准线 (红色)
    p.setPen(QPen(QColor(255, 50, 50, 180), 1));
    p.drawLine(cx - 14, cy, cx + 14, cy);
    p.drawLine(cx, cy - 14, cx, cy + 14);

    // 外圆 (绿色)
    p.setPen(QPen(QColor(0, 255, 100, 220), 2));
    p.drawEllipse(QPointF(cx, cy), 8, 8);

    // 编号标签 (白字黑底)
    p.setPen(Qt::white);
    p.setBrush(QColor(0, 0, 0, 160));
    p.drawRoundedRect(QRectF(cx + 10, cy - 22, 22, 18), 4, 4);
    p.drawText(QRectF(cx + 10, cy - 22, 22, 18), Qt::AlignCenter,
               QString::number(i + 1));
}

// BoardRectifier.cpp — computeFromFourCorners()
int BoardRectifier::computeFromFourCorners(
    cv::Point2f tl,  // (3,3)   左上
    cv::Point2f tr,  // (3,15)  右上
    cv::Point2f br,  // (15,15) 右下
    cv::Point2f bl,  // (15,3)  左下
    const cv::Mat &gray)
{
    // 1. 4 角 → 直接 4 点精确解单应
    std::vector<cv::Point2f> indexedPts(9);
    std::vector<bool> hasPt(9, false);
    indexedPts[0] = tl; hasPt[0] = true;  // (3,3)
    indexedPts[2] = tr; hasPt[2] = true;  // (3,15)
    indexedPts[8] = br; hasPt[8] = true;  // (15,15)
    indexedPts[6] = bl; hasPt[6] = true;  // (15,3)

    // 2. 用 4 点算出精确单应 H4
    std::vector<cv::Point2f> src4, dst4;
    for (int i : {0, 2, 6, 8}) {
        src4.push_back(indexedPts[i]);
        dst4.emplace_back(starPositions[i].boardCol / 18.0f,
                          starPositions[i].boardRow / 18.0f);
    }
    cv::Mat H4 = cv::findHomography(dst4, src4, 0);  // 0 = 精确解

    // 3. 用 H4 预测其余 5 星位 → guided HoughCircles 补搜
    // ...

    // 4. 按身份构建匹配点对 → RANSAC
    m_srcPts.clear();
    std::vector<cv::Point2f> dstOrdered;
    for (int i = 0; i < 9; i++) {
        if (hasPt[i]) {
            m_srcPts.push_back(indexedPts[i]);
            dstOrdered.emplace_back(starPositions[i].boardCol / 18.0f,
                                    starPositions[i].boardRow / 18.0f);
        }
    }

    cv::Mat mask;
    m_H = cv::findHomography(dstOrdered, m_srcPts, cv::RANSAC, 3.0, mask);
    if (m_H.empty()) m_H = H4;  // RANSAC 失败 → 回退精确解
    return totalStars;
}

// MainWindow 构造函数中的核心连接
m_stream = new MjpegStream(this);
connect(m_stream, &MjpegStream::frameReady,
        this, &MainWindow::onStreamFrame);

m_liveView = new LiveView;
connect(m_liveView, &LiveView::detectionUpdated,
        this, &MainWindow::onDetectionUpdated);

// 人工标记完成 → 自动矫正
m_markWidget = new MarkWidget;
connect(m_markWidget, &MarkWidget::allMarked,
        this, &MainWindow::onMarkingDone);

// 左面板: QStackedWidget 在 LiveView 和 MarkWidget 之间切换
m_leftStack = new QStackedWidget;
m_leftStack->addWidget(m_liveView);   // [0] 实时流模式
m_leftStack->addWidget(m_markWidget); // [1] 人工标记模式

// 工具栏按钮触发切换
m_btnRectify  → onRectifyImage()   → m_leftStack->setCurrentIndex(1)
m_btnQuad     → onQuadRectify()    → m_leftStack->setCurrentIndex(1)
m_btnTriangle → onTriangleRectify()→ m_leftStack->setCurrentIndex(1)

// 流模式下自动保持在 [0]
m_btnConnect  → m_leftStack->setCurrentIndex(0)

cmake_minimum_required(VERSION 3.16)
project(GoBoardCalib LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)

find_package(Qt6 REQUIRED COMPONENTS Widgets Network)
find_package(OpenCV REQUIRED)

add_executable(go-board-calib
    src/main.cpp
    src/MainWindow.h       src/MainWindow.cpp
    src/MjpegStream.h      src/MjpegStream.cpp
    src/GoBoardDetector.h  src/GoBoardDetector.cpp
    src/BoardRectifier.h   src/BoardRectifier.cpp
    src/LiveView.h         src/LiveView.cpp
    src/DewarpView.h       src/DewarpView.cpp
    src/MarkWidget.h       src/MarkWidget.cpp
)

target_link_libraries(go-board-calib PRIVATE
    Qt6::Widgets Qt6::Network ${OpenCV_LIBS})
target_include_directories(go-board-calib PRIVATE
    ${OpenCV_INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR}/src)

cd workspace/go-board-cpp
mkdir -p build && cd build
cmake -DCMAKE_PREFIX_PATH=/opt/Qt/6.5.3/gcc_64 ..
make -j$(nproc)