【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners

opencv3.4.15源文档链接: link

ChArUco标定板角点的检测

  • Goal
  • Source code
  • Charuco板创建
  • ChArUco板检测
  • ChArUco姿势估计

ArUco标记和板的快速检测和多功能性是非常有用的。然而,ArUco标定板的一个问题是,即使应用亚像素细化,其角点位置的精度也不是太高。相反,棋盘图案的角可以更精确地细化,因为每个角都被两个黑色方块包围。然而,寻找一个棋盘图案不像寻找一个ArUco板:它必须是完全可见的,闭塞是不允许的。(拍摄的图片,标定板必须无遮盖)

ChArUco标定板试图结合这两种方法的优点:

【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners_第1张图片
ArUco部分用于插值棋盘角点的位置,因此它具有标记板的多功能性,因为它允许遮挡或部分视图。此外,由于插值角点属于棋盘,它们在亚像素精度方面非常精确。

当需要高精度时,例如在相机校准中,Charuco板是比标准Aruco板更好的选择。

Goal

在本教程中,您将学习:

  • 如何创建一个charuco板?
  • 如何在不进行相机校准的情况下检测charuco角?
  • 如何利用相机标定和位姿估计来检测charuco角?

Source code

您可以在opencv_contrib/modules/aruco/samples/tutorial_charuco_create_detect.cpp中找到此代码
下面是如何实现目标列表中列出的所有内容的示例代码。

#include 
#include 
#include 
#include 
namespace {
const char* about = "A tutorial code on charuco board creation and detection of charuco board with and without camera caliberation";
const char* keys = "{c        |       | Put value of c=1 to create charuco board;\nc=2 to detect charuco board without camera calibration;\nc=3 to detect charuco board with camera calibration and Pose Estimation}";
}
void createBoard();
void detectCharucoBoardWithCalibrationPose();
void detectCharucoBoardWithoutCalibration();
static bool readCameraParameters(std::string filename, cv::Mat& camMatrix, cv::Mat& distCoeffs)
{
    cv::FileStorage fs(filename, cv::FileStorage::READ);
    if (!fs.isOpened())
        return false;
    fs["camera_matrix"] >> camMatrix;
    fs["distortion_coefficients"] >> distCoeffs;
    return (camMatrix.size() == cv::Size(3,3)) ;
}
void createBoard()
{
    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
    cv::Mat boardImage;
    board->draw(cv::Size(600, 500), boardImage, 10, 1);
    cv::imwrite("BoardImage.jpg", boardImage);
}
void detectCharucoBoardWithCalibrationPose()
{
    cv::VideoCapture inputVideo;
    inputVideo.open(0);
    cv::Mat cameraMatrix, distCoeffs;
    std::string filename = "calib.txt";
    bool readOk = readCameraParameters(filename, cameraMatrix, distCoeffs);
    if (!readOk) {
        std::cerr << "Invalid camera file" << std::endl;
    } else {
        cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
        cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
        cv::Ptr<cv::aruco::DetectorParameters> params = cv::aruco::DetectorParameters::create();
        while (inputVideo.grab()) {
            cv::Mat image;
            cv::Mat imageCopy;
            inputVideo.retrieve(image);
            image.copyTo(imageCopy);
            std::vector<int> markerIds;
            std::vector<std::vector<cv::Point2f> > markerCorners;
            cv::aruco::detectMarkers(image, board->dictionary, markerCorners, markerIds, params);
            // if at least one marker detected
            if (markerIds.size() > 0) {
                cv::aruco::drawDetectedMarkers(imageCopy, markerCorners, markerIds);
                std::vector<cv::Point2f> charucoCorners;
                std::vector<int> charucoIds;
                cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, image, board, charucoCorners, charucoIds, cameraMatrix, distCoeffs);
                // if at least one charuco corner detected
                if (charucoIds.size() > 0) {
                    cv::Scalar color = cv::Scalar(255, 0, 0);
                    cv::aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, color);
                    cv::Vec3d rvec, tvec;
                    // cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
                    bool valid = cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
                    // if charuco pose is valid
                    if (valid)
                        cv::aruco::drawAxis(imageCopy, cameraMatrix, distCoeffs, rvec, tvec, 0.1f);
                }
            }
            cv::imshow("out", imageCopy);
            char key = (char)cv::waitKey(30);
            if (key == 27)
                break;
        }
    }
}
void detectCharucoBoardWithoutCalibration()
{
    cv::VideoCapture inputVideo;
    inputVideo.open(0);
    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
    cv::Ptr<cv::aruco::DetectorParameters> params = cv::aruco::DetectorParameters::create();
    params->cornerRefinementMethod = cv::aruco::CORNER_REFINE_NONE;
    while (inputVideo.grab()) {
        cv::Mat image, imageCopy;
        inputVideo.retrieve(image);
        image.copyTo(imageCopy);
        std::vector<int> markerIds;
        std::vector<std::vector<cv::Point2f> > markerCorners;
        cv::aruco::detectMarkers(image, board->dictionary, markerCorners, markerIds, params);
        //or
        //cv::aruco::detectMarkers(image, dictionary, markerCorners, markerIds, params);
        // if at least one marker detected
        if (markerIds.size() > 0) {
            cv::aruco::drawDetectedMarkers(imageCopy, markerCorners, markerIds);
            std::vector<cv::Point2f> charucoCorners;
            std::vector<int> charucoIds;
            cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, image, board, charucoCorners, charucoIds);
            // if at least one charuco corner detected
            if (charucoIds.size() > 0)
                cv::aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, cv::Scalar(255, 0, 0));
        }
        cv::imshow("out", imageCopy);
        char key = (char)cv::waitKey(30);
        if (key == 27)
            break;
    }
}
int main(int argc, char* argv[])
{
    cv::CommandLineParser parser(argc, argv, keys);
    parser.about(about);
    if (argc < 2) {
        parser.printMessage();
        return 0;
    }
    int choose = parser.get<int>("c");
    switch (choose) {
    case 1:
        createBoard();
        std::cout << "An image named BoardImg.jpg is generated in folder containing this file" << std::endl;
        break;
    case 2:
        detectCharucoBoardWithoutCalibration();
        break;
    case 3:
        detectCharucoBoardWithCalibrationPose();
        break;
    default:
        break;
    }
    return 0;
}

