#include <SENSCalibrationEstimator.h>

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

Public Member Functions
	SENSCalibrationEstimator (SENSCalibrationEstimatorParams params, int camSizeIndex, bool mirroredH, bool mirroredV, SENSCameraType camType, std::string computerInfos, std::string calibDataPath, std::string imageOutputPath, std::string exePath)

	~SENSCalibrationEstimator ()

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

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

State	state ()

int	numImgsToCapture ()

int	numCapturedImgs ()

bool	calibrationSuccessful ()

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

bool	isBusyExtracting ()

bool	isCalculating ()

bool	isStreaming ()

bool	isDone ()

bool	isDoneCaptureAndSave ()

Static Public Member Functions
static bool	calcCalibration (cv::Size &imageSize, cv::Mat &cameraMatrix, cv::Mat &distCoeffs, const vector< vector< cv::Point2f >> &imagePoints, std::vector< cv::Mat > &rvecs, std::vector< cv::Mat > &tvecs, vector< float > &reprojErrs, float &totalAvgErr, cv::Size &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 vector< vector< cv::Point3f >> &objectPoints, const vector< vector< cv::Point2f >> &imagePoints, const std::vector< cv::Mat > &rvecs, const std::vector< cv::Mat > &tvecs, const cv::Mat &cameraMatrix, const cv::Mat &distCoeffs, vector< float > &perViewErrors)
	Calculates the reprojection error of the calibration. More...

static void	calcBoardCorners3D (const cv::Size &boardSize, float squareSize, std::vector< cv::Point3f > &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

vector< vector< cv::Point2f > >	_imagePoints
	2D vector of corner points in chessboard More...

cv::Size	_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...

cv::Size	_imageSize
	Input image size in pixels (after cropping) More...

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

SENSCalibrationEstimatorParams	_params

int	_camSizeIndex = -1

bool	_mirroredH = false

bool	_mirroredV = false

SENSCameraType	_camType = SENSCameraType::FRONTFACING

std::unique_ptr< SENSCalibration >	_calibration
	estimated calibration More...

std::string	_calibParamsFileName
	name of calibration paramters file More...

std::string	_computerInfos

std::string	_calibDataPath

std::string	_calibImgOutputDir

std::string	_exePath

bool	_hasAsyncError = false

SENSCalibrationEstimatorException	_exception

Detailed Description

Definition at line 37 of file SENSCalibrationEstimator.h.

Member Enumeration Documentation

◆ State

enum SENSCalibrationEstimator::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 40 of file SENSCalibrationEstimator.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

◆ SENSCalibrationEstimator()

SENSCalibrationEstimator::SENSCalibrationEstimator	(	SENSCalibrationEstimatorParams	params,
		int	camSizeIndex,
		bool	mirroredH,
		bool	mirroredV,
		SENSCameraType	camType,
		std::string	computerInfos,
		std::string	calibDataPath,
		std::string	imageOutputPath,
		std::string	exePath
	)

Definition at line 20 of file SENSCalibrationEstimator.cpp.

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

◆ ~SENSCalibrationEstimator()

SENSCalibrationEstimator::~SENSCalibrationEstimator ( )

Definition at line 74 of file SENSCalibrationEstimator.cpp.

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

Member Function Documentation

◆ calcBoardCorners3D()

void SENSCalibrationEstimator::calcBoardCorners3D	(	const cv::Size &	boardSize,
		float	squareSize,
		std::vector< cv::Point3f > &	objectPoints3D
	)

staticprivate

Calculates the 3D positions of the chessboard corners.

Definition at line 534 of file SENSCalibrationEstimator.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(cv::Point3f((float)x * squareSize,
                                                  (float)y * squareSize,
                                                  0));
 }

◆ calcCalibration()

bool SENSCalibrationEstimator::calcCalibration	(	cv::Size &	imageSize,
		cv::Mat &	cameraMatrix,
		cv::Mat &	distCoeffs,
		const vector< vector< cv::Point2f >> &	imagePoints,
		std::vector< cv::Mat > &	rvecs,
		std::vector< cv::Mat > &	tvecs,
		vector< float > &	reprojErrs,
		float &	totalAvgErr,
		cv::Size &	boardSize,
		float	squareSize,
		int	flag,
		bool	useReleaseObjectMethod
	)

static

Calculates the calibration with the given set of image points.

