相机标定 matlab opencv ROS三种方法标定步骤（2）

二  ubuntu下Opencv的相机标定

一般直接用Opencv的源码就可以进行相机的标定，但是可能只是会实现结果，却不懂实现的过程，我也是模模糊糊的看了《计算机视觉中的多视图几何》以及实现一些经典的算法，对Opencv有一些了解才开始做相机的标定，可以先看看源码：

#include <iostream>
#include <sstream>
#include <time.h>
#include <stdio.h>

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/highgui/highgui.hpp>

#ifndef _CRT_SECURE_NO_WARNINGS
# define _CRT_SECURE_NO_WARNINGS
#endif

using namespace cv;
using namespace std;

static void help()
{
    cout <<  "This is a camera calibration sample." << endl
         <<  "Usage: calibration configurationFile"  << endl
         <<  "Near the sample file you'll find the configuration file, which has detailed help of "
             "how to edit it.  It may be any OpenCV supported file format XML/YAML." << endl;
}
class Settings
{
public:
    Settings() : goodInput(false) {}
    enum Pattern { NOT_EXISTING, CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
    enum InputType {INVALID, CAMERA, VIDEO_FILE, IMAGE_LIST};

    void write(FileStorage& fs) const                        //Write serialization for this class
    {
        fs << "{" << "BoardSize_Width"  << boardSize.width
                  << "BoardSize_Height" << boardSize.height
                  << "Square_Size"         << squareSize
                  << "Calibrate_Pattern" << patternToUse
                  << "Calibrate_NrOfFrameToUse" << nrFrames
                  << "Calibrate_FixAspectRatio" << aspectRatio
                  << "Calibrate_AssumeZeroTangentialDistortion" << calibZeroTangentDist
                  << "Calibrate_FixPrincipalPointAtTheCenter" << calibFixPrincipalPoint

                  << "Write_DetectedFeaturePoints" << bwritePoints
                  << "Write_extrinsicParameters"   << bwriteExtrinsics
                  << "Write_outputFileName"  << outputFileName

                  << "Show_UndistortedImage" << showUndistorsed

                  << "Input_FlipAroundHorizontalAxis" << flipVertical
                  << "Input_Delay" << delay
                  << "Input" << input
           << "}";
    }
    void read(const FileNode& node)                          //Read serialization for this class
    {
        node["BoardSize_Width" ] >> boardSize.width;
        node["BoardSize_Height"] >> boardSize.height;
        node["Calibrate_Pattern"] >> patternToUse;
        node["Square_Size"]  >> squareSize;
        node["Calibrate_NrOfFrameToUse"] >> nrFrames;
        node["Calibrate_FixAspectRatio"] >> aspectRatio;
        node["Write_DetectedFeaturePoints"] >> bwritePoints;
        node["Write_extrinsicParameters"] >> bwriteExtrinsics;
        node["Write_outputFileName"] >> outputFileName;
        node["Calibrate_AssumeZeroTangentialDistortion"] >> calibZeroTangentDist;
        node["Calibrate_FixPrincipalPointAtTheCenter"] >> calibFixPrincipalPoint;
        node["Input_FlipAroundHorizontalAxis"] >> flipVertical;
        node["Show_UndistortedImage"] >> showUndistorsed;
        node["Input"] >> input;
        node["Input_Delay"] >> delay;
        interprate();
    }
    void interprate()
    {
        goodInput = true;
        if (boardSize.width <=  || boardSize.height <= )
        {
            cerr << "Invalid Board size: " << boardSize.width << " " << boardSize.height << endl;
            goodInput = false;
        }
        if (squareSize <= 10e-)
        {
            cerr << "Invalid square size " << squareSize << endl;
            goodInput = false;
        }
        if (nrFrames <= )
        {
            cerr << "Invalid number of frames " << nrFrames << endl;
            goodInput = false;
        }

        if (input.empty())      // Check for valid input
                inputType = INVALID;
        else
        {
            if (input[] >= '' && input[] <= '')
            {
                stringstream ss(input);
                ss >> cameraID;
                inputType = CAMERA;
            }
            else
            {
                if (readStringList(input, imageList))
                    {
                        inputType = IMAGE_LIST;
                        nrFrames = (nrFrames < (int)imageList.size()) ? nrFrames : (int)imageList.size();
                    }
                else
                    inputType = VIDEO_FILE;
            }
            if (inputType == CAMERA)
                inputCapture.open(cameraID);
            if (inputType == VIDEO_FILE)
                inputCapture.open(input);
            if (inputType != IMAGE_LIST && !inputCapture.isOpened())
                    inputType = INVALID;
        }
        if (inputType == INVALID)
        {
            cerr << " Inexistent input: " << input;
            goodInput = false;
        }

        flag = ;
        if(calibFixPrincipalPoint) flag |= CV_CALIB_FIX_PRINCIPAL_POINT;
        if(calibZeroTangentDist)   flag |= CV_CALIB_ZERO_TANGENT_DIST;
        if(aspectRatio)            flag |= CV_CALIB_FIX_ASPECT_RATIO;

        calibrationPattern = NOT_EXISTING;
        if (!patternToUse.compare("CHESSBOARD")) calibrationPattern = CHESSBOARD;
        if (!patternToUse.compare("CIRCLES_GRID")) calibrationPattern = CIRCLES_GRID;
        if (!patternToUse.compare("ASYMMETRIC_CIRCLES_GRID")) calibrationPattern = ASYMMETRIC_CIRCLES_GRID;
        if (calibrationPattern == NOT_EXISTING)
            {
                cerr << " Inexistent camera calibration mode: " << patternToUse << endl;
                goodInput = false;
            }
        atImageList = ;

    }
    Mat nextImage()
    {
        Mat result;
        if( inputCapture.isOpened() )
        {
            Mat view0;
            inputCapture >> view0;
            view0.copyTo(result);
        }
        else if( atImageList < (int)imageList.size() )
            result = imread(imageList[atImageList++], CV_LOAD_IMAGE_COLOR);

        return result;
    }

