#include <CVCalibrationEstimator.h>

Public Types
enum class	State { Streaming = 0 , Calculating , BusyExtracting , Done , DoneCaptureAndSave , Error }

Public Member Functions
	CVCalibrationEstimator (CVCalibrationEstimatorParams params, int camSizeIndex, bool mirroredH, bool mirroredV, CVCameraType camType, string computerInfos, string calibDataPath, string imageOutputPath, string exePath)

	~CVCalibrationEstimator ()

bool	calculate ()
	Initiates the final calculation. More...

bool	updateAndDecorate (CVMat imageColor, const CVMat &imageGray, bool grabFrame, bool drawCorners=true)
	< Finds the inner chessboard corners in the given image More...

State	state ()

int	numImgsToCapture ()

int	numCapturedImgs ()

bool	calibrationSuccessful ()

CVCalibration	getCalibration ()
	Get resulting calibration. More...

bool	isBusyExtracting ()

bool	isCalculating ()

bool	isStreaming ()

bool	isDone ()

bool	isDoneCaptureAndSave ()

Static Public Member Functions
static bool	calcCalibration (CVSize &imageSize, CVMat &cameraMatrix, CVMat &distCoeffs, const CVVVPoint2f &imagePoints, CVVMat &rvecs, CVVMat &tvecs, vector< float > &reprojErrs, float &totalAvgErr, CVSize &boardSize, float squareSize, int flag, bool useReleaseObjectMethod)
	Calculates the calibration with the given set of image points. More...

Private Member Functions
bool	calibrateAsync ()

bool	extractAsync ()

bool	loadCalibParams ()
	Loads the chessboard calibration pattern parameters. More...

void	updateExtractAndCalc (bool found, bool grabFrame, cv::Mat imageGray)

void	updateOnlyCapture (bool found, bool grabFrame, cv::Mat imageGray)

void	saveImage (cv::Mat imageGray)

Static Private Member Functions
static double	calcReprojectionErrors (const CVVVPoint3f &objectPoints, const CVVVPoint2f &imagePoints, const CVVMat &rvecs, const CVVMat &tvecs, const CVMat &cameraMatrix, const CVMat &distCoeffs, vector< float > &perViewErrors)
	Calculates the reprojection error of the calibration. More...

static void	calcBoardCorners3D (const CVSize &boardSize, float squareSize, CVVPoint3f &objectPoints3D)
	Calculates the 3D positions of the chessboard corners. More...

Private Attributes
State	_state = State::Streaming

bool	_calibrationSuccessful = false

std::future< bool >	_calibrationTask
	future object for calculation of calibration in async task More...

cv::Mat	_currentImgToExtract

CVVVPoint2f	_imagePoints
	2D vector of corner points in chessboard More...

CVSize	_boardSize
	NO. of inner chessboard corners. More...

float	_boardSquareMM = 10.f
	Size of chessboard square in mm. More...

int	_numOfImgsToCapture = 20
	NO. of images to capture. More...

int	_numCaptured = 0
	NO. of images captured. More...

CVSize	_imageSize
	Input image size in pixels (after cropping) More...

float	_reprojectionError = -1.f
	Reprojection error after calibration. More...

CVCalibrationEstimatorParams	_params

int	_camSizeIndex = -1

bool	_mirroredH = false

bool	_mirroredV = false

CVCameraType	_camType = CVCameraType::FRONTFACING

CVCalibration	_calibration
	estimated calibration More...

string	_calibParamsFileName
	name of calibration paramters file More...

string	_computerInfos

string	_calibDataPath

string	_calibImgOutputDir

string	_exePath

bool	_hasAsyncError = false

CVCalibrationEstimatorException	_exception

Detailed Description

Definition at line 43 of file CVCalibrationEstimator.h.

Member Enumeration Documentation

◆ State

enum CVCalibrationEstimator::State

strong

