task2.cpp

// Sakshi B.

#include "task2.h"
#include "task1.h"
#include "config.h"
#include <iostream>

// ── buildPointSet ─────────────────────────────────────────────────────────────

std::vector<cv::Vec3f> buildPointSet()
{
    std::vector<cv::Vec3f> point_set;
    point_set.reserve(BOARD_ROWS * BOARD_COLS);

    // Outer loop = rows, inner loop = columns.
    // Must match findChessboardCorners() ordering: left-to-right, top-to-bottom.
    for (int r = 0; r < BOARD_ROWS; ++r)
        for (int c = 0; c < BOARD_COLS; ++c)
            point_set.emplace_back(
                 static_cast<float>(c) * SQUARE_SIZE,   // X  (right)
                -static_cast<float>(r) * SQUARE_SIZE,   // Y  (up, -row so Z faces viewer)
                 0.0f);                                  // Z  (flat on board)

    return point_set;
}

// ── selectCalibrationImages ───────────────────────────────────────────────────

void selectCalibrationImages(int argc, char* argv[],
                              std::vector<std::vector<cv::Point2f>>& corner_list,
                              std::vector<std::vector<cv::Vec3f>>&   point_list,
                              cv::Size& imageSize)
{
    cv::VideoCapture cap = openVideoSource(argc, argv);
    if (!cap.isOpened()) {
        std::cerr << "[Task2][ERROR] Cannot open video source.\n";
        return;
    }

    // Pre-build point_set once — it is the same for every frame
    const std::vector<cv::Vec3f> point_set = buildPointSet();

    std::cout << "=== Task 2: Select Calibration Images ===\n"
              << "  's'     — save frame (uses last detected corners)\n"
              << "  'q'/ESC — quit\n\n";

    cv::Mat frame, gray;
    cv::Mat      lastGoodFrame;           // frame where corners were last found
    std::vector<cv::Point2f> lastCorners; // most recent successful corner set
    bool haveGoodCorners = false;
    int savedCount = 0;

    while (true) {
        cap >> frame;
        if (frame.empty()) { std::cout << "[Task2] End of stream.\n"; break; }

        imageSize = frame.size();
        cv::cvtColor(frame, gray, cv::COLOR_BGR2GRAY);

        std::vector<cv::Point2f> corners;
        bool found = detectCorners(gray, corners);

        if (found) {
            lastCorners     = corners;
            lastGoodFrame   = frame.clone();
            haveGoodCorners = true;
        }

        // Draw on a display copy
        cv::Mat display = frame.clone();
        drawCornersOverlay(display, found ? corners : lastCorners,
                           found || haveGoodCorners);

        // Overlay: saved count
        std::string info = "Saved: " + std::to_string(savedCount) +
                           "   Press 's' to save";
        cv::putText(display, info, cv::Point(10, 60),
                    cv::FONT_HERSHEY_SIMPLEX, 0.65,
                    cv::Scalar(255, 200, 0), 2);

        if (!found && haveGoodCorners)
            cv::putText(display, "(showing cached corners)",
                        cv::Point(10, 90),
                        cv::FONT_HERSHEY_SIMPLEX, 0.55,
                        cv::Scalar(180, 180, 0), 1);

        cv::imshow("Task 2 - Select Calibration Images", display);
        int key = cv::waitKey(1) & 0xFF;

        // ── 's': save ────────────────────────────────────────────────────────
        if (key == 's') {
            if (!haveGoodCorners) {
                std::cout << "[Task2] No corners detected yet — "
                             "move the board into view first.\n";
            } else {
                corner_list.push_back(lastCorners);
                point_list.push_back(point_set);
                ++savedCount;

                // Write annotated image to disk for the report
                std::string filename = "calib_" + std::to_string(savedCount) + ".png";
                cv::Mat annotated = lastGoodFrame.clone();
                cv::drawChessboardCorners(annotated, BOARD_SIZE, lastCorners, true);
                cv::imwrite(filename, annotated);

                std::cout << "[Task2] Saved frame " << savedCount
                          << " → " << filename << "\n";
            }
        }

        if (key == 'q' || key == 27) break;
    }

    cap.release();
    cv::destroyAllWindows();
    std::cout << "[Task2] Done. " << savedCount << " frame(s) saved.\n";
}

// ── runTask2 ──────────────────────────────────────────────────────────────────

void runTask2(int argc, char* argv[])
{
    std::vector<std::vector<cv::Point2f>> corner_list;
    std::vector<std::vector<cv::Vec3f>>   point_list;
    cv::Size imageSize;

    selectCalibrationImages(argc, argv, corner_list, point_list, imageSize);

    std::cout << "[Task2] " << corner_list.size()
              << " calibration frame(s) collected.\n"
              << "[Task2] Run task 3 to calibrate the camera.\n";
}