OpenCV相機標定的全過程記錄

2022-03-09 13:00:35

一、OpenCV標定的幾個常用函數

findChessboardCorners() 棋盤格角點檢測

bool findChessboardCorners( InputArray image, 
                                Size patternSize, 
                                OutputArray corners,
                                int flags = CALIB_CB_ADAPTIVE_THRESH + 
                                CALIB_CB_NORMALIZE_IMAGE );

第一個引數是輸入的棋盤格影象（可以是8位元單通道或三通道影象）；

第二個引數是棋盤格內部的角點的行列數（注意：不是棋盤格的行列數，如棋盤格的行列數分別為4、8，而內部角點的行列數分別是3、7，因此這裡應該指定為cv::Size(3, 7)）；

第三個引數是檢測到的棋盤格角點，型別為std::vectorcv::Point2f。

第四個引數flag，用於指定在檢測棋盤格角點的過程中所應用的一種或多種過濾方法，可以使用下面的一種或多種，如果都是用則使用OR：

cv::CALIB_CB_ADAPTIVE_THRESH：使用自適應閾值將影象轉化成二值影象
cv::CALIB_CB_NORMALIZE_IMAGE：歸一化影象灰度係數(用直方圖均衡化或者自適應閾值)
cv::CALIB_CB_FILTER_QUADS：在輪廓提取階段，使用附加條件排除錯誤的假設
cv::CALIB_CV_FAST_CHECK：快速檢測

cv::drawChessboardCorners() 棋盤格角點的繪製

drawChessboardCorners( InputOutputArray image, 
                           Size patternSize,
                           InputArray corners, 
                           bool patternWasFound );

image為8-bit，三通道影象
patternSize，每一行每一列的角
corners，已經檢測到的角
patternWasFound，findChessboardCorners的返回值

find4QuadCornerSubpix() 對粗提取的角點進行精確化

find4QuadCornerSubpix( InputArray img, 
                           InputOutputArray corners, 
                           Size region_size );

image源影象
corners，提供角點的初始座標
region_size：搜尋視窗的一般尺寸

cornerSubPix() 亞畫素檢測

void cornerSubPix( InputArray image, 
                       InputOutputArray corners,
                       Size winSize, 
                       Size zeroZone,
                       TermCriteria criteria );

image源影象
corners，提供角點的初始座標，返回更加精確的點
winSize，搜尋視窗的一般尺寸，如果winSize=Size(5,5),則search windows為11*11
winSize,死區的一般尺寸，用來避免自相關矩陣的奇點，(-1,-1)表示沒有死區
criteria，控制迭代次數和精度

calibrateCamera() 求解攝像機的內在引數和外在引數

double calibrateCamera( InputArrayOfArrays objectPoints,
                            InputArrayOfArrays imagePoints,
                            Size imageSize,
                            InputOutputArray cameraMatrix, 
                            InputOutputArray distCoeffs,
                            OutputArrayOfArrays rvecs, OutputArrayOfArrays tvecs,
                            int flags = 0, 
                            TermCriteria criteria = TermCriteria(TermCriteria::COUNT + 
                            TermCriteria::EPS, 30, DBL_EPSILON) );

objectPoints，世界座標，用vector<vector>，輸入x,y座標，z座標為0

imagePoints，影象座標，vector<vector>

imageSize，影象的大小用於初始化標定攝像機的image的size

cameraMatrix，內引數矩陣

distCoeffs，畸變矩陣

rvecs，位移向量

tvecs，旋轉向量

flags，可以組合：

CV_CALIB_USE_INTRINSIC_GUESS：使用該引數時，將包含有效的fx,fy,cx,cy的估計值的內參矩陣cameraMatrix，作為初始值輸入，然後函數對其做進一步優化。如果不使用這個引數，用影象的中心點初始化光軸點座標(cx, cy)，使用最小二乘估算出fx，fy（這種求法好像和張正友的論文不一樣，不知道為何要這樣處理）。注意，如果已知內部引數（內參矩陣和畸變係數），就不需要使用這個函數來估計外參，可以使用solvepnp()函數計算外引數矩陣。

CV_CALIB_FIX_PRINCIPAL_POINT：在進行優化時會固定光軸點，光軸點將保持為影象的中心點。當CV_CALIB_USE_INTRINSIC_GUESS引數被設定，保持為輸入的值。

CV_CALIB_FIX_ASPECT_RATIO：固定fx/fy的比值，只將fy作為可變數，進行優化計算。當
CV_CALIB_USE_INTRINSIC_GUESS沒有被設定，fx和fy的實際輸入值將會被忽略，只有fx/fy的比值被計算和使用。

CV_CALIB_ZERO_TANGENT_DIST：切向畸變係數（P1，P2）被設定為零並保持為零。

CV_CALIB_FIX_K1,…,CV_CALIB_FIX_K6：對應的徑向畸變係數在優化中保持不變。如果設定了CV_CALIB_USE_INTRINSIC_GUESS引數，就從提供的畸變係數矩陣中得到。否則，設定為0。