Enumerator
Streaming	Estimator waits for new frames.
Calculating	Estimator is currently calculating the calibration.
BusyExtracting	Estimator is busy extracting the corners of a frame.
Done	Estimator finished.
DoneCaptureAndSave	All images are captured in.
Error

Definition at line 46 of file CVCalibrationEstimator.h.

     {
         Streaming = 0,      //!< Estimator waits for new frames
         Calculating,        //!< Estimator is currently calculating the calibration
         BusyExtracting,     //!< Estimator is busy extracting the corners of a frame
         Done,               //!< Estimator finished
         DoneCaptureAndSave, //!< All images are captured in
         Error
     };

Constructor & Destructor Documentation

◆ CVCalibrationEstimator()

CVCalibrationEstimator::CVCalibrationEstimator	(	CVCalibrationEstimatorParams	params,
		int	camSizeIndex,
		bool	mirroredH,
		bool	mirroredV,
		CVCameraType	camType,
		string	computerInfos,
		string	calibDataPath,
		string	imageOutputPath,
		string	exePath
	)

Definition at line 15 of file CVCalibrationEstimator.cpp.

   : _params(params),
     _camSizeIndex(camSizeIndex),
     _mirroredH(mirroredH),
     _mirroredV(mirroredV),
     _camType(camType),
     _calibration(_camType, ""),
     _calibParamsFileName("calib_in_params.yml"),
     _exception("Undefined error", 0, __FILE__),
     _computerInfos(computerInfos),
     _calibDataPath(calibDataPath),
     _exePath(exePath)
 {
     if (!loadCalibParams())
     {
         throw CVCalibrationEstimatorException("Could not load calibration parameter!",
                                               __LINE__,
                                               __FILE__);
     }
  
     if (params.mode == CVCalibrationEstimatorParams::EstimatorMode::OnlyCaptureAndSave)
     {
         if (!Utils::dirExists(imageOutputPath))
         {
             stringstream ss;
             ss << "Image output directory does not exist: " << imageOutputPath;
             throw CVCalibrationEstimatorException(ss.str(),
                                                   __LINE__,
                                                   __FILE__);
         }
         else
         {
             // make subdirectory where images are stored to
             _calibImgOutputDir = Utils::unifySlashes(imageOutputPath) + "calibimages/";
             Utils::makeDir(_calibImgOutputDir);
             if (!Utils::dirExists(_calibImgOutputDir))
             {
                 stringstream ss;
                 ss << "Could not create image output directory: " << _calibImgOutputDir;
                 throw CVCalibrationEstimatorException(ss.str(),
                                                       __LINE__,
                                                       __FILE__);
             }
         }
     }
 }

◆ ~CVCalibrationEstimator()

CVCalibrationEstimator::~CVCalibrationEstimator ( )

Definition at line 70 of file CVCalibrationEstimator.cpp.

 {
     // wait for the async task to finish
     if (_calibrationTask.valid())
         _calibrationTask.wait();
 }

Member Function Documentation

◆ calcBoardCorners3D()

void CVCalibrationEstimator::calcBoardCorners3D	(	const CVSize &	boardSize,
		float	squareSize,
		CVVPoint3f &	objectPoints3D
	)

staticprivate

Calculates the 3D positions of the chessboard corners.

Definition at line 532 of file CVCalibrationEstimator.cpp.

 {
     // Because OpenCV image coords are top-left we define the according
     // 3D coords also top-left.
     objectPoints3D.clear();
     for (int y = boardSize.height - 1; y >= 0; --y)
         for (int x = 0; x < boardSize.width; ++x)
             objectPoints3D.push_back(CVPoint3f((float)x * squareSize,
                                                (float)y * squareSize,
                                                0));
 }

◆ calcCalibration()