Definition at line 226 of file SENSCalibrationEstimator.cpp.

 {
     // Init camera matrix with the eye setter
     cameraMatrix = cv::Mat::eye(3, 3, CV_64F);
  
     // We need to set eleme at 0,0 to 1 if we want a fix aspect ratio
     if (flag & CALIB_FIX_ASPECT_RATIO)
         cameraMatrix.at<double>(0, 0) = 1.0;
  
     // init the distortion coeffitients to zero
     distCoeffs = cv::Mat::zeros(8, 1, CV_64F);
  
     vector<vector<cv::Point3f>> objectPoints(1);
  
     SENSCalibrationEstimator::calcBoardCorners3D(boardSize,
                                                  squareSize,
                                                  objectPoints[0]);
  
     objectPoints.resize(imagePoints.size(), objectPoints[0]);
  
     ////////////////////////////////////////////////
     //Find intrinsic and extrinsic camera parameters
     int iFixedPoint = -1;
     if (useReleaseObjectMethod)
         iFixedPoint = boardSize.width - 1;
 #if 0
     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 SENSCalibrationEstimator::calcReprojectionErrors	(	const vector< vector< cv::Point3f >> &	objectPoints,
		const vector< vector< cv::Point2f >> &	imagePoints,
		const std::vector< cv::Mat > &	rvecs,
		const std::vector< cv::Mat > &	tvecs,
		const cv::Mat &	cameraMatrix,
		const cv::Mat &	distCoeffs,
		vector< float > &	perViewErrors
	)

staticprivate

Calculates the reprojection error of the calibration.

Definition at line 302 of file SENSCalibrationEstimator.cpp.

 {
     std::vector<cv::Point2f> 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, 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 SENSCalibrationEstimator::calculate ( )

Initiates the final calculation.

Definition at line 82 of file SENSCalibrationEstimator.cpp.

 {
     bool calibrationSuccessful = false;
     if (!_calibrationTask.valid())
     {
         _calibrationTask = std::async(std::launch::async, &SENSCalibrationEstimator::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 SENSCalibrationEstimator::calibrateAsync ( )

private

Definition at line 160 of file SENSCalibrationEstimator.cpp.

 {
     bool ok = false;
     try
     {
         _numCaptured = 0;
         std::vector<cv::Mat> 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 = std::make_unique<SENSCalibration>(cameraMat,
                                                              distortion,
                                                              _imageSize,
                                                              _boardSize,
                                                              _boardSquareMM,
                                                              _reprojectionError,
                                                              _numCaptured,
                                                              Utils::getDateTime2String(),
                                                              _camSizeIndex,
                                                              _mirroredH,
                                                              _mirroredV,
                                                              _camType,
                                                              _computerInfos,
                                                              _params.calibrationFlags(),
                                                              true);
         }
     }
     catch (std::exception& e)
     {
         _hasAsyncError = true;
         _exception     = SENSCalibrationEstimatorException(e.what(), __LINE__, __FILE__);
         return false;
     }
     catch (...)
     {
         _hasAsyncError = true;
         _exception     = SENSCalibrationEstimatorException("Unknown exception during calibration!", __LINE__, __FILE__);
         return false;
     }
  
     return ok;
 }

◆ calibrationSuccessful()

bool SENSCalibrationEstimator::calibrationSuccessful ( )

inline

Definition at line 74 of file SENSCalibrationEstimator.h.

74 { return _calibrationSuccessful; }

SENSCalibrationEstimator::_calibrationSuccessful

bool _calibrationSuccessful

Definition: SENSCalibrationEstimator.h:116

◆ extractAsync()

bool SENSCalibrationEstimator::extractAsync ( )

private

Definition at line 106 of file SENSCalibrationEstimator.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     = SENSCalibrationEstimatorException("Image size changed during capturing process!",
                                                        __LINE__,
                                                        __FILE__);
         return false;
     }
  
     bool foundPrecisely = false;
     try
     {
         std::vector<cv::Point2f> preciseCorners2D;
         int                      flags          = CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_NORMALIZE_IMAGE;
         bool                     foundPrecisely = cv::findChessboardCorners(_currentImgToExtract,
                                                         _boardSize,
                                                         preciseCorners2D,
                                                         flags);
  
         if (foundPrecisely)
         {
             cv::cornerSubPix(_currentImgToExtract,
                              preciseCorners2D,
                              cv::Size(11, 11),
                              cv::Size(-1, -1),
                              TermCriteria(TermCriteria::EPS + TermCriteria::COUNT,
                                           30,
                                           0.0001));
  
             //add detected points
             _imagePoints.push_back(preciseCorners2D);
             _numCaptured++;
         }
     }
     catch (std::exception& e)
     {
         _hasAsyncError = true;
         _exception     = SENSCalibrationEstimatorException(e.what(), __LINE__, __FILE__);
         return false;
     }
     catch (...)
     {
         _hasAsyncError = true;
         _exception     = SENSCalibrationEstimatorException("Unknown exception during calibration!", __LINE__, __FILE__);
         return false;
     }
  
     return foundPrecisely;
 }

◆ getCalibration()

SENSCalibration SENSCalibrationEstimator::getCalibration ( )

inline

Get resulting calibration.

Definition at line 76 of file SENSCalibrationEstimator.h.

76 { return *_calibration; }

◆ isBusyExtracting()

bool SENSCalibrationEstimator::isBusyExtracting ( )

inline

Definition at line 77 of file SENSCalibrationEstimator.h.

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

SENSCalibrationEstimator::State::BusyExtracting

@ BusyExtracting

Estimator is busy extracting the corners of a frame.

SENSCalibrationEstimator::_state

State _state

Definition: SENSCalibrationEstimator.h:115

◆ isCalculating()

bool SENSCalibrationEstimator::isCalculating ( )

inline

Definition at line 78 of file SENSCalibrationEstimator.h.

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

SENSCalibrationEstimator::State::Calculating

@ Calculating

Estimator is currently calculating the calibration.

◆ isDone()

bool SENSCalibrationEstimator::isDone ( )

inline

Definition at line 80 of file SENSCalibrationEstimator.h.

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

SENSCalibrationEstimator::State::Done

@ Done

Estimator finished.

◆ isDoneCaptureAndSave()

bool SENSCalibrationEstimator::isDoneCaptureAndSave ( )

inline

Definition at line 81 of file SENSCalibrationEstimator.h.

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

SENSCalibrationEstimator::State::DoneCaptureAndSave

@ DoneCaptureAndSave

All images are captured in.

◆ isStreaming()

bool SENSCalibrationEstimator::isStreaming ( )

inline

Definition at line 79 of file SENSCalibrationEstimator.h.

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

SENSCalibrationEstimator::State::Streaming

@ Streaming

Estimator waits for new frames.

◆ loadCalibParams()

bool SENSCalibrationEstimator::loadCalibParams ( )

private

Loads the chessboard calibration pattern parameters.

Definition at line 336 of file SENSCalibrationEstimator.cpp.

 {
     FileStorage fs;
     string      fullCalibIniFile = Utils::findFile(_calibParamsFileName,
                                                    {_calibDataPath, _exePath});
     fs.open(fullCalibIniFile, 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 SENSCalibrationEstimator::numCapturedImgs ( )

inline

Definition at line 72 of file SENSCalibrationEstimator.h.

72 { return _numCaptured; }

◆ numImgsToCapture()

int SENSCalibrationEstimator::numImgsToCapture ( )

inline

Definition at line 71 of file SENSCalibrationEstimator.h.

71 { return _numOfImgsToCapture; }

◆ saveImage()

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

private

Definition at line 357 of file SENSCalibrationEstimator.cpp.

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

◆ state()

State SENSCalibrationEstimator::state ( )

inline

Definition at line 67 of file SENSCalibrationEstimator.h.

     {
         return _state;
     }

◆ updateAndDecorate()

bool SENSCalibrationEstimator::updateAndDecorate	(	cv::Mat	imageColor,
		const cv::Mat &	imageGray,
		bool	grabFrame,
		bool	drawCorners = `true`
	)

< Finds the inner chessboard corners in the given image

Definition at line 462 of file SENSCalibrationEstimator.cpp.

 {
     assert(!imageGray.empty() &&
            "SENSCalibrationEstimator::findChessboard: imageGray is empty!");
     assert(!imageColor.empty() &&
            "SENSCalibrationEstimator::findChessboard: imageColor is empty!");
     assert(_boardSize.width && _boardSize.height &&
            "SENSCalibrationEstimator::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);
     }
  
     std::vector<cv::Point2f> 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,
                                       cv::Mat(corners2D),
                                       found);
         }
     }
  
     if (_params.mode == SENSCalibrationEstimatorParams::EstimatorMode::ExtractAndCalculate)
     {
         //update state machine for extraction and calculation
         updateExtractAndCalc(found, grabFrame, imageGray);
     }
     else // SENSCalibrationEstimatorParams::EstimatorMode::OnlyCaptureAndSave
     {
         updateOnlyCapture(found, grabFrame, imageGray);
     }
  
     return found;
 }

◆ updateExtractAndCalc()

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

private

Definition at line 364 of file SENSCalibrationEstimator.cpp.

 {
     switch (_state)
     {
         case State::Streaming:
         {
             if (grabFrame && found)
             {
                 _currentImgToExtract = imageGray.clone();
                 //start async extraction
                 if (!_calibrationTask.valid())
                 {
                     _calibrationTask = std::async(std::launch::async, &SENSCalibrationEstimator::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, &SENSCalibrationEstimator::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 SENSCalibrationEstimator::updateOnlyCapture	(	bool	found,
		bool	grabFrame,
		cv::Mat	imageGray
	)

private

Definition at line 438 of file SENSCalibrationEstimator.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

cv::Size SENSCalibrationEstimator::_boardSize

private

NO. of inner chessboard corners.

Definition at line 122 of file SENSCalibrationEstimator.h.

◆ _boardSquareMM

float SENSCalibrationEstimator::_boardSquareMM = 10.f

private

Size of chessboard square in mm.

Definition at line 123 of file SENSCalibrationEstimator.h.

◆ _calibDataPath

std::string SENSCalibrationEstimator::_calibDataPath

private

Definition at line 138 of file SENSCalibrationEstimator.h.

◆ _calibImgOutputDir

std::string SENSCalibrationEstimator::_calibImgOutputDir

private

Definition at line 139 of file SENSCalibrationEstimator.h.

◆ _calibParamsFileName

std::string SENSCalibrationEstimator::_calibParamsFileName

private

name of calibration paramters file

Definition at line 136 of file SENSCalibrationEstimator.h.

◆ _calibration

std::unique_ptr<SENSCalibration> SENSCalibrationEstimator::_calibration

private

estimated calibration

Definition at line 135 of file SENSCalibrationEstimator.h.

◆ _calibrationSuccessful

bool SENSCalibrationEstimator::_calibrationSuccessful = false

private

Definition at line 116 of file SENSCalibrationEstimator.h.

◆ _calibrationTask

std::future<bool> SENSCalibrationEstimator::_calibrationTask

private

future object for calculation of calibration in async task

Definition at line 118 of file SENSCalibrationEstimator.h.

◆ _camSizeIndex

int SENSCalibrationEstimator::_camSizeIndex = -1

private

Definition at line 131 of file SENSCalibrationEstimator.h.

◆ _camType

SENSCameraType SENSCalibrationEstimator::_camType = SENSCameraType::FRONTFACING

private

Definition at line 134 of file SENSCalibrationEstimator.h.

◆ _computerInfos

std::string SENSCalibrationEstimator::_computerInfos

private

Definition at line 137 of file SENSCalibrationEstimator.h.

◆ _currentImgToExtract

cv::Mat SENSCalibrationEstimator::_currentImgToExtract

private

Definition at line 120 of file SENSCalibrationEstimator.h.

◆ _exception

SENSCalibrationEstimatorException SENSCalibrationEstimator::_exception

private

Definition at line 144 of file SENSCalibrationEstimator.h.

◆ _exePath

std::string SENSCalibrationEstimator::_exePath

private

Definition at line 140 of file SENSCalibrationEstimator.h.

◆ _hasAsyncError

bool SENSCalibrationEstimator::_hasAsyncError = false

private

Definition at line 143 of file SENSCalibrationEstimator.h.

◆ _imagePoints

vector<vector<cv::Point2f> > SENSCalibrationEstimator::_imagePoints

private

2D vector of corner points in chessboard

Definition at line 121 of file SENSCalibrationEstimator.h.

◆ _imageSize

cv::Size SENSCalibrationEstimator::_imageSize

private

Input image size in pixels (after cropping)

Definition at line 126 of file SENSCalibrationEstimator.h.

◆ _mirroredH

bool SENSCalibrationEstimator::_mirroredH = false

private

Definition at line 132 of file SENSCalibrationEstimator.h.

◆ _mirroredV

bool SENSCalibrationEstimator::_mirroredV = false

private

Definition at line 133 of file SENSCalibrationEstimator.h.

◆ _numCaptured

int SENSCalibrationEstimator::_numCaptured = 0

private

NO. of images captured.

Definition at line 125 of file SENSCalibrationEstimator.h.

◆ _numOfImgsToCapture

int SENSCalibrationEstimator::_numOfImgsToCapture = 20

private

NO. of images to capture.

Definition at line 124 of file SENSCalibrationEstimator.h.

◆ _params

SENSCalibrationEstimatorParams SENSCalibrationEstimator::_params

private

Definition at line 130 of file SENSCalibrationEstimator.h.

◆ _reprojectionError

float SENSCalibrationEstimator::_reprojectionError = -1.f

private

Reprojection error after calibration.

Definition at line 127 of file SENSCalibrationEstimator.h.

◆ _state

State SENSCalibrationEstimator::_state = State::Streaming

private

Definition at line 115 of file SENSCalibrationEstimator.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

◆ SENSCalibrationEstimator()

◆ ~SENSCalibrationEstimator()

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