大家好，又见面了，我是你们的朋友全栈君。

0.前言

  OpenCv中，相机标定所使用的标定图案分为棋盘格、对称圆形及非对称圆形特征图、ArUco板和ChArUco板等。在OpenCV的官方例程中，采用的是棋盘格图案，因为其操作简单、快速，标定精度满足一般应用场景的需求。对于标定精度要求高的场景，则一般采用圆形标定图案。本文主要介绍如何使用圆形标定图案（对称和非对称）完成相机的标定，并将OpenCv标定结果与Halcon标定结果进行对比分析。

1.标定图案

  OpenCv中使用的圆形标定图案如图1所示：

OpenCv中，使用圆形标定图案用到的函数为 cv::findCirclesGrid()。函数原型如下：
 bool cv::findCirclesGrid(//找到圆心坐标返回True
     cv::InputArray,//输入标定图像，8位单通道或三通道
     cv::Size patternSize,//标定图案的尺寸
     cv::OutputArray centers,//输出数组，为检测到的圆心坐标
     int flags,//标志位，对称图案——cv::CALIB_CB_SYMMETRIC_GRID,非对称图案——  cv::CALIB_CB_ASYMMETRIC_GRID
     const cv::Ptrcv::FeatureDetector&blobDetector=new SimpleBlobDetector()
)；
  图1所示的非对称圆形标定图案，其width=11，height=6。在计算标定图案上标志点圆心的世界坐标时，参数squareSize即为图1中标注的圆心距。关于圆的半径大小，可以自行设定，因为在提取圆心坐标时不涉及圆的半径（这点和halcon标定不同，halcon在进行相机标定时，圆的半径作为标定文件中的已知参数）。圆心距一般取圆直径的4倍左右。
  图2为本文使用的标定板，其为高精度铝制标定板，精度为±0.01mm，是200x200mm的halcon标准标定板，圆的直径为12.5mm,圆心距为25mm。

2.OpenCv标定

  本文采用的标定为离线标定，先由相机采集N幅图像，再由标定程序读取图像。为了保证标定精度，建议采集10幅或更多的视图，尽量使得标定板的移动范围覆盖相机视野。
  在OpenCv官方相机标定代码的基础上进行了修改，得到了下面的对圆形标定图案标定的代码。由于代码近500行，为了缩短篇幅，省略的一些头文件、说明性文字、函数的实现。省略部分可参考:OpenCv/sources/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp.

#include "stdafx.h"
//此处省略各种头文件
using namespace cv;
using namespace std;
//此处省略help()函数
enum { 
 DETECTION = 0, CAPTURING = 1, CALIBRATED = 2 };
enum Pattern { 
 CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };
//计算重投影误差函数
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)
{ 

//此处省略...
}
static void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CIRCLES_GRID)
{ 

//省略...
//本文中用到的标定板，在该函数中的参数为：boardSize.width=7,boardSize.height=7,squareSize=0.025(此处单位为米)
}
//执行标定，包括计算重投影误差
static bool runCalibration(vector<vector<Point2f> > imagePoints,
Size imageSize, Size boardSize, Pattern patternType,
float squareSize, float aspectRatio,
int flags, Mat& cameraMatrix, Mat& distCoeffs,
vector<Mat>& rvecs, vector<Mat>& tvecs,
vector<float>& reprojErrs,
double& totalAvgErr)
{ 

//省略...
}
//保存相机参数
static void saveCameraParams(const string& filename,
Size imageSize, Size boardSize,
float squareSize, float aspectRatio, int flags,
const Mat& cameraMatrix, const Mat& distCoeffs,
const vector<Mat>& rvecs, const vector<Mat>& tvecs,
const vector<float>& reprojErrs,
const vector<vector<Point2f> >& imagePoints,
double totalAvgErr)
{ 

//省略...
}
//读取字符串
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["images"];
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;
}
//运行并保存
static bool runAndSave(const string& outputFilename,
const vector<vector<Point2f> >& imagePoints,
Size imageSize, Size boardSize, Pattern patternType, float squareSize,
float aspectRatio, int flags, Mat& cameraMatrix,
Mat& distCoeffs, bool writeExtrinsics, bool writePoints)
{ 

//省略...
}
int main(int argc, char** argv)
{ 

cout << argc << endl;
for (size_t i = 0; i < argc; i++)
{ 

cout << argv[i] << endl;
}
Size boardSize, imageSize;
float squareSize, aspectRatio;
Mat cameraMatrix, distCoeffs;
string outputFilename;
string inputFilename = "";
int i, nframes;
bool writeExtrinsics, writePoints;
bool undistortImage = false;
int flags = 0;
VideoCapture capture;
bool flipVertical;
bool showUndistorted;
bool videofile;
int delay;
clock_t prevTimestamp = 0;
int mode = DETECTION;
int cameraId = 0;
vector<vector<Point2f> > imagePoints;
vector<string> imageList;
Pattern pattern = CIRCLES_GRID;//标定图案类型，对称圆形图案
cv::CommandLineParser parser(argc, argv,
"{help ||}{w|7|}{h|7|}{pt|circles|}{n|30|}{d|1000|}{s|0.025|}{o|D:/opencv/cameracalibration/out_camera_params_25x25_circleboard.yml|}"
"{op|D:/opencv/cameracalibration/Detected_feature_points.yml|}{oe|D:/opencv/cameracalibration/Extrinsic_parameters_circleboard.yml|}{zt||}{a|1|}{p||}{v||}{V||}{su||}"
"{input_data|D:/opencv/cameracalibration/VID25x25_CircleGrid.xml|}");
//命令行参数赋值，参数说明：w,h为标定板宽，高; pt为标定图案类型; n为读取图片的张数; d为相机在线抓图的时间间隔(ms)(本代码
//为离线标定，该参数可以不设置); o为程序输出的相机内参、外参文件(自定义的文件); op为输出检测到特征点的文件(自定义的文件); 
//oe为输出的相机外参数(这里可以不用设置，因为外参数已经在o中输出了，标定完后该文件为空文件); a为比例系数，默认为1; 
//input_data为存放图片路径的xml文件，本代码读取的VID25X25_CircleGrid.xml文件内容见图3。
if (parser.has("help"))
{ 

help();
return 0;
}
boardSize.width = parser.get<int>("w");
boardSize.height = parser.get<int>("h");
if (parser.has("pt"))
{ 

string val = parser.get<string>("pt");
if (val == "circles")
pattern = CIRCLES_GRID;
else if (val == "acircles")
pattern = ASYMMETRIC_CIRCLES_GRID;
else if (val == "chessboard")
pattern = CHESSBOARD;
else
return fprintf(stderr, "Invalid pattern type: must be chessboard or circles\n"), -1;
}
squareSize = parser.get<float>("s");
nframes = parser.get<int>("n");
aspectRatio = parser.get<float>("a");
delay = parser.get<int>("d");
writePoints = parser.has("op");
writeExtrinsics = parser.has("oe");
if (parser.has("a"))
flags |= CALIB_FIX_ASPECT_RATIO;
if (parser.has("zt"))
flags |= CALIB_ZERO_TANGENT_DIST;
if (parser.has("p"))
flags |= CALIB_FIX_PRINCIPAL_POINT;
flipVertical = parser.has("v");
videofile = parser.has("V");
if (parser.has("o"))
outputFilename = parser.get<string>("o");
showUndistorted = parser.has("su");
if (isdigit(parser.get<string>("input_data")[0]))
cameraId = parser.get<int>("input_data");
else
inputFilename = parser.get<string>("input_data");
if (!parser.check())
{ 

help();
parser.printErrors();
return -1;
}
if (squareSize <= 0)
return fprintf(stderr, "Invalid board square width\n"), -1;
if (nframes <= 3)
return printf("Invalid number of images\n"), -1;
if (aspectRatio <= 0)
return printf("Invalid aspect ratio\n"), -1;
if (delay <= 0)
return printf("Invalid delay\n"), -1;
if (boardSize.width <= 0)
return fprintf(stderr, "Invalid board width\n"), -1;
if (boardSize.height <= 0)
return fprintf(stderr, "Invalid board height\n"), -1;
if (!inputFilename.empty())
{ 

if (!videofile && readStringList(inputFilename, imageList))
mode = CAPTURING;
else
capture.open(inputFilename);
}
else
capture.open(cameraId);
if (!capture.isOpened() && imageList.empty())
return fprintf(stderr, "Could not initialize video (%d) capture\n", cameraId), -2;
if (!imageList.empty())
nframes = (int)imageList.size();
if (capture.isOpened())
printf("%s", liveCaptureHelp);
namedWindow("Image View", 1);
for (i = 0;; i++)
{ 

Mat view, viewGray;
bool blink = false;
if (capture.isOpened())
{ 

Mat view0;
capture >> view0;
view0.copyTo(view);
}
else if (i < (int)imageList.size())
view = imread(imageList[i], 1);
if (view.empty())
{ 

if (imagePoints.size() > 0)
runAndSave(outputFilename, imagePoints, imageSize,
boardSize, pattern, squareSize, aspectRatio,
flags, cameraMatrix, distCoeffs,
writeExtrinsics, writePoints);
break;
}
imageSize = view.size();
if (flipVertical)
flip(view, view, 0);
vector<Point2f> pointbuf;
cvtColor(view, viewGray, COLOR_BGR2GRAY);
bool found;
switch (pattern)
{ 

case CHESSBOARD:
found = findChessboardCorners(view, boardSize, pointbuf,
CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_FAST_CHECK | CALIB_CB_NORMALIZE_IMAGE);
break;
case CIRCLES_GRID:
found = findCirclesGrid(view, boardSize, pointbuf,CALIB_CB_SYMMETRIC_GRID);
break;
case ASYMMETRIC_CIRCLES_GRID:
found = findCirclesGrid(view, boardSize, pointbuf, CALIB_CB_ASYMMETRIC_GRID);
break;
default:
return fprintf(stderr, "Unknown pattern type\n"), -1;
}
if (found)
drawChessboardCorners(view, boardSize, Mat(pointbuf), found);//在原图中绘制找到的圆心点，图4为其中的一幅图
string msg = mode == CAPTURING ? "100/100" :
mode == CALIBRATED ? "Calibrated" : "Press 'g' to start";
int baseLine = 0;
Size textSize = getTextSize(msg, 1, 1, 1, &baseLine);
Point textOrigin(view.cols - 2 * textSize.width - 10, view.rows - 2 * baseLine - 10);
if (mode == CAPTURING)
{ 

if (undistortImage)
msg = format("%d/%d Undist", (int)imagePoints.size(), nframes);
else
msg = format("%d/%d", (int)imagePoints.size(), nframes);
}
putText(view, msg, textOrigin, 1, 1,
mode != CALIBRATED ? Scalar(0, 0, 255) : Scalar(0, 255, 0));
if (blink)
bitwise_not(view, view);
if (mode == CALIBRATED && undistortImage)
{ 

Mat temp = view.clone();
undistort(temp, view, cameraMatrix, distCoeffs);
}
imshow("Image View", view);
char key = (char)waitKey(capture.isOpened() ? 50 : 500);
if (key == 27)
break;
if (key == 'u' && mode == CALIBRATED)
undistortImage = !undistortImage;
if (capture.isOpened() && key == 'g')
{ 

mode = CAPTURING;
imagePoints.clear();
}
if (mode == CAPTURING && imagePoints.size() >= (unsigned)nframes)
{ 

if (runAndSave(outputFilename, imagePoints, imageSize,
boardSize, pattern, squareSize, aspectRatio,
flags, cameraMatrix, distCoeffs,
writeExtrinsics, writePoints))
mode = CALIBRATED;
else
mode = DETECTION;
if (!capture.isOpened())
break;
}
}
if (!capture.isOpened() && showUndistorted)
{ 

Mat view, rview, map1, map2;
initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0),
imageSize, CV_16SC2, map1, map2);
for (i = 0; i < (int)imageList.size(); i++)
{ 

view = imread(imageList[i], 1);
if (view.empty())
continue;
//undistort( view, rview, cameraMatrix, distCoeffs, cameraMatrix );
remap(view, rview, map1, map2, INTER_LINEAR);
imshow("Image View", rview);
char c = (char)waitKey();
if (c == 27 || c == 'q' || c == 'Q')
break;
}
}
return 0;
}