bool CVCalibrationEstimator::calcCalibration	(	CVSize &	imageSize,
		CVMat &	cameraMatrix,
		CVMat &	distCoeffs,
		const CVVVPoint2f &	imagePoints,
		CVVMat &	rvecs,
		CVVMat &	tvecs,
		vector< float > &	reprojErrs,
		float &	totalAvgErr,
		CVSize &	boardSize,
		float	squareSize,
		int	flag,
		bool	useReleaseObjectMethod
	)

static

Calculates the calibration with the given set of image points.

Definition at line 222 of file CVCalibrationEstimator.cpp.

 {
     // Init camera matrix with the eye setter
     cameraMatrix = CVMat::eye(3, 3, CV_64F);
  
     // We need to set eleme at 0,0 to 1 if we want a fix aspect ratio
     if (flag & cv::CALIB_FIX_ASPECT_RATIO)
         cameraMatrix.at<double>(0, 0) = 1.0;
  
     // init the distortion coeffitients to zero
     distCoeffs = CVMat::zeros(8, 1, CV_64F);
  
     CVVVPoint3f objectPoints(1);
  
     CVCalibrationEstimator::calcBoardCorners3D(boardSize,
                                                squareSize,
                                                objectPoints[0]);
  
     objectPoints.resize(imagePoints.size(), objectPoints[0]);
  
     ////////////////////////////////////////////////
     // Find intrinsic and extrinsic camera parameters
 #if 0
     int iFixedPoint = -1;
     if (useReleaseObjectMethod)
         iFixedPoint = boardSize.width - 1;
     double rms = cv::calibrateCameraRO(objectPoints,
                                        imagePoints,
                                        imageSize,
                                        iFixedPoint,
                                        cameraMatrix,
                                        distCoeffs,
                                        rvecs,
                                        tvecs,
                                        cv::noArray(),
                                        flag);
 #else
     double rms = cv::calibrateCamera(objectPoints,
                                      imagePoints,
                                      imageSize,
                                      // iFixedPoint,
                                      cameraMatrix,
                                      distCoeffs,
                                      rvecs,
                                      tvecs,
                                      // cv::noArray(),
                                      flag);
 #endif
     ////////////////////////////////////////////////
  
     Utils::log("SLProject", "Re-projection error reported by calibrateCamera: %f", rms);
  
     bool ok = cv::checkRange(cameraMatrix) && cv::checkRange(distCoeffs);
  
     totalAvgErr = (float)calcReprojectionErrors(objectPoints,
                                                 imagePoints,
                                                 rvecs,
                                                 tvecs,
                                                 cameraMatrix,
                                                 distCoeffs,
                                                 reprojErrs);
     return ok;
 }

◆ calcReprojectionErrors()

double CVCalibrationEstimator::calcReprojectionErrors	(	const CVVVPoint3f &	objectPoints,
		const CVVVPoint2f &	imagePoints,
		const CVVMat &	rvecs,
		const CVVMat &	tvecs,
		const CVMat &	cameraMatrix,
		const CVMat &	distCoeffs,
		vector< float > &	perViewErrors
	)

staticprivate

Calculates the reprojection error of the calibration.

Definition at line 298 of file CVCalibrationEstimator.cpp.

 {
     CVVPoint2f imagePoints2;
     size_t     totalPoints = 0;
     double     totalErr    = 0, err;
     perViewErrors.resize(objectPoints.size());
  
     for (size_t i = 0; i < objectPoints.size(); ++i)
     {
         cv::projectPoints(objectPoints[i],
                           rvecs[i],
                           tvecs[i],
                           cameraMatrix,
                           distCoeffs,
                           imagePoints2);
  
         err = norm(imagePoints[i], imagePoints2, cv::NORM_L2);
  
         size_t n         = objectPoints[i].size();
         perViewErrors[i] = (float)std::sqrt(err * err / n);
         totalErr += err * err;
         totalPoints += n;
     }
  
     return std::sqrt(totalErr / totalPoints);
 }

◆ calculate()

bool CVCalibrationEstimator::calculate ( )

Initiates the final calculation.