    static bool readStringList( const string& filename, vector<string>& l )
    {
        l.clear();
        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;
    }
public:
    Size boardSize;            // The size of the board -> Number of items by width and height
    Pattern calibrationPattern;// One of the Chessboard, circles, or asymmetric circle pattern
    float squareSize;          // The size of a square in your defined unit (point, millimeter,etc).
    int nrFrames;              // The number of frames to use from the input for calibration
    float aspectRatio;         // The aspect ratio
    int delay;                 // In case of a video input
    bool bwritePoints;         //  Write detected feature points
    bool bwriteExtrinsics;     // Write extrinsic parameters
    bool calibZeroTangentDist; // Assume zero tangential distortion
    bool calibFixPrincipalPoint;// Fix the principal point at the center
    bool flipVertical;          // Flip the captured images around the horizontal axis
    string outputFileName;      // The name of the file where to write
    bool showUndistorsed;       // Show undistorted images after calibration
    string input;               // The input ->

    int cameraID;
    vector<string> imageList;
    int atImageList;
    VideoCapture inputCapture;
    InputType inputType;
    bool goodInput;
    int flag;

private:
    string patternToUse;

};

static void read(const FileNode& node, Settings& x, const Settings& default_value = Settings())
{
    if(node.empty())
        x = default_value;
    else
        x.read(node);
}

enum { DETECTION = , CAPTURING = , CALIBRATED =  };

bool runCalibrationAndSave(Settings& s, Size imageSize, Mat&  cameraMatrix, Mat& distCoeffs,
                           vector<vector<Point2f> > imagePoints );

int main(int argc, char* argv[])
{
    help();
    Settings s;
    const string inputSettingsFile = argc >  ? argv[] : "default.xml";
    FileStorage fs(inputSettingsFile, FileStorage::READ); // Read the settings
    if (!fs.isOpened())
    {
        cout << "Could not open the configuration file: \"" << inputSettingsFile << "\"" << endl;
        return -;
    }
    fs["Settings"] >> s;
    fs.release();                                         // close Settings file

    if (!s.goodInput)
    {
        cout << "Invalid input detected. Application stopping. " << endl;
        return -;
    }

    vector<vector<Point2f> > imagePoints;
    Mat cameraMatrix, distCoeffs;
    Size imageSize;
    int mode = s.inputType == Settings::IMAGE_LIST ? CAPTURING : DETECTION;
    clock_t prevTimestamp = ;
    const Scalar RED(,,), GREEN(,,);
    const char ESC_KEY = ;

    for(int i = ;;++i)
    {
      Mat view;
      bool blinkOutput = false;

      view = s.nextImage();

      //-----  If no more image, or got enough, then stop calibration and show result -------------
      if( mode == CAPTURING && imagePoints.size() >= (unsigned)s.nrFrames )
      {
          if( runCalibrationAndSave(s, imageSize,  cameraMatrix, distCoeffs, imagePoints))
              mode = CALIBRATED;
          else
              mode = DETECTION;
      }
      if(view.empty())          // If no more images then run calibration, save and stop loop.
      {
            if( imagePoints.size() >  )
                runCalibrationAndSave(s, imageSize,  cameraMatrix, distCoeffs, imagePoints);
            break;
      }

        imageSize = view.size();  // Format input image.
        if( s.flipVertical )    flip( view, view,  );

        vector<Point2f> pointBuf;

        bool found;
        switch( s.calibrationPattern ) // Find feature points on the input format
        {
        case Settings::CHESSBOARD:
            found = findChessboardCorners( view, s.boardSize, pointBuf,
                CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FAST_CHECK | CV_CALIB_CB_NORMALIZE_IMAGE);
            break;
        case Settings::CIRCLES_GRID:
            found = findCirclesGrid( view, s.boardSize, pointBuf );
            break;
        case Settings::ASYMMETRIC_CIRCLES_GRID:
            found = findCirclesGrid( view, s.boardSize, pointBuf, CALIB_CB_ASYMMETRIC_GRID );
            break;
        default:
            found = false;
            break;
        }

        if ( found)                // If done with success,
        {
              // improve the found corners' coordinate accuracy for chessboard
                if( s.calibrationPattern == Settings::CHESSBOARD)
                {
                    Mat viewGray;
                    cvtColor(view, viewGray, COLOR_BGR2GRAY);
                    cornerSubPix( viewGray, pointBuf, Size(,),
                        Size(-,-), TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, , 0.1 ));
                }

                if( mode == CAPTURING &&  // For camera only take new samples after delay time
                    (!s.inputCapture.isOpened() || clock() - prevTimestamp > s.delay*1e-*CLOCKS_PER_SEC) )
                {
                    imagePoints.push_back(pointBuf);
                    prevTimestamp = clock();
                    blinkOutput = s.inputCapture.isOpened();
                }

                // Draw the corners.
                drawChessboardCorners( view, s.boardSize, Mat(pointBuf), found );
        }

        //----------------------------- Output Text ------------------------------------------------
        string msg = (mode == CAPTURING) ? "100/100" :
                      mode == CALIBRATED ? "Calibrated" : "Press 'g' to start";
        int baseLine = ;
        Size textSize = getTextSize(msg, , , , &baseLine);
        Point textOrigin(view.cols - *textSize.width - , view.rows - *baseLine - );

        if( mode == CAPTURING )
        {
            if(s.showUndistorsed)
                msg = format( "%d/%d Undist", (int)imagePoints.size(), s.nrFrames );
            else
                msg = format( "%d/%d", (int)imagePoints.size(), s.nrFrames );
        }

        putText( view, msg, textOrigin, , , mode == CALIBRATED ?  GREEN : RED);

        if( blinkOutput )
            bitwise_not(view, view);

        //------------------------- Video capture  output  undistorted ------------------------------
        if( mode == CALIBRATED && s.showUndistorsed )
        {
            Mat temp = view.clone();
            undistort(temp, view, cameraMatrix, distCoeffs);
        }

        //------------------------------ Show image and check for input commands -------------------
        imshow("Image View", view);
        char key = (char)waitKey(s.inputCapture.isOpened() ?  : s.delay);

        if( key  == ESC_KEY )
            break;

        if( key == 'u' && mode == CALIBRATED )
           s.showUndistorsed = !s.showUndistorsed;

        if( s.inputCapture.isOpened() && key == 'g' )
        {
            mode = CAPTURING;
            imagePoints.clear();
        }
    }