CV_CALIB_RATIONAL_MODEL（理想模型）：啟用畸變k4，k5，k6三個畸變引數。使標定函數使用有理模型，返回8個係數。如果沒有設定，則只計算其它5個畸變引數。

CALIB_THIN_PRISM_MODEL （薄稜鏡畸變模型）：啟用畸變係數S1、S2、S3和S4。使標定函數使用薄稜柱模型並返回12個係數。如果不設定標誌，則函數計算並返回只有5個失真係數。

CALIB_FIX_S1_S2_S3_S4 ：優化過程中不改變薄稜鏡畸變係數S1、S2、S3、S4。如果cv_calib_use_intrinsic_guess設定，使用提供的畸變係數矩陣中的值。否則，設定為0。

CALIB_TILTED_MODEL （傾斜模型）：啟用畸變係數tauX and tauY。標定函數使用傾斜感測器模型並返回14個係數。如果不設定標誌，則函數計算並返回只有5個失真係數。

CALIB_FIX_TAUX_TAUY ：在優化過程中，傾斜感測器模型的係數不被改變。如果cv_calib_use_intrinsic_guess設定，從提供的畸變係數矩陣中得到。否則，設定為0。

initUndistortRectifyMap() 計算畸變引數

void initUndistortRectifyMap(InputArray cameraMatrix, 
                                InputArray distCoeffs, 
                                InputArray R, 
                                InputArray newCameraMatrix, 
                                Size size, 
                                int m1type, 
                                OutputArray map1, 
                                OutputArray map2)

cameraMatrix，攝像機內引數矩陣
distCoeffs，攝像機的5個畸變係數，(k1,k2,p1,p2[,k3[,k4,k5,k6]])
R，在客觀空間中的轉換物件
newCameraMatrix，新的3*3的浮點型矩矩陣
size，為失真影象的大小
m1type，第一個輸出的map，型別為CV_32FC1或CV_16SC2
map1，x對映函數
map2，y對映函數

二、繪製棋盤格，拍攝照片

這裡自己畫一個棋盤格用作標定，長度為1280畫素，寬490畫素，橫向10方格，縱向7方格

std_cb = Vision::makeCheckerboard(1280, 490, 10, 7, 0, 
(char *)"../blizzard/res/calibration/std_cb.png");

效果如圖

Vision是我個人建立的視覺類，可以用來繪製標準的棋盤格。

標頭檔案vision.h

//
// Created by czh on 18-10-16.
//
#ifndef OPENGL_PRO_VISION_H
#define OPENGL_PRO_VISION_H

#include "opencv2/opencv.hpp"
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgcodecs/imgcodecs.hpp>

#include "iostream"

class Vision {
public:
    static cv::Mat read(std::string file_path, int flags = cv::IMREAD_ANYCOLOR | cv::IMREAD_ANYDEPTH);

    static cv::Mat write(std::string file_path, int flags = cv::IMREAD_ANYCOLOR | cv::IMREAD_ANYDEPTH);

    static void dispConfig(cv::Mat img);

    static cv::Mat makeCheckerboard(int bkgWidth, int bkgHeight, int sqXnum, int sqYnum = 0, int borderThickness = 0, char *savePath = NULL);
private:

};
#endif //OPENGL_PRO_VISION_H

原始檔vision.cpp

//
// Created by czh on 18-10-16.
//

#include "vision.h"
#include "string.h"

using namespace std;
using namespace cv;

const char *findName(const char *ch) {
    const char *name = strrchr(ch, '/');
    return ++name;
}

cv::Mat Vision::read(std::string file_path, int flags) {
    printf("#Vision readn");
    cv::Mat img;
    img = cv::imread(file_path, flags);
    if (img.data == NULL) {
        printf("tError:vision readn");
    } else {
        dispConfig(img);
    }
    return img;
}

void Vision::dispConfig(cv::Mat img) {
    printf("tpixel:%d*%d, channels:%dn", img.size().width, img.size().height, img.channels());
}

cv::Mat Vision::makeCheckerboard(int bkgWidth, int bkgHeight, int sqXnum, int sqYnum, int thickNum, char *savePath) {
    if(sqYnum == 0){
        sqYnum = sqXnum;
    }
    if(savePath == NULL){
        char *defaultPath = (char *)"../res/calibration/maths.png";
        savePath = defaultPath;
    }
    int checkboardX = 0;//棋盤x座標
    int checkboardY = 0;//棋盤y座標
    int xLen = bkgWidth / sqXnum;//x方格長度
    int yLen = bkgHeight / sqYnum;//y方格長度
    cv::Mat img(bkgHeight + thickNum * 2, bkgWidth + thickNum * 2, CV_8UC4, cv::Scalar(0, 255, 255, 255));
    for (int i = 0; i < img.rows; i++) {

        for (int j = 0; j < img.cols; j++) {

            if (i < thickNum || i >= thickNum + bkgHeight || j < thickNum || j >= thickNum + bkgWidth) {
                img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(0, 0, 0, 255);
                continue;
            }
            checkboardX = j - thickNum;
            checkboardY = i - thickNum;
            if (checkboardY / yLen % 2 == 0) {
                if ((checkboardX) / xLen % 2 == 0) {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(255, 255, 255, 255);
                } else {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(0, 0, 0, 255);
                }
            }
            else{
                if ((checkboardX) / xLen % 2 != 0) {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(255, 255, 255, 255);
                } else {
                    img.at<Vec<uchar, 4>>(i, j) = cv::Scalar(0, 0, 0, 255);
                }
            }
        }
    }
    imwrite(savePath, img);    //儲存生成的圖片
    printf("#makeCheckerboard %d*%dn", bkgWidth + thickNum, bkgHeight + thickNum);
    return img;
}