Definition at line 78 of file CVCalibrationEstimator.cpp.

 {
     bool calibrationSuccessful = false;
     if (!_calibrationTask.valid())
     {
         _calibrationTask = std::async(std::launch::async, &CVCalibrationEstimator::calibrateAsync, this);
     }
     else if (_calibrationTask.wait_for(std::chrono::milliseconds(1)) == std::future_status::ready)
     {
         calibrationSuccessful = _calibrationTask.get();
         if (calibrationSuccessful)
         {
             Utils::log("SLProject", "Calibration succeeded.");
             Utils::log("SLProject", "Reproj. error: %f", _reprojectionError);
         }
         else
         {
             Utils::log("SLProject", "Calibration failed.");
         }
     }
  
     return calibrationSuccessful;
 }

◆ calibrateAsync()

bool CVCalibrationEstimator::calibrateAsync ( )

private

Definition at line 156 of file CVCalibrationEstimator.cpp.

 {
     bool ok = false;
     try
     {
         _numCaptured = 0;
         CVVMat        rvecs, tvecs;
         vector<float> reprojErrs;
         cv::Mat       cameraMat;
         cv::Mat       distortion;
  
         ok = calcCalibration(_imageSize,
                              cameraMat,
                              distortion,
                              _imagePoints,
                              rvecs,
                              tvecs,
                              reprojErrs,
                              _reprojectionError,
                              _boardSize,
                              _boardSquareMM,
                              _params.calibrationFlags(),
                              _params.useReleaseObjectMethod);
         // correct number of caputured, extraction may have failed
         if (!rvecs.empty() || !reprojErrs.empty())
             _numCaptured = (int)std::max(rvecs.size(), reprojErrs.size());
         else
             _numCaptured = 0;
  
         if (ok)
         {
             // instantiate calibration
             _calibration = CVCalibration(cameraMat,
                                          distortion,
                                          _imageSize,
                                          _boardSize,
                                          _boardSquareMM,
                                          _reprojectionError,
                                          _numCaptured,
                                          Utils::getDateTime2String(),
                                          _camSizeIndex,
                                          _mirroredH,
                                          _mirroredV,
                                          _camType,
                                          _computerInfos,
                                          _params.calibrationFlags(),
                                          true);
         }
     }
     catch (std::exception& e)
     {
         _hasAsyncError = true;
         _exception     = CVCalibrationEstimatorException(e.what(), __LINE__, __FILE__);
         return false;
     }
     catch (...)
     {
         _hasAsyncError = true;
         _exception     = CVCalibrationEstimatorException("Unknown exception during calibration!", __LINE__, __FILE__);
         return false;
     }
  
     return ok;
 }

◆ calibrationSuccessful()

bool CVCalibrationEstimator::calibrationSuccessful ( )

inline

Definition at line 80 of file CVCalibrationEstimator.h.

80 { return _calibrationSuccessful; }

CVCalibrationEstimator::_calibrationSuccessful

bool _calibrationSuccessful

Definition: CVCalibrationEstimator.h:122

◆ extractAsync()

bool CVCalibrationEstimator::extractAsync ( )

private

