Camera Calibration（opencv官方实例）

Camera Calibration

1、stereo_calib.cpp代码：

/* This is sample from the OpenCV book. The copyright notice is below *//* *************** License:**************************   ************************************************** */#include "opencv2/calib3d/calib3d.hpp"#include "opencv2/highgui/highgui.hpp"#include "opencv2/imgproc/imgproc.hpp"#include <vector>#include <string>#include <algorithm>#include <iostream>#include <iterator>#include <stdio.h>#include <stdlib.h>#include <ctype.h>using namespace cv;using namespace std;static int print_help(){    cout <<            " Given a list of chessboard images, the number of corners (nx, ny)\n"            " on the chessboards, and a flag: useCalibrated for \n"            "   calibrated (0) or\n"            "   uncalibrated \n"            "     (1: use cvStereoCalibrate(), 2: compute fundamental\n"            "         matrix separately) stereo. \n"            " Calibrate the cameras and display the\n"            " rectified results along with the computed disparity images.   \n" << endl;    cout << "Usage:\n ./stereo_calib -w board_width -h board_height [-nr /*dot not view results*/] <image list XML/YML file>\n" << endl;    return 0;}static void StereoCalib(const vector<string>& imagelist, Size boardSize, bool useCalibrated=true, bool showRectified=true){    if( imagelist.size() % 2 != 0 )    {        cout << "Error: the image list contains odd (non-even) number of elements\n";        return;    }    bool displayCorners = false;//true;    const int maxScale = 2;    const float squareSize = 1.f;  // Set this to your actual square size    // ARRAY AND VECTOR STORAGE:    vector<vector<Point2f> > imagePoints[2];    vector<vector<Point3f> > objectPoints;    Size imageSize;    int i, j, k, nimages = (int)imagelist.size()/2;    imagePoints[0].resize(nimages);    imagePoints[1].resize(nimages);    vector<string> goodImageList;    for( i = j = 0; i < nimages; i++ )    {        for( k = 0; k < 2; k++ )        {            const string& filename = imagelist[i*2+k];            Mat img = imread(filename, 0);            if(img.empty())                break;            if( imageSize == Size() )                imageSize = img.size();            else if( img.size() != imageSize )            {                cout << "The image " << filename << " has the size different from the first image size. Skipping the pair\n";                break;            }            bool found = false;            vector<Point2f>& corners = imagePoints[k][j];            for( int scale = 1; scale <= maxScale; scale++ )            {                Mat timg;                if( scale == 1 )                    timg = img;                else                    resize(img, timg, Size(), scale, scale);                found = findChessboardCorners(timg, boardSize, corners,                    CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE);                if( found )                {                    if( scale > 1 )                    {                        Mat cornersMat(corners);                        cornersMat *= 1./scale;                    }                    break;                }            }            if( displayCorners )            {                cout << filename << endl;                Mat cimg, cimg1;                cvtColor(img, cimg, COLOR_GRAY2BGR);                drawChessboardCorners(cimg, boardSize, corners, found);                double sf = 640./MAX(img.rows, img.cols);                resize(cimg, cimg1, Size(), sf, sf);                imshow("corners", cimg1);                char c = (char)waitKey(500);                if( c == 27 || c == 'q' || c == 'Q' ) //Allow ESC to quit                    exit(-1);            }            else                putchar('.');            if( !found )                break;            cornerSubPix(img, corners, Size(11,11), Size(-1,-1),                         TermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30, 0.01));        }        if( k == 2 )        {            goodImageList.push_back(imagelist[i*2]);            goodImageList.push_back(imagelist[i*2+1]);            j++;        }    }    cout << j << " pairs have been successfully detected.\n";    nimages = j;    if( nimages < 2 )    {        cout << "Error: too little pairs to run the calibration\n";        return;    }    imagePoints[0].resize(nimages);    imagePoints[1].resize(nimages);    objectPoints.resize(nimages);    for( i = 0; i < nimages; i++ )    {        for( j = 0; j < boardSize.height; j++ )            for( k = 0; k < boardSize.width; k++ )                objectPoints[i].push_back(Point3f(j*squareSize, k*squareSize, 0));    }    cout << "Running stereo calibration ...\n";    Mat cameraMatrix[2], distCoeffs[2];    cameraMatrix[0] = Mat::eye(3, 3, CV_64F);    cameraMatrix[1] = Mat::eye(3, 3, CV_64F);    Mat R, T, E, F;    double rms = stereoCalibrate(objectPoints, imagePoints[0], imagePoints[1],                    cameraMatrix[0], distCoeffs[0],                    cameraMatrix[1], distCoeffs[1],                    imageSize, R, T, E, F,                    TermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 100, 1e-5),                    CV_CALIB_FIX_ASPECT_RATIO +                    CV_CALIB_ZERO_TANGENT_DIST +                    CV_CALIB_SAME_FOCAL_LENGTH +                    CV_CALIB_RATIONAL_MODEL +                    CV_CALIB_FIX_K3 + CV_CALIB_FIX_K4 + CV_CALIB_FIX_K5);    cout << "done with RMS error=" << rms << endl;// CALIBRATION QUALITY CHECK// because the output fundamental matrix implicitly// includes all the output information,// we can check the quality of calibration using the// epipolar geometry constraint: m2^t*F*m1=0    double err = 0;    int npoints = 0;    vector<Vec3f> lines[2];    for( i = 0; i < nimages; i++ )    {        int npt = (int)imagePoints[0][i].size();        Mat imgpt[2];        for( k = 0; k < 2; k++ )        {            imgpt[k] = Mat(imagePoints[k][i]);            undistortPoints(imgpt[k], imgpt[k], cameraMatrix[k], distCoeffs[k], Mat(), cameraMatrix[k]);            computeCorrespondEpilines(imgpt[k], k+1, F, lines[k]);        }        for( j = 0; j < npt; j++ )        {            double errij = fabs(imagePoints[0][i][j].x*lines[1][j][0] +                                imagePoints[0][i][j].y*lines[1][j][1] + lines[1][j][2]) +                           fabs(imagePoints[1][i][j].x*lines[0][j][0] +                                imagePoints[1][i][j].y*lines[0][j][1] + lines[0][j][2]);            err += errij;        }        npoints += npt;    }    cout << "average reprojection err = " <<  err/npoints << endl;    // save intrinsic parameters    FileStorage fs("intrinsics.yml", CV_STORAGE_WRITE);    if( fs.isOpened() )    {        fs << "M1" << cameraMatrix[0] << "D1" << distCoeffs[0] <<            "M2" << cameraMatrix[1] << "D2" << distCoeffs[1];        fs.release();    }    else        cout << "Error: can not save the intrinsic parameters\n";    Mat R1, R2, P1, P2, Q;    Rect validRoi[2];    stereoRectify(cameraMatrix[0], distCoeffs[0],                  cameraMatrix[1], distCoeffs[1],                  imageSize, R, T, R1, R2, P1, P2, Q,                  CALIB_ZERO_DISPARITY, 1, imageSize, &validRoi[0], &validRoi[1]);    fs.open("extrinsics.yml", CV_STORAGE_WRITE);    if( fs.isOpened() )    {        fs << "R" << R << "T" << T << "R1" << R1 << "R2" << R2 << "P1" << P1 << "P2" << P2 << "Q" << Q;        fs.release();    }    else        cout << "Error: can not save the intrinsic parameters\n";    // OpenCV can handle left-right    // or up-down camera arrangements    bool isVerticalStereo = fabs(P2.at<double>(1, 3)) > fabs(P2.at<double>(0, 3));// COMPUTE AND DISPLAY RECTIFICATION    if( !showRectified )        return;    Mat rmap[2][2];// IF BY CALIBRATED (BOUGUET'S METHOD)    if( useCalibrated )    {        // we already computed everything    }// OR ELSE HARTLEY'S METHOD    else // use intrinsic parameters of each camera, but // compute the rectification transformation directly // from the fundamental matrix    {        vector<Point2f> allimgpt[2];        for( k = 0; k < 2; k++ )        {            for( i = 0; i < nimages; i++ )                std::copy(imagePoints[k][i].begin(), imagePoints[k][i].end(), back_inserter(allimgpt[k]));        }        F = findFundamentalMat(Mat(allimgpt[0]), Mat(allimgpt[1]), FM_8POINT, 0, 0);        Mat H1, H2;        stereoRectifyUncalibrated(Mat(allimgpt[0]), Mat(allimgpt[1]), F, imageSize, H1, H2, 3);        R1 = cameraMatrix[0].inv()*H1*cameraMatrix[0];        R2 = cameraMatrix[1].inv()*H2*cameraMatrix[1];        P1 = cameraMatrix[0];        P2 = cameraMatrix[1];    }    //Precompute maps for cv::remap()    initUndistortRectifyMap(cameraMatrix[0], distCoeffs[0], R1, P1, imageSize, CV_16SC2, rmap[0][0], rmap[0][1]);    initUndistortRectifyMap(cameraMatrix[1], distCoeffs[1], R2, P2, imageSize, CV_16SC2, rmap[1][0], rmap[1][1]);    Mat canvas;    double sf;    int w, h;    if( !isVerticalStereo )    {        sf = 600./MAX(imageSize.width, imageSize.height);        w = cvRound(imageSize.width*sf);        h = cvRound(imageSize.height*sf);        canvas.create(h, w*2, CV_8UC3);    }    else    {        sf = 300./MAX(imageSize.width, imageSize.height);        w = cvRound(imageSize.width*sf);        h = cvRound(imageSize.height*sf);        canvas.create(h*2, w, CV_8UC3);    }    for( i = 0; i < nimages; i++ )    {        for( k = 0; k < 2; k++ )        {            Mat img = imread(goodImageList[i*2+k], 0), rimg, cimg;            remap(img, rimg, rmap[k][0], rmap[k][1], CV_INTER_LINEAR);            cvtColor(rimg, cimg, COLOR_GRAY2BGR);            Mat canvasPart = !isVerticalStereo ? canvas(Rect(w*k, 0, w, h)) : canvas(Rect(0, h*k, w, h));            resize(cimg, canvasPart, canvasPart.size(), 0, 0, CV_INTER_AREA);            if( useCalibrated )            {                Rect vroi(cvRound(validRoi[k].x*sf), cvRound(validRoi[k].y*sf),                          cvRound(validRoi[k].width*sf), cvRound(validRoi[k].height*sf));                rectangle(canvasPart, vroi, Scalar(0,0,255), 3, 8);            }        }        if( !isVerticalStereo )            for( j = 0; j < canvas.rows; j += 16 )                line(canvas, Point(0, j), Point(canvas.cols, j), Scalar(0, 255, 0), 1, 8);        else            for( j = 0; j < canvas.cols; j += 16 )                line(canvas, Point(j, 0), Point(j, canvas.rows), Scalar(0, 255, 0), 1, 8);        imshow("rectified", canvas);        char c = (char)waitKey();        if( c == 27 || c == 'q' || c == 'Q' )            break;    }}static bool readStringList( const string& filename, vector<string>& l ){    l.resize(0);    FileStorage fs(filename, FileStorage::READ);    if( !fs.isOpened() )        return false;    FileNode n = fs.getFirstTopLevelNode();    if( n.type() != FileNode::SEQ )        return false;    FileNodeIterator it = n.begin(), it_end = n.end();    for( ; it != it_end; ++it )        l.push_back((string)*it);    return true;}int main(int argc, char** argv){    Size boardSize;    string imagelistfn;    bool showRectified = true;   /* for( int i = 1; i < argc; i++ )    {        if( string(argv[i]) == "-w" )        {            if( sscanf(argv[++i], "%d", &boardSize.width) != 1 || boardSize.width <= 0 )            {                cout << "invalid board width" << endl;                return print_help();            }        }        else if( string(argv[i]) == "-h" )        {            if( sscanf(argv[++i], "%d", &boardSize.height) != 1 || boardSize.height <= 0 )            {                cout << "invalid board height" << endl;                return print_help();            }        }        else if( string(argv[i]) == "-nr" )            showRectified = false;        else if( string(argv[i]) == "--help" )            return print_help();        else if( argv[i][0] == '-' )        {            cout << "invalid option " << argv[i] << endl;            return 0;        }        else            imagelistfn = argv[i];    }*/    if( imagelistfn == "" )    {        imagelistfn = "stereo_calib.xml";//图片列表文件        boardSize = Size(9, 6);    }    else if( boardSize.width <= 0 || boardSize.height <= 0 )    {        cout << "if you specified XML file with chessboards, you should also specify the board width and height (-w and -h options)" << endl;        return 0;    }    vector<string> imagelist;    bool ok = readStringList(imagelistfn, imagelist);    if(!ok || imagelist.empty())    {        cout << "can not open " << imagelistfn << " or the string list is empty" << endl;        return print_help();    }    StereoCalib(imagelist, boardSize, true, showRectified);    return 0;}

