Subversion Repositories OpenCV2-Cookbook

   Computer Vision Programming using the OpenCV Library.

 Computer Vision Programming using the OpenCV Library.

   by Robert Laganiere, Packt Publishing, 2011.

 by Robert Laganiere, Packt Publishing, 2011.

   This program is free software; permission is hereby granted to use, copy, modify,

 This program is free software; permission is hereby granted to use, copy, modify,

   and distribute this source code, or portions thereof, for any purpose, without fee,

 and distribute this source code, or portions thereof, for any purpose, without fee,

   subject to the restriction that the copyright notice may not be removed

 subject to the restriction that the copyright notice may not be removed

   or altered from any source or altered source distribution.

 or altered from any source or altered source distribution.

   The software is released on an as-is basis and without any warranties of any kind.

 The software is released on an as-is basis and without any warranties of any kind.

   In particular, the software is not guaranteed to be fault-tolerant or free from failure.

 In particular, the software is not guaranteed to be fault-tolerant or free from failure.

   The author disclaims all warranties with regard to this software, any use,

 The author disclaims all warranties with regard to this software, any use,

   and any consequent failure, is purely the responsibility of the user.

 and any consequent failure, is purely the responsibility of the user.

   Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name

 Copyright (C) 2010-2011 Robert Laganiere, www.laganiere.name

\*------------------------------------------------------------------------------------------*/

 \*------------------------------------------------------------------------------------------*/

int CameraCalibrator::addChessboardPoints(

int

         const std::vector<std::string>& filelist,

CameraCalibrator::addChessboardPoints(const std::vector<std::string>& filelist,

         cv::Size & boardSize) {

    cv::Size & boardSize)

        // the points on the chessboard

  // the points on the chessboard

    std::vector<cv::Point2f> imageCorners;

  std::vector<cv::Point2f> imageCorners;

    std::vector<cv::Point3f> objectCorners;

  std::vector<cv::Point3f> objectCorners;

    // 3D Scene Points:

  // 3D Scene Points:

    // Initialize the chessboard corners 

  // Initialize the chessboard corners

    // in the chessboard reference frame

  // in the chessboard reference frame

        // The corners are at 3D location (X,Y,Z)= (i,j,0)

  // The corners are at 3D location (X,Y,Z)= (i,j,0)

        for (int i=0; i<boardSize.height; i++) {

  for (int i = 0; i < boardSize.height; i++)

                for (int j=0; j<boardSize.width; j++) {

      for (int j = 0; j < boardSize.width; j++)

                        objectCorners.push_back(cv::Point3f(i, j, 0.0f));

          objectCorners.push_back(cv::Point3f(i, j, 0.0f));

                }

        }

    // 2D Image points:

  // 2D Image points:

    cv::Mat image; // to contain chessboard image

  cv::Mat image; // to contain chessboard image

    int successes = 0;

  int successes = 0;

    // for all viewpoints

  // for all viewpoints

    for (int i=0; i<filelist.size(); i++) {

  for (unsigned int i = 0; i < filelist.size(); i++)

        // Open the image

      // Open the image

        image = cv::imread(filelist[i],0);

      image = cv::imread(filelist[i], 0);

        // Get the chessboard corners

      // Get the chessboard corners

                        image, boardSize, imageCorners);

      bool found = cv::findChessboardCorners(image, boardSize, imageCorners);

        // Get subpixel accuracy on the corners

      // Get subpixel accuracy on the corners

        cv::cornerSubPix(image, imageCorners,

      cv::cornerSubPix(image, imageCorners, cv::Size(5, 5), cv::Size(-1, -1),

                        cv::TermCriteria(cv::TermCriteria::MAX_ITER +

          cv::TermCriteria(cv::TermCriteria::MAX_ITER + cv::TermCriteria::EPS,

             30,                // max number of iterations 

              30, // max number of iterations

             0.1));     // min accuracy

              0.1)); // min accuracy

          // If we have a good board, add it to our data

      // If we have a good board, add it to our data

                  if (imageCorners.size() == boardSize.area()) {

      if (imageCorners.size() == (unsigned int) boardSize.area())

                        // Add image and scene points from one view

          // Add image and scene points from one view

            addPoints(imageCorners, objectCorners);

          addPoints(imageCorners, objectCorners);

            successes++;

          successes++;

          }

        }

        //Draw the corners

      //Draw the corners

        cv::drawChessboardCorners(image, boardSize, imageCorners, found);

      cv::drawChessboardCorners(image, boardSize, imageCorners, found);

        cv::imshow("Corners on Chessboard", image);

      cv::imshow("Corners on Chessboard", image);

        cv::waitKey(100);

      cv::waitKey(100);

        return successes;

  return successes;