Definition at line 102 of file CVCalibrationEstimator.cpp.

 {
     if (_imageSize.width == 0 && _imageSize.height == 0)
         _imageSize = _currentImgToExtract.size();
     else if (_imageSize.width != _currentImgToExtract.size().width || _imageSize.height != _currentImgToExtract.size().height)
     {
         _hasAsyncError = true;
         _exception     = CVCalibrationEstimatorException("Image size changed during capturing process!",
                                                      __LINE__,
                                                      __FILE__);
         return false;
     }
  
     bool foundPrecisely = false;
     try
     {
         CVVPoint2f preciseCorners2D;
         int        flags          = cv::CALIB_CB_ADAPTIVE_THRESH | cv::CALIB_CB_NORMALIZE_IMAGE;
         bool       foundPrecisely = cv::findChessboardCorners(_currentImgToExtract,
                                                         _boardSize,
                                                         preciseCorners2D,
                                                         flags);
  
         if (foundPrecisely)
         {
             cv::cornerSubPix(_currentImgToExtract,
                              preciseCorners2D,
                              CVSize(11, 11),
                              CVSize(-1, -1),
                              cv::TermCriteria(cv::TermCriteria::EPS + cv::TermCriteria::COUNT,
                                               30,
                                               0.0001));
  
             // add detected points
             _imagePoints.push_back(preciseCorners2D);
             _numCaptured++;
         }
     }
     catch (std::exception& e)
     {
         _hasAsyncError = true;
         _exception     = CVCalibrationEstimatorException(e.what(), __LINE__, __FILE__);
         return false;
     }
     catch (...)
     {
         _hasAsyncError = true;
         _exception     = CVCalibrationEstimatorException("Unknown exception during calibration!", __LINE__, __FILE__);
         return false;
     }
  
     return foundPrecisely;
 }

◆ getCalibration()

CVCalibration CVCalibrationEstimator::getCalibration ( )

inline

Get resulting calibration.

Definition at line 82 of file CVCalibrationEstimator.h.

82 { return _calibration; }

◆ isBusyExtracting()

bool CVCalibrationEstimator::isBusyExtracting ( )

inline

Definition at line 83 of file CVCalibrationEstimator.h.

83 { return _state == State::BusyExtracting; }

CVCalibrationEstimator::_state

State _state

Definition: CVCalibrationEstimator.h:121

CVCalibrationEstimator::State::BusyExtracting

@ BusyExtracting

Estimator is busy extracting the corners of a frame.

◆ isCalculating()

bool CVCalibrationEstimator::isCalculating ( )

inline

Definition at line 84 of file CVCalibrationEstimator.h.

84 { return _state == State::Calculating; }

CVCalibrationEstimator::State::Calculating

@ Calculating

Estimator is currently calculating the calibration.

◆ isDone()

bool CVCalibrationEstimator::isDone ( )

inline

Definition at line 86 of file CVCalibrationEstimator.h.

86 { return _state == State::Done; }

CVCalibrationEstimator::State::Done

@ Done

Estimator finished.

◆ isDoneCaptureAndSave()

bool CVCalibrationEstimator::isDoneCaptureAndSave ( )

inline

Definition at line 87 of file CVCalibrationEstimator.h.

87 { return _state == State::DoneCaptureAndSave; }

CVCalibrationEstimator::State::DoneCaptureAndSave

@ DoneCaptureAndSave

All images are captured in.

◆ isStreaming()

bool CVCalibrationEstimator::isStreaming ( )

inline

Definition at line 85 of file CVCalibrationEstimator.h.

85 { return _state == State::Streaming; }

CVCalibrationEstimator::State::Streaming

@ Streaming

Estimator waits for new frames.

◆ loadCalibParams()

bool CVCalibrationEstimator::loadCalibParams ( )

private

Loads the chessboard calibration pattern parameters.

Definition at line 332 of file CVCalibrationEstimator.cpp.

 {
     cv::FileStorage fs;
     string          fullCalibIniFile = Utils::findFile(_calibParamsFileName,
                                                        {_calibDataPath, _exePath});
     fs.open(fullCalibIniFile, cv::FileStorage::READ);
     if (!fs.isOpened())
     {
         Utils::log("SLProject", "Could not open the calibration parameter file: %s", fullCalibIniFile.c_str());
         return false;
     }
  
     // assign paramters
     fs["numInnerCornersWidth"] >> _boardSize.width;
     fs["numInnerCornersHeight"] >> _boardSize.height;
     fs["squareSizeMM"] >> _boardSquareMM;
     fs["numOfImgsToCapture"] >> _numOfImgsToCapture;
  
     return true;
 }

◆ numCapturedImgs()