    // -----------------------Show the undistorted image for the image list ------------------------
    if( s.inputType == Settings::IMAGE_LIST && s.showUndistorsed )
    {
        Mat view, rview, map1, map2;
        initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
            getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, , imageSize, ),
            imageSize, CV_16SC2, map1, map2);

        for(int i = ; i < (int)s.imageList.size(); i++ )
        {
            view = imread(s.imageList[i], );
            if(view.empty())
                continue;
            remap(view, rview, map1, map2, INTER_LINEAR);
            imshow("Image View", rview);
            char c = (char)waitKey();
            if( c  == ESC_KEY || c == 'q' || c == 'Q' )
                break;
        }
    }

    return ;
}

static double computeReprojectionErrors( const vector<vector<Point3f> >& objectPoints,
                                         const vector<vector<Point2f> >& imagePoints,
                                         const vector<Mat>& rvecs, const vector<Mat>& tvecs,
                                         const Mat& cameraMatrix , const Mat& distCoeffs,
                                         vector<float>& perViewErrors)
{
    vector<Point2f> imagePoints2;
    int i, totalPoints = ;
    double totalErr = , err;
    perViewErrors.resize(objectPoints.size());

    for( i = ; i < (int)objectPoints.size(); ++i )
    {
        projectPoints( Mat(objectPoints[i]), rvecs[i], tvecs[i], cameraMatrix,
                       distCoeffs, imagePoints2);
        err = norm(Mat(imagePoints[i]), Mat(imagePoints2), CV_L2);

        int n = (int)objectPoints[i].size();
        perViewErrors[i] = (float) std::sqrt(err*err/n);
        totalErr        += err*err;
        totalPoints     += n;
    }

    return std::sqrt(totalErr/totalPoints);
}