2、实验结果

（1）原图像

（2）效果图

3、函数介绍

（1）findChessboardCorners

查找棋盘格内角点位置

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

参数：image：输入的棋盘图，必须是8位的灰度或者彩色图像。
pattern_size：棋盘图中每行和每列角点的个数。
corners：检测到的角点
flags：各种操作标志，可以是0或者下面值的组合：

• CV_CALIB_CB_ADAPTIVE_THRESH - 使用自适应阈值（通过平均图像亮度计算得到）将图像转换为黑白图，而不是一个固定的阈值。
• CV_CALIB_CB_NORMALIZE_IMAGE - 在利用固定阈值或者自适应的阈值进行二值化之前，先使用cvNormalizeHist来均衡化图像亮度。
• CV_CALIB_CB_FILTER_QUADS - 使用其他的准则（如轮廓面积，周长，方形形状）来去除在轮廓检测阶段检测到的错误方块。

Sample usage of detecting and drawing chessboard corners:

Size patternsize(8,6); //interior number of cornersMat gray = ....; //source imagevector<Point2f> corners; //this will be filled by the detected corners//CALIB_CB_FAST_CHECK saves a lot of time on images//that do not contain any chessboard cornersbool patternfound = findChessboardCorners(gray, patternsize, corners,        CALIB_CB_ADAPTIVE_THRESH + CALIB_CB_NORMALIZE_IMAGE        + CALIB_CB_FAST_CHECK);if(patternfound)  cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),    TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));drawChessboardCorners(img, patternsize, Mat(corners), patternfound);