int CVCalibrationEstimator::numCapturedImgs ( )

inline

Definition at line 78 of file CVCalibrationEstimator.h.

78 { return _numCaptured; }

◆ numImgsToCapture()

int CVCalibrationEstimator::numImgsToCapture ( )

inline

Definition at line 77 of file CVCalibrationEstimator.h.

77 { return _numOfImgsToCapture; }

◆ saveImage()

void CVCalibrationEstimator::saveImage ( cv::Mat imageGray )

private

Definition at line 353 of file CVCalibrationEstimator.cpp.

 {
 #ifndef __EMSCRIPTEN__
     stringstream ss;
     ss << _calibImgOutputDir << "CalibImge_" << Utils::getDateTime2String() << ".jpg";
     cv::imwrite(ss.str(), imageGray);
 #endif
 }

◆ state()

State CVCalibrationEstimator::state ( )

inline

Definition at line 73 of file CVCalibrationEstimator.h.

     {
         return _state;
     }

◆ updateAndDecorate()

bool CVCalibrationEstimator::updateAndDecorate	(	CVMat	imageColor,
		const CVMat &	imageGray,
		bool	grabFrame,
		bool	drawCorners = `true`
	)

< Finds the inner chessboard corners in the given image

Definition at line 460 of file CVCalibrationEstimator.cpp.

 {
     assert(!imageGray.empty() &&
            "CVCalibration::findChessboard: imageGray is empty!");
     assert(!imageColor.empty() &&
            "CVCalibration::findChessboard: imageColor is empty!");
     assert(_boardSize.width && _boardSize.height &&
            "CVCalibration::findChessboard: _boardSize is not set!");
  
     cv::Size imageSize = imageColor.size();
  
     cv::Mat imageGrayExtract = imageGray;
     // resize image so that we get fluent caputure workflow for high resolutions
     double scale              = 1.0;
     bool   doScale            = false;
     int    targetExtractWidth = 640;
     if (imageSize.width > targetExtractWidth)
     {
         doScale = true;
         scale   = (double)imageSize.width / (double)targetExtractWidth;
         cv::resize(imageGray, imageGrayExtract, cv::Size(), 1 / scale, 1 / scale);
     }
  
     CVVPoint2f corners2D;
     bool       found = cv::findChessboardCorners(imageGrayExtract,
                                            _boardSize,
                                            corners2D,
                                            cv::CALIB_CB_FAST_CHECK);
  
     if (found)
     {
         if (grabFrame && _state == State::Streaming)
         {
             // simulate a snapshot
             cv::bitwise_not(imageColor, imageColor);
         }
  
         if (drawCorners)
         {
             if (doScale)
             {
                 // scale corners into original image size
                 for (cv::Point2f& pt : corners2D)
                 {
                     pt *= scale;
                 }
             }
  
             cv::drawChessboardCorners(imageColor,
                                       _boardSize,
                                       CVMat(corners2D),
                                       found);
         }
     }
  
     if (_params.mode == CVCalibrationEstimatorParams::EstimatorMode::ExtractAndCalculate)
     {
         // update state machine for extraction and calculation
         updateExtractAndCalc(found, grabFrame, imageGray);
     }
     else // CVCalibrationEstimatorParams::EstimatorMode::OnlyCaptureAndSave
     {
         updateOnlyCapture(found, grabFrame, imageGray);
     }
  
     return found;
 }

◆ updateExtractAndCalc()

void CVCalibrationEstimator::updateExtractAndCalc	(	bool	found,
		bool	grabFrame,
		cv::Mat	imageGray
	)

private