static void calcBoardCornerPositions(Size boardSize, float squareSize, vector<Point3f>& corners,
                                     Settings::Pattern patternType /*= Settings::CHESSBOARD*/)
{
    corners.clear();

    switch(patternType)
    {
    case Settings::CHESSBOARD:
    case Settings::CIRCLES_GRID:
        for( int i = ; i < boardSize.height; ++i )
            for( int j = ; j < boardSize.width; ++j )
                corners.push_back(Point3f(float( j*squareSize ), float( i*squareSize ), ));
        break;

    case Settings::ASYMMETRIC_CIRCLES_GRID:
        for( int i = ; i < boardSize.height; i++ )
            for( int j = ; j < boardSize.width; j++ )
                corners.push_back(Point3f(float((*j + i % )*squareSize), float(i*squareSize), ));
        break;
    default:
        break;
    }
}

static bool runCalibration( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
                            vector<vector<Point2f> > imagePoints, vector<Mat>& rvecs, vector<Mat>& tvecs,
                            vector<float>& reprojErrs,  double& totalAvgErr)
{

    cameraMatrix = Mat::eye(, , CV_64F);
    if( s.flag & CV_CALIB_FIX_ASPECT_RATIO )
        cameraMatrix.at<double>(,) = 1.0;

    distCoeffs = Mat::zeros(, , CV_64F);

    vector<vector<Point3f> > objectPoints();
    calcBoardCornerPositions(s.boardSize, s.squareSize, objectPoints[], s.calibrationPattern);

    objectPoints.resize(imagePoints.size(),objectPoints[]);

    //Find intrinsic and extrinsic camera parameters
    double rms = calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix,
                                 distCoeffs, rvecs, tvecs, s.flag|CV_CALIB_FIX_K4|CV_CALIB_FIX_K5);

    cout << "Re-projection error reported by calibrateCamera: "<< rms << endl;

    bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);

    totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints,
                                             rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);

    return ok;
}