（2）drawChessboardCorners

呈现发现棋盘格角点。

C++: void drawChessboardCorners(InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound)

参数：

• image：输入的单幅图像，必须为8-bit的灰度图像。

• patternSize ：棋盘格每行每列的交点个数
  
• corners：角点的坐标，findChessboardCorners（）的输出。
  
• patternWasFound：角点是否全部找到的标志，findChessboardCorners()的返回值应给传给它。
  

（3）cornerSubPix

精确角点的位置。

C++: void cornerSubPix(InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria)

参数：

• image：输入图像。

• corners：初始输入角点的坐标和精确坐标用于输出。

• winSize：搜索窗口的长度的一半。如果：winSize=Size(5,5)，那么大小为5*2+1X5*2+1=11X11的搜索窗被用。
• zeroZone：搜索禁区，有时用于避免可能的自相关矩阵的奇异性。
• criteria：终止条件，达到criteria.maxCount将停止或者corner position moves by less than criteria.epsilon on some iteration.

示例1.

代码：

#include <opencv2/opencv.hpp>#include <iostream>using namespace std;using namespace cv;int main(){Size patternsize(8,6); //interior number of cornersMat gray = imread("D:\\opencv\\sources\\samples\\cpp\\right01.jpg",0); //source imageimshow("Source",gray);vector<Point2f> corners; //this will be filled by the detected corners//CALIB_CB_FAST_CHECK saves a lot of time on images//that do not contain any chessboard cornersbool patternfound = findChessboardCorners(gray, patternsize, corners,CALIB_CB_ADAPTIVE_THRESH|CALIB_CB_NORMALIZE_IMAGE);if(patternfound)cornerSubPix(gray, corners, Size(11, 11), Size(-1, -1),TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));drawChessboardCorners(gray, patternsize, Mat(corners), patternfound);imshow("dst",gray);waitKey(0);return 0;}