Charuco板创建

aruco模块提供了cv::aruco::CharucoBoard类,它表示一个Charuco标定板,继承自Board类。
这个类和ChArUco的其他函数一样,定义在:

#include 

要定义CharucoBoard,需要:

  • 棋盘X方向上的方格数。
  • Y方向的棋盘方格数。
  • 正方形边长。
  • 标记边长度。
  • 标记者的字典。
  • 所有标记的id。
    至于GridBoard对象,aruco模块提供了一个函数来轻松创建charucoboard。这个函数是静态函数cv::aruco::CharucoBoard::create():
```cv::aruco::CharucoBoard board = cv::aruco::CharucoBoard::create(5, 7, 0.04, 0.02, dictionary); ```
  • 第一个和第二个参数分别是X方向和Y方向的平方数。
  • 第三个和第四个参数分别是正方形和标记的长度。它们可以以任何单位提供,记住这个板的估计姿态将以相同的单位测量(通常使用米)。
  • 最后,给出了标记的字典。

默认情况下,每个标记的id按升序分配,并从0开始,就像GridBoard::create()中那样。就像Board的父类一样,可以通过board.ids访问ids向量很容易地自定义。
有了CharucoBoard对象之后,就可以创建一个图像来打印它。这可以通过CharucoBoard::draw()方法来完成:

cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
cv::Mat boardImage;
board->draw(cv::Size(600, 500), boardImage, 10, 1); ```
  • 第一个参数是输出图像的大小,以像素为单位。在这种情况下,600x500像素。如果这与板的尺寸不成比例,它将以图像为中心。
  • boardImage:带有板的输出图像。
  • 第三个参数是(可选的)像素边距,因此没有任何标记接触图像边界。在本例中,差额为10。
  • 最后,标记边框的大小,类似于drawMarker()函数。缺省值为1。

输出的图像将是这样的:
【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners_第2张图片
完整的工作示例包含在模块示例文件夹中的create_board_charuco.cpp中。
注意:create_board_charuco.cpp现在通过OpenCV命令行解析器通过命令行获取输入。对于这个文件,示例参数如下所示

"_ output path_/chboard.png" -w=5 -h=7 -sl=200 -ml=120 -d=10

ChArUco板检测

当你检测ChArUco板子时,你实际上是在检测板子的每个棋盘角点。
ChArUco板上的每个角点都有一个分配的唯一标识符(id)。这些id从0到标定板上的角点的总数。
charuco标定板检测的步骤可以分解为以下步骤:

  • 将输入图像
cv::Mat image;

要检测标记的原始图像。图像是必要的执行亚像素细化ChArUco角。

  • 读取摄像头标定参数(仅用于摄像头标定检测)
cv::Mat cameraMatrix, distCoeffs;
std::string filename = "calib.txt";
bool readOk = readCameraParameters(filename, cameraMatrix, distCoeffs);

readcameraparparameters的参数是:

  • filename-这是calibra .txt文件的路径,该文件是calibrate_camera_charuco.cpp生成的输出文件
  • cameraMatrix和distCoeffs-可选的相机标定参数

这个函数将这些参数作为输入,并返回一个布尔值,表示摄像机标定参数是否有效。对于没有校准的角的检测,这一步是不需要的。

  • 检测标记
        cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
        cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
        cv::Ptr<cv::aruco::DetectorParameters> params = cv::aruco::DetectorParameters::create();
            std::vector<int> markerIds;
            std::vector<std::vector<cv::Point2f> > markerCorners;
            cv::aruco::detectMarkers(image, board->dictionary, markerCorners, markerIds, params);

detectmarker的参数为:

  • image -输入图像。
  • dictionary -指向要搜索的字典/标记集的指针。
  • markerCorners -检测到的标记角点的向量。
  • markerIds - 被检测标记的标识符向量
  • params - ChArUco角的检测是基于之前检测到的标记。因此,首先检测标记,然后从标记插值ChArUco角。
  • 从标记插值charuco角

用于标定检测

        std::vector charucoCorners;
        std::vector charucoIds;
        cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, image, board, charucoCorners, charucoIds, cameraMatrix, distCoeffs);

无需标定的检测

    std::vector charucoCorners;
    std::vector charucoIds;
    cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, image, board, charucoCorners, charucoIds);

检测ChArUco角点的函数是cv::aruco::interpolateCornersCharuco()。这个函数返回插值的Charuco角点的数量。

  • std::vector charucoCorners : list of image positions of the detected corners.
  • std::vector charucoIds : ids for each of the detected corners in charucoCorners.

如果提供了标定参数,则首先从ArUco标记估计一个粗略的姿势,然后将ChArUco角点重新投影回图像,从而插值ChArUco角点。

另一方面,在不提供标定参数的情况下,通过计算ChArUco平面与ChArUco图像投影之间的对应单应性来插值ChArUco角点。

单应性插值的主要问题是插值对图像失真更敏感。实际上,单应性只使用每个ChArUco角点的最近标记来执行,以减少失真的影响。

当检测ChArUco板的标记时,特别是当使用单应性时,建议禁用标记的角点细化。这是因为,由于棋盘方格的接近性,亚像素过程会在角点的位置上产生重要的偏差,这些偏差会传播到ChArUco角插值中,产生较差的结果。

此外,只返回那些已经找到两个周围标记的角点。如果周围的两个标记中有任何一个没有被检测到,这通常意味着该区域有一些遮挡或图像质量不好。在任何情况下,最好不要考虑那个角点,因为我们想要的是确保插值ChArUco角点是非常准确的。

在插值ChArUco角点之后,执行亚像素细化。
一旦我们插值了ChArUco角点,我们可能想要画出它们,看看它们的检测是否正确。这可以使用drawdetectedcornscharuco()函数轻松完成:

 cv::aruco::drawDetectedCornersCharuco(image, charucoCorners, charucoIds, color); 
  • image是将绘制角点的图像(它通常是检测角点的图像)。
  • outputImage将是inputImage的克隆,并绘制了角。
  • charucoCornerscharucoIdsinterpolateCornersCharuco()函数检测到的Charuco角。
  • 最后,最后一个参数是我们想要绘制角的颜色(可选),类型为cv::Scalar

这张图片:
【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners_第3张图片
图像与Charuco标定板

结果将是:
【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners_第4张图片
Charuco板检测

在图片被遮盖的情况下。就像下图一样,虽然一些角点是清晰可见的,但由于遮挡,并不是所有它们周围的标记都被检测到,因此,它们没有被插值:
【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners_第5张图片
带有遮挡的Charuco检测

最后,这是ChArUco检测的完整示例(不使用标定参数):

void detectCharucoBoardWithoutCalibration()
{
    cv::VideoCapture inputVideo;
    inputVideo.open(0);
    cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
    cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
    cv::Ptr<cv::aruco::DetectorParameters> params = cv::aruco::DetectorParameters::create();
    params->cornerRefinementMethod = cv::aruco::CORNER_REFINE_NONE;
    while (inputVideo.grab()) {
        cv::Mat image, imageCopy;
        inputVideo.retrieve(image);
        image.copyTo(imageCopy);
        std::vector<int> markerIds;
        std::vector<std::vector<cv::Point2f> > markerCorners;
        cv::aruco::detectMarkers(image, board->dictionary, markerCorners, markerIds, params);
        //or
        //cv::aruco::detectMarkers(image, dictionary, markerCorners, markerIds, params);
        // if at least one marker detected
        if (markerIds.size() > 0) {
            cv::aruco::drawDetectedMarkers(imageCopy, markerCorners, markerIds);
            std::vector<cv::Point2f> charucoCorners;
            std::vector<int> charucoIds;
            cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, image, board, charucoCorners, charucoIds);
            // if at least one charuco corner detected
            if (charucoIds.size() > 0)
                cv::aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, cv::Scalar(255, 0, 0));
        }
        cv::imshow("out", imageCopy);
        char key = (char)cv::waitKey(30);
        if (key == 27)
            break;
    }
} 

样本视频:

10月14日

完整的工作示例包含在模块示例文件夹中的detect_board_charuco.cpp中。
注意:示例现在通过OpenCV命令行解析器通过命令行获取输入。对于这个文件,示例参数如下所示

-c="_path_/calib.txt" -dp="_path_/detector_params.yml" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10

这里的calibrb .txt是calibrate_camera_charuco.cpp生成的输出文件。

ChArUco姿势估计

ChArUco板的最终目标是为高精度校准或位姿估计找到非常准确的角点。
aruco模块提供了一个函数来轻松地执行ChArUco位姿估计。与GridBoard一样,CharucoBoard的坐标系统被放置在标定板板的平面上,Z轴指向外,并在标定板的左下角居中。
姿态估计的函数是estimatePoseCharucoBoard():

cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec); 
  • charucoCornerscharucoIds参数是从interpolateCornersCharuco()函数中检测到的charuco角点。
  • 第三个参数是CharucoBoard对象。
  • cameraMatrixdistCoeffs是相机定标参数,是位姿估计所必需的。
  • 最后,rvectvec参数是Charuco板的输出位姿。
  • 如果姿势被正确估计,函数返回true,否则返回false。失败的主要原因是没有足够的角位估计或它们在同一条线上。

可以使用drawAxis()绘制轴,以检查姿势是否正确估计。结果是:(X:红色,Y:绿色,Z:蓝色)
【OpenCV】ChArUco标定板角点的检测Detection of ChArUco Corners_第6张图片
Charuco板轴
ChArUco检测与姿态估计的完整示例:

void detectCharucoBoardWithCalibrationPose()
{
    cv::VideoCapture inputVideo;
    inputVideo.open(0);
    cv::Mat cameraMatrix, distCoeffs;
    std::string filename = "calib.txt";
    bool readOk = readCameraParameters(filename, cameraMatrix, distCoeffs);
    if (!readOk) {
        std::cerr << "Invalid camera file" << std::endl;
    } else {
        cv::Ptr<cv::aruco::Dictionary> dictionary = cv::aruco::getPredefinedDictionary(cv::aruco::DICT_6X6_250);
        cv::Ptr<cv::aruco::CharucoBoard> board = cv::aruco::CharucoBoard::create(5, 7, 0.04f, 0.02f, dictionary);
        cv::Ptr<cv::aruco::DetectorParameters> params = cv::aruco::DetectorParameters::create();
        while (inputVideo.grab()) {
            cv::Mat image;
            cv::Mat imageCopy;
            inputVideo.retrieve(image);
            image.copyTo(imageCopy);
            std::vector<int> markerIds;
            std::vector<std::vector<cv::Point2f> > markerCorners;
            cv::aruco::detectMarkers(image, board->dictionary, markerCorners, markerIds, params);
            // if at least one marker detected
            if (markerIds.size() > 0) {
                cv::aruco::drawDetectedMarkers(imageCopy, markerCorners, markerIds);
                std::vector<cv::Point2f> charucoCorners;
                std::vector<int> charucoIds;
                cv::aruco::interpolateCornersCharuco(markerCorners, markerIds, image, board, charucoCorners, charucoIds, cameraMatrix, distCoeffs);
                // if at least one charuco corner detected
                if (charucoIds.size() > 0) {
                    cv::Scalar color = cv::Scalar(255, 0, 0);
                    cv::aruco::drawDetectedCornersCharuco(imageCopy, charucoCorners, charucoIds, color);
                    cv::Vec3d rvec, tvec;
                    // cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
                    bool valid = cv::aruco::estimatePoseCharucoBoard(charucoCorners, charucoIds, board, cameraMatrix, distCoeffs, rvec, tvec);
                    // if charuco pose is valid
                    if (valid)
                        cv::aruco::drawAxis(imageCopy, cameraMatrix, distCoeffs, rvec, tvec, 0.1f);
                }
            }
            cv::imshow("out", imageCopy);
            char key = (char)cv::waitKey(30);
            if (key == 27)
                break;
        }
    }
}

完整的工作示例包含在modules/aruco/samples/detect_board_charuco.cpp中的detect_board_charuco.cpp中。
注意:示例现在通过OpenCV命令行解析器通过命令行获取输入。对于这个文件,示例参数如下所示

"_path_/calib.txt" -dp="_path_/detector_params.yml" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10

你可能感兴趣的:(OpenCV,opencv,计算机视觉,人工智能)