void CameraCalibrator::addPoints(const std::vector<cv::Point2f>& imageCorners, const std::vector<cv::Point3f>& objectCorners) {

CameraCalibrator::addPoints(const std::vector<cv::Point2f>& imageCorners,

        // 2D image points from one view

  // 2D image points from one view

        imagePoints.push_back(imageCorners);          

  imagePoints.push_back(imageCorners);

        // corresponding 3D scene points

  // corresponding 3D scene points

        objectPoints.push_back(objectCorners);

  objectPoints.push_back(objectCorners);

double CameraCalibrator::calibrate(cv::Size &imageSize)

CameraCalibrator::calibrate(cv::Size imageSize)

        // undistorter must be reinitialized

  // undistorter must be reinitialized

        mustInitUndistort= true;

  mustInitUndistort = true;

        //Output rotations and translations

  //Output rotations and translations

    std::vector<cv::Mat> rvecs, tvecs;

  std::vector<cv::Mat> rvecs, tvecs;

        // start calibration

  // start calibration

     calibrateCamera(objectPoints, // the 3D points

  return calibrateCamera(objectPoints, // the 3D points

                            imagePoints,  // the image points

      imagePoints, // the image points

                                        imageSize,    // image size

      imageSize, // image size

                                        cameraMatrix, // output camera matrix

      cameraMatrix, // output camera matrix

                                        distCoeffs,   // output distortion matrix

      distCoeffs, // output distortion matrix

                                        rvecs, tvecs, // Rs, Ts 

      rvecs, tvecs, // Rs, Ts

                                        flag);        // set options

      flag); // set options

cv::Mat CameraCalibrator::remap(const cv::Mat &image) {

CameraCalibrator::remap(const cv::Mat &image)

        cv::Mat undistorted;

  cv::Mat undistorted;

        if (mustInitUndistort) { // called once per calibration

    { // called once per calibration

                        cameraMatrix,  // computed camera matrix

      cv::initUndistortRectifyMap(cameraMatrix, // computed camera matrix

            distCoeffs,    // computed distortion matrix

          distCoeffs, // computed distortion matrix

            cv::Mat(),     // optional rectification (none) 

          cv::Mat(), // optional rectification (none)

                        cv::Mat(),     // camera matrix to generate undistorted

          cv::Mat(), // camera matrix to generate undistorted

                        cv::Size(640,480),

          cv::Size(640, 480),

            CV_32FC1,      // type of output map

          CV_32FC1,// type of output map

            map1, map2);   // the x and y mapping functions

          map1, map2); // the x and y mapping functions

                mustInitUndistort= false;

      mustInitUndistort = false;

        }

    }

        // Apply mapping functions

  // Apply mapping functions

    cv::remap(image, undistorted, map1, map2,

  cv::remap(image, undistorted, map1, map2, cv::INTER_LINEAR); // interpolation type

        return undistorted;

  return undistorted;

void CameraCalibrator::setCalibrationFlag(bool radial8CoeffEnabled, bool tangentialParamEnabled) {

CameraCalibrator::setCalibrationFlag(bool radial8CoeffEnabled,

    // Set the flag used in cv::calibrateCamera()

  // Set the flag used in cv::calibrateCamera()

    flag = 0;

  flag = 0;

    if (!tangentialParamEnabled) flag += CV_CALIB_ZERO_TANGENT_DIST;

    flag += CV_CALIB_ZERO_TANGENT_DIST;

        if (radial8CoeffEnabled) flag += CV_CALIB_RATIONAL_MODEL;

    flag += CV_CALIB_RATIONAL_MODEL;