void PatternDetector::setPattern(cv::Size grid_size_, float square_size_, Pattern pattern_type_, cv::Point3f offset_)
{
ideal_points = calcChessboardCorners(grid_size_, square_size_, pattern_type_, offset_);
pattern_type = pattern_type_;
grid_size = grid_size_;
square_size = square_size_;
}
static int 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)
{
cameraMatrix = Mat::eye(3, 3, CV_64F);
if( flags & CV_CALIB_FIX_ASPECT_RATIO )
cameraMatrix.at<double>(0,0) = aspectRatio;
distCoeffs = Mat::zeros(8, 1, CV_64F);
vector<vector<Point3f> > objectPoints(1);
calcChessboardCorners(boardSize, squareSize, objectPoints[0], patternType);
objectPoints.resize(imagePoints.size(),objectPoints[0]);
double rms = calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix,
distCoeffs, rvecs, tvecs, flags|CV_CALIB_FIX_K4|CV_CALIB_FIX_K5);
///*|CV_CALIB_FIX_K3*/|CV_CALIB_FIX_K4|CV_CALIB_FIX_K5);
printf("RMS error reported by calibrateCamera: %g\n", rms);
bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);
if(ok == false)
return -1;
totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints,
rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);
return 0;
}
void stereoCalibThread::monoCalibration(const vector<string>& imageList, int boardWidth, int boardHeight, Mat &K, Mat &Dist)
{
vector<vector<Point2f> > imagePoints;
Size boardSize, imageSize;
boardSize.width=boardWidth;
boardSize.height=boardHeight;
int flags=0;
int i;
float squareSize = 1.f, aspectRatio = 1.f;
Mat view, viewGray;
for(i = 0; i<(int)imageList.size();i++)
{
view = cv::imread(imageList[i], 1);
imageSize = view.size();
vector<Point2f> pointbuf;
cvtColor(view, viewGray, CV_BGR2GRAY);
bool found = false;
if(boardType == "CIRCLES_GRID") {
found = findCirclesGridDefault(view, boardSize, pointbuf, CALIB_CB_SYMMETRIC_GRID | CALIB_CB_CLUSTERING);
} else if(boardType == "ASYMMETRIC_CIRCLES_GRID") {
found = findCirclesGridDefault(view, boardSize, pointbuf, CALIB_CB_ASYMMETRIC_GRID | CALIB_CB_CLUSTERING);
} else {
found = findChessboardCorners( view, boardSize, pointbuf,
CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FAST_CHECK | CV_CALIB_CB_NORMALIZE_IMAGE);
}
if(found)
{
drawChessboardCorners( view, boardSize, Mat(pointbuf), found );
imagePoints.push_back(pointbuf);
}
}
std::vector<Mat> rvecs, tvecs;
std::vector<float> reprojErrs;
double totalAvgErr = 0;
K = Mat::eye(3, 3, CV_64F);
if( flags & CV_CALIB_FIX_ASPECT_RATIO )
K.at<double>(0,0) = aspectRatio;
Dist = Mat::zeros(4, 1, CV_64F);
std::vector<std::vector<Point3f> > objectPoints(1);
calcChessboardCorners(boardSize, squareSize, objectPoints[0]);
objectPoints.resize(imagePoints.size(),objectPoints[0]);
double rms = calibrateCamera(objectPoints, imagePoints, imageSize, K,
Dist, rvecs, tvecs,CV_CALIB_FIX_K3);
printf("RMS error reported by calibrateCamera: %g\n", rms);
cout.flush();
}
bool CameraCalibrationAlgorithm::runCalibration
(
VectorOfVectorOf2DPoints imagePoints,
cv::Size imageSize,
cv::Size boardSize,
PatternType patternType,
float squareSize,
float aspectRatio,
int flags,
cv::Mat& cameraMatrix,
cv::Mat& distCoeffs,
VectorOfMat& rvecs,
VectorOfMat& tvecs,
std::vector<float>& reprojErrs,
double& totalAvgErr
)
{
cameraMatrix = cv::Mat::eye(3, 3, CV_64F);
if (flags & cv::CALIB_FIX_ASPECT_RATIO)
{
cameraMatrix.at<double>(0, 0) = aspectRatio;
}
distCoeffs = cv::Mat::zeros(8, 1, CV_64F);
VectorOfVectorOf3DPoints objectPoints(1);
calcChessboardCorners(boardSize, squareSize, objectPoints[0], patternType);
objectPoints.resize(imagePoints.size(), objectPoints[0]);
//LOG_TRACE_MESSAGE("Object points size:" << objectPoints.size());
//LOG_TRACE_MESSAGE("Image points size :" << imagePoints.size());
//LOG_TRACE_MESSAGE("Image size :" << imageSize);
double rms = cv::calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix,
distCoeffs, rvecs, tvecs, flags | cv::CALIB_FIX_K4 | cv::CALIB_FIX_K5);
//LOG_TRACE_MESSAGE("RMS error reported by calibrateCamera: " << rms);
bool ok = cv::checkRange(cameraMatrix) && cv::checkRange(distCoeffs);
totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints, rvecs, tvecs, cameraMatrix, distCoeffs, reprojErrs);
return ok;
}
bool runCalibration(const std::vector<std::vector<cv::Point2f> >& imagePoints,
cv::Size imageSize, cv::Size boardSize,
double squareSize,
cv::Mat& cameraMatrix, cv::Mat& distCoeffs)
{
cameraMatrix = cv::Mat::eye(3, 3, CV_64F);
distCoeffs = cv::Mat::zeros(8, 1, CV_64F);
std::vector<std::vector<cv::Point3f> > objectPoints(1);
calcChessboardCorners(boardSize, squareSize, objectPoints[0]);
objectPoints.resize(imagePoints.size(),objectPoints[0]);
std::vector<cv::Mat> rvecs, tvecs;
double rms = cv::calibrateCamera(objectPoints, imagePoints, imageSize, cameraMatrix,
distCoeffs, rvecs, tvecs, CV_CALIB_FIX_K4|CV_CALIB_FIX_K5);
bool ok = cv::checkRange(cameraMatrix) && cv::checkRange(distCoeffs);
return ok;
}