Definition at line 362 of file CVCalibrationEstimator.cpp.

 {
     switch (_state)
     {
         case State::Streaming:
         {
             if (grabFrame && found)
             {
                 _currentImgToExtract = imageGray.clone();
                 // start async extraction
                 if (!_calibrationTask.valid())
                 {
                     _calibrationTask = std::async(std::launch::async, &CVCalibrationEstimator::extractAsync, this);
                 }
  
                 _state = State::BusyExtracting;
             }
             break;
         }
         case State::BusyExtracting:
         {
             // check if async task is ready
             if (_calibrationTask.wait_for(std::chrono::milliseconds(1)) == std::future_status::ready)
             {
                 bool extractionSuccessful = _calibrationTask.get();
  
                 if (_hasAsyncError)
                 {
                     _state = State::Error;
                     throw _exception;
                 }
                 else if (_numCaptured >= _numOfImgsToCapture)
                 {
                     // if ready and number of capturings exceed number of required start calculation
                     _calibrationTask = std::async(std::launch::async, &CVCalibrationEstimator::calibrateAsync, this);
                     _state           = State::Calculating;
                 }
                 else
                 {
                     _state = State::Streaming;
                 }
             }
             break;
         }
         case State::Calculating:
         {
             if (_calibrationTask.wait_for(std::chrono::milliseconds(1)) == std::future_status::ready)
             {
                 _calibrationSuccessful = _calibrationTask.get();
  
                 if (_calibrationSuccessful)
                 {
                     _state = State::Done;
                     Utils::log("SLProject", "Calibration succeeded.");
                     Utils::log("SLProject", "Reproj. error: %f", _reprojectionError);
                 }
                 else
                 {
                     Utils::log("SLProject", "Calibration failed.");
                     if (_hasAsyncError)
                     {
                         _state = State::Error;
                         throw _exception;
                     }
                     else
                         _state = State::Done;
                 }
             }
             break;
         }
         default: break;
     }
 }

◆ updateOnlyCapture()

void CVCalibrationEstimator::updateOnlyCapture	(	bool	found,
		bool	grabFrame,
		cv::Mat	imageGray
	)

private

Definition at line 436 of file CVCalibrationEstimator.cpp.

 {
     switch (_state)
     {
         case State::Streaming:
         {
             if (grabFrame && found)
             {
                 saveImage(imageGray);
                 _numCaptured++;
             }
  
             if (_numCaptured >= _numOfImgsToCapture)
             {
                 _state                 = State::DoneCaptureAndSave;
                 _calibrationSuccessful = true;
             }
             break;
         }
         default: break;
     }
 }

Member Data Documentation

◆ _boardSize

CVSize CVCalibrationEstimator::_boardSize

private

NO. of inner chessboard corners.

Definition at line 128 of file CVCalibrationEstimator.h.

◆ _boardSquareMM

float CVCalibrationEstimator::_boardSquareMM = 10.f

private

Size of chessboard square in mm.

Definition at line 129 of file CVCalibrationEstimator.h.

◆ _calibDataPath

string CVCalibrationEstimator::_calibDataPath

private

Definition at line 144 of file CVCalibrationEstimator.h.

◆ _calibImgOutputDir

string CVCalibrationEstimator::_calibImgOutputDir

private

Definition at line 145 of file CVCalibrationEstimator.h.

◆ _calibParamsFileName

string CVCalibrationEstimator::_calibParamsFileName

private

name of calibration paramters file

Definition at line 142 of file CVCalibrationEstimator.h.

◆ _calibration

CVCalibration CVCalibrationEstimator::_calibration

private

estimated calibration

Definition at line 141 of file CVCalibrationEstimator.h.

◆ _calibrationSuccessful

bool CVCalibrationEstimator::_calibrationSuccessful = false

private

Definition at line 122 of file CVCalibrationEstimator.h.

◆ _calibrationTask

std::future<bool> CVCalibrationEstimator::_calibrationTask

private

future object for calculation of calibration in async task

Definition at line 124 of file CVCalibrationEstimator.h.

◆ _camSizeIndex

int CVCalibrationEstimator::_camSizeIndex = -1

private

Definition at line 137 of file CVCalibrationEstimator.h.

◆ _camType