// Print camera parameters to the output file
static void saveCameraParams( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
                              const vector<Mat>& rvecs, const vector<Mat>& tvecs,
                              const vector<float>& reprojErrs, const vector<vector<Point2f> >& imagePoints,
                              double totalAvgErr )
{
    FileStorage fs( s.outputFileName, FileStorage::WRITE );

    time_t tm;
    time( &tm );
    struct tm *t2 = localtime( &tm );
    char buf[];
    strftime( buf, sizeof(buf)-, "%c", t2 );

    fs << "calibration_Time" << buf;

    if( !rvecs.empty() || !reprojErrs.empty() )
        fs << "nrOfFrames" << (int)std::max(rvecs.size(), reprojErrs.size());
    fs << "image_Width" << imageSize.width;
    fs << "image_Height" << imageSize.height;
    fs << "board_Width" << s.boardSize.width;
    fs << "board_Height" << s.boardSize.height;
    fs << "square_Size" << s.squareSize;

    if( s.flag & CV_CALIB_FIX_ASPECT_RATIO )
        fs << "FixAspectRatio" << s.aspectRatio;

    if( s.flag )
    {
        sprintf( buf, "flags: %s%s%s%s",
            s.flag & CV_CALIB_USE_INTRINSIC_GUESS ? " +use_intrinsic_guess" : "",
            s.flag & CV_CALIB_FIX_ASPECT_RATIO ? " +fix_aspectRatio" : "",
            s.flag & CV_CALIB_FIX_PRINCIPAL_POINT ? " +fix_principal_point" : "",
            s.flag & CV_CALIB_ZERO_TANGENT_DIST ? " +zero_tangent_dist" : "" );
        cvWriteComment( *fs, buf,  );

    }

    fs << "flagValue" << s.flag;

    fs << "Camera_Matrix" << cameraMatrix;
    fs << "Distortion_Coefficients" << distCoeffs;

    fs << "Avg_Reprojection_Error" << totalAvgErr;
    if( !reprojErrs.empty() )
        fs << "Per_View_Reprojection_Errors" << Mat(reprojErrs);

    if( !rvecs.empty() && !tvecs.empty() )
    {
        CV_Assert(rvecs[].type() == tvecs[].type());
        Mat bigmat((int)rvecs.size(), , rvecs[].type());
        for( int i = ; i < (int)rvecs.size(); i++ )
        {
            Mat r = bigmat(Range(i, i+), Range(,));
            Mat t = bigmat(Range(i, i+), Range(,));

            CV_Assert(rvecs[i].rows ==  && rvecs[i].cols == );
            CV_Assert(tvecs[i].rows ==  && tvecs[i].cols == );
            //*.t() is MatExpr (not Mat) so we can use assignment operator
            r = rvecs[i].t();
            t = tvecs[i].t();
        }
        cvWriteComment( *fs, "a set of 6-tuples (rotation vector + translation vector) for each view",  );
        fs << "Extrinsic_Parameters" << bigmat;
    }

    if( !imagePoints.empty() )
    {
        Mat imagePtMat((int)imagePoints.size(), (int)imagePoints[].size(), CV_32FC2);
        for( int i = ; i < (int)imagePoints.size(); i++ )
        {
            Mat r = imagePtMat.row(i).reshape(, imagePtMat.cols);
            Mat imgpti(imagePoints[i]);
            imgpti.copyTo(r);
        }
        fs << "Image_points" << imagePtMat;
    }
}

bool runCalibrationAndSave(Settings& s, Size imageSize, Mat&  cameraMatrix, Mat& distCoeffs,vector<vector<Point2f> > imagePoints )
{
    vector<Mat> rvecs, tvecs;
    vector<float> reprojErrs;
    double totalAvgErr = ;

    bool ok = runCalibration(s,imageSize, cameraMatrix, distCoeffs, imagePoints, rvecs, tvecs,
                             reprojErrs, totalAvgErr);
    cout << (ok ? "Calibration succeeded" : "Calibration failed")
        << ". avg re projection error = "  << totalAvgErr ;

    if( ok )
        saveCameraParams( s, imageSize, cameraMatrix, distCoeffs, rvecs ,tvecs, reprojErrs,
                            imagePoints, totalAvgErr);
    return ok;
}

网上有很多关于相机标定的代码，但都是没有官方网站的源文件更详细，给源文件同时写一个Makefile文件

#Makefile for camera_calibrateion
EXE =camera_calibration
OBJS += camera_calibration.o

CC = g++
CFLAGS += -g -O3 -Wall
INC += -I. `pkg-config --cflags opencv`
LIBS += `pkg-config --libs opencv`

all:$(EXE)

$(EXE):$(OBJS)
	$(CC) $(INC) $(CFLAGS) $(OBJS) -o $(EXE) $(LIBS)
$(OBJS):%.o:%.cpp
	$(CC) $(INC) $(CFLAGS) -c $< -o $@

.PHONY:clean
clean:
	rm -r *.o $(EXE)

然后make一下就会生成可执行文件，那么同时还要有一个配置文件 .xml  要在同一个目录文件下，原文件提供了三种方式进行标定，

（1）  直接输入摄像头信息

（2）采用已经采集好的多照不同位置的标定模板

（3 ）使用采集下的视频流文件

那么我这里只做了（1）  （2）并且标定不同的摄像头

(1)采用摄像头的输入方式的mycamera.xml 代码如下：（同时要在camera_calibration.cpp文件里更改读取的.xml文件）