3.标定结果分析

  OpenCv标定得到的相机参数矩阵为：

  本次标定使用的镜头焦距 f=8mm, 像元尺寸为3.45μm，图像尺寸为2040×1200。
  Halcon标定得到的内参为（k,s_x,s_y,c_x,c_y）将其转换为式（1）中的矩阵。表1为OpenCv和Halcon标定的对比数据。

  本实验中，镜头与世界坐标系z=0平面的距离为112cm左右。从表中可以看出，OpenCv标定的重投影误差为0.01759，精度较高，小于Halcon标定的0.069。（OpenCv标定过程中采用了5项畸变系数k₁,k₂,p₁,p₂,k₃;Halcon标定中只考虑径向畸变k,表中没有列出）
  需要指出的是，实验数据来源于对同一组图片的标定。Halcon中对相机的标定，采用的方法是Tsai两步标定法，需要预先给出相机的内参数，理论上具有较高的标定精度。但是在本次的Halcon标定中，由于采用的是离线采集的图片，在标定过程中提示图片过曝、旋转角度没有覆盖全、标定图案偏小、光照不均匀等图像品质问题，因此标定的精度不高。如果使用halcon在线抓图标定，可以有效避免图像品质问题，从而大幅度提高标定精度，预计标定精度和OpenCv标定相当或者更高。标定结果表明，OpenCv标定算法的鲁棒性更好，而Halcon标定算法对采集到的图像品质要求较高，也可以理解为高精度标定下对图像品质的高要求。
 
 
ps:如有错误，谢谢指出。转载请注明出处。