用A4紙列印棋盤格，相機拍攝照片。

我偷懶，拿了別人的標定照片

三、相機標定

下面是相機標定程式碼

cv::imwrite("../blizzard/res/calibration/cb_source.png", cb_source);

    printf("#Start scan cornern");
    cv::Mat img;
    std::vector<cv::Point2f> image_points;
    std::vector<std::vector<cv::Point2f>> image_points_seq; /* 儲存檢測到的所有角點 */
    if (cv::findChessboardCorners(cb_source, cv::Size(aqXnum, aqYnum), image_points, 0) == 0) {
        printf("#Error: Corners not find ");
        return 0;
    } else {
        cvtColor(cb_source, img, CV_RGBA2GRAY);
        cv::imwrite("../blizzard/res/calibration/cb_gray.png", img);
        //find4QuadCornerSubpix(img, image_points, cv::Size(5, 5));

        cv::cornerSubPix(img, image_points, cv::Size(11, 11), cv::Size(-1, -1),
                         cv::TermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 30, 0.01));

        image_points_seq.push_back(image_points);

        cv::Mat cb_corner;
        cb_corner = cb_source.clone();
        drawChessboardCorners(cb_corner, cv::Size(aqXnum, aqYnum), image_points, true);
        cv::imwrite("../blizzard/res/calibration/cb_corner.png", cb_corner);
    }

    printf("#Start calibraten");
    cv::Size square_size = cv::Size(14.2222, 12);
    std::vector<std::vector<cv::Point3f>> object_points; /* 儲存標定板上角點的三維座標 */
    cv::Mat cameraMatrix = cv::Mat(3, 3, CV_32FC1, cv::Scalar::all(0)); /* 攝像機內引數矩陣 */
    cv::Mat distCoeffs = cv::Mat(1, 5, CV_32FC1, cv::Scalar::all(0)); /* 攝像機的5個畸變係數：k1,k2,p1,p2,k3 */
    std::vector<cv::Mat> tvecsMat;  /* 每幅影象的旋轉向量 */
    std::vector<cv::Mat> rvecsMat;  /* 每幅影象的平移向量 */

    std::vector<cv::Point3f> realPoint;
    for (int i = 0; i < aqYnum; i++) {
        for (int j = 0; j < aqXnum; j++) {
            cv::Point3f tempPoint;
            /* 假設標定板放在世界座標系中z=0的平面上 */
            tempPoint.x = i * square_size.width;
            tempPoint.y = j * square_size.height;
            tempPoint.z = 0;
            realPoint.push_back(tempPoint);
        }
    }
    object_points.push_back(realPoint);

    printf("#objectPoints： %ldn", sizeof(object_points[0]));
    std::cout << object_points[0] << std::endl;

    printf("#image_points： %ldn", sizeof(image_points_seq[0]));
    std::cout << image_points << std::endl;

    printf("#image sizen");
    std::cout << SCREEN_WIDTH << "*" << SCREEN_HEIGHT << std::endl;

    cv::calibrateCamera(object_points, image_points_seq, cb_source.size(), cameraMatrix, distCoeffs, rvecsMat, tvecsMat,
                        CV_CALIB_FIX_K3);

    std::cout << "tvecsMat:n" << tvecsMat[0] << std::endl;
    std::cout << "rvecsMat:n" << rvecsMat[0] << std::endl;

    std::cout << "#cameraMatrix:n" << cameraMatrix << std::endl;
    std::cout << "#distCoeffs:n" << distCoeffs << std::endl;

四、對圖片進行校正

	cv::Mat cb_final;

    cv::Mat mapx = cv::Mat(cb_source.size(), CV_32FC1);
    cv::Mat mapy = cv::Mat(cb_source.size(), CV_32FC1);
    cv::Mat R = cv::Mat::eye(3, 3, CV_32F);
    //initUndistortRectifyMap(cameraMatrix, distCoeffs, R, cv::Mat(), cb_source.size(), CV_32FC1,
    //                        mapx, mapy);
    //cv::remap(cb_source, cb_final, mapx, mapy, cv::INTER_LINEAR);

    undistort(cb_source, cb_final, cameraMatrix, distCoeffs);
    
    cv::imwrite("../blizzard/res/calibration/cb_final.png", cb_final);

1.校正前的圖片