(这里的标定模板我是用A3纸张打印出来，为8*6     35mm的标定棋盘)

<?xml version="1.0"?>
<opencv_storage>
           <!--设置标定参数-->
<Settings>

           <!-- Number of inner corners per a item row and column. 宽度和高度的设置(square, circle) -->
<BoardSize_Width> 8</BoardSize_Width>
<BoardSize_Height>6</BoardSize_Height>

           <!-- The size of a square in some user defined metric system 每个方格的边长的长度单位一般是mm(pixel, millimeter)-->
<Square_Size>35</Square_Size>

         <!-- The type of input used for camera calibration. 标定模板的样式（棋盘）
         这里一共有三种模板One of: CHESSBOARD CIRCLES_GRID ASYMMETRIC_CIRCLES_GRID -->
<Calibrate_Pattern>"CHESSBOARD"</Calibrate_Pattern>

                <!-- The input to use for calibration.
		To use an input camera -> give the ID of the camera, like "1"
		To use an input video  -> give the path of the input video, like "/tmp/x.avi"
		To use an image list   -> give the path to the XML or YAML file containing the list of the images,
                like "/tmp/circles_list.xml"
		输入标定模板的方式有三种方式：摄像头输入；视频输入；照片文件流输入-->
<Input>"1"</Input>

              <!--  If true (non-zero) we flip the input images around the horizontal axis.
                 如果为真（非零），安照垂直方向翻转输入图像，这里选择为零，即不翻转-->
<Input_FlipAroundHorizontalAxis>0</Input_FlipAroundHorizontalAxis>

                  <!-- Time delay between frames in case of camera.在使用相机的情况下的帧之间的时间延迟 -->
<Input_Delay>100</Input_Delay>
                  <!-- How many frames to use, for calibration.用多少帧照片去校准，可以自己设置，一般不能低于20个 -->
<Calibrate_NrOfFrameToUse>25</Calibrate_NrOfFrameToUse>
                 <!-- Consider only fy as a free parameter, the ratio fx/fy stays the same as in the input cameraMatrix.
	           Use or not setting. 0 - False Non-Zero - True
                    假设fy是一个自由参数，而fx/fy是一个固定的比例参数，使用或者不设置 0    假  非零  真-->
<Calibrate_FixAspectRatio> 1 </Calibrate_FixAspectRatio>
                <!-- If true (non-zero) tangential distortion coefficients  are set to zeros and stay zero.
                 如果设置为真，表示切向畸变系数被设置为0  保持为零-->
<Calibrate_AssumeZeroTangentialDistortion>1</Calibrate_AssumeZeroTangentialDistortion>
                 <!-- If true (non-zero) the principal point（摄像机坐标系下真实的坐标原点） is not changed during the global optimization.-->
<Calibrate_FixPrincipalPointAtTheCenter> 1 </Calibrate_FixPrincipalPointAtTheCenter>
                   <!-- The name of the output log file. 输出文件的名称-->
<Write_outputFileName>"out_camera_data.xml"</Write_outputFileName>
                  <!-- If true (non-zero) we write to the output file the feature points.（如果为真我们向输出文件写入特征点）-->
<Write_DetectedFeaturePoints>1</Write_DetectedFeaturePoints>
                  <!-- If true (non-zero) we write to the output file the extrinsic camera parameters.（写入相机的外部参数）-->
<Write_extrinsicParameters>1</Write_extrinsicParameters>
                         <!-- If true (non-zero) we show after calibration the undistorted images.展示校准后不失真的照片-->
 <Show_UndistortedImage>1</Show_UndistortedImage>

</Settings>

</opencv_storage>

里面的汉字是我写的标注，其中有几个地方需要修改的与我们的实际标定模板一致

<BoardSize_Width> 8</BoardSize_Width>      ：表示标定模板的宽度  实际一共有9个黑白方格
<BoardSize_Height>6</BoardSize_Height>      ：实际有7个黑白方格
<Calibrate_Pattern>"CHESSBOARD"</Calibrate_Pattern>   
：选择棋盘形式，一共有  CHESSBOARD ，CIRCLES_GRID， ASYMMETRIC_CIRCLES_GRID三种

<Square_Size>35</Square_Size>             ：每个黑白方格的边长35mm（根据实际情况）