效果：

（4）stereoCalibrate

校定立体相机。

C++: double stereoCalibrate(InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, 

InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, 

Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, 

TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC )

（5）undistortPoints

从观察到的点坐标计算理想的点坐标。

C++: void undistortPoints(InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, 

InputArray R=noArray(), InputArray P=noArray())

参数：

• src：观测的点坐标, 1xN或者Nx1 2-channel (CV_32FC2 or CV_64FC2).
• dst：输出理想点坐标. 如果矩阵P 是 identity或者省略, dst将包含归一化点坐标.
• cameraMatrix：相机矩阵。

.

• distCoeffs ：输入畸变系数向量 of 4, 5, or 8 elements.如果向量是 NULL/empty, 零畸变系数b被假定。
• R ： 在对象空间的矫正转换(3x3 矩阵). R1或者R2 由stereoRectify()计算可以传递到这.如果矩阵是空的，使用的恒等变换.
• P – 新的相机矩阵(3x3)或者新的投影矩阵 (3x4). P1 或者 P2 由stereoRectify()就算 can be passed here. 如果矩阵为空, the identity new camera matrix is used.

（6）computeCorrespondEpilines

为一幅图像中的点计算其在另一幅图像中对应的对极线。

C++: void computeCorrespondEpilines(InputArray points, int whichImage, InputArray F, OutputArray lines)

参数:

• points ：输入点，是2xN 或者 3xN 数组 (N为点的个数)
• whichImage ： 包含点的图像指数(1 or 2).
• F：基本矩阵可以被评估，用 findFundamentalMat() or stereoRectify() .
• lines –输出在其他图像对应点极线向量 。每条线 ax + by + c=0 .

（7）stereoRectify

Computes rectification transforms for each head of a calibrated stereo camera.

C++: void stereoRectify(InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, 

InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, 

OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, 

double alpha=-1, Size newImageSize=Size(), Rect* validPixROI1=0, Rect* validPixROI2=0 )

（8）findFundamentalMat

由两幅图像中对应点计算出基本矩阵

C++: Mat findFundamentalMat(InputArray points1, InputArray points2, int method=FM_RANSAC, 

double param1=3., double param2=0.99, OutputArray mask=noArray() )

（9）stereoRectifyUncalibrated

Computes a rectification transform for an uncalibrated stereo camera.

C++: bool stereoRectifyUncalibrated(InputArray points1, InputArray points2, InputArray F, Size imgSize,

 OutputArray H1, OutputArray H2, double threshold=5 )

（10）initUndistortRectifyMap

Computes the undistortion and rectification transformation map.

C++: void initUndistortRectifyMap(InputArray cameraMatrix, InputArray distCoeffs, InputArray R, 

InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2)