bool Calibration::findBoard(Mat img, vector<Point2f>& pointBuf, bool refine) {
bool found=false;
if(patternType == CHESSBOARD) {
// no CV_CALIB_CB_FAST_CHECK, because it breaks on dark images (e.g., dark IR images from kinect)
// int chessFlags = CV_CALIB_CB_ADAPTIVE_THRESH;// | CV_CALIB_CB_NORMALIZE_IMAGE;
int chessFlags = CV_CALIB_CB_ADAPTIVE_THRESH;
found = findChessboardCorners(img, patternSize, pointBuf, chessFlags);
// improve corner accuracy
if(found) {
if(img.type() != CV_8UC1) {
cvtColor(img, grayMat, CV_RGB2GRAY);
} else {
grayMat = img;
}
if(refine) {
// the 11x11 dictates the smallest image space square size allowed
// in other words, if your smallest square is 11x11 pixels, then set this to 11x11
cornerSubPix(grayMat, pointBuf, subpixelSize, cv::Size(-1,-1), TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1 ));
}
}
}
//#ifdef USING_OPENCV_2_3
else {
int flags = (patternType == CIRCLES_GRID ? CALIB_CB_SYMMETRIC_GRID : CALIB_CB_ASYMMETRIC_GRID); // + CALIB_CB_CLUSTERING
found = findCirclesGrid(img, patternSize, pointBuf, flags);
}
//#endif
return found;
}
vector<cv::Point2f> getCenters(ofImage& img, cv::Size patternSize) {
Mat imgMat = toCv(img);
vector<cv::Point2f> centers;
bool found = findCirclesGrid(imgMat, patternSize, centers, CALIB_CB_CLUSTERING | CALIB_CB_ASYMMETRIC_GRID);
if(!found) {
cout << "failed to find circles" << endl;
}
return centers;
}
JNIEXPORT void JNICALL Java_com_mobile_perimeter_poseestimation_PoseEstimator_FindChessboard(JNIEnv*, jobject, jlong addrGray, jlong addrPtvec, jint boardHeight, jint boardWidth)
{
cv::Mat& mGr = *(cv::Mat*)addrGray;
cv::Mat& mPtvec = *(cv::Mat*)addrPtvec;
cv::Size boardSize = cvSize(boardHeight, boardWidth);
findCirclesGrid(mGr, boardSize, mPtvec, cv::CALIB_CB_ASYMMETRIC_GRID);
}
void CameraCalibration::calibrate()
{
const string inputSettingsFile = "default.xml";
// Read the settings
FileStorage fs( inputSettingsFile, FileStorage::READ );
if ( !fs.isOpened() ) {
FileStorage fs( inputSettingsFile, FileStorage::WRITE );
fs.release();
cerr << "Could not open the configuration file: \"" << inputSettingsFile << "\"" << endl;
return;
}
else {
s.read( fs["Settings"] );
// close Settings file
fs.release();
}
if ( !s.goodInput ) {
cerr << "Invalid input detected. Application stopping." << endl;
return;
}
vector<vector<Point2f> > imagePoints;
Mat distCoeffs;
Size imageSize;
int mode = s.inputType == Settings::IMAGE_LIST ? CAPTURING : DETECTION;
clock_t prevTimestamp = 0;
const Scalar RED( 0, 0, 255 ), GREEN( 0, 255, 0 );
const char ESC_KEY = 27;
for ( int i = 0; ; ++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 no more images then run calibration, save and stop loop.
if ( view.empty() ) {
if ( imagePoints.size() > 0 ) {
runCalibrationAndSave(s, imageSize, cameraMatrix, distCoeffs, imagePoints);
}
break;
}
imageSize = view.size(); // Format input image.
if ( s.flipVertical ) {
flip( view, view, 0 );
}
vector<Point2f> pointBuf;
bool found;
// Find feature points on the input format
switch ( s.calibrationPattern ) {
case Settings::CHESSBOARD:
found = findChessboardCorners( view, s.boardSize, pointBuf,
CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_FAST_CHECK | 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 done with success, improve the found corners' coordinate accuracy for chessboard
if ( found ) {
if ( s.calibrationPattern == Settings::CHESSBOARD ) {
Mat viewGray;
cvtColor( view, viewGray, COLOR_BGR2GRAY );
cornerSubPix( viewGray, pointBuf, Size( 11,11 ), Size(-1,-1), TermCriteria( TermCriteria::EPS + TermCriteria::MAX_ITER, 30, 0.1 ) );
}
// For camera only take new samples after delay time
if ( mode == CAPTURING && (!s.inputCapture.isOpened() || clock() - prevTimestamp > s.delay*1e-3*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 = 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 ( 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, 1, 1, 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() ? 50 : 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, 1, imageSize, 0 ),
imageSize, CV_16SC2, map1, map2 );
for ( int i = 0; i < (int)s.imageList.size(); i++ ) {
view = imread( s.imageList[i], 1 );
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;
}
}
}
}
void CalibrateThread::run()
{
Size boardSize, imageSize;
float squareSize = 1.f, aspectRatio = 1.f;
Mat cameraMatrix, distCoeffs;
//QString of = ui->lineEdit_WorkFolder->text() + '/' + ui->lineEdit_OutputName->text();
QByteArray ba = strFileName.toLatin1();
const char* outputFilename = ba.data();
int i, nframes = 0;
bool writeExtrinsics = true, writePoints = true;
bool undistortImage = false;
int flags = 0;
VideoCapture capture;
bool flipVertical = false;
bool showUndistorted = false;
int delay = 1000;
clock_t prevTimestamp = 0;
int mode = CAPTURING;
vector<vector<Point2f> > imagePoints;
vector<string> imageList;
Pattern pattern = CHESSBOARD;
boardSize.width = m_width;
boardSize.height = m_height;
squareSize = m_squaresize;
//ui->textEdit_Information->append("\nCalibrating... Please wait for a while\n");
if( imgList.size() == 0 )
{
//QMessageBox::warning(NULL, "Error", "Please choose a right folder");
emit popupErrorInformation("Please choose a right folder");
emit closeImageWindow();
return;
}
else
{
nframes = imgList.size();
}
emit appendText("\nCalibrating... Please wait for a while\n");
//namedWindow( "Image View", 1 );
//bDialog->show();
for(i = 0; i < nframes ;i++)
{
//ui->textEdit_Information->append("Processing the image No. " + QString::number(i + 1));
emit appendText("Processing the image No. " + QString::number(i + 1));
Mat view, viewGray;
bool blink = false;
qDebug(imgList.at(i).toLatin1().data());
if( i < (int)imgList.size() )
view = imread(imgList.at(i).toLatin1().data(), 1);
if(!view.data)
{
//QMessageBox::warning(NULL, "Error", );
emit popupErrorInformation("Could not open image files");
return;
}
imageSize = view.size();
if( flipVertical )
flip( view, view, 0 );
vector<Point2f> pointbuf;
cvtColor(view, viewGray, CV_BGR2GRAY);
bool found;
switch( pattern )
{
case CHESSBOARD:
found = findChessboardCorners( view, boardSize, pointbuf,
CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FAST_CHECK | CV_CALIB_CB_NORMALIZE_IMAGE);
break;
case CIRCLES_GRID:
found = findCirclesGrid( view, boardSize, pointbuf );
break;
case ASYMMETRIC_CIRCLES_GRID:
found = findCirclesGrid( view, boardSize, pointbuf, CALIB_CB_ASYMMETRIC_GRID );
break;
}
// improve the found corners' coordinate accuracy
if( pattern == CHESSBOARD && found) cornerSubPix( viewGray, pointbuf, Size(11,11),
Size(-1,-1), TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
if( mode == CAPTURING && found &&
(!capture.isOpened() || clock() - prevTimestamp > delay*1e-3*CLOCKS_PER_SEC) )
{
imagePoints.push_back(pointbuf);
prevTimestamp = clock();
blink = capture.isOpened();
}
if(found)
drawChessboardCorners( view, boardSize, Mat(pointbuf), found );
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);
}
Mat rgb;
cvtColor(view, rgb, CV_BGR2RGB);
QImage image32 = QImage(rgb.cols, rgb.rows, QImage::Format_RGB32);
QRgb value;
for(int r = 0; r < rgb.rows; r++)
{
for(int c = 0; c < rgb.cols; c++)
{
value = qRgb(rgb.ptr<uchar>(0)[r * rgb.cols * 3 + c * 3 + 0], rgb.ptr<uchar>(0)[r * rgb.cols * 3 + c * 3 + 1], rgb.ptr<uchar>(0)[r * rgb.cols * 3 + c * 3 + 2]);
image32.setPixel(c, r, value);
}
}
emit showBitmap(image32);
int key;
if(i < nframes - 1)
{
key = 0xff & waitKey(500);
}
else
{
key = waitKey(500);
}
if( (key & 255) == 27 )
break;
if( key == 'u' && mode == CALIBRATED )
undistortImage = !undistortImage;
}
if(imagePoints.size() > 0)
{
emit appendText("\n" + QString::number(imagePoints.size()) + " out of " + QString::number(nframes) + " images are effective!\n" );
runAndSave(outputFilename, imagePoints, imageSize,
boardSize, pattern, squareSize, aspectRatio,
flags, cameraMatrix, distCoeffs,
writeExtrinsics, writePoints);
}
else
{
emit appendText("Calibrating is not successful! \nPlease change the parameters and try again!");
emit popupErrorInformation("Sorry, no enough points are detected! Please try another group of images!");
emit closeImageWindow();
return;
}
emit appendText("Calibrating Successfully! \nPlease go to the folder to check the out put files!");
emit closeImageWindow();
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.data)
continue;
//undistort( view, rview, cameraMatrix, distCoeffs, cameraMatrix );
remap(view, rview, map1, map2, INTER_LINEAR);
imshow("Image View", rview);
int c = 0xff & waitKey();
if( (c & 255) == 27 || c == 'q' || c == 'Q' )
break;
}
}
return;
}
/// it has multithread support under c++ 11
void CameraCalibration::getImagesAndFindPatterns(const string &cameraName)
{
// set mode
mode = CAPTURING;
frameCounter = 0;
imageCounter = 0;
capturedFrame currentImage;
// read current path
currentPath = boost::filesystem::current_path();
resultsPath = currentPath;
cout << "current Results Path" << currentPath << '\n' << endl;
//mode = s.inputType == Settings::IMAGE_LIST ? CAPTURING : DETECTION;// check enum type
// Capture only the frames settled in the configuration file
// in the original code it was a endless loop
for (int i = 0;; ++i)
{
Mat view,currentView;
bool blinkOutput = false;
// capture the image
view = s.nextImage();
frameCounter = frameCounter + 1;
//------------------------- Show original distorted image -----------------------------------
Mat originalView = view.clone();
//imshow("original Image", originalView);
//----- 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() > 0)
runCalibrationAndSave(s, imageSize, cameraMatrix, distCoeffs, imagePoints);
break;
}
imageSize = view.size(); // Format input image.
if (s.flipVertical) flip(view, view, 0);
vector<Point2f> pointBuf;
bool found;
switch (s.calibrationPattern) // Find feature points on the input format
{
case Settings::CHESSBOARD:
found = findChessboardCorners(view, s.boardSize, pointBuf,
CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_FAST_CHECK | 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(11, 11),
Size(-1, -1), TermCriteria(TermCriteria::EPS+TermCriteria::MAX_ITER, 30, 0.1));
}
if (mode == CAPTURING && // For camera only take new samples after delay time
(!s.inputCapture.isOpened() || clock() - prevTimestamp > s.delay*1e-3*CLOCKS_PER_SEC))
{
imagePoints.push_back(pointBuf);
prevTimestamp = clock();
blinkOutput = s.inputCapture.isOpened();
circlePoints = pointBuf; // save ordered circle points
}
// Draw the corners with ID according order criteria distance(x+y) from origin point 1
savedImage = view.clone();
drawChessboardCorners(view, s.boardSize, Mat(pointBuf), found);
// order the points according to d(x+y) from the upper left corner that is used as the origin frame
std::sort(pointBuf.begin(), pointBuf.end(), [](const cv::Point2f &a, const cv::Point2f &b)
{return ((a.x + a.y) < (b.x + b.y)); });
int pointCounter = 1;
for (auto k:pointBuf){
cv::putText(view,std::to_string(pointCounter),cv::Point(k.x,k.y),cv::FONT_HERSHEY_PLAIN,1.0,cv::Scalar(255,0,0),1);
pointCounter = pointCounter + 1;
}
}
//----------------------------- Output Text ------------------------------------------------
string msg = (mode == CAPTURING) ? "100/100" :
mode == CALIBRATED ? "Calibrated" : "the images are being captured";
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 (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, 1, 1, mode == CALIBRATED ? GREEN : RED);
if (blinkOutput){
bitwise_not(view, view);
// save the image used for calibration to disk
imageCounter = imageCounter + 1;
string pathToFile;
string filename;
if (imageCounter <= s.nrFrames)
{
string imageName{ "Image" + string(std::to_string(imageCounter)) + cameraName + ".jpg" };
boost::filesystem::path p{ "/" }; // add a slash to generate a portable string
filename.assign(resultsPath.string() + p.generic_string() + imageName);
vector<int> compression_params;
compression_params.push_back(IMWRITE_JPEG_QUALITY);
compression_params.push_back(100);
// check if the file already exist? if yes, erase it
bool found = getPathForThisFile(imageName,pathToFile);
if (found){
boost::filesystem::remove(pathToFile);
}
// write the new version of the file
cv::imwrite(filename, savedImage);
// save the points use to estimate the scale factor
int currentBufferPosition = imagePoints.size();
int pointCounter = 1;
circlePatternInfo currentCircle;
circlesDataPerImage dataCurrentImage;
vector<circlePatternInfo> circlesInfoFromThisImage;
for (auto k : circlePoints){
currentCircle.circleID = pointCounter;
currentCircle.circlePosition = cv::Point2f(k.x, k.y);
currentCircle.circle3DPosition = circle_Mis_Positions.at(pointCounter - 1);
circlesInfoFromThisImage.push_back(currentCircle);
pointCounter = pointCounter + 1;
}
circlePoints.clear();
dataCurrentImage.imageID= imageCounter;
dataCurrentImage.cameraID = s.cameraID;
dataCurrentImage.circlesData = circlesInfoFromThisImage;
// save all the data from the asymetric circles pattern
DataFromCirclesPattern.push_back(dataCurrentImage);
}
}
//------------------------- Video capture output undistorted ------------------------------
if (mode == CALIBRATED && s.showUndistorsed)
{
Mat temp = view.clone();
undistort(temp, view, cameraMatrix, distCoeffs);
string msgEsckey = "Press 'esc' key to quit";
putText(view, msgEsckey, textOrigin, 1, 1, GREEN, 2);
}
//------------------------------ Show image and check for input commands -------------------
imshow(cameraName, view);
//delay 30ms so that screen can refresh.
//image will not appear without this waitKey() command
cv::waitKey(30);
char c = waitKey(1);
if (c == ESC_KEY) // Escape key
break; // Breaks the capture loop
}
}
///////////////////////////////////////////////////////
// Panel::CalibrateCamera() Description
///////////////////////////////////////////////////////
void Panel::CalibrateCamera(string sFilePath)
{
help();
//! [file_read]
Settings s;
const string inputSettingsFile = sFilePath;
FileStorage fs(inputSettingsFile, FileStorage::READ); // Read the settings
if (!fs.isOpened())
{
cout << "Could not open the configuration file: \"" << inputSettingsFile << "\"" << endl;
// return -1;
}
fs["Settings"] >> s;
fs.release(); // close Settings file
//! [file_read]
//FileStorage fout("settings.yml", FileStorage::WRITE); // write config as YAML
//fout << "Settings" << s;
if (!s.goodInput)
{
cout << "Invalid input detected. Application stopping. " << endl;
// return -1;
}
vector<vector<Point2f> > imagePoints;
Mat cameraMatrix, distCoeffs;
Size imageSize;
int mode = s.inputType == Settings::IMAGE_LIST ? CAPTURING : DETECTION;
clock_t prevTimestamp = 0;
const Scalar RED(0, 0, 255), GREEN(0, 255, 0);
const char ESC_KEY = 27;
int counter = 1;
//! [get_input]
for (;;)
{
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() >= (size_t)s.nrFrames)
{
if (runCalibrationAndSave(s, imageSize, cameraMatrix, distCoeffs, imagePoints))
mode = CALIBRATED;
else
mode = DETECTION;
}
if (view.empty()) // If there are no more images stop the loop
{
// if calibration threshold was not reached yet, calibrate now
if (mode != CALIBRATED && !imagePoints.empty())
runCalibrationAndSave(s, imageSize, cameraMatrix, distCoeffs, imagePoints);
break;
}
//! [get_input]
imageSize = view.size(); // Format input image.
if (s.flipVertical) flip(view, view, 0);
//! [find_pattern]
vector<Point2f> pointBuf;
bool found;
switch (s.calibrationPattern) // Find feature points on the input format
{
case Settings::CHESSBOARD:
found = findChessboardCorners(view, s.boardSize, pointBuf,
CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_FAST_CHECK | 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;
}
//! [find_pattern]
//! [pattern_found]
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(11, 11),
Size(-1, -1), TermCriteria(TermCriteria::EPS + TermCriteria::COUNT, 30, 0.1));
}
if (mode == CAPTURING && // For camera only take new samples after delay time
(!s.inputCapture.isOpened() || clock() - prevTimestamp > s.delay*1e-3*CLOCKS_PER_SEC))
{
imagePoints.push_back(pointBuf);
prevTimestamp = clock();
blinkOutput = s.inputCapture.isOpened();
}
// Draw the corners.
drawChessboardCorners(view, s.boardSize, Mat(pointBuf), found);
}
//! [pattern_found]
//----------------------------- Output Text ------------------------------------------------
//! [output_text]
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 (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, 1, 1, mode == CALIBRATED ? GREEN : RED);
if (blinkOutput)
bitwise_not(view, view);
//! [output_text]
//------------------------- Video capture output undistorted ------------------------------
//! [output_undistorted]
if (mode == CALIBRATED && s.showUndistorsed)
{
Mat temp = view.clone();
undistort(temp, view, cameraMatrix, distCoeffs);
}
//! [output_undistorted]
//------------------------------ Show image and check for input commands -------------------
//! [await_input]
namedWindow("Image View" + to_string(counter), WINDOW_NORMAL);
resizeWindow("Image View" + to_string(counter), 640, 480);
imshow("Image View" + to_string(counter), view);
char key = (char)waitKey(s.inputCapture.isOpened() ? 50 : s.delay);
cout << "Image " << to_string(counter) << " Completed" << endl;
counter++;
if (key == ESC_KEY)
break;
if (key == 'u' && mode == CALIBRATED)
s.showUndistorsed = !s.showUndistorsed;
if (s.inputCapture.isOpened() && key == 'g')
{
mode = CAPTURING;
imagePoints.clear();
}
//! [await_input]
}
// -----------------------Show the undistorted image for the image list ------------------------
//! [show_results]
if (s.inputType == Settings::IMAGE_LIST && s.showUndistorsed)
{
Mat view, rview, map1, map2;
initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),
getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0),
imageSize, CV_16SC2, map1, map2);
m_mainMap1 = map1;
m_mainMap2 = map2;
for (size_t i = 0; i < s.imageList.size(); i++)
{
view = imread(s.imageList[i], 1);
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;
}
}
//! [show_results]
// return 0;
}