<Input>"1"</Input>                   ：选择标定模板的输入种类  1. To use an input camera -> give the ID of the camera, like "1"
                                                           2. To use an input video  -> give the path of the input video, like "/tmp/x.avi"
                                                           3. To use an image list   -> give the path to the XML or YAML file containing the list of the images,      <Write_outputFileName>"out_camera_data.xml"</Write_outputFileName>  

<Write_outputFileName>"out_camera_data.xml"</Write_outputFileName>   ：表示标定输出文件

运行文件夹下运行./camera_calibration  会启动摄像头，然后选择“g”开始标定   ，但是如果上面的这些参数没有设置的与实际相符合，是不会开始采集标定模板的，（我刚开始就出现了这个错误，所以一定亚设置与实际的标定模板一致）

就会开始采集25个不同角度和位置的标定模板，如下图：

注意（我这样直接拿着标定模板来标定是不正确的，应该用一个平面模板把标定模板固定住，这样的标定的结果才是更加准确的，因为这样只是做实验，）

每采集成功一次就会变为二图，颜色略有变化，采集完成就会自动开始校准如下：

此时在工程文件夹下就会生成out_camera_data.xml，就是相机的标定结果报告

（2）使用Opencv 提供的标定模板进行标定

我们只需要更改

<BoardSize_Width> 8</BoardSize_Width>   改为   <BoardSize_Width> 6</BoardSize_Width>        
<BoardSize_Height>6</BoardSize_Height>   改为  <BoardSize_Height>4</BoardSize_Height>

<Square_Size>35</Square_Size>      改为     <Square_Size108</Square_Size>

<Input>"1"</Input>      改为     <Input>"/home/salm/myopencv/calibrate/VID.xml"</Input>       
这里就是指定了另一个.xml文件，就是标定模板的图片，其中VID.xml内容为：

<?xml version="1.0"?>
<opencv_storage>
<images>
/home/salm/myopencv/images/chessboards/chessboard01.jpg
/home/salm/myopencv/images/chessboards/chessboard02.jpg
/home/salm/myopencv/images/chessboards/chessboard03.jpg
/home/salm/myopencv/images/chessboards/chessboard04.jpg
/home/salm/myopencv/images/chessboards/chessboard05.jpg
/home/salm/myopencv/images/chessboards/chessboard06.jpg
/home/salm/myopencv/images/chessboards/chessboard07.jpg
/home/salm/myopencv/images/chessboards/chessboard08.jpg
/home/salm/myopencv/images/chessboards/chessboard09.jpg
/home/salm/myopencv/images/chessboards/chessboard10.jpg
/home/salm/myopencv/images/chessboards/chessboard11.jpg
/home/salm/myopencv/images/chessboards/chessboard12.jpg
/home/salm/myopencv/images/chessboards/chessboard13.jpg
/home/salm/myopencv/images/chessboards/chessboard14.jpg
/home/salm/myopencv/images/chessboards/chessboard15.jpg
/home/salm/myopencv/images/chessboards/chessboard16.jpg
/home/salm/myopencv/images/chessboards/chessboard17.jpg
/home/salm/myopencv/images/chessboards/chessboard18.jpg
/home/salm/myopencv/images/chessboards/chessboard19.jpg
/home/salm/myopencv/images/chessboards/chessboard20.jpg
/home/salm/myopencv/images/chessboards/chessboard21.jpg
/home/salm/myopencv/images/chessboards/chessboard22.jpg
/home/salm/myopencv/images/chessboards/chessboard23.jpg
/home/salm/myopencv/images/chessboards/chessboard24.jpg
/home/salm/myopencv/images/chessboards/chessboard25.jpg
</images>
</opencv_storage>

运行文件夹下运行./camera_calibration  会启动VID.xml文件下的图片，这是标定过程中的截图文件 如图

此时在工程文件夹下就会生成out_camera_data.xml

后续还有其他相关的只是待我学习完了再写出来，只是为了记录我的实验过程，如果能有人从中获取帮助，那就更好了

（如果很不幸，被大神们看见了，就直接嗤之以鼻吧，因为没有什么创新的东西，谢谢）

如果您觉得看完有所收获，可以资助一分，几分money,不在乎多少（我也是跟网上的大神们学的），不想挣钱娶媳妇的程序员不是好程序员（同时我也看看到底有没有人认可），谢谢

版权所有，转载请注明出处 http://www.cnblogs.com/li-yao7758258/p/5933653.html