CVCameraType CVCalibrationEstimator::_camType = CVCameraType::FRONTFACING

private

Definition at line 140 of file CVCalibrationEstimator.h.

◆ _computerInfos

string CVCalibrationEstimator::_computerInfos

private

Definition at line 143 of file CVCalibrationEstimator.h.

◆ _currentImgToExtract

cv::Mat CVCalibrationEstimator::_currentImgToExtract

private

Definition at line 126 of file CVCalibrationEstimator.h.

◆ _exception

CVCalibrationEstimatorException CVCalibrationEstimator::_exception

private

Definition at line 150 of file CVCalibrationEstimator.h.

◆ _exePath

string CVCalibrationEstimator::_exePath

private

Definition at line 146 of file CVCalibrationEstimator.h.

◆ _hasAsyncError

bool CVCalibrationEstimator::_hasAsyncError = false

private

Definition at line 149 of file CVCalibrationEstimator.h.

◆ _imagePoints

CVVVPoint2f CVCalibrationEstimator::_imagePoints

private

2D vector of corner points in chessboard

Definition at line 127 of file CVCalibrationEstimator.h.

◆ _imageSize

CVSize CVCalibrationEstimator::_imageSize

private

Input image size in pixels (after cropping)

Definition at line 132 of file CVCalibrationEstimator.h.

◆ _mirroredH

bool CVCalibrationEstimator::_mirroredH = false

private

Definition at line 138 of file CVCalibrationEstimator.h.

◆ _mirroredV

bool CVCalibrationEstimator::_mirroredV = false

private

Definition at line 139 of file CVCalibrationEstimator.h.

◆ _numCaptured

int CVCalibrationEstimator::_numCaptured = 0

private

NO. of images captured.

Definition at line 131 of file CVCalibrationEstimator.h.

◆ _numOfImgsToCapture

int CVCalibrationEstimator::_numOfImgsToCapture = 20

private

NO. of images to capture.

Definition at line 130 of file CVCalibrationEstimator.h.

◆ _params

CVCalibrationEstimatorParams CVCalibrationEstimator::_params

private

Definition at line 136 of file CVCalibrationEstimator.h.

◆ _reprojectionError

float CVCalibrationEstimator::_reprojectionError = -1.f

private

Reprojection error after calibration.

Definition at line 133 of file CVCalibrationEstimator.h.

◆ _state

State CVCalibrationEstimator::_state = State::Streaming

private

Definition at line 121 of file CVCalibrationEstimator.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ State

Constructor & Destructor Documentation

◆ CVCalibrationEstimator()

◆ ~CVCalibrationEstimator()

Member Function Documentation

◆ calcBoardCorners3D()

◆ calcCalibration()

◆ calcReprojectionErrors()

◆ calculate()

◆ calibrateAsync()

◆ calibrationSuccessful()

◆ extractAsync()

◆ getCalibration()

◆ isBusyExtracting()

◆ isCalculating()

◆ isDone()

◆ isDoneCaptureAndSave()

◆ isStreaming()

◆ loadCalibParams()

◆ numCapturedImgs()

◆ numImgsToCapture()

◆ saveImage()

◆ state()

◆ updateAndDecorate()

◆ updateExtractAndCalc()

◆ updateOnlyCapture()

Member Data Documentation

◆ _boardSize

◆ _boardSquareMM

◆ _calibDataPath

◆ _calibImgOutputDir

◆ _calibParamsFileName

◆ _calibration

◆ _calibrationSuccessful

◆ _calibrationTask

◆ _camSizeIndex

◆ _camType

◆ _computerInfos

◆ _currentImgToExtract

◆ _exception

◆ _exePath

◆ _hasAsyncError

◆ _imagePoints

◆ _imageSize

◆ _mirroredH

◆ _mirroredV

◆ _numCaptured

◆ _numOfImgsToCapture

◆ _params

◆ _reprojectionError

